Per ogni ciclo - Foreach loop

I cicli For each sono quasi sempre utilizzati per scorrere gli elementi in una sequenza di elementi.

Il ciclo Foreach (o per ogni ciclo ) è un'istruzione del flusso di controllo per l'attraversamento degli elementi in una raccolta . Foreach viene solitamente utilizzato al posto di un'istruzione for loop standard . A differenza di altri costrutti del ciclo for, tuttavia, i cicli foreach di solito non mantengono alcun contatore esplicito: essenzialmente dicono "fai questo a tutto in questo set", piuttosto che "fai questo x volte". Ciò evita potenziali errori off-by-one e rende il codice più semplice da leggere. Nei linguaggi orientati agli oggetti un iteratore , anche se implicito, viene spesso utilizzato come mezzo di attraversamento.

L' istruzione foreach in alcune lingue ha un ordine definito, elaborando ogni elemento della raccolta dal primo all'ultimo. L' istruzione foreach in molti altri linguaggi, in particolare i linguaggi di programmazione array , non ha un ordine particolare. Ciò semplifica l' ottimizzazione del ciclo in generale e in particolare consente l' elaborazione vettoriale degli elementi nella raccolta contemporaneamente.

Sintassi

La sintassi varia tra le lingue. La maggior parte usa la semplice parola for, più o meno come segue:

for each item in collection:
  do something to item

Supporto linguistico

I linguaggi di programmazione che supportano i cicli foreach includono ABC , ActionScript , Ada , C++11 , C# , ColdFusion Markup Language (CFML), Cobra , D , Daplex (linguaggio di query), Delphi , ECMAScript , Erlang , Java (dal 1.5), JavaScript , Lua , Objective-C (dal 2.0), ParaSail , Perl , PHP , Prolog , Python , REALbasic , Rebol , Red , Ruby , Scala , Smalltalk , Swift , Tcl , tcsh , shell Unix , Visual Basic .NET e Windows PowerShell . I linguaggi notevoli senza foreach sono C e C++ pre-C++11.

ActionScript 3.0

ActionScript supporta lo standard ECMAScript 4.0 per il for each .. inquale estrae il valore a ogni indice.

var foo:Object = {
	"apple":1,
	"orange":2
};

for each (var value:int in foo) { 
	trace(value); 
}

// returns "1" then "2"

Supporta anche for .. inche estrae la chiave ad ogni indice.

for (var key:String in foo) { 
	trace(key); 
}

// returns "apple" then "orange"

Ada

Ada supporta i cicli foreach come parte del normale ciclo for . Diciamo che X è un array :

for I in X'Range loop
   X (I) := Get_Next_Element;
end loop;

Questa sintassi viene utilizzata principalmente sugli array, ma funzionerà anche con altri tipi quando è necessaria un'iterazione completa.

Ada 2012 ha generalizzato i loop per foreach loop su qualsiasi tipo di contenitore (array, liste, mappe...):

for Obj of X loop
   -- Work on Obj
end loop;

C

Il linguaggio C non ha raccolte o un costrutto foreach. Tuttavia, ha diverse strutture dati standard che possono essere utilizzate come raccolte e ciascuna può essere facilmente creata con una macro .

Tuttavia, si verificano due problemi evidenti:

• La macro non è igienica: dichiara una nuova variabile nell'ambito esistente che rimane dopo il ciclo.
• Non è possibile definire una macro per ciascuna che funzioni con diversi tipi di raccolta (ad es. array ed elenchi collegati) o che sia estensibile ai tipi di utente.

Stringa C come raccolta di char

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

C int array come raccolta di int (dimensione dell'array nota in fase di compilazione)

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

Più generale: stringa o array come raccolta (dimensione della raccolta nota in fase di esecuzione)

Nota: idxtypepuò essere rimosso e typeof(col[0])utilizzato al suo posto con GCC

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

C#

In C# , supponendo che myArray sia un array di interi:

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

Language Integrated Query (LINQ) fornisce la seguente sintassi, accettando un delegato o un'espressione lambda :

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

C++

C++11 fornisce un ciclo foreach. La sintassi è simile a quella di Java :

#include <iostream>

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

  for (int i : myint)
  {
    std::cout << i << '\n';
  }
}

C++11 per le istruzioni basate sull'intervallo sono state implementate in GNU Compiler Collection (GCC) (dalla versione 4.6), Clang (dalla versione 3.0) e Visual C++ 2012 (versione 11 )

Il range-based forè zucchero sintattico equivalente a:

  for (auto __anon = begin(myint); __anon != end(myint); ++__anon)
  {
    auto i = *__anon;
    std::cout << i << '\n';
  }

Il compilatore usa la ricerca dipendente dall'argomento per risolvere le funzioni begine end.

La libreria standard C++ supporta anche for_each, che applica ogni elemento a una funzione, che può essere qualsiasi funzione predefinita o un'espressione lambda. Sebbene l'intervallo basato su sia solo dall'inizio alla fine, l'intervallo e la direzione è possibile modificare la direzione o l'intervallo modificando i primi due parametri.

#include <iostream>
#include <algorithm> // contains std::for_each
#include <vector>

int main()
{
  std::vector<int> v {1, 2, 3, 4, 5};

  std::for_each(v.begin(), v.end(), [](int i)
  {
    std::cout << i << '\n';
  });

  std::cout << "reversed but skip 2 elements:\n";

  std::for_each(v.rbegin()+2, v.rend(), [](int i)
  {
    std::cout << i << '\n';
  });
}

Qt , un framework C++, offre una macro che fornisce cicli foreach utilizzando l'interfaccia dell'iteratore STL:

#include <QList>
#include <QDebug>

int main()
{
  QList<int> list;

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

  foreach (int i, list)
  {
    qDebug() << i;
  }
}

Boost , un insieme di librerie C++ portatili peer-reviewed gratuite fornisce anche cicli foreach:

#include <boost/foreach.hpp>
#include <iostream>
 
int main()
{
  int myint[] = {1, 2, 3, 4, 5};
 
  BOOST_FOREACH(int &i, myint)
  {
    std::cout << i << '\n';
  }
}

C++/CLI

Il linguaggio C++/CLI propone un costrutto simile a C#.

Supponendo che myArray sia un array di interi:

    for each (int x in myArray)
    {
        Console::WriteLine(x);
    }

Linguaggio di marcatura ColdFusion (CFML)

Sintassi dello script

// arrays
arrayeach([1,2,3,4,5], function(v){
    writeOutput(v);
});

// or

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

// or

// (Railo only; not supported in ColdFusion)
letters = ["a","b","c","d","e"];
letters.each(function(v){
    writeOutput(v); // abcde
});

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

// or

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

// or
// (Railo only; not supported in ColdFusion)
collection.each(function(k,v){
    writeOutput("key: #k#, value: #v#;");
});

Sintassi dei tag

<!--- arrays --->
<cfloop index="v" array="#['a','b','c','d','e']#">
  <cfoutput>#v#</cfoutput><!--- a b c d e  --->
</cfloop>

CFML identifica erroneamente il valore come "indice" in questo costrutto; la indexvariabile riceve il valore effettivo dell'elemento dell'array, non il suo indice.

<!--- structs --->
<cfloop item="k" collection="#collection#">
    <cfoutput>#collection[k]#</cfoutput>
</cfloop>

Lispa comune

Common Lisp fornisce per ogni capacità sia con la macro dolist :

(dolist (i '(1 3 5 6 8 10 14 17))
  (print i))

o la potente macro loop per iterare su più tipi di dati

(loop for i in '(1 3 5 6 8 10 14 17)
      do (print i))

e anche con la funzione mapcar :

(mapcar #'print '(1 3 5 6 8 10 14 17))

D

foreach(item; set) {
  // do something to item
}

o

foreach(argument) {
  // pass value
}

Dardo

for (final element in someCollection) {
  // do something with element
}

Oggetto Pascal, Delphi

Il supporto Foreach è stato aggiunto in Delphi 2005 e utilizza una variabile enumeratore che deve essere dichiarata nella sezione var .

for enumerator in collection do
begin
  //do something here
end;

Eiffel

La forma di iterazione (foreach) del costrutto del ciclo Eiffel è introdotta dalla parola chiave across.

In questo esempio my_listviene stampato ogni elemento della struttura :

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

L'entità locale icè un'istanza della classe della libreria ITERATION_CURSOR. La funzione del cursore itemfornisce l'accesso a ciascun elemento della struttura. ITERATION_CURSORÈ possibile creare discendenti di classe per gestire algoritmi di iterazione specializzati. I tipi di oggetti che possono essere ripetuti ( my_listnell'esempio) sono basati su classi che ereditano dalla classe della libreria ITERABLE.

La forma di iterazione del ciclo Eiffel può essere utilizzata anche come espressione booleana quando la parola chiave loopviene sostituita da all(che effettua la quantificazione universale ) o some(che effettua la quantificazione esistenziale ).

Questa iterazione è un'espressione booleana che è vera se tutti gli elementi in my_listhanno conteggi maggiori di tre:

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

Quanto segue è vero se almeno un elemento ha un conteggio maggiore di tre:

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

andare

Il ciclo foreach di Go può essere utilizzato per eseguire il ciclo su un array, una porzione, una stringa, una mappa o un canale.

Usando la forma a due valori, otteniamo l'indice/chiave (primo elemento) e il valore (secondo elemento):

for index, value := range someCollection {
	// Do something to index and value
}

Usando il modulo a un valore, otteniamo l'indice/chiave (primo elemento):

for index := range someCollection {
	// Do something to index
}

Groovy

Groovy supporti per i loop oltre collezioni come array, liste e intervalli:

def x = [1,2,3,4]
for (v in x)           // loop over the 4-element array x
{
    println v
}

for (v in [1,2,3,4])   // loop over 4-element literal list 
{
    println v
}

for (v in 1..4)        // loop over the range 1..4
{
    println v
}

Groovy supporta anche un ciclo for in stile C con un indice di array:

for (i = 0; i < x.size(); i++)
{
    println x[i]
}

Le raccolte in Groovy possono anche essere ripetute utilizzando la parola chiave each e una chiusura. Per impostazione predefinita, il loop fittizio si chiama it

x.each{ println it }     // print every element of the x array
x.each{i-> println i}    // equivalent to line above, only loop dummy explicitly named "i"

Haskell

Haskell consente di eseguire il loop su elenchi con azioni monadiche utilizzando mapM_e forM_( mapM_con i suoi argomenti capovolti) da Control.Monad :

mapM_ print [1..4]

1
2
3
4

forM_ "test" $ \char -> do 
    putChar char
    putChar char

tteesstt

È anche possibile generalizzare tali funzioni per lavorare su funtori applicativi piuttosto che su monadi e qualsiasi struttura di dati che è attraversabile utilizzando traverse( forcon i suoi argomenti capovolti) e mapM( forMcon i suoi argomenti capovolti) da Data.Traversable .

Haxe

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

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

Giava

In Java , un costrutto foreach è stato introdotto in Java Development Kit (JDK) 1.5.0.

Le fonti ufficiali usano diversi nomi per il costrutto. Viene indicato come "Enhanced for Loop", "For-Each Loop" e "istruzione foreach".

for (Type item : iterableCollection) {
    // Do something to item
}

JavaScript

Lo standard ECMAScript 6 prevede l' for..ofiterazione senza indice su generatori, array e altro:

for (var item of array){
    // Do stuff
}

In alternativa, stile basato sulla funzione:

array.forEach(item => {
    // Do stuff
})

Per l'iterazione non ordinata sulle chiavi in ​​un oggetto, JavaScript presenta il for...inciclo:

for (var key in object) {
    // Do stuff with object[key]
}

Per limitare l'iterazione alle proprietà proprie dell'oggetto, escludendo quelle ereditate tramite la catena di prototipi, è talvolta utile aggiungere un test hasOwnProperty(), se supportato dal motore JavaScript (per WebKit/Safari, ciò significa "nella versione 3 o successiva ").

for (var key in object) {
    if (object.hasOwnProperty(key)) {
        // Do stuff with object[key]
    }
}

ECMAScript 5 ha fornito il metodo Object.keys, per trasferire le proprie chiavi di un oggetto nell'array.

var book = { name: "A Christmas Carol", author: "Charles Dickens" }; 
for(var key of Object.keys(book)){
    alert("PropertyName = " key + " Property Value = " + book[key]);
}

Lua

Iterare solo attraverso i valori dell'indice numerico:

for index, value in ipairs(array) do
	-- do something
end

Itera attraverso tutti i valori dell'indice:

for index, value in pairs(array) do
	-- do something
end

matematica

In Mathematica , Dovaluti semplicemente un'espressione per ciascun elemento di una lista, senza restituire alcun valore.

In[]:= Do[doSomethingWithItem, {item, list}]

È più comune usare Table, che restituisce il risultato di ogni valutazione in un nuovo elenco.

In[]:= list = {3, 4, 5};

In[]:= Table[item^2, {item, list}]
Out[]= {9, 16, 25}

MATLAB

for item = array
%do something
end

menta

Per ogni loop sono supportati in Mint, possedendo la seguente sintassi:

for each element of list
    /* 'Do something.' */
end

Il ciclofor (;;) o while (true) infinito in Mint può essere scritto usando un ciclo for each e una lista infinitamente lunga .

import type
/* 'This function is mapped to'
 * 'each index number i of the'
 * 'infinitely long list.'
 */
sub identity(x)
    return x
end
/* 'The following creates the list'
 * '[0, 1, 2, 3, 4, 5, ..., infinity]'
 */
infiniteList = list(identity)
for each element of infiniteList
    /* 'Do something forever.' */
end

Obiettivo-C

I cicli Foreach, chiamati Fast enumeration , sono supportati a partire da Objective-C 2.0. Possono essere utilizzati per eseguire l'iterazione su qualsiasi oggetto che implementa il protocollo NSFastEnumeration, inclusi NSArray, NSDictionary (itera sulle chiavi), NSSet, ecc.

NSArray *a = [NSArray new];       // Any container class can be substituted

for(id obj in a) {                // Note the dynamic typing (we do not need to know the
                                  // Type of object stored in 'a'.  In fact, there can be
                                  // many different types of object in the array.

    printf("%s\n", [[obj description] UTF8String]);  // Must use UTF8String with %s
    NSLog(@"%@", obj);                               // Leave as an object
}

NSArrays può anche trasmettere un messaggio ai propri membri:

NSArray *a = [NSArray new];

[a makeObjectsPerformSelector:@selector(printDescription)];

Laddove i blocchi sono disponibili, un NSArray può eseguire automaticamente un blocco su ogni elemento contenuto:

[myArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop)
	{
		NSLog(@"obj %@", obj);
		if ([obj shouldStopIterationNow])
			*stop = YES;
	}];

Il tipo di raccolta iterata determinerà l'elemento restituito ad ogni iterazione. Per esempio:

NSDictionary *d = [NSDictionary new];

for(id key in d) {
    NSObject *obj = [d objectForKey:key];      // We use the (unique) key to access the (possibly nonunique) object.
    NSLog(@"%@", obj);
}

OCaml

OCaml è un linguaggio funzionale . Pertanto, l'equivalente di un ciclo foreach può essere ottenuto come funzione di libreria su elenchi e array.

Per le liste:

List.iter (fun x -> print_int x) [1;2;3;4];;

o in breve:

List.iter print_int [1;2;3;4];;

Per gli array:

Array.iter (fun x -> print_int x) [|1;2;3;4|];;

o in breve:

Array.iter print_int [|1;2;3;4|];;

ParaSail

Il linguaggio di programmazione parallelo ParaSail supporta diversi tipi di iteratori, incluso un iteratore generale "per ogni" su un contenitore:

var Con : Container<Element_Type> := ...
// ...
for each Elem of Con concurrent loop  // loop may also be "forward" or "reverse" or unordered (the default)
  // ... do something with Elem
end loop

ParaSail supporta anche i filtri sugli iteratori e la possibilità di fare riferimento sia alla chiave che al valore di una mappa. Ecco un'iterazione in avanti sugli elementi di "My_Map" selezionando solo gli elementi in cui le chiavi si trovano in "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
   // ... do something with Str or Tr
end loop

Pascal

In Pascal , lo standard ISO 10206: 1990 ha introdotto l'iterazione sui tipi di set , quindi:

var
  elt: ElementType;
  eltset: set of ElementType;

{...}

for elt in eltset do
  { ... do something with elt }

Perla

In Perl , foreach (che è equivalente al più breve for) può essere usato per attraversare gli elementi di una lista. L'espressione che denota la collezione su cui eseguire il ciclo viene valutata nel contesto della lista e ogni elemento della lista risultante viene, a sua volta, alias alla variabile del ciclo.

Elenco letterale esempio:

foreach (1, 2, 3, 4) {
    print $_;
}

Esempi di array:

foreach (@arr) {
    print $_;
}

foreach $x (@arr) { #$x is the element in @arr
    print $x;
}

Esempio di hash:

foreach $x (keys %hash) {
    print $x . " = " . $hash{$x}; # $x is a key in %hash and $hash{$x} is its value
}

Modifica diretta dei membri della raccolta:

@arr = ( 'remove-foo', 'remove-bar' );
foreach $x (@arr){
    $x =~ s/remove-//;
}
# Now @arr = ('foo', 'bar');

PHP

foreach ($set as $value) {
    // Do something to $value;
}

È anche possibile estrarre sia chiavi che valori utilizzando la sintassi alternativa:

foreach ($set as $key => $value) {
    echo "{$key} has a value of {$value}";
}

Modifica diretta dei membri della raccolta:

$arr = array(1, 2, 3);
foreach ($arr as &$value) { // Note the &, $value is a reference to the original value inside $arr
    $value++;
}
// Now $arr = array(2, 3, 4);

// also works with the full syntax
foreach ($arr as $key => &$value) {
    $value++;
}

• Maggiori informazioni

Pitone

for item in iterable_collection:
    # Do something with item

L'assegnazione della tupla di Python, completamente disponibile nel suo ciclo foreach, rende anche banale l'iterazione su coppie (chiave, valore) in array associativi :

for key, value in some_dict.items():  # Direct iteration on a dict iterates on its keys
    # Do stuff

Poiché for ... inè l'unico tipo di ciclo for in Python, l'equivalente del ciclo "counter" trovato in altri linguaggi è...

for i in range(len(seq)):
    # Do something to seq[i]

... anche se l'uso della enumeratefunzione è considerato più "Pythonic":

for i, item in enumerate(seq):
    # Do stuff with item
    # Possibly assign it back to seq[i]

Racchetta

(for ([item set])
  (do-something-with item))

o utilizzando la for-eachfunzione Schema convenzionale :

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

do-something-with è una funzione a un argomento.

Raku

In Raku , una lingua sorella di Perl, for deve essere utilizzata per attraversare gli elementi di una lista ( foreach non è consentito). L'espressione che denota la raccolta su cui eseguire il ciclo viene valutata nel contesto elenco, ma non appiattita per impostazione predefinita, e ogni elemento dell'elenco risultante è, a sua volta, alias alle variabili di ciclo.

Elenco letterale esempio:

for 1..4 {
    .say;
}

Esempi di array:

for @arr {
    .say;
}

Il ciclo for nella sua forma di modifica dell'istruzione:

.say for @arr;

for @arr -> $x {
    say $x;
}

for @arr -> $x, $y {    # more than one item at a time
    say "$x, $y";
}

Esempio di hash:

for keys %hash -> $key {
    say "$key: $hash{$key}";
}

o

for %hash.kv -> $key, $value {
    say "$key: $value";
}

o

for %hash -> $x {
    say "$x.key(): $x.value()";    # Parentheses needed to inline in double quoted string
}

Modifica diretta dei membri della raccolta con un blocco doppiamente appuntito, <-> :

my @arr = 1,2,3;
for @arr <-> $x {
    $x *= 2;
}
# Now @arr = 2,4,6;

Rubino

set.each do |item|
  # do something to item
end

o

for item in set
  # do something to item
end

Questo può essere utilizzato anche con un hash.

set.each do |item,value|
  # do something to item
  # do something to value
end

Ruggine

Il forciclo ha la struttura for <pattern> in <expression> { /* optional statements */ }. Chiama implicitamente il IntoIterator::into_itermetodo sull'espressione e usa il valore risultante, che deve implementare il Iteratortratto. Se l'espressione è essa stessa un iteratore, è usato direttamente dal forciclo attraverso un'attuazione di IntoIteratortutti Iterators che restituisce l'iteratore invariato. Il ciclo chiama il Iterator::nextmetodo sull'iteratore prima di eseguire il corpo del ciclo. Se Iterator::nextrestituisce Some(_), il valore all'interno viene assegnato al modello e viene eseguito il corpo del ciclo; se restituisce None, il ciclo è terminato.

let mut numbers = vec![1, 2, 3];

// Immutable reference:
for number in &numbers { // calls IntoIterator::into_iter(&numbers)
    println!("{}", number);
}

for square in numbers.iter().map(|x| x * x) { // numbers.iter().map(|x| x * x) implements Iterator
    println!("{}", square);
}

// Mutable reference:
for number in &mut numbers { // calls IntoIterator::into_iter(&mut numbers)
    *number *= 2;
}

// prints "[2, 4, 6]":
println!("{:?}", numbers);

// Consumes the Vec and creates an Iterator:
for number in numbers { // calls IntoIterator::into_iter(numbers)
    // ...
}

// Errors with "borrow of moved value":
// println!("{:?}", numbers);

Scala

// return list of modified elements
items map { x => doSomething(x) }
items map multiplyByTwo

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

// return nothing, just perform action
items foreach { x => doSomething(x) }
items foreach println

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

// pattern matching example in for-comprehension
for ((key, value) <- someMap) println(s"$key -> $value")

schema

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

do-something-with è una funzione a un argomento.

chiacchiere

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

Swift

Swift usa il costrutto for… inper scorrere i membri di una raccolta.

for thing in someCollection {
    // do something with thing
}

Il ciclo for… inviene spesso utilizzato con i costrutti di intervallo chiuso e semiaperto per scorrere il corpo del ciclo un certo numero di volte.

for i in 0..<10 {
    // 0..<10 constructs a half-open range, so the loop body
    // is repeated for i = 0, i = 1, …, i = 9.
}

for i in 0...10 {
    // 0...10 constructs a closed range, so the loop body
    // is repeated for i = 0, i = 1, …, i = 9, i = 10.
}

SystemVerilog

SystemVerilog supporta l'iterazione su qualsiasi vettore o tipo di matrice di qualsiasi dimensionalità utilizzando la foreachparola chiave.

Un banale esempio itera su un array di interi:

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

Un esempio più complesso itera su un array associativo di array di interi:

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 usa foreach per scorrere gli elenchi. È possibile specificare più di una variabile iteratore, nel qual caso vengono assegnati valori sequenziali dall'elenco.

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

1 2
3 4
5 6

È anche possibile eseguire l'iterazione su più di un elenco contemporaneamente. Di seguito iassume valori sequenziali della prima lista, jvalori sequenziali della seconda lista:

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
    ' Do something with item.
Next

o senza inferenza del tipo

For Each item As type In enumerable
    ' Do something with item.
Next

finestre

Processore di comando convenzionale

Invocare un frobcomando ipotetico tre volte, assegnandogli ogni volta un nome di colore.

C:\>FOR %%a IN ( red green blue ) DO frob %%a

Windows PowerShell

foreach ($item in $set) {
    # Do something to $item
}

Da un gasdotto

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

# or using the aliases
$list | foreach {write $_}
$list | % {write $_}

XSLT

 <xsl:for-each select="set">
   <!-- do something for the elements in <set> -->
 </xsl:for-each>

Guarda anche

• Fai mentre loop
• Per ciclo
• Mentre il ciclo
• Mappa (funzione di ordine superiore)

Riferimenti