For petlja

U nauci o kompjuterima ** for-petlja** (ili jednostavnije **for petlja**) je kontrolna izjava u programskim jezicima za navođenje ponavljanja, koja omogućava kodu da se izvršava u više navrata. Sintaka for petlje je napravljena u stilu programskog jezika u kojem se koristi ili je pozajmljena iz starijih programskih jezika, pa tako programski jezici koji su potomci ili izdanci istog jezika će često koristiti istu reč da označe interator, npr., potomci ALGOL-a koriste „for“, dok potomci Fortran-a koriste „do“. Postoje i druge mogućnosti, na primer COBOL koristi „PERFORM“.

Za razliku od drugih petlji, kao što je while petlja, for petlje često odlikuju izraženiji brojači ili izraženije promenljive. Ovo omogućava telu for petlje (kod koji se u više navrata izvršava) da zna redosled svakog ponavljanja. For petlje se uglavnom koriste kada se broj ponavljanja zna pre nego što se petlja napiše. Kada se while petlja može napisati kao For petlja i kada se zna broj ponavljanja, bolje je koristiti For petlju jer je kraća.

Ime For petlje potiče od engleske reči , koja se koristi kao ključna reč u najvećem broju programskih da bi se uvela for petlja. Ovaj izraz se koristio još u ALGOL-u 58, a postao je popularan kasnije u ALGOL-u 60; on je direktan prevod nemačke reči ****, korišćene u *[[Superplan|Superplan-u]]* (1949-1951) Hajnca Rutishausera, koji je takođe bio uključen u programiranju ALGOL-a 58 i ALGOL-a 60. Telo petlje izvršava „for“ za vrednosti promenljivih iz petlje, i ovo je mnogo izraženije u ALGOL izjavama, u kojima se liste potencijalnih vrednosti i/ili koraka mogu odrediti.

U FORTRAN i PL/I, se koristi ključna reč DO, a petlja se zove **do petlja**, i pošto je skoro identična for petlji opisanoj ovde, nećemo je koristiti kako je ne bi mešali sa do while petljom.

## Vrste for petlji
Izjave For petlji su dostupne u većini imperativnih programskih jezika. Čak i ignorišući manje razlike u sintaksama postoji mnogo razlika u tome kako ove izjave rade i kakav nivo izražajnosti podržavaju. Generalno for petlje se mogu podeliti na:
### Tradicionalne for petlje
Tradicionalne for petlje u C / C++ sastoje se iz 3 dela: uvođenje, uslov i naknadna misao i sva 3 dela su opciona.

```
for (UVOĐENjE; USLOV; NAKNADNA MISAO) 
{
    // Kod tela for petlje ide ovde
}
```


U uvođenju se navode (verovatno i dodeljuju) sve potrbne promenljive. Tip promenljivih bi trebalo da bude isti ako koristite više promenljivih u delu uvođenja. Uslov proverava uslov, i prekida petlju ako uslov daje logički odgovor netačno. Naknadna misao se izvršava samo jednom svaki put kada se petlja završava i ponavlja.

Evo primera tradicionalne for petlje u Javi.

```
for (int i = 0; i < 100; i++) // Štampa brojeve od 0 do 99 (ne i 100), svaki odvojen razmakom.
{
    System.out.print(i);
    System.out.print(' ');
}
System.out.println();
```


### For petlje zasnovane na ponavljanju

Ovaj tip for petlje je kopija for petlje zasnovane na numeričkim opsezima; jer omogućava brojanje skupova stavki koji ne moraju biti nizovi brojeva. Obično se odlikuje upotrebom implicitnog ili eksplicitnog iteratora, u kojoj promenljiva petlje preuzima vrednost iz sekvenci ili iz druge mogće kolekcije. Reprezentativan primer u Pajtonu je:

```
for stavka in objekat:
    uradi nešto
    uradi nešto drugo
```


Gde je `objekat` ili kolekcija koja podržava implicitno ponavljanje (kao lista imena zaposlenih) ili je to možda sam interator. Neki jezici imaju ovo kao dodatak drugim sintaksama for petlje; posebno PHP ima ovaj tip petlje pod imenom `for each`, kao i troizraznu for petlju (videti dole) pod imenom `for`.

### Vektorizovane for petlje
Neki jezici nude for petlje koje obavljaju if proces na svim ponavljanjima paralelno, za razliku od ekspilcitne forme ponavljanja. Na primer to radi ključna reč `for all` u FORTRAN 95, koji ima tumačenje da su svi izrazi sa desne strane vrednovani pre nego što su zadaci napravljeni. U for izjvama u sledećim delovima pseudokoda, gde računajući novu vrednost za `A(i)`, osim za prvu (za `i = 2`), pozivanje na `A(i - 1)` će dobiti novu vrednost koja će biti postavljena na isto mesto kao u prethodnom koraku. U `for all` verziji, svaki račun odnosi se samo na originalan, neizmenjeni `A`.
 **for**     i := 2 : N - 1 **do** A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3; **next** i;
 **for all** i := 2 : N - 1 **do** A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3;
Razlika može biti značajna.

Neki jezici (kao FORTRAN 95, PL/I) takođe nude niz izjava za dodeljivanje, koje omogućuju da mnoge for petlje budu izistavljene. Tako će pseudokod `A := 0;` postaviti sve elemente niza A na nulu, bez obzira na njenu veličinu ili dimenziju. Na primer takva petlja može biti:


```fortran
A(2 : N - 1) := [A(1 : N - 2) + A(2 : N - 1) + A(3 : N)] / 3;
```


Da li je izražena u stilu for petlje, for all petlje ili neke druge možda neće biti tačno opisano u uputstvu.

### Spojene for petlje

Uvedene u ALGOL 68 i ispraćene sa PL/I, omogućavaju da ponavljanje petlje bude spojeno sa ispitivanjem, kao u
 for i := 1 : N while A(i) > 0 uradi *itd.*
To jest, vrednost je dodeljena promenljivoj *i* i samo ako je izraz **tačan** telo petlje će se izvršiti. Ako je vrednost **netačna** izračunavanje se završava. Pod pretpostavkom da je vrednost promenljive definisana nakon završetka petlje, gornja naredba će pronaći prvi ne pozitivan element niza A (ako takav ne postoji, negova vrednost će biti N+1) ili, sa odgovarajućim varijantama, prvi ne prazan karakter u niskoj, itd.

## Dodatne semantike i konstrukcije

### Korišćenje beskonačne petlje
Ovaj S-stil for petlji je još od osnovnih koraka ponavljanja je potpuno u kontroli programera. U stvari, kada su beskonačne petlje namerno stvorene, ova vrsta for petlji se može koristiti (sa praznim izrazima) kao:

```c
for (;;)
   //telo petlje
```


Ovaj stil se koristi umesto beskonačne  petlje da bi se izbeglo upozorenje u nekim S/S++ komplajerima. Neki programeri vole više jezgrovitu  formu nego semantički ekvivalentnu ali opširniju  formu.

### Rani izlaz i nastavak
Neki jezici takođe mogu da pruže i druge prateće izjave, koje kada su prisutne mogu da menjaju ponavljanje for petlje. Zajedničke među njima su break i continue izjave koje se nalaze u C programskom jeziku i njegovim izdancima. Izjava break prekida petlju odmah nakon zadatog uslova. Izjava continue će odmah krenuti na sledeću iteraciju bez daljeg napretka kroz telo petlje za tekuću iteracijy. Ostali jezici mogu imati slične izjave ili da na drugi način obezbede sredstva za menjanje for petlje ; na primer u FORTRAN-u 95:


```fortran
DO I = 1, N
  izjave                   !Izvršava sve vrednosti za "I", sve do katastrofe ako postoji.
  IF (nije dobro) CYCLE    !Preskače ovu vrednost za "I", nastavlja sa sledećom.
  izjave                   !Izvršava samo gde je dobro.
  IF (katastrofa) EXIT     !Napušta petlju.
  izjave                   !Sve dok je dobro, dok nije katastrofa.

END DO !Treba da se uskladi sa "DO".
```


### Obim promenljive u petlji i semantika
Različiti jezici navode različita pravila za ono što će vrednost promenljive u petlji imati nakon završetka petlje. Ovo dozvoljava prevodiocu da generiše kod koji ne ostavlja nikakvu vrednost promenljivoj iz petlje, ili možda čak i ostavlja, ali je to nepromenjena vrednost petlje i nikada se ne čuva u memoriji. Stvarno ponašanje može čak da varira u skladu sa postavkama optimizacije kompajlera, kao sa Honywell Fortran66 kompajlerom.

U nekim jezicima (ali ne u S i C++) petlja promenljive je nepromenljiva u okviru tela petlje, svaki pokušaj da se promeni njena vrednost smatra se semantičkom greškom. Takve modifikacije su ponekad posledica greške programera, što može biti veoma teško identifikovati. Međutim sama greška će verovatno biti otkrivena od strane ljudi koji proveravaju kod. Situacije u kojima adrese promenljivih u petlji prolaze kao argumenti potprograma su veoma teško proverljive, jer ponašanje rutine je u celini nepoznato u kompajleru. Neki primeri u Fortranovom stilu:


```fortran
DO I = 1, N
  I = 7                           !Očito podešavanje promenljive iz petlje. Verovatno prigovor.
  Z = ADJUST(I)                   !Funkcija "ADJUST" će izmeniti "I", u neizvesno.
  normalne izjave                 !Memorija će izbrisati da je "I" promenljiva iz petlje.
  PRINT (A(I), B(I), I = 1, N, 2) !Koristi petlju da odštampa neparne elemente niza A i V, ponovo koristeći "I"…
  PRINT I                         !Koja vrednost će biti odštampana?
END DO !Koliko puta će petlja biti računata?
```


Zajednički pristup je da izračuna tačku ponavljanja na početku petlje (sa posebnim osvrtom na izlivanje kao u `for i := 0 : 65535 do ... ;` u šesnaestobitnom intidžeru aritmetike) i sa svakim novim izdanjem smanji ovo, računajući while takođe dodavanjem vrednosti `I`: duplo brojanje rezultata. Takođe prilagođavanje vrednosti I: duplo brojati rezultate. Međutim, prilagođavanja vrednosti `I` u okviru petlje neće promeniti broj ponavljanja izvršenja.

Još jedna mogućnost je da je kod generisan i može se koristiti pomoćnu promenljive kao promenljiva petlje, verovatno sačuvanom u registaru, čija vrednost može ili ne može biti kopirana u `I` na svakom ponavljanju. Opet, modifikacije `I` neće uticati na kontrolu petlje, ali sada je na raskrsnici moguće: u okviru petlje, reference vrednosti `I` mogu biti (eventualno izmenjene) sadašnje vrednosti `I` ili pomoćne promenljive `I` pa su zbunjujući rezultati zagarantovani. Na primer, u okviru petlje referencu na element `I` niza verovatno će zaposliti pomoćnu promenljive (pogotovo ako je održana u registaru), ali ako je parametar na neku rutinu (na primer, štampanje izjava otkriva svoju vrednost), verovatno bi pozivalo na odgovarajuće promenljive `I`. Najbolje je da se izbegnu takve mogućnosti.
#### Prilagođavanje granica
Baš kao što indeks promenljive može biti modifikovan u okviru for petlji, tako se mogu menjati i granice i pravaci. Ali sa neizvesnim efektima. Prevodilac može sprečiti takve pokušaje, jer oni možda nemaju nikakav efekat, ili čak možda nakon toga neće raditi ispravno, mada bi mnogi rekli da je pogršno to uraditi. Razmotrite izjavu kao 
**for** i := first : last : step **do**
   A(i) := A(i) / A(last);
Ako pristup sastavljanju takve petlje treba da bude procena prvog, poslednjeg člana, broja koraka i obračun ponavljanja sa nečim kao (*poslednji*-*prvi*)/*korak* samo na početku, i onda ako te stavke budu jednostavne promenljive i njihove vrednosti su nekako uvećane tokom ponavljanja, to neće imati nikakvog efekta na interaciju count iako je element izabran za podelu sa *A (poslednji)* promenjen.

### Lista vrednosti opsega
PL/I i ALGOL 68 omogućava petljama u kojima se nalazi promenljiva da se ponavljaju izvan opsega vrednosti umesto u jednom opsegu. Sledi PL/I primer koji izračunava petlju sa 6 vrednosti za i:1,7,12,13,14,15:

```rexx
do i = 1, 7, 12 to 15;
  /*izjave*/
end;
```


## Ekvivalentnost sa while petljom
For petlja se može konvertovati u ekvivalentnu while petlju dopisivanjem brojača promenljive direktno. Sledeći pseudokod pokazuje ovu tehniku:
 faktorijel = 1
  for broj from 1 to 5
      faktorijel = faktorijel * broj

Lako se prevodi u while petlju:
 faktorijel = 1
  broj = 1
  while broj 
do broj = 1, 5, 1
  write(*, '(i2)') broj
end do


U FORTRAN-u `for` petlja je ekvivalentna sa `DO` petljom. Sintaksa Fortran-ove `DO` petlje je:
 
```fortran
DO oznaka broj=početak, kraj, korak
         izjave
  oznaka izjava
```

 
Gde se deo koraka može izostaviti ukoliko je korak jedan. Primer: (prostori su irelevantni u Fortran izjavama, tako SUM SQ je isto kao SUMSQ)

```fortran
! Primer DO petlje
       PROGRAM MAIN
         SUM SQ = 0
         DO 101 I = 1, 9999999
           IF (SUM SQ.GT.1000) GO TO 109
           SUM SQ = SUM SQ + I**2
101 CONTINUE
109 CONTINUE
       END
```


### 1958: Algol
Algol je prvi put formalizovan u izveštaju Algol58.
### 1960: COBOL
COBOL je formalizovan krajem 1959 god. I imao je mnogo elaboracija. Koristi PERFORM reč koja ima mnogo opcija, uz kasnije dodavanje „sastavnih“ izjava kao što su END-PERFORM. Ignorisanjem potrebe za deklarisanjem i inicijalizacijom promenljive, ekvivalento sa for petljom će biti:

```cobol
PERFORM VARYING I FROM 1 BY 1 UNTIL I > 1000
             ADD I**2 TO SUM-SQ.
      END-PERFORM
```

Ako reč PERFORM ima opcioni dodatak TEST AFTER, dobijena petlja je nešto drugačija: telo petlje izvršava se najmanje jednom, pre bilo kakvog testa.

### 1964: BASIC
Petlje u BASIC ponekad se nazivaju for next petlje.

```basic
For I = 1 to 5;
 Print I;
Next I
```

Obratite pažnju da marker kraja petlje navodi ime indeksa promenljive, koja mora da odgovara imenu indeksa promenljive na početku for petlje. Neki jezici (PL/I, FORTRAN 95 i kasnije) omogućavaju oznaku izjave na početku for petlje tako da može biti uhvaćena od strane kompajlera u odnosu na isti tekst na odgovarajućoj izjavi end. Fortran takođe omogućava EXIT i CYCLE izjave da bi označili ime ovog teksta; u gnezdu petlje ovo čisti petlju koja je namenjena. Međutim, na ovim jezicima etikete moraju da budu jedinstvene, tako uzastopne petlje koje uključuju isti indeks promenljive ne mogu da koriste isti tekst, niti može etiketa biti ista kao ime promenljive, kao što je indeks promenljive u for petlji.

### 1964: PL/I

```rexx
do broj = 1 to 5 by 1; /* "by 1" je podrazumevano ako ništa nije navedeno */
  /*izjave*/;
  end;
```


Izjava *LEAVE* može da se koristi za izlazak iz petlje. Petlja može biti označena, i *leave* će možda ostaviti posebnu petlju u grupi gnezda petlji. Neki PL/I dijalekti uključuju izjavu *ITERATE* da prekine trenutnu interaciju petlje i da počne sledeća.

### 1968: Algol 68
Algol68 ima ono što je smatrano univerzalnom petljom, puna sintaksa je:

```
FOR i FROM 1 BY 2 TO 3 WHILE i≠4 DO ~ OD
```

Dalje, jedan opseg ponavljanja može biti zamenjen listom takvih opsega. Postoji nekoliko neobičnih aspekata konstrukcije.
* samo "**do ~ od**" deo je obavezan, u ovom slučaju petlja će se ponavljati u nedogled.
* tako će se deo "**to** 100 **do** ~ **od**" ponoviti tačno 100 puta.
* element "**while**" će dozvoliti programeru da prekine **for** petlju ranije, kao u:


```
INT sum sq := 0;
FOR i
 WHILE
  print(("Do sada:", i, new line)); # Uvedeno za svrhu praćenja. #
  sum sq ≠ 70↑2                    # Ovo je test za WHILE   #
DO
  sum sq +:= i↑2
OD
```


### 1970:Pascal

```pascal
for Broj := 1 to 5 do
  (*izjava*);
```


Opadanje (računajući unazad) koristi „downto“ ključnu reč umesto „to“, kao u:

```pascal
for Broj := 5 downto 1 do
  (*izjava*);
```


Numerički opseg for petlje varira nešto više.

### 1972: C/C++


```c
for (inicijalizacija; uslov; uvećanje/smanjenje)
    izjava
```

Izjava je obično blok izjava; primer ovoga je:
```c
//Korišćenje for petlji za dodavanje brojeva 1 - 5
int sum = 0;
for (int i = 1; i < 6; ++i) {
    sum += i;
}
```


### 1972: Smalltalk

```smalltalk
1 to: 5 do: [ :broj | "izjave" ]
```

Za razliku od drugih jezika, u Smalltalk-u for petlja nije jezikička konstrukcija, ali je definisana u klasi Broj kao metod sa dva parametra, na kraju vrednosti i zatvaranja, koristeći sebe kao početnu vrednost.

### 1980: Ada

```ada
for Broj in 1 .. 5 loop
   -- izjave
end loop;
```


Izjava exit može da se koristi za izlazak iz petlje. Petlje mogu biti označene, a izlaz može ostaviti posebno označenu petlju u grupu ugnežđenih petlji:

```ada
Racun:
    for Broj in 1 .. 5 loop
   Trougao:
       for Secondary_Index in 2 .. Broj loop
          -- izjave
          exit Račun;
          -- izjave
       end loop Trougao;
    end loop Račun;
```


### 1980: Maple

Maple ima dva oblika for petlji, jedan za ponavljanje opsega vrednosti, a drugi za ponavljanja sadržaja kontejnera. Vrednost opsega je sledeći:

 **for** *i* **from** *f* **by** *b* **to** *t* **while** *w* **do**
     *# telo petlje*
 **od**;

Svi delovi osim **do** i **od** su opcioni. "**For** *i*" deo, ako je prisutan, mora biti prvi. Preostali deo ("**from** *f*", "**by** *b*", "**to** *t*", "**while** *w*") može da se pojavi u bilo kom redosledu.

Iteratvno preko posude vrši se koristeći ovaj oblik petlje:
 **for** *e* **in** *c* **while** *w* **do**
     *# telo petlje*
 **od**;

"**In** *c*" deo precizira kontejner, koji može biti lista, skup, zbir, proizvod, funkcija, niz, ili objekat sprovođenje iterator.

For petlja može se raskinuti sa **od**, **end**, ili **end do**.

### 1982: Maxima CAS
U Maxima CAS-u mogu se koristiti i ne celobrojne vrednosti:

```lua
for x:0.5 step 0.1 thru 0.9 do
    /* "Radi nešto sa x" */
```


### 1982: PostScript
For petlja, napisana kao `[početna] [prirast] [limit] {...}for` započinje sa unutrašnjom promenljivom, i izvršava telo dok unutrašnja promenljiva nije viša od limita (ili ne manja, ako je negativan priraštaj ) i, na kraju svake iteracije, povećava unutrašnju promenljivu. Pre svakog ponavljanja, vrednost unutrašnje promenljive je prebačena u stek.

```applescript
1 1 6 {IZJAVE} for
```

Tu je takođe i prosta repeat petlja. Repeat petlja, napisana sa H { ... } repeat ponavlja telo tačno H puta.

```applescript
5 { IZJAVE } repeat
```


### 1983: Ada 83 i iznad

```ada
procedure Main is
  Sum_Sq : Integer := 0;
begin
  for I in 1 .. 9999999 loop 
    if Sum_Sq <= 1000 then
      Sum_Sq := Sum_Sq + I**2
    end if;
  end loop;
end;
```


### 1984: MATLAB

```matlab
for i = 1:5 
     -- izjave
end
```


### 1987: Perl

```perl
for ($broj = 1; $broj <= 5; $broj++) { # sadašnje ili prethodno definisane promenljive
  # izjave;
}
for (my $broj = 1; $broj <= 5; $broj++) { # promenljive iz petlje
  # izjave;
}
for (1..5) { # promenljive implicitno nazvane $_; 1..5 stvaraju liste od 5 elemenata
  # izjave;
}
izjava for 1..5; # gotovo ista (samo 1 izjava) sa prirodnim nizom
for my $broj (1..5) { # promenljive iz petlje
  # izjave;
}
```


### 1988: Mathematica

Konstrukcija for petlje koja odgovara većini drugih jezika u Mathematica se naziva Do. 

```ruby
Do[f[x], {x, 0, 1, 0.1}]
```


Mathematica takođe ima For konstrukciju koji imitira for petlju S jezika.


```ruby
For[x= 0 , x <= 1, x += 0.1,
    f[x]
]
```


### 1989: Bash

```bash
# prva forma
for i in 1 2 3 4 5
do
    # mora imati najmanje jednu komandu u petlji
    echo $i  # samo štampa vrednost i
done
```



```bash
# druga forma
for (( i = 1; i <= 5; i++ ))
do
    # mora imati najmanje jednu komandu u petlji
    echo $i  # samo štampa vrednost i
done
```


Imajte na umu da se prazna petlja (tj jedna bez komandi između `do` i `done`)tretira kao sintaksna greška. Ako iznad petlje sadrži samo komentare, izvršenje će rezultirati porukom "`sintaksna greška kod neočekivanog znaka 'Done'`".

### 1990: Haskell
Ugrađeni imperativ *forM_* mapira izraz u listu, kao
```haskell
forM_ [1..5] $ \indx -> do izjave
```


ili da svakim novim izdanjem rezultat bude kao u listi
```haskell
statements_result_list <- forM [1..5] $ \indx -> do izjave
```


Ali, ako želite da sačuvate prostor [1..5] u listi, više autentična *forLoop_* konstrukcija može se definisati kao

```haskell
import Control.Monad as M

forLoopM_ :: Monad m => a -> (a -> Bool) -> (a -> a) -> (a -> m ()) -> m ()
forLoopM_ indx prop incr f = do
        f indx
        M.when (prop next) $ forLoopM_ next prop incr f
  where      
    next = incr indx
```

I koristiti se kao:

```haskell
forLoopM_ (0::Int) (< len) (+1) $ \indx -> do -- bilo šta sa indeksom
```


### 1991: Oberon-2, Oberon-07, or Component Pascal

```modula2
FOR Broj := 1 TO 5 DO
  (* izjava *)
END
```

Imajte na umu da je u originalnom jeziku Oberon for petlja izostavljena u korist generalnog konstrukta Oberon petlje. For petlja je ponovo uvedena u Oberon 2.

### 1991: Python

```python
for broj in range(1, 6): # opseg (1, 6) daje vrednost od 1 do 5 (ali ne 6)
  # izjave
```


### 1993: AppleScript

```applescript
repeat with i from 1 to 5
	-- izjave
	log i
end repeat
```

Takođe možete proći kroz listu stavki, slično onome što možete da uradite sa nizovima y drugim jezicima:

```applescript
set x to {1, "vafli", "slanina", 5.1, false}
repeat with i in x
	log i
end repeat
```

Takođe možete koristiti "exit repeat" da izađete iz petlje u bilo kom trenutku. Za razliku od drugih jezika, AppleScript trenutno nema nikakvu naredbu da nastavi do sledeće naredbe u petlji.

### 1993: Lua

```lua
for i = početak, kraj, interval do
     -- izjave
end
```


Dakle, ovaj kod 
```lua
for i = 1, 5, 2 do
     print(i)
end
```
 će ispisati:

```lua
1 3 5
```


For petlje mogu takođe da idu kroz tabelu korišćenjem 
```lua
ipairs()
```
 da brojčano ponovi kroz nizove i 
```lua
pairs()
```
 da nasumice prelazili preko rečnika.

Generisana for petlja pravi zatvaranja:


```lua
for ime, telefon, adresa in kontakti() do
     -- kontakti() moraju biti ponavljajuća funkcija
end
```


### 1995: [[CFML]]

#### Skript sintaksa
Jednostavan indeks petlje:

```cfm
for (i = 1; i <= 5; i++) {
	// izjave
}
```


Koristeći niz:

```cfm
for (i in [1,2,3,4,5]) {
	// izjave
}
```


Korišćenjem "liste" vrednosti niski:

```cfm
loop index="i" list="1;2,3;4,5" delimiters=",;" {
	// izjave
}
```


#### Tag sintaksa
Jednostavan indeks petlje:

```cfm
<cfloop index="i" from="1" to="5">
	
</cfloop>
```


Koristeći niz:

```cfm
<cfloop index="i" array="#[1,2,3,4,5]#">
	
</cfloop>
```


Korišćenjem "liste" vrednosti niski:

```cfm
<cfloop index="i" list="1;2,3;4,5" delimiters=",;">
	
</cfloop>
```


### 1995:Java

```java
for (int i = 0; i < 5; i++) {
    //obavlja funkcije u okviru petlje;
    //može koristiti izjavu 'break;' da brzo izađe iz petlje
    //može koristiti izjavu 'continue;' da preskoči trenutni korak 
}
```


Za produženu for petlju, pogledajte Foreach petlju

### 1995:JavaScript
JavaScript podržava S stil "troizraznih" petlji. `Vreak` i `continue` izjave su podržane u petlji.

```javascript
for (var i = 0; i < 5; i++) {
    // ...
}
```


Alternativno, moguće je ponoviti preko svih ključeva jednog niza.

```javascript
for (var key in array) { // takođe radi sa assoc. arrays
  // koristi array[key]
  ...
}
```


### 1995: PHP

```php
for ($i = 0; $i <= 5; $i++)
{
  for ($j = 0; $j <= $i; $j++)
  {
    echo "*";
  }
  echo "<br />";
}
```


### 1995: Ruby

```ruby
for broj in 1..5
  # izjave
end

5.times do |broj| # broj se ponavlja od 0 do 4
  # izjave
end

1.upto(5) do |broj|
  # izjave
end
```


### 1996: OCaml
Pogledajte sintaksu izraza.

```ocaml
(* for_izjava := "for" ident '='  expr  ( "to" ∣  "downto" ) expr "do" expr "done" *)

for i = 1 to 5 do
    (* izjave *)
  done ;;

for j = 5 downto 0 do
    (* izjave *)
  done ;;
```


### 1998: ActionScript 3

```actionscript3
for (var broj:uint = 1; broj <= 5; broj++){
  //izjava;
}
```


## Implementacija u Interpretiranim programskim jezicima
U interpretiranim programskim jezicima, for petlje mogu biti realizovane na više načina. Često su for petlje direktno prevedene na asembler kao upoređujuća uputstva i uputstva uslovnih skokova. Međutim, to nije uvek tako. U nekim tumačima programskih jezika, for petlje su samo prevedene na while petlje. Na primer, uzmite sledeći Mint/Horchata kod:


```text
for i = 0; i < 100; i++
    print i
end

za svaku stavku sekvence
    štampaj stavku
kraj

/* 'Prevedena tradicionalna for petlja' */
i = 0
while i < 100
    print i
    i++
end

/* 'Prevedena for each petlja' */
SYSTEM_VAR_0000 = 0
while SYSTEM_VAR_0000 < sekvenca.length()
    stavka = sekvenca[SYSTEM_VAR_0000]
    print stavka
    SYSTEM_VAR_0000++
end
```


## Povezano
* Do while petlja
* Forič petlja
* Brojač u petlji
* While petlja

## Reference

## Literatura
*