dijagram protoka for petlje

| Konstrukcije petlji |
| --- |
| Do while petlja |
| While petlja |
| For petlja |
| Foreach petlja |
| Beskonačna petlja |
| Kontrola toka |

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 for, 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 **für**, korišćene u *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

*Glavni članak: Forič petlja*
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:

```
 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:

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

```

Ovaj stil se koristi umesto beskonačne `while (1)` petlje da bi se izbeglo upozorenje u nekim S/S++ komplajerima. Neki programeri vole više jezgrovitu `for (;;)` formu nego semantički ekvivalentnu ali opširniju `while (tačno)` 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:

```
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:

```
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:

```
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 <= 5
    faktorijel = faktorijel * broj
    broj = broj + 1
```

Ovaj prevod je malo komplikovan za jezike koji dozvoljavaju skakanje do novog ponavljanja u petlji (kao continue izjava u S-u). Ove izjave će obično implicitno povećavati broj petlje, ali ne i ekvivalent while petlje (jer u ovom drugom slučaju broj nije sastavni deo konstrukcije petlje). Bilo koji prevod će morati da stavi sve izjave unutar bloka koji eksplicitno povećava broj pre pokretanja izjave.

Hronologija sintakse for petlje u raznim programskim jezicima
-------------------------------------------------------------

Na osnovu akcije koja mora biti ponovljena, na primer, pet puta, različiti jezici će for petlju napisati drugačije. Sintaksa za tri izraza for petlje je skoro identična u svim jezicima koji ga imaju, nakon različitih stilova bloka-kraj petlje i tako dalje.

### 1957: FORTRAN

Dok koristite ključnu reč do umesto for, ovaj tip FORTRAN-ove do petlje se ponaša slično kao troargumentna for petlja u ostalim jezicima. Ovaj primer se ponaša isto kao ostali, inicijalizujući broj promenljive na 1, uvećavajući je za 1 u svakoj interaciji petlje i stopirati kada dostigne vrednost 5.

```
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:

```
 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)

```
! 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:

```
 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.

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

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

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

```

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

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

```

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

### 1972: C/C++

|  |  |
| --- | --- |
|  | *Za više informacija pogledajte članak **C sintakse#Naredbe ponavljanja*** |

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

```

Izjava je obično blok izjava; primer ovoga je:

```
//Korišćenje for petlji za dodavanje brojeva 1 - 5
int sum = 0;
for (int i = 1; i < 6; ++i) {
 sum += i;
}

```

### 1972: 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

```
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:

```
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:

```
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.

```
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.

```
5 { IZJAVE } repeat

```

### 1983: Ada 83 i iznad

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

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

```

### 1987: 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. 

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

```

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

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

```

### 1989: 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

```

```
# 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

```
forM\_ [1..5] $ \indx -> do izjave

```

ili da svakim novim izdanjem rezultat bude kao u listi

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

```
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:

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

```

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

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

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

```

### 1993: 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:

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

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

```

Dakle, ovaj kod 

```
for i = 1, 5, 2 do
     print(i)
end

```
 će ispisati:

```
1 3 5

```

For petlje mogu takođe da idu kroz tabelu korišćenjem 

```
ipairs()

```
 da brojčano ponovi kroz nizove i 

```
pairs()

```
 da nasumice prelazili preko rečnika.

Generisana for petlja pravi zatvaranja:

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

```

### 1995: CFML

#### Skript sintaksa

Jednostavan indeks petlje:

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

```

Koristeći niz:

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

```

Korišćenjem "liste" vrednosti niski:

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

```

#### Tag sintaksa

Jednostavan indeks petlje:

```
<cfloop index="i" from="1" to="5">
	<!--- izjave --->
</cfloop>

```

Koristeći niz:

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

```

Korišćenjem "liste" vrednosti niski:

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

```

### 1995: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.

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

```

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

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

```

### 1995: PHP

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

```

### 1995: 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.

```
 (\* 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

```
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:

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

```

Vidi još
--------

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

Literatura
----------

* *PostScript Language Reference*. Addison-Wesley Publishing Company. str. 596. ISBN 978-0-201-37922-8.