Foreach petlja

U računarskom programiranju, ***foreach*** ili ***for-each'' petlja''' je [[Naredba (programiranje)|naredba]] za prolaženje kroz stavke u [[Kolekcija (programiranje)|kolekciji]]. Za razliku od drugih [[for petlja|for petlji]], foreach petlje obično ne održavaju izričiti brojač: oni u suštini kažu "uradi ovo svima u ovom setu", umjesto "uradi ovo ''n'' puta". Ovime se izbegava moguća [[Greška za jedan|"greška za jedan"]] i čini kod lakšim za čitanje.

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

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

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

for each ( var value in someArray ) {
   trace( typeof value + " " + value );
}
</syntaxhighlight>
; 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

=== [[Ada (programski jezik)|Ada]] ===
Ada podržava foreach petlje kao deo normalne [[For petlja|for petlje]]. Recimo da je H neki [[Niz (struktura podataka)|niz]]:<syntaxhighlight lang="Ada">
for I in X'Range loop
   X (I) := Get_Next_Element;
end loop;
</syntaxhighlight>
; 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,...):<syntaxhighlight lang="Ada">
for Obj of X loop
   -- Work on Obj
end loop;
</syntaxhighlight>

=== [[C (programski jezik)|C]] ===
C jezik nema zbirke ili foreach konstrukcije. Ona, međutim, ima veliki broj standardnih strukturnih podataka koji mogu biti teški kao zbirke, i foreach mogu biti lako napravljene sa [[makroom]].

Međutim, postoje dva očigledna problema:
* Makro je higijenski neispravan - on deklariše novu vrednost u postojećem obimu koji preostaje nakon petlje.
* 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.
C niska kao zbirka članova:
<syntaxhighlight lang="c" highlight="4-6" line>
#include <stdio.h>

/* foreach macro viewing a string as a collection of char values */
#define foreach(ptrvar, strvar) \
char* ptrvar; \
for (ptrvar = strvar; (*ptrvar) != '\0'; *ptrvar++)

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);
 }
 return 0;
}
</syntaxhighlight>
C int niz kao zbirka od int (niz veličine poznat prilikom kompilacije)
<syntaxhighlight lang="c" highlight="4-6" line>
#include <stdio.h>

/* foreach macro viewing an array of int values as a collection of int values */
#define foreach(intpvar, intarr) \
int* intpvar; \
for (intpvar = intarr; intpvar < (intarr + (sizeof(intarr)/sizeof(intarr[0]))); ++intpvar)

int main(int argc, char** argv) {
 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);
 }
 return 0;
}
</syntaxhighlight>
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 [[GNU kolekcija kompajlera|GCC]]''
<syntaxhighlight lang="c" highlight="5-8" line>
#include <stdio.h>
#include <string.h>

/* foreach macro viewing an array of given type as a collection of values of given type */
#define arraylen(arr) (sizeof(arr)/sizeof(arr[0]))
#define foreach(idxtype, idxpvar, col, colsiz) \
idxtype* idxpvar; \
for (idxpvar = col; idxpvar < (col + colsiz); ++idxpvar)

int main(int argc, char** argv) {
 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;

 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: %.1lf\n", *p3);
 }
 return 0;
}
</syntaxhighlight>

=== [[C Sharp|C#]] ===
Pod pretpostavkom da je myArray  niz celih brojeva:<syntaxhighlight lang="csharp">

foreach (int x in myArray) { Console.WriteLine(x); }

</syntaxhighlight>[[LINQ]] daje sledeću sintaksu, prihvatanje [[Delegat (CLI)|delegata]] ili [[Anonimna funkcija|lambda ekspresije]]:<syntaxhighlight lang="csharp">

myArray.ToList().ForEach(x => Console.WriteLine(x));

</syntaxhighlight>

=== [[C++]] ===
[[Nacrt C++0x od marta 2010.|C++11]] daje  forič petlju. Sintaksa je slična Javi:<syntaxhighlight lang="Cpp">
#uključuje <iostream>

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

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

[[Qt]], C++ okvir, nudi makro  forič petlje koristi STL iterator interfejs:<syntaxhighlight lang="Cpp">
#uključuje <QList>
#uključuje <QDebug>

int main()
{
  QList<int> list;

  list << 1 << 2 << 3 << 4 << 5;

  foreach (int i, list)
  {
    qDebug() << i;
  }
}</syntaxhighlight>[[Boost]], set besplatnih portabla sa recenzijom C++ biblioteka takođe pruža foreach petlje:<syntaxhighlight lang="Cpp">
#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;
  }
}
</syntaxhighlight>

=== C++/CLI ===
C++/CLI jezika predlaže konstrukciju sličnu C#.

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

=== CFML ===

==== Script syntax ====
<syntaxhighlight lang="javascript">
// nizovi
arrayeach([1,2,3,4,5], function(v){
    writeOutput(v);
});

// ili

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

// ili

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

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

// ili

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

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

==== Tag syntax ====
<syntaxhighlight lang="CFM">

<cfloop index="v" array="#['a','b','c','d','e']#">
  <cfoutput>#v#</cfoutput>
</cfloop>
</syntaxhighlight>Imati na umu da CFML pogrešno identifikuje vrednost kao "indeks" u ovoj konstrukciji;  <code>index</code> promenljiva prima stvarnu vrednost elementa niza , a ne njegov indeks.<syntaxhighlight lang="CFM">

<cfloop item="k" collection="#collection#">
    <cfoutput>#collection[k]#</cfoutput>
</cfloop>
</syntaxhighlight>

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

=== [[D (programski jezik)|D]] ===
<syntaxhighlight lang="D">
foreach(item; set) {
  // uraditi nešto stavki
}
or
foreach(argument) {
  // propustiti vrednost
}
</syntaxhighlight>

=== [[Dart(programski jezik)]] ===
<syntaxhighlight lang="Java">
for (final element in someCollection) {
  // uraditi nešto sa elementom
}
</syntaxhighlight>

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

=== [[Ajfel (programski jezik)|Ajfel]] ===
Iteracioni (forič) oblik Eiffel petlje uvodi ključ <code lang="Eiffel">across</code>.

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

Ponavljanje iz Eiffel petlje se takođe može koristiti kao logičku ekspresija kada je ključna reč <code>loop</code> zamenjena ili sa<code>all</code> (vrši [[Univerzalna kvantifikacija|univerzalnu kvantifikaciju]]) ili sa <code>some</code> (vrši [[Egzistencijalna kvantifikacija|egzistencijalnu kvantifikaciju]]).

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

=== [[Gou]] ===
Go foreach petlja može se koristiti za petlju preko niza, kriške, niske, mape, ili preko kanala.

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

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

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

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

=== [[Haskel (programski jezik)|Haskell]] ===
Petlja preko listi sa  [[monadic]] aktivnostima koristi <code>mapM_</code>i  <code>forM_</code> (<code>mapM_</code> sa obrnutim argumentima) iz [http://hackage.haskell.org/package/base-4.6.0.1/docs/Control-Monad.html Control.][http://hackage.haskell.org/package/base-4.6.0.1/docs/Control-Monad.html Monad]:

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 <code>traverse</code> (<code>for</code> sa obrnutim argumentima) i <code>mapM</code> (<code>forM</code> sa obrnutim argumentima) iz [http://hackage.haskell.org/package/base-4.6.0.1/docs/Data-Traversable.html Data.][http://hackage.haskell.org/package/base-4.6.0.1/docs/Data-Traversable.html Traversable].

=== [[Haxe]] ===
<syntaxhighlight lang="actionscript">
for (value in iterable) {
    trace(value);
}

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

=== [[Java (programski jezik)|Java]] ===
Foreach-konstrukcija je uvedena u JDK 1.5.0.

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

=== [[Javaskript]] ===
Za ne naređeno ponavljanje nad ključevima u Object, JavaScript karakteriše<code>for...in</code> petlju:<syntaxhighlight lang="JavaScript">
for (var key in object) {
    // Raditi nešto sa objektom [ključem]
}
</syntaxhighlight>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, [[Poređenje rasporeda endžina (za ECMASkript)|ako je podržano od strane JavaScript-a]](za WebKit/Safari, to znači "u verziji 3 ili kasnije").<syntaxhighlight lang="JavaScript">
for (var key in object) {
    if (object.hasOwnProperty(key)) {
        // Raditi nešto sa objektom [ključem]
    }
}
</syntaxhighlight>U [[ECMAScript 5]] moguće je koristiti metod ključeva funkcije Object da ponovi preko sopstvenih ključeva prirodnije.
<syntaxhighlight lang="JavaScript">
var book = { name: "A Christmas Carol", author: "Charles Dickens" }; 
Object.keys(book).forEach(function (key, index) {
    alert("PropertyName = " key + " Property Value = " + book[key]);
}
</syntaxhighlight>U ECMAScript 5 takođe je moguće koristiti <code>forEach</code> izvornog niza.<syntaxhighlight lang="JavaScript">
var animals = ['pas', 'mačka', 'medved'];
animals.forEach(function(animal, index) {
    alert(index + ':' + animal); // '0:pas', '1:mačka', '2:medved'
});
</syntaxhighlight>Gecko-ov JavaScript endžin takođe ima <code>for each...in</code> izjavu, koja primenjuje preko vrednosti u objektu, a ne preko ključeva.

Imajte na umu da nije preporučljivo koristiti <code>for...in</code> ili <code>for each...in</code> 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. Trebalo bi koristiti redovan S-stil petlje. EcmaScript 6 ima ***for..of  ** ''za ponavljanje indeksa nad generatorima, nizovima i više.

=== [[MATLAB]] ===
<syntaxhighlight lang="MATLAB">
for item = array
%uradi nešto
end
</syntaxhighlight>

=== Mint ===
For each petlje su podržani u Mintu i poseduju sledeću sintaksu :<syntaxhighlight lang="Ruby">
for each element of list
    /* 'Uradi nešto.' */
end
</syntaxhighlight>Zanimljivo je da <code>for (;;)</code> ili <code>while (true)</code> [[beskonačna petlja]] u Mintu može biti napisana koristeći for each petlju i [[beskonačno dugu listu]].<syntaxhighlight lang="Ruby">
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
</syntaxhighlight>

=== [[Objective-C]] ===
Foreach petlje, pod nazivom [[Objective-C]], su u početku podržani u Objective-C 2.0. 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.<syntaxhighlight lang="ObjC">
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'. Ustvari, može biti
                                  // mnogo različitih tipova objekta u redu.

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

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

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

=== [[OCaml]] ===
Još od kad je OCaml [[Funkcionalno programiranje]], jednakost foreach petlje se može postići pomoću funkcije biblioteke nad listama i nizovima.

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

=== [[ParaSail]] ===
ParaSail paralelno programskom jeziku podržava nekoliko vrsti iteratora, uključujući i opšti  "for ič" iterator nad sadrživačem:<syntaxhighlight lang="text">
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 loop
</syntaxhighlight>ParaSail takođe podržava filtere nad iteratorima, kao i mogućnost da se poziva i na ključ i na vrednost mape. Ovde iteracija nad elementima  "My_Map" bira samo one elemente kod kojih su ključevi u "My_Set":<syntaxhighlight lang="text">
var My_Map : Map<Key_Type => Univ_String, Value_Type => Tree<Integer>> := ...
const My_Set : Set<Univ_String> := ["abc", "def", "ghi"];

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

=== [[Paskal (programski jezik)|Paskal]] ===
ISO 10206:1990 standard je predstavio iteraciju preko [[Paskal (programski jezik)|određene vrste]] u Pascal-u:<syntaxhighlight lang="Pascal">
var
  elt: ElementType;
  eltset: set of ElementType;

{...}

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

=== [[Perl (programski jezik)|Perl]] ===
U Perl programskom jeziku, **forič''' (što je ekvivalentno kraćem for ) može se koristiti za prebacivanje elemenata liste. Izraz koji označava zbiku petlje se ocenjuje u listu konteksta i svaka stavka rezultata liste je, zauzvrat, šifrovan za vrednost petlje.

Bukvalni primer liste:
```perl
foreach (1, 2, 3, 4) {
    print $_;
}
```
Primer niza:
```perl
foreach (@arr) {
    print $_;
}
```

```perl
foreach $x (@arr) { #$x je element u @arr
    print $x;
}
```
Heš primer:
```perl
foreach $x (keys %hash) {
    print $x . " = " . $hash{$x}; # $x je ključ u %hash i $hash{$x} je njegova vrednost
}
```
Direktna modifikacija članova zbirke:
```perl
@arr = ( 'remove-foo', 'remove-bar' );
foreach $x (@arr){
    $x =~ s/remove-//;
}
# Sada @arr = ('foo', 'bar');
```


### [[PHP]]

```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:
```php
foreach ($set as $key => $value) {
    echo "{$key} ima vrednost od {$value}";
}
```
Direct modification of collection members:
```php
$arr = array(1, 2, 3);
foreach ($arr as &$value) { // Primetiti &, $value je referenca originalne vrednosti unutar $arr
    $value++;
}
// Sada $arr = array(2, 3, 4);

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


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

```python
for item in iterable_collection:
    # uraditi nešto sa stavkom
```
Pajtonov zadatak torki, u potpunosti dostupan u  foreach petlji, takođe čini trivijalno ponavljanje nad (ključ, vrednost) parovima u asocijativnom nizu:
```python
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 ...
```python
for i in range(len(seq)):
    # radi nešto sa seq[i]
```
... mada koristi `enumerate` funkciju, koja se smatra "Pythonic":
```python
for i, item in enumerate(seq):
    # radi nešto sa stavkom
    # moguće je da dodeljuje seq[i]
```


### [[DrScheme|Racket]]

```scheme
(for ([item set])
  (do-something-with item))
```
ili koristeći konvencijalnu šemu `for-each` funkcije:
```scheme
(for-each do-something-with a-list)
```
`do-something-with`je jedan-argument funkcija.

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

```ruby
set.each do |item|
  # uraditi nešto stavki
end
```
ili
```ruby
for item in set
  # uraditi nešto stavki
end
```
Takođe možete koristiti sa crtom.
```ruby
set.each do |item,value|
  # uraditi nešto stavki
  # uraditi nešto nad vrednosti
end
```


### [[Skala (programski jezik)|Scala]]

```scala
// vraća listu modifikovanih elemenata
items map { x => doSomething(x) }
items map multiplyByTwo

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

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

for {x <- items} doSomething(x)
for {x <- items} println(x)
```


### [[Scheme]]

```scheme
(for-each do-something-with a-list)
```
`do-something-with` je jedan-argument funkcija.

### [[Smalltalk]]

```smalltalk
collection do: [:item| "do something to item" ]
```


### [[Svift (programski jezik)|Svift]]
Swift koristi `for`…`in` konstrukcija za ponavljanje kroz članove zbirke.
```objc
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.
```objc
for i in 0..<10 {
    // 0..<10 konstruiše polu-otvoreni interval, tako da je telo petlje
    // ponovljeno za i = 0, i = 1, …, i = 9.
}

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


### [[SystemVerilog]]
SystemVerilog ima podršku za ponavljanje nad nekim vektorom ili nizom bilo kojih dimenzija koristeći reč `foreach`.

Trivijalni primer ponavljanja nad nizom celih brojeva je:

Složeniji primer ponavljanja nad asocijativnim nizom nizova celih brojeva :

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

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

### [[Visual Basic .NET]]

```vbnet
For Each item In enumerable
    ' Radi nešto sa stavkom.
Next
```
ili bez vrste zaključivanja:
```vbnet
For Each item As type In enumerable
    ' Radi nešto sa stavkom.
Next
```


### [[Windows PowerShell]]

```powershell
foreach ($item in $set) {
    # Radi nešto sa $item
}
```
Iz pajplajna
```powershell
$list | ForEach-Object {Write-Host $_}
```


### [[XSL]]

```xml
<xsl:for-each select="set">
   
 </xsl:for-each>
```


## Povezano
* Do while petlja 
* For petlja
* While petlja 
* Map (funkcija viših naredba)

## Reference