Forič petlja
<s>Forič petlja (engl.</s><s>For each ili foreach) je programski jezik, idiom , za  prolaženje kroz stavke u zbirci.</s><s>Foreach se obično koristi umesto standardne for izjave.</s><s>Za razliku od drugih for petlji, foreach petlje obično održavaju neizričiti brojač: oni u suštini kažu "uradi ovo svima u ovom setu", više nego "uradi ovo h puta".</s><s>Ovime se izbegava moguća  "greška za jedan" i čini kod lakšim za čitanje .</s><s>U objektno orijentisanim jezicima iterator, čak i ako implicitno, se često koristi kao sredstvo za prolazak.</s>

<s>Sintaksa 
Sintaksa varira među jezicima.</s><s>Najviše se koristi jednostavna reč  for, otprilike ovako:
 for each item in collection:
   do something to item</s>

<s>Jezička podrška 
Neki od jezika sa podrškom za foreach petlje sadrže ABC, ActionScript, Ada, C++11, C#, CFML, Cobra, D, Daplex (jezik upita), ECMAScript, Erlang, Java (još od 1.5, koristi zadržanu reč for za for petlju i  foreach petlju), Javaskript, Objective-C (još od 2.0), ParaSail, Perl, PHP, Pajton, REALbasic, Rubi, Scala, Smalltalk, Svift, Tcl, tcsh, Unix shells, Visual Basic .</s><s>NET and Windows PowerShell.</s><s>Značajni jezici bez foreach su C i C++ pre C++11.</s>

<s>ActionScript 
ActionScript podržava foreach petlje od strane ključa/indeksa i vrednosti:for ( var key:String in someObject ) {
   var value = someObject[key];
   trace( "someObject[" + key + "] = " + someObject[key] );
}</s>

<s>for each ( var value in someArray ) {
   trace( typeof value + " " + value );
}
 Beleška
 someArray može biti bilo koji objekat i someObject može biti niz, ali tipično korišćenje je kako je i prikazano</s>

<s>Ada 
Ada podržava foreach petlje kao deo normalne for petlje.</s><s>Recimo da je H neki niz:for I in X'Range loop
   X (I) := Get_Next_Element;
end loop;
 Beleška
 Ova sintaksa je najčešće korišćena u nizovima, ali će takođe raditi i sa ostalim tipovima kada je potpuna iteracija potrebna
Ada 2012 je generalizovala petlje u foreach petlje za bilo koju vrstu sadržine (nizove, liste, mape,...):for Obj of X loop
   -- Work on Obj
end loop;</s>

<s>C 
C jezik nema zbirke ili foreach konstrukcije.</s><s>Ona, međutim, ima veliki broj standardnih strukturnih podataka koji mogu biti teški kao zbirke, i foreach mogu biti lako napravljene sa makroom.</s>

<s>Međutim, postoje dva očigledna problema:
 Makro je higijenski neispravan - on deklariše novu vrednost u postojećem obimu koji preostaje nakon petlje.</s><s>Ne možete se definisati jedinstveni foreach makro koji radi sa različitim tipovima zbirke (npr. niz i povezana lista) ili koji se može proširiti na tipove korisnika.</s><s>C niska kao zbirka članova:#include <stdio.h>
#include <stdlib.h>
/* forič makro za korišćenje niske kao kolekcije karaktera */
#define foreach( ptrvar, strvar ) char* ptrvar; for( ptrvar=strvar ; (*ptrvar) != '\0' ; *ptrvar++)</s>

<s>int main(int argc,char* argv[]){
 char* s1 = "abcdefg";
 char* s2 = "123456789";
 foreach (p1, s1) {
  printf("loop 1 %c\n",*p1);
 }
 foreach (p2, s2){
  printf("loop 2 %c\n",*p2);
 }
 exit(0);
 return(0);
}C int niz kao zbirka od int (niz veličine poznat prilikom kompilacije)#include <stdio.h>
#include <stdlib.h>
int main(int argc, char* argv[]){
/* forič makro vidi niz celobrojnih vrednosti kao zbirku celobrojnih vrednosti */
#define foreach( intpvar, intary ) int* intpvar; for( intpvar=intary; intpvar < (intary + (sizeof(intary)/sizeof(intary[0]))) ; intpvar++)
 int a1[] = { 1, 1, 2, 3, 5, 8 };
 int a2[] = { 3, 1, 4, 1, 5, 9 };
 foreach (p1, a1) {
  printf("loop 1 %d\n", *p1);
 }
 foreach (p2, a2){
  printf("loop 2 %d\n", *p2);
 }
 exit(0);
 return(0);
}Najčešće: string ili niz kao zbirka (veličina zbirke poznata u vreme pokretanja)
 Beleška: idxtype se može izbrisati i typeof(col[0]) se može koristiti na mestu GCC#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char* argv[]){
#define foreach(idxtype, idxpvar, col, colsiz ) idxtype* idxpvar; for( idxpvar=col ; idxpvar < (col + (colsiz)) ; idxpvar++)
#define arraylen( ary ) ( sizeof(ary)/sizeof(ary[0]) )
 char* c1 = "collection";
 int c2[] = { 3, 1, 4, 1, 5, 9 };
 double* c3;
 int c3len = 4;
 c3 = (double*)calloc(c3len, sizeof(double)); 
 c3[0] = 1.2; c3[1] = 3.4; c3[2] = 5.6; c3[3] = 7.8;</s>

<s>foreach (char, p1, c1, strlen(c1) ) {
  printf("loop 1 : %c\n",*p1);
 }
 foreach (int, p2, c2, arraylen(c2) ){
  printf("loop 2 : %d\n",*p2);
 }
 foreach (double, p3, c3, c3len ){
  printf("loop 3 : %3.1lf\n",*p3);
 }
 exit(0);
 return(0);
}</s>

<s>C# 
Pod pretpostavkom da je myArray  niz celih brojeva:foreach (int x in myArray) { Console.</s><s>WriteLine(x); }LINQ daje sledeću sintaksu, prihvatanje delegata ili lambda ekspresije:myArray.</s><s>ToList().</s><s>ForEach(x => Console.</s><s>WriteLine(x));</s>

<s>C++ 
C++11 daje  forič petlju.</s><s>Sintaksa je slična Javi:#uključuje <iostream></s>

<s>int main()
{
  int myint[] = {1,2,3,4,5};</s>

<s>for (int i : myint)
  {
    std::cout << i << std::endl;
  }
}Trenutno, C++11 opseg zasnovan na izjavama je realizovan u GCC (još u verziji 4.6), jeka (još u verziji 3.0) i Vižual C++ 2012 (verzija 11 )</s>

<s>Qt, C++ okvir, nudi makro  forič petlje koristi STL iterator interfejs:#uključuje <QList>
#uključuje <QDebug></s>

<s>int main()
{
  QList<int> list;</s>

<s>list << 1 << 2 << 3 << 4 << 5;</s>

<s>foreach (int i, list)
  {
    qDebug() << i;
  }
}Boost, set besplatnih portabla sa recenzijom C++ biblioteka takođe pruža foreach petlje:#uključuje <boost/foreach.hpp>
#uključuje<iostream>
 
int main()
{
  int myint[] = {1,2,3,4,5};
 
  BOOST_FOREACH(int &i, myint)
  {
    std::cout << i << std::endl;
  }
}</s>

<s>C++/CLI 
C++/CLI jezika predlaže konstrukciju sličnu C#.</s>

<s>Pretpostavimo da je myArray niz celih brojeva:
    for each (int x in myArray)
    {
        Console::WriteLine(x);
    }</s>

<s>CFML</s>

<s>Script syntax 
// nizovi
arrayeach([1,2,3,4,5], function(v){
    writeOutput(v);
});</s>

<s>// ili</s>

<s>for (v in [1,2,3,4,5]){
    writeOutput(v);
}</s>

<s>// ili</s>

<s>// (Reilo samo; ne podržava u ColdFusion-u)
letters = ["a","b","c","d","e"];
letters.each(function(v){
    writeOutput(v); // abcde
});</s>

<s>// strukture
for (k in collection){
    writeOutput(collection[k]);
}</s>

<s>// ili</s>

<s>structEach(collection, function(k,v){
    writeOutput("key: #k#, value: #v#;");
});</s>

<s>// ili
// (Reilo samo; ne podržava u ColdFusion-u)
collection.each(function(k,v){
    writeOutput("key: #k#, value: #v#;");
});</s>

<s>Tag syntax 
<!--- arrays --->
<cfloop index="v" array="#['a','b','c','d','e']#">
  <cfoutput>#v#</cfoutput><!--- a b c d e  --->
</cfloop>Imati na umu da CFML pogrešno identifikuje vrednost kao "indeks" u ovoj konstrukciji;  index promenljiva prima stvarnu vrednost elementa niza , a ne njegov indeks.<!--- structs --->
<cfloop item="k" collection="#collection#">
    <cfoutput>#collection[k]#</cfoutput>
</cfloop></s>

<s>Common Lisp 
Common Lisp omogućava foreach funkcionalnost sa dolist makro:(dolist (i '(1 3 5 6 8 10 14 17))
  (print i))ili sa mapcar funkcijom:(mapcar #'print '(1 3 5 6 8 10 14 17))</s>

<s>D 
foreach(item; set) {
  // uraditi nešto stavki
}
or
foreach(argument) {
  // propustiti vrednost
}</s>

<s>Dart(programski jezik) 
for (final element in someCollection) {
  // uraditi nešto sa elementom
}</s>

<s>Delphi 
Foreach podrška je dodata u Delphi 2005, i koristi popisivača promenljive koja mora biti deklarisana u var sekciji.for enumerator in collection do
begin
  //uraditi nešto ovde
end;</s>

<s>Ajfel 
Iteracioni (forič) oblik Eiffel petlje uvodi ključ across.</s>

<s>U ovom primeri, svaki element strukture my_list je ištampan:            across my_list as ic loop print (ic.item) endLokalni entitet ic je instanca klase biblioteka ITERATION_CURSOR.</s><s>Funkcija item pruža pristup svakom elementu strukture.</s><s>Potomci klase ITERATION_CURSOR mogu biti kreirani za rukovanje specijalizovanih  iteracija algoritama.</s><s>Vrste objekata koji mogu biti ponovo pronađeni (my_list in the example)su bazirani na klasama koje naslede iz klase biblioteke ITERABLE.</s>

<s>Ponavljanje iz Eiffel petlje se takođe može koristiti kao logičku ekspresija kada je ključna reč loop zamenjena ili saall (vrši univerzalnu kvantifikaciju) ili sa some (vrši egzistencijalnu kvantifikaciju).</s>

<s>Ovo ponavljanje je logička ekspresija koja je tačna ako sve stavke u my_list broje više od tri:            across my_list as ic all ic.item.count > 3 endNastavak je tačan ako barem jedna od stavki broji više od tri :            across my_list as ic some ic.item.count > 3 end</s>

<s>Gou 
Go foreach petlja može se koristiti za petlju preko niza, kriške, niske, mape, ili preko kanala.</s>

<s>Koristeći formu od dve vrednosti, dobijamo indeks/ključ (prvi element) i vrednost (drugi element):for index, value := range someCollection {
	// Uraditi nešto za indeksiranje i vrednosovanje
}Koristeći formu od jedne vrednost, dobijamo indeks/ključ (prvi element):for index := range someCollection {
	// Uraditi nešto indeksu
}</s>

<s>Gruvi 
Groovy podržava for petlje preko zbirki poput nizova, listi i opsega :def x = [1,2,3,4]
for (v in x) // petlja nad 4-elementa niza h
{
    println v
}</s>

<s>for (v in [1,2,3,4]) // petlja nad 4-elementa literalne liste
{
    println v
}</s>

<s>for (v in 1..4) // petlja nad opsegom 1..4
{
    println v
}Groovy takođe podržava  C-stil za petlju sa indeksom niza :for (i = 0; i < x.size(); i++)
{
    println x[i]
}Zbirke u Groovy takođe mogu biti ponovljene korišćenjem ključne reči svaki i zatvaranjem.</s><s>Po podrazumevanom podešavanju, petlja lutka je tako nazvanax.each{ println it } // štampa svaki lementa niza h
x.each{i-> println i} // ekvivalentno liniji ispod, samo lutka petlje eksplicitno nazvana "i"</s>

<s>Haskell 
Petlja preko listi sa  monadic aktivnostima koristi mapM_i  forM_ (mapM_ sa obrnutim argumentima) iz Control.</s><s>Monad:</s>

<s>Takođe je moguće generalizovati te funkcije da rade na aplikativnim funktorima pre nego monade i bilo koje strukture podataka koje prolaze koristeći traverse (for sa obrnutim argumentima) i mapM (forM sa obrnutim argumentima) iz Data.</s><s>Traversable.</s>

<s>Haxe 
for (value in iterable) {
    trace(value);
}</s>

<s>Lambda.iter(iterable, function(value) trace(value));</s>

<s>Java 
Foreach-konstrukcija je uvedena u JDK 1.5.0.</s>

<s>Zvanični izvori koriste nekoliko imena za konstrukciju.</s><s>To se naziva "Poboljšanje za Petlju", "For-Each Petlja", i "foreach izjava".for (type item: iterableCollection) {
    // Uradi nešto stavki
}</s>

<s>Javaskript 
Za ne naređeno ponavljanje nad ključevima u Object, JavaScript karakterišefor...in petlju:for (var key in object) {
    // Raditi nešto sa objektom [ključem]
}Da bi se ograničilo ponavljanje na sopstvenim osobinama objekta, isključujući one nasleđene kroz prototip lanca, ponekad je korisnije dodati hasOwnProperty() test, ako je podržano od strane JavaScript-a(za WebKit/Safari, to znači "u verziji 3 ili kasnije").for (var key in object) {
    if (object.hasOwnProperty(key)) {
        // Raditi nešto sa objektom [ključem]
    }
}U ECMAScript 5 moguće je koristiti metod ključeva funkcije Object da ponovi preko sopstvenih ključeva prirodnije.
var book = { name: "A Christmas Carol", author: "Charles Dickens" }; 
Object.keys(book).forEach(function (key, index) {
    alert("PropertyName = " key + " Property Value = " + book[key]);
}U ECMAScript 5 takođe je moguće koristiti forEach izvornog niza.var animals = ['pas', 'mačka', 'medved'];
animals.forEach(function(animal, index) {
    alert(index + ':' + animal); // '0:pas', '1:mačka', '2:medved'
});Gecko-ov JavaScript endžin takođe ima for each...in izjavu, koja primenjuje preko vrednosti u objektu, a ne preko ključeva.</s>

<s>Imajte na umu da nije preporučljivo koristiti for...in ili for each...in izjavu na niz objekata u  JavaScript-i, zbog gore pomenutog problema imovine nasleđenog od prototipa, kao i zato što on samo primenjuje već postojeće ključeve i ne garantuje da će ponoviti nad elementima u određenom smeru.</s><s>Trebalo bi koristiti redovan S-stil petlje.</s><s>EcmaScript 6 ima for..of   za ponavljanje indeksa nad generatorima, nizovima i više.</s>

<s>MATLAB 
for item = array
%uradi nešto
end</s>

<s>Mint 
For each petlje su podržani u Mintu i poseduju sledeću sintaksu :for each element of list
    /* 'Uradi nešto.' */
endZanimljivo je da for (;;) ili while (true) beskonačna petlja u Mintu može biti napisana koristeći for each petlju i beskonačno dugu listu.import type
/* 'Ova funkcija je takođe mapirana'
 * 'svaki broj indeksa i '
 * 'beskonačno duga lista.'
 */
sub identity(x)
    return x
end
/* 'Sledeće stvara listu'
 * '[0, 1, 2, 3, 4, 5, ..., beskonačnost]'
 */
infiniteList = list(identity)
for each element of infiniteList
    /* 'Radi nešto večno.' */
end</s>

<s>Objective-C 
Foreach petlje, pod nazivom Objective-C, su u početku podržani u Objective-C 2.0.</s><s>Mogu se koristiti da ponavljaju bilo koji objekat koji iplementira NSFastEnumeration protokol, uključujući i NSArray, NSDictionary (vrši ponavljanje preko ključeva), NSSet, etc.</s><s>NSArray *a = [NSArray new]; // Bilo koja klasa sadržine može biti supstituisana
for(id obj in a) { // Imati na umu da dinamično kucanje (ne moramo da znamo
                                  // Tip objektna koji je sačuvan u 'a'.</s><s>Ustvari, može biti
                                  // mnogo različitih tipova objekta u redu.</s>

<s>printf("%s\n", [[obj description] UTF8String]);  // Najviše se koristi UTF8String sa %s
    NSLog(@"%@", obj);                               // Izlazi kao objekat
}NSArrays mogu takođe da emituju poruku njihovim članovima:NSArray *a = [NSArray new];</s>

<s>[a makeObjectsPerformSelector:@selector(printDescription)];Gde su blokovi dostupni, NSArray može automatski da izvrši blokadu nad sadržanom stavkom:[myArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop)
	{
		NSLog(@"obj %@", obj);
		if ([obj shouldStopIterationNow])
			*stop = YES;
	}];Tip kolekcije koji se ponavlja će diktirati stavku koja će se vraćati prilikom svakog ponavljanja.</s><s>Na primer:NSDictionary *d = [NSDictionary new];</s>

<s>for(id key in d) {
    NSObject *obj = [d objectForKey:key];      // Koristimo (jedinstven) ključ kako bi se pristupilo (moguće nejednistvenom) objektu.</s><s>NSLog(@"%@", obj);
}</s>

<s>OCaml 
Još od kad je OCaml Funkcionalno programiranje, jednakost foreach petlje se može postići pomoću funkcije biblioteke nad listama i nizovima.</s>

<s>For Liste:List.iter (fun x -> print_int x) [1;2;3;4];; ili kraće:List.iter print_int [1;2;3;4];; For Nizovi:Array.iter (fun x -> print_int x) [|1;2;3;4|];;ili kraće:Array.iter print_int [|1;2;3;4|];;</s>

<s>ParaSail 
ParaSail paralelno programskom jeziku podržava nekoliko vrsti iteratora, uključujući i opšti  "for ič" iterator nad sadrživačem:var Con : Container<Element_Type> := ...
// ...
for each Elem of Con concurrent loop // petlja takođe može biti "napredna" ili "nazadujuća" ili neodređena (podrzumevana)
  // ... raditi nešto sa Elem
end loopParaSail takođe podržava filtere nad iteratorima, kao i mogućnost da se poziva i na ključ i na vrednost mape.</s><s>Ovde iteracija nad elementima  "My_Map" bira samo one elemente kod kojih su ključevi u "My_Set":var My_Map : Map<Key_Type => Univ_String, Value_Type => Tree<Integer>> := ...
const My_Set : Set<Univ_String> := ["abc", "def", "ghi"];</s>

<s>for each [Str => Tr] of My_Map {Str in My_Set} forward loop
   // ... raditi nešto sa Str ili Tr
end loop</s>

<s>Paskal 
ISO 10206:1990 standard je predstavio iteraciju preko određene vrste u Pascal-u:var
  elt: ElementType;
  eltset: set of ElementType;</s>

<s>{...}</s>

<s>for elt in eltset do
  { ... uraditi nešto sa elt }</s>

<s>Perl 
U Perl programskom jeziku, forič (što je ekvivalentno kraćem for ) može se koristiti za prebacivanje elemenata liste.</s><s>Izraz koji označava zbiku petlje se ocenjuje u listu konteksta i svaka stavka rezultata liste je, zauzvrat, šifrovan za vrednost petlje.</s>

<s>Bukvalni primer liste:foreach (1, 2, 3, 4) {
    print $_;
}Primer niza:foreach (@arr) {
    print $_;
}foreach $x (@arr) { #$x je element u @arr
    print $x;
} Heš primer:foreach $x (keys %hash) {
    print $x . " = " . $hash{$x}; # $x je ključ u %hash i $hash{$x} je njegova vrednost
}Direktna modifikacija članova zbirke:@arr = ( 'remove-foo', 'remove-bar' );
foreach $x (@arr){
    $x =~ s/remove-//;
}
# Sada @arr = ('foo', 'bar');</s>

<s>PHP 
 
foreach ($set as $value)
{
    // Uraditi nešto nad $value;
}Takođe je moguće ekstraktovati oba ključa i vrednosti koristeći se alternativnom sintaksom:foreach ($set as $key => $value) {
    echo "{$key} ima vrednost od {$value}";
}Direct modification of collection members:$arr = array(1, 2, 3);
foreach ($arr as &$value) { // Primetiti &, $value je referenca originalne vrednosti unutar $arr
    $value++;
}
// Sada $arr = array(2, 3, 4);</s>

<s>// takođe radi sa potpunom sintaksom
foreach ($arr as $key => &$value) {
    $value++;
}</s>

<s>Pajton 
for item in iterable_collection:
    # uraditi nešto sa stavkomPajtonov zadatak torki, u potpunosti dostupan u  foreach petlji, takođe čini trivijalno ponavljanje nad (ključ, vrednost) parovima u asocijativnom nizu:for key, value in some_dict.items(): # direct iteration on a dict iterates on its keys
    # radi neštoŠto se tiče for ... in je jedina vrsta petlji u Python-u, ekvivalentna "kontra" petlji pronađenoj u drugim jezicima ...for i in range(len(seq)):
    # radi nešto sa seq[i]... mada koristi enumerate funkciju, koja se smatra "Pythonic":for i, item in enumerate(seq):
    # radi nešto sa stavkom
    # moguće je da dodeljuje seq[i]</s>

<s>Racket 
(for ([item set])
  (do-something-with item))ili koristeći konvencijalnu šemu for-each funkcije:(for-each do-something-with a-list)do-something-withje jedan-argument funkcija.</s>

<s>Rubi 
set.each do |item|
  # uraditi nešto stavki
endilifor item in set
  # uraditi nešto stavki
endTakođe možete koristiti sa crtom.set.each do |item,value|
  # uraditi nešto stavki
  # uraditi nešto nad vrednosti
end</s>

<s>Scala 
// vraća listu modifikovanih elemenata
items map { x => doSomething(x) }
items map multiplyByTwo</s>

<s>for {x <- items} yield doSomething(x)
for {x <- items} yield multiplyByTwo(x)</s>

<s>// ne vraća ništa, samo izvršava akciju
items foreach { x => doSomething(x) }
items foreach println</s>

<s>for {x <- items} doSomething(x)
for {x <- items} println(x)</s>

<s>Scheme 
(for-each do-something-with a-list)do-something-with je jedan-argument funkcija.</s>

<s>Smalltalk 
collection do: [:item| "do something to item" ]</s>

<s>Svift 
Swift koristi for…in konstrukcija za ponavljanje kroz članove zbirke.for thing in someCollection {
    // radi nešto sa stvari
} for…in petlja se često koristi sa zatvorenim i otvorenim intervalima za ponavljanje kroz telo petlje određeni broj puta.for i in 0..</s><s><10 {
    // 0..</s><s><10 konstruiše polu-otvoreni interval, tako da je telo petlje
    // ponovljeno za i = 0, i = 1, …, i = 9.
}</s>

<s>for i in 0...10 {
    // 0...10 konstruiše zatvoreni interval, tako da je telo petlje
    // ponovljeno za i = 0, i = 1, …, i = 9, i = 10.
}</s>

<s>SystemVerilog 
SystemVerilog ima podršku za ponavljanje nad nekim vektorom ili nizom bilo kojih dimenzija koristeći reč foreach.</s>

<s>Trivijalni primer ponavljanja nad nizom celih brojeva je:</s>

<s>Složeniji primer ponavljanja nad asocijativnim nizom nizova celih brojeva :</s>

<s>Tcl 
Tcl koristi foreach za ponavljanje nad listama.</s><s>Moguće je navesti više od jednog iteratora promenljive, u čijem slučaju su dodeljene uzastopne vrednosti iz liste.</s>

<s>Takođe je moguće ponavljanje nad više od jedne liste istovremeno .</s><s>U nastavku  i preuzima niz navedenih vrednosti prve liste, j niz vrednosti druge liste:</s>

<s>Visual Basic .</s><s>NET 
For Each item In enumerable
    ' Radi nešto sa stavkom.</s><s>Nextili bez vrste zaključivanja:For Each item As type In enumerable
    ' Radi nešto sa stavkom.</s><s>Next</s>

<s>Windows PowerShell 
foreach ($item in $set) {
    # Radi nešto sa $item
}Iz pajplajna$list | ForEach-Object {Write-Host $_}</s>

<s>XSL 
 <xsl:for-each select="set">
   <!-- radi nešto za elemente u <set> -->
 </xsl:for-each></s>

<s>Vidi još 
 Do while petlja 
 For petlja
 While petlja 
 Map (funkcija viših naredba)</s>

<s>Reference</s>

<s>Kontrola toka</s>

