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.

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) &mdash; dok "while" petlja radi sve dok je kontrolni izraz tačan (i zaustavlja se čim izraz postane netačan).

## Jednake konstrukcije

```c
do {
   do_work();  
} while (condition);
```
je jednako 
```c
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):
```c
while (true) {
   do_work();
   if (!condition) break;
}
```
ili
```c
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|ActionScript 3]]

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


### [[Ada (programski jezik)|Ada]]

```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 :
```vb
Dim factorial As Integer
Dim counter As Integer
factorial = 1
counter = 5
Do 
   factorial = factorial * counter
   counter = counter - 1
Loop While counter > 0
```


### [[C Sharp|C#]]

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


### [[C (programski jezik)|C]]

```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++]]

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


### [[CFScript]]

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

writeOutput(factorial);
```


### [[D (programski jezik)|D]]

```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:
```fortran
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.
```fortran
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 (programski jezik)|Java]]

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


### [[Javaskript]]

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


### [[PHP]]

```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 (programski jezik)|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 .
```python
counter = 5
factorial = 1
while True:
    factorial *= counter
    counter -= 1
    if counter == 0:
        break
print(factorial)
```


### [[DrScheme|Racket]]
U Racket-u, kao druga Scheme implementacija, "named-let" je popularan način da se sprovede petlja :
```scheme
#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 (programski jezik)|Rubi]]

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


### [[Smalltalk]]

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


### [[Svift (programski jezik)|Svift]]
Swift 2.x:
```javascript
var counter = 5
var factorial = 1
repeat {
     factorial *= counter
     counter -= 1
} while counter > 0
print(factorial)
```
Swift 1.x:
```javascript
var counter = 5
var factorial = 1
do {
     factorial *= counter
     counter -= 1
} while counter > 0
println(factorial)
```


### [[Vižual Bejzicks .NET]]

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


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

## Reference