Do while petlja

Kod većine programskih jezika,do while petlja je naredba kontrola protoka koji izvršava blok koda najmanje jednom, i onda neprestano izvršava blok, ili ne, u zavisnosti od datog logičkog stanja na kraju bloka. Imati na umu da za razliku od većine jezika, Fortran-ova do petlja je ustvari ista kao i  for petlja.

Do While protok petlje dijagram

Do while konstrukcija se sastoji od procesa simbola i uslova. Prvo, kod unutar bloka se izvršava, i onda se uslov procenjuje. Ako je uslov tačan kod unutar bloka se izvršava ponovo. Ovo se ponavlja sve dok uslov ne postane netačan. Zato što do while  petlje proveravaju uslov nakon što je blok izvršen, kontrolna struktura je takođe poznata kao i post-test petlje. Suprotno od while petlje, koja testira uslov pre nego što se kod unutar bloka izvršio, do-while petlja je izlazna-uslov petlja. Ovo znači da se kod mora uvek izvršiti prvo i onda se procenjuje izraz ili test stanja. Ako je tačno, kod izršava telo petlje ponovo. Ovaj proces se ponavlja  sve dok izraz ima tačnu vrednost. Ako je vrednost netačna, petlja se zaustavlja i kontroliše protok do izjave prateći do-while petlju.

Moguće je i u nekim poželjnim slučajevima, da se uslov uvek procenjuje kao tačan, stavarući beskonačnu petlju. Kada je ovakva petlja stvorena namerno, obično postoji još jedna kontrolna struktura (kao što je izjava prekida) koja dozvoljava prekid petlje.

Neki jezici mogu koristiti različitu konvenciju naziva za ovaj tip petlje. Na primer, jezik Paskal ima "repeat until" petlju, koja se nastavlja sve dok kontrolni izraz nije tačan (a zatim se završava) — dok "while" petlja radi sve dok je kontrolni izraz tačan (i zaustavlja se čim izraz postane netačan).

Jednake konstrukcije

do {
   do_work();  
} while (condition);

je jednako 

do_work();
while (condition) {
   do_work();
}

Na ovaj način, do ... while petlja čuva osnovnu petlju sa  do_work();  u redu prewhilepetlje. Sve dok continue izjava nije korišćena, ovo gore je tehnički jednako sledećem (iako ovi primeri nisu tipični ili u modernom stilu):

while (true) {
   do_work();
   if (!condition) break;
}

ili

LOOPSTART:
   do_work();
   if (condition) goto LOOPSTART;

Demonstriranje do while petlji

Ovi primeri programa izračunavaju faktorijel od 5 koristeći odgovarajući jezik sintakse za do-while petlju.

ActionScript 3

var counter:int = 5;
var factorial:int = 1;
do {
  factorial *= counter--; /* Množi, onda opada. */
} while (counter > 0);
trace(factorial);

Ada

with Ada.Integer_Text_IO;

procedure Factorial is
  Counter   : Integer := 5;
  Factorial : Integer := 1;
begin
  loop
    Factorial := Factorial * Counter;
    Counter   := Counter - 1;
    exit when Counter = 0;
  end loop;

  Ada.Integer_Text_IO.Put (Factorial);
end Factorial;

Bejsik

Raniji Bejsik (kao što je GW-BASIC) je koristio sintaksu WHILE/WEND. Moderni Bejsik kao što je  PowerBASIC obezbeđuje  WHILE/WEND i DO/LOOP strukture, sa sintkaskom DO WHILE/LOOP, DO UNTIL/LOOP, DO/LOOP WHILE, DO/LOOP UNTIL, i DO/LOOP (bez spoljašnjeg testiranja, ali sa uslovnom EXIT LOOP negde unutar petlje). Tipični  Bejsik izvor koda :

Dim factorial As Integer
Dim counter As Integer
factorial = 1
counter = 5
Do 
   factorial = factorial * counter
   counter = counter - 1
Loop While counter > 0

C#

int counter = 5;
int factorial = 1;
do 
{
  factorial *= counter--; /* Množi, onda opada. */
} while (counter > 0);
System.Console.WriteLine(factorial);

C

int counter = 5;
int factorial = 1;
do {
  factorial *= counter--; /* Množi, onda opada. */
} while (counter > 0);
printf("factorial of 5 is %d\n", factorial);

C++

int counter = 5;
int factorial = 1;
do {
  factorial *= counter--;
} while (counter > 0);
std::cout<<"factorial of 5 is "<<factorial<<std::endl;

CFScript

factorial = 1;
count = 10;
do {
   factorial *= count--;
} while (count > 1);

writeOutput(factorial);

D

int counter = 5;
int factorial = 1;

do {
  factorial *= counter--; // Množi, onda opada.
} while (counter > 0);
writeln("factorial of 5 is ", factorial);

Fortran

U zastarelom FORTRAN 77 ne postoji DO-WHILE konstrukcija ali isti efekat se može postići sa GOTO:

      INTEGER CNT,FACT
      CNT=5
      FACT=1
    1 CONTINUE
      FACT=FACT*CNT
      CNT=CNT-1
      IF (CNT.GT.0) GOTO 1
      PRINT*,FACT
      END

Sa Fortran 90 i kasnijim, koristimo konstrukciju jednakosti koja je pomenuta gore.

program FactorialProg
  integer :: counter = 5
  integer :: factorial = 1
  factorial = factorial * counter
  counter = counter - 1
  do while (counter > 0)
    factorial = factorial * counter
    counter = counter - 1
  end do
  print *, factorial
end program FactorialProg

Java

int counter = 5;
int factorial = 1;
do {
  factorial *= counter--; /* Množi, onda opada. */
} while (counter > 0);
System.out.println(factorial);

Javaskript

var counter = 5;
var factorial = 1;
do {
    factorial *= counter--;
} while (counter > 0);
console.log(factorial);

PHP

<?php
$counter = 5;
$factorial = 1;
do {
    $factorial *= $counter--;
} while ($counter > 0);
echo $factorial;
?>

PL/I

PL/I DO izjava sažima funkciju post-test petlje (do until), the pre-test loop (do while), i for petlje. Sve funkcije mogu biti uključene u jednoj izjavi. Primer pokazuje samo"do until" sintaksu.

declare counter fixed initial(5);
declare factorial fixed initial(1);
do until(counter<=0);
  factorial = factorial * counter;
  counter = counter - 1;
  end;
put(factorial);

Pajton

Pajtonu nedostaje određena do while konstrukcija kontrole protoka. Međutim, nešto slično može biti izvedeno uz pomoć while petlje sa prekidom .

counter = 5
factorial = 1
while True:
    factorial *= counter
    counter -= 1
    if counter == 0:
        break
print(factorial)

Racket

U Racket-u, kao druga Scheme implementacija, "named-let" je popularan način da se sprovede petlja :

#lang racket
(define counter 5)
(define factorial 1)
(let loop ()
  (set! factorial (* factorial counter))
  (set! counter (sub1 counter))
  (when (> counter 0) (loop)))
(displayln factorial)

Uporediti ovo sa prvim primerom while petlje primera za Racket.

Rubi

counter = 5
factorial = 1
begin
  factorial *= counter
  counter -= 1
end while counter > 0
puts factorial

Smalltalk

| counter factorial |
counter := 5.
factorial := 1.
[counter > 0] whileTrue: 
  [factorial := factorial * counter.
  counter := counter - 1].
Transcript show: factorial printString

Svift

Swift 2.x:

var counter = 5
var factorial = 1
repeat {
     factorial *= counter
     counter -= 1
} while counter > 0
print(factorial)

Swift 1.x:

var counter = 5
var factorial = 1
do {
     factorial *= counter
     counter -= 1
} while counter > 0
println(factorial)

Vižual Bejzicks .NET

Dim counter As Integer = 5
Dim factorial As Integer = 1
Do
   factorial *= counter
   counter -= 1 
Loop While counter > 0
Console.WriteLine(factorial)

Vidi još

• Control flow
• For petlja
• Forič petlja
• While petlja
• Petlja ponvaljanja (višeznačna odrednica)