Foreach petlja

For each petlje se najčešće koriste da ponove stavke u nizu elemenata .

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

Forič petlja (engl. For each ili foreach) je programski jezik, idiom , za  prolaženje kroz stavke u zbirci. Foreach se obično koristi umesto standardne for izjave. 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". Ovime se izbegava moguća  "greška za jedan" i čini kod lakšim za čitanje . U objektno orijentisanim jezicima iterator, čak i ako implicitno, se često koristi kao sredstvo za prolazak.

Sintaksa

Sintaksa varira među jezicima. Najviše se koristi jednostavna reč  for, 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, 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 .NET and Windows PowerShell. Značajni jezici bez foreach su C i C++ pre C++11.

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] );
}

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

Ada

Ada podržava foreach petlje kao deo normalne for petlje. 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;

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:

#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++)

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;

 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);
}

C#

Pod pretpostavkom da je myArray  niz celih brojeva:

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

LINQ daje sledeću sintaksu, prihvatanje delegata ili lambda ekspresije:

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

C++

C++11 daje  forič petlju. Sintaksa je slična Javi:

#uključuje <iostream>

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

  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 ) Qt, C++ okvir, nudi makro  forič petlje koristi STL iterator interfejs:

#uključuje <QList>
#uključuje <QDebug>

int main()
{
  QList<int> list;

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

  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;
  }
}

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

// 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#;");
});

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>

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

D

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

Dart(programski jezik)

for (final element in someCollection) {
  // uraditi nešto sa elementom
}

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;

Ajfel

Iteracioni (forič) oblik Eiffel petlje uvodi ključ across.

U ovom primeri, svaki element strukture my_list je ištampan:

            across my_list as ic loop print (ic.item) end

Lokalni entitet ic je instanca klase biblioteka ITERATION_CURSOR. Funkcija item pruža pristup svakom elementu strukture. Potomci klase ITERATION_CURSOR mogu biti kreirani za rukovanje specijalizovanih  iteracija algoritama. Vrste objekata koji mogu biti ponovo pronađeni (my_list in the example)su bazirani na klasama koje naslede iz klase biblioteke ITERABLE.

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

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 end

Nastavak je tačan ako barem jedna od stavki broji više od tri :

            across my_list as ic some ic.item.count > 3 end

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

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
}

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
}

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
}

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. Po podrazumevanom podešavanju, petlja lutka je tako nazvana

x.each{ println it } // štampa svaki lementa niza h
x.each{i-> println i} // ekvivalentno liniji ispod, samo lutka petlje eksplicitno nazvana "i"

Haskell

Petlja preko listi sa  monadic aktivnostima koristi mapM_i  forM_ (mapM_ sa obrnutim argumentima) iz Control.Monad:

kod	štampa
mapM_ print [1..4]	1 2 3 4
forM_ "test" $ \char -> do putChar char putChar char	tteesstt

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

Haxe

for (value in iterable) {
    trace(value);
}

Lambda.iter(iterable, function(value) trace(value));

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

for (type item: iterableCollection) {
    // Uradi nešto stavki
}

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.

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. Trebalo bi koristiti redovan S-stil petlje. EcmaScript 6 ima for..of   za ponavljanje indeksa nad generatorima, nizovima i više.

MATLAB

for item = array
%uradi nešto
end

Mint

For each petlje su podržani u Mintu i poseduju sledeću sintaksu :

for each element of list
    /* 'Uradi nešto.' */
end

Zanimljivo 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

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.

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
}

NSArrays mogu takođe da emituju poruku njihovim članovima:

NSArray *a = [NSArray new];

[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. Na primer:

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);
}

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:

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|];;

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 loop

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

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

Paskal

ISO 10206:1990 standard je predstavio iteraciju preko određene vrste u Pascal-u:

var
  elt: ElementType;
  eltset: set of ElementType;

{...}

for elt in eltset do
  { ... uraditi nešto sa elt }

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:

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');

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

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

Pajton

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:

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]

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.

Rubi

set.each do |item|
  # uraditi nešto stavki
end

ili

for item in set
  # uraditi nešto stavki
end

Takođe možete koristiti sa crtom.

set.each do |item,value|
  # uraditi nešto stavki
  # uraditi nešto nad vrednosti
end

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

(for-each do-something-with a-list)

do-something-with je jedan-argument funkcija.

Smalltalk

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

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

kod	štampa
int array_1d[] = '{ 3, 2, 1, 0 }; foreach array_1d[index] $display("array_1d[%0d]: %0d", index, array_1d[index]);	array_1d[0]: 3 array_1d[1]: 2 array_1d[2]: 1 array_1d[3]: 0

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

kod	štampa
int array_2d[string][] = '{ "tens": '{ 10, 11 }, "twenties": '{ 20, 21 } }; foreach array_2d[key,index] $display("array_2d[%s,%0d]: %0d", key, index, array_2d[key,index]);	array_2d[tens,0]: 10 array_2d[tens,1]: 11 array_2d[twenties,0]: 20 array_2d[twenties,1]: 21

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.

kod	štampa
foreach {i j} {1 2 3 4 5 6} { puts "$i $j" }	1 2 3 4 5 6

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:

kod	štampa
foreach i {1 2 3} j {a b c} { puts "$i $j" }	1 a 2 b 3 c

Visual Basic .NET

For Each item In enumerable
    ' Radi nešto sa stavkom.
Next

ili bez vrste zaključivanja:

For Each item As type In enumerable
    ' Radi nešto sa stavkom.
Next

Windows PowerShell

foreach ($item in $set) {
    # Radi nešto sa $item
}

Iz pajplajna

$list | ForEach-Object {Write-Host $_}

XSL

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

Vidi još

• Do while petlja 
• For petlja
• While petlja 
• Map (funkcija viših naredba)