Do While protok petlje dijagram

| Konstrukcije petlji |
| --- |
| Do while petlja |
| While petlja |
| For petlja |
| Foreach petlja |
| Beskonačna petlja |
| Upravljanje tokom |

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.

D*o 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 pre`while`petlje.

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)