Do while petlja
<s>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.</s><s>Imati na umu da za razliku od većine jezika, Fortran-ova do petlja je ustvari ista kao i  for petlja.</s>

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

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

<s>Neki jezici mogu koristiti različitu konvenciju naziva za ovaj tip petlje.</s><s>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).</s>

<s>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.</s>

<s>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;
}iliLOOPSTART:
   do_work();
   if (condition) goto LOOPSTART;</s>

<s>Demonstriranje do while petlji 
Ovi primeri programa izračunavaju faktorijel od 5 koristeći odgovarajući jezik sintakse za do-while petlju.</s>

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

<s>Ada 
with Ada.</s><s>Integer_Text_IO;</s>

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

<s>Ada.</s><s>Integer_Text_IO.</s><s>Put (Factorial);
end Factorial;</s>

<s>Bejsik 
Raniji Bejsik (kao što je GW-BASIC) je koristio sintaksu WHILE/WEND.</s><s>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).</s><s>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</s>

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

<s>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);</s>

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

<s>CFScript 
factorial = 1;
count = 10;
do {
   factorial *= count--;
} while (count > 1);</s>

<s>writeOutput(factorial);</s>

<s>D 
int counter = 5;
int factorial = 1;</s>

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

<s>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.</s><s>GT.0) GOTO 1
      PRINT*,FACT
      ENDSa 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</s>

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

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

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

<s>PL/I 
PL/I DO izjava sažima funkciju post-test petlje (do until), the pre-test loop (do while), i for petlje.</s><s>Sve funkcije mogu biti uključene u jednoj izjavi.</s><s>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);</s>

<s>Pajton 
Pajtonu nedostaje određena do while konstrukcija kontrole protoka.</s><s>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)</s>

<s>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.</s>

<s>Rubi 
counter = 5
factorial = 1
begin
  factorial *= counter
  counter -= 1
end while counter > 0
puts factorial</s>

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

<s>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)</s>

<s>Vižual Bejzicks .</s><s>NET 
Dim counter As Integer = 5
Dim factorial As Integer = 1
Do
   factorial *= counter
   counter -= 1 
Loop While counter > 0
Console.</s><s>WriteLine(factorial)</s>

<s>Vidi još 
 Control flow
 For petlja
 Forič petlja
 While petlja
 Petlja ponvaljanja (višeznačna odrednica)</s>

<s>Reference</s>

<s>Kontrola toka</s>

