While petlja

Kod većine programskih jezika, **while petlja** je naredba kontrole toka koja omogućava kodu da se izvršava više puta na osnovu vraćenog logičkog tipa. *While* petlja se može posmatrati i kao ponavljajuća if naredba.

## Pregled
*While* konstrukcija se sastoji od bloka naredbi i uslova. Uslov se prvo procenjuje – ako je uslov tačan, naredbe unutar bloka se izvršavaju. Ovo se ponavlja sve dok uslov ne postane netačan. Zbog toga što while petlja proverava uslov pre nego što izvrši blok naredbi, upravljačka struktura je često poznata i kao pred-test petlja. Poredi se sa do while petljom, koja proverava uslov nakon što je petlja izvršena.

Na primer, u C programskom jeziku (kao i u Javi, C#, Objective-C i C++u, koji koriste istu sintaksu u ovom slučaju), odsečak koda je:


```c
int x = 0;
while (x < 5) 
{
    printf ("x = %d\n", x);
    x++;
}
```


prvo proverava da li je h manji od 5, i zato što jeste, funkcija *printf* je pokrenuta i nakon toga h se povećava za 1. Zatim se opet proverava da li je uslov zadovoljen i petlja se izvršava sve dok je uslov zadovoljen odnosno dok promenljiva h ne dobije vrednost 5.

Uočite da je moguće, u nekim slučajevima čak i poželjno, da za zadate uslove logički odgovor *uvek* bude tačan, i da se tako stvara beskonačna petlja. Kada se takva petlja namerno napravi, obično postoji druga kontrolna struktura (kao što je break naredba) koja upravlja završetkom petlje. Na primer:


```c
while (true) 
{
    //radi komplikovane stvari
    if (Uslov) break;
    //više stvari
}
```


## Ekvivalentne strukture
U S programskom jeziku,


```c
while (Uslov) 
{
   Izjave;
}
```


je ekvivalentno sa


```c
if (Uslov) 
{
   do 
   {
      Izjave;
   } while (Uslov);
}
```


ili


```c
while (true) 
{
   if (!Uslov) break;
   Izjave;
}
```


ili


```c
goto TEST;
PETLJA:
   Izjave;
TEST:
   if (Uslov) goto PETLJA;
```


ili


```c
TEST:
   if (!Uslov) goto KRAJPETLJE;
   Izjave
   goto TEST;
KRAJPETLJE:
```

Poslednje dve nisu preporučljive zato što korišćenje „goto“ izjava otežava programeru da razume tok kontrole, i generalno se koriste kao poslednje sredstvo.

Takođe u S-u i njegovim potomcima, *while* petlja je for petlja bez inicijalizacije ili brojanja izraza tj.


```c
for ( ; Uslov; )
{
   Izjave;
}
```


## Demonstriranje ''while'' petlji
Ove while petlje će računati faktorijel broja 5:

### [[Actionscript|ActionScript 3]]

```actionscript
var broj:int = 5;
var faktorijel:int = 1;

while ( broj > 1 )
{
  faktorijel *= broj;
  broj--;
}
trace ("Faktorijel ", faktorijel);
```


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


```ada
with Ada.Integer_Text_IO;

procedure Faktorijel is
  Broj   : Integer := 5;
  Faktorijel : Integer := 1;
begin
  while Broj > 0 loop
    Faktorijel := Faktorijel * Broj;
    Broj   := Broj - 1;
  end loop;

  Ada.Integer_Text_IO.Put (Faktorijel);
end Faktorijel;
```


### Basic - [[QBasic]] ili [[Vižual bejsik|Visual Basic]]

```vb
Dim broj As Integer = 10 ' daje vrednost promenljivoj

Do While broj > 0
    broj = broj - 1
Loop ' program ide ovde, sve dok broj ne bude 0
```


### [[Bourne shell (sh)|Bourne (Unix) shell]]

```bash
broj=5
faktorijel=1
while [ $broj -gt 0 ]; do
    faktorijel=$((faktorijel * broj))
    broj=$((broj - 1))
done

echo $faktorijel
```


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

```c
int main (void)
{
  int broj = 5;
  long faktorijel = 1;
 
  while (broj > 1)
  {
     faktorijel *= broj--;
  }
  printf("%d", faktorijel);
  return 0;
}
```


#### Skript sintaksa

```cfm
broj = 5;
faktorijel = 1;
 
while ( broj > 1 ){
    faktorijel *= broj--;
}
writeOutput(faktorijel);
```


#### Tag sintaksa

```cfm
<cfset broj = 5>
<cfset faktorijel = 1>
<cfloop uslov="broj GT 1">
    <cfset faktorijel *= broj-->
</cfloop>
<cfoutput>#faktorijel#</cfoutput>
```


### [[Fortran]]

```fortran
program FaktorijelProg
  integer :: broj = 5
  integer :: faktorijel = 1
  do while (broj > 0)
    faktorijel = faktorijel * broj
    broj = broj - 1
  end do
  print *, faktorijel
end program FaktorijelProg
```


### [[Java (programski jezik)|Java]], [[C Sharp|C#]], [[D (programski jezik)|D]]
Kod while petlje je isti za programe Java, C# i D:


```csharp
int broj = 5;
long faktorijel = 1;

while (broj > 1)
{
   faktorijel *= broj--;
}
```


Za program Java rezultat se štampa kao sledeće:
  
```java
System.out.println(faktorijel);
```


Ista stvar u S#:
  
```csharp
System.Console.WriteLine(faktorijel);
```


I konačno u D:
  
```d
writefln(faktorijel);
```


### [[Javaskript]]

```javascript
var broj = 5;
var faktorijel = 1;

while ( broj > 1 )
{
  faktorijel *= broj--;
}

document.write(faktorijel);
```


### [[Lua]]

```lua
broj = 5
faktorijel = 1

while broj > 0 do
  faktorijel = faktorijel * broj
  broj = broj - 1
end

print(faktorijel)
```


### [[MATLAB]]

```matlab
broj = 5;
faktorijel = 1;

while (broj > 0)
  faktorijel = faktorijel * broj;      %Uvećava se višestruko
  broj = broj - 1;                %Opada
end

faktorijel
```


### [[Mathematica]]

```mathematica
Block[{broj=5,faktorijel=1},          (*Lokalizuje broj i faktorijel*)
         While[broj>0,                (*While petlja*)
                faktorijel*=broj;      (*Uvećava se višestruko*)
                broj--;               (*Opada*)
              ];
      faktorijel
     ]
```


### [[Oberon]], [[Oberon-2]], [[Oberon-07]], ili [[Component Pascal]]

```pascal
MODULE Faktorijel;
IMPORT Out;
VAR
  Broj, Faktorijel: INTEGER;
BEGIN
  Broj := 5;
  Faktorijel := 1;
  WHILE Broj > 0 DO
    Faktorijel := Faktorijel * Broj;
    DEC(Broj)
  END;
  Out.Int(Faktorijel,0)
END Faktorijel.
```


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

```perl
int $broj = 5;
int $faktorijel = 1;

int $multiplication;

while ($broj > 0)
{
    $multiplication = ($faktorijel * $broj);
     
    $broj -= 1;
    
    print ("Broj is: " + $broj + ", multiplication is: " + $multiplication + "\n");
}
```


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

```pascal
program Faktorijel1;
var
  Broj, Faktorijel: integer;
begin
  Broj := 5;
  Faktorijel := 1;
  while Broj > 0 do
  begin
    Faktorijel := Faktorijel * Broj;
    Broj := Broj - 1
  end;
  WriteLn(Faktorijel)
end.
```


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

```perl
my $broj = 5;
my $faktorijel = 1;

while ( $broj > 0 ) {
    $faktorijel *= $broj--; # Uvećava se višestruko, nakon toga opada
}

print $faktorijel;
```


*While* petlje se često koriste za čitanje podataka liniju po liniju (kao što je definisano sa `$/` separatorom) iz otvorenog fajla:


```perl
open IN, "<test.txt";
while ( <IN> ) {
  print;
}
close IN;
```


### [[PHP]]

```php
$broj = 5;
$faktorijel = 1;
while($broj > 0) {
  $faktorijel *= $broj; // Prvo se uvećava višestruko.
  $broj--; // Nakon toga opada.
}
echo $faktorijel;
```


### [[PL/I]]

```rexx
declare broj fixed initial(5);
declare faktorijel fixed initial(1);

do while(broj > 0)
  faktorijel = faktorijel * broj;
  broj = broj - 1;
  end;
```


### [[Pajton (programski jezik)|Python]]

```python
broj = 5 # Vrednost promenljive je 5 
faktorijel = 1 # Vrednost promenljive je 1

while broj > 0: # Dok je broj(5) veći od 0 
    faktorijel *= broj              # Promeni vrednost faktorijela u 
                                      # faktorijel h broj.
    
    broj -= 1                      # Promeni vrednost broja u
                                      # broj - 1.

print(faktorijel) # Štampa vrednost faktorijela.
```


While petlja koja se ne završava:

```python
while True:
    print("Upomoć! Zaglavljen sam u petlji!")
```


### [[DrScheme|Racket]]
U Racket, kao i u ostalim Scheme implementacijama, let je popularan način da se implementira petlja:

```scheme
#lang racket
(define broj 5)
(define faktorijel 1)
(let loop ()
  (when (> broj 0)
    (set! faktorijel (* faktorijel broj))
    (set! broj (sub1 broj))
    (loop)))
(displayln faktorijel)
```

Koristeći makro sistem, implementacija while petlje je trivialna vežba:

```scheme
#lang racket
(define-syntax-rule (while test body ...) ; ubacuje while petlju
  (let loop () (when test body ... (loop))))
(define broj 5)
(define faktorijel 1)
(while (> broj 0)
  (set! faktorijel (* faktorijel broj))
  (set! broj (sub1 broj)))
(displayln faktorijel)
```


### [[Rubi (programski jezik)|Ruby]]

```python
# Izračunava faktorijel od 5
i = 1
faktorijel = 1
while i < 5
  faktorijel *= i
  i += 1
end
puts faktorijel
```


### [[Smalltalk]]
Za razliku od ostalih jezika, u Smalltalk-u while petlja nije jezička konstrukcija već je definisana u klasi `BlockClosure` kao metod sa jednim parametrom, telom kao zatvaranjem, koristeći sebe kao uslov.


```smalltalk
| count faktorijel |
count := 5.
faktorijel := 1.
[ count > 0 ] whileTrue: 
    [ faktorijel := faktorijel * count.
    count := count - 1 ].
Transcript show: faktorijel
```


Smalltalk takođe ima odgovarajući whileFalse: metod.

### [[Tcl]] (Tool command language)

```tcl
set broj 5
set faktorijel 1

while {$broj > 0} {
  set faktorijel [expr $faktorijel * $broj] 
  incr broj -1 
}

puts $faktorijel
```


### [[Windows PowerShell]]

```powershell
$broj = 5
$faktorijel = 1
while ($broj) {
    $faktorijel *= $broj--
}
$faktorijel
```


### While jezik
While programski jezik je prost programski jezik napravljen od zadataka, uslova i while izjava, korišćenih u teoretskoj analizi imperativne semantike programskog jezika.

```text
C := 5;
F := 1;
while (C > 1) do
    F := F * C;
    C := C - 1;
```


## Povezano
* Do while petlja
* For petlja
* Forič petlja

## Reference

## Literatura
*