Bucle foreach

En programación informática , un bucle foreach (o bucle for-each ) es una declaración de flujo de control para recorrer elementos de una colección . Por lo general, foreach se utiliza en lugar de una declaración de bucle for estándar . Sin embargo, a diferencia de otras construcciones de bucle for , los bucles foreach ^[1] por lo general no mantienen un contador explícito: básicamente dicen "haz esto con todo en este conjunto", en lugar de "haz esto x veces". Esto evita posibles errores de error de uno en uno y hace que el código sea más fácil de leer. En lenguajes orientados a objetos , un iterador , incluso si es implícito, se utiliza a menudo como medio de recorrido.

En algunos lenguajes, la instrucción foreach tiene un orden definido y procesa cada elemento de la colección desde el primero hasta el último. En muchos otros lenguajes, especialmente en los de programación de matrices , la instrucción foreach no tiene ningún orden en particular. Esto simplifica la optimización de bucles en general y, en particular, permite el procesamiento de vectores de elementos de la colección de manera concurrente.

La sintaxis varía según el idioma. La mayoría utiliza la palabra simple for, aunque otros utilizan la palabra más lógica foreach, aproximadamente de la siguiente manera:

foreach(clave, valor) en la colección { # Haz algo para valorar #}

Los lenguajes de programación que admiten bucles foreach incluyen ABC , ActionScript , Ada , C++ (desde C++11 ), C# , ColdFusion Markup Language (CFML), Cobra , D , Daplex (lenguaje de consulta), Delphi , ECMAScript , Erlang , Java (desde 1.5), JavaScript , Lua , Objective-C (desde 2.0), ParaSail , Perl , PHP , Prolog , ^[2] Python , R , REALbasic , Rebol , ^[3] Red , ^[4] Ruby , Scala , Smalltalk , Swift , Tcl , tcsh , Unix shells , Visual Basic (.NET) y Windows PowerShell . Los lenguajes notables sin foreach son C y C++ pre-C++11.

ActionScript admite el estándar ECMAScript 4.0 ^[5] para for each .. in^[6], que extrae el valor en cada índice.

var foo : Objeto = { "manzana" : 1 , "naranja" : 2 };   para cada ( var valor : int en foo ) { trace ( valor ); }        // devuelve "1" y luego "2"

También admite for .. in^[7] que extrae la clave en cada índice.

para ( var clave : cadena en foo ) { trace ( clave ); }       // devuelve "manzana" y luego "naranja"

El Wikilibro Ada Programming tiene una página sobre el tema: Control

Ada admite bucles foreach como parte del bucle for normal . Digamos que X es una matriz :

para  I  en  X ' Rango  bucle  X  ( I )  :=  Get_Next_Element ; fin  bucle ;

Esta sintaxis se utiliza principalmente en matrices, pero también funcionará con otros tipos cuando se necesite una iteración completa.

Ada 2012 ha generalizado los bucles a bucles foreach en cualquier tipo de contenedor (matrices, listas, mapas...):

para  Obj  del  bucle X  - Trabajar en Obj fin del bucle ;  

El lenguaje C no tiene colecciones ni una estructura foreach. Sin embargo, tiene varias estructuras de datos estándar que se pueden usar como colecciones y se puede crear una estructura foreach fácilmente con una macro .

Sin embargo, surgen dos problemas evidentes:

• La macro no es higiénica: declara una nueva variable en el ámbito existente que permanece después del bucle.
• No se puede definir una macro foreach que funcione con diferentes tipos de colecciones (por ejemplo, matriz y lista enlazada) o que sea extensible a tipos de usuario.

Cadena C como una colección de caracteres

#incluir <stdio.h> /* foreach macro visualiza una cadena como una colección de valores de caracteres */#define foreach(varptr, varstr) \carácter* ptrvar; \para (ptrvar = strvar; (*ptrvar) != '\0'; *ptrvar++)int principal ( int argc , char ** argv ) {      char * s1 = "abcdefg" ;    char * s2 = "123456789" ;    para cada ( p1 , s1 ) {    printf ( "bucle 1: %c \n " , * p1 );  } para cada ( p2 , s2 ) {    printf ( "bucle 2: %c \n " , * p2 );  } devuelve 0 ; }

Matriz C int como una colección de int (tamaño de la matriz conocido en tiempo de compilación)

#incluir <stdio.h> /* foreach macro visualiza una matriz de valores int como una colección de valores int */#definir foreach(intpvar, intarr) \int* intpvar; \for (intpvar = intarr; intpvar < (intarr + (tamañode(intarr)/tamañode(intarr[0]))); ++intpvar)int principal ( int argc , char ** argv ) {      int a1 [] = { 1 , 1 , 2 , 3 , 5 , 8 };         int a2 [] = { 3 , 1 , 4 , 1 , 5 , 9 };         para cada ( p1 , a1 ) {    printf ( "bucle 1: %d \n " , * p1 );  } para cada ( p2 , a2 ) {    printf ( "bucle 2: %d \n " , * p2 );  } devuelve 0 ; }

Más general: cadena o matriz como colección (el tamaño de la colección se conoce en tiempo de ejecución)

idxtypeSe puede quitar y typeof(col[0])utilizar en su lugar con GCC.

#incluir <stdio.h> #include <cadena.h> /* foreach macro visualiza una matriz del tipo dado como una colección de valores del tipo dado */#define arraylen(arr) (tamañode(arr)/tamañode(arr[0]))#define foreach(idxtype, idxpvar, col, colsiz) \tipo_idx* idxpvar; \para (idxpvar = col; idxpvar < (col + colsiz); ++idxpvar)int principal ( int argc , char ** argv ) {      char * c1 = "colección" ;    int c2 [] = { 3 , 1 , 4 , 1 , 5 , 9 };         doble * c3 ;  int c3len = 4 ;    c3 = ( doble * ) calloc ( c3len , sizeof ( doble ));     c3 [ 0 ] = 1,2 ; c3 [ 1 ] = 3,4 ; c3 [ 2 ] = 5,6 ; c3 [ 3 ] = 7,8 ;            foreach ( char , p1 , c1 , strlen ( c1 )) {      printf ( "bucle 1: %c \n " , * p1 );  } foreach ( int , p2 , c2 , arraylen ( c2 )) {      printf ( "bucle 2: %d \n " , * p2 );  } foreach ( doble , p3 , c3 , c3len ) {      printf ( "bucle 3: %.1lf \n " , * p3 );  } devuelve 0 ; }

En C# , suponiendo que myArray es una matriz de números enteros:

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

Language Integrated Query (LINQ) proporciona la siguiente sintaxis, aceptando un delegado o una expresión lambda :

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

C++11 ofrece un bucle foreach. La sintaxis es similar a la de Java:

#include <flujo de datos> int principal () { int myint [] = { 1 , 2 , 3 , 4 , 5 };          para ( int i : myint ) { std :: cout << i << '\n' ; } }           

Las instrucciones for basadas en rangos de C++11 se han implementado en GNU Compiler Collection (GCC) (desde la versión 4.6), Clang (desde la versión 3.0) y Visual C++ 2012 (versión 11 ^[8] )

El azúcar sintáctico basado en rango fores equivalente a:

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

El compilador utiliza una búsqueda dependiente de argumentos para resolver las funciones beginy end. ^[9]

La biblioteca estándar de C++ también admite for_each, ^[10] que aplica cada elemento a una función, que puede ser cualquier función predefinida o una expresión lambda. Si bien el for basado en rangos solo va del principio al final, el rango o la dirección se pueden cambiar modificando los dos primeros parámetros.

#include <iostream> #include <algoritmo> // contiene std::for_each #include <vector>   int principal () { std :: vector < int > v { 1 , 2 , 3 , 4 , 5 };         std :: for_each ( v.begin ( ) , v.end ( ) , []( int i ) { std :: cout << i << '\n' ; } ) ;           std :: cout << "invertido pero omite 2 elementos: \n " ;   std :: for_each ( v.rbegin () + 2 , v.rend ( ) , []( int i ) { std :: cout << i << ' \n' ; } ); }          

Qt , un marco de C++, ofrece una macro que proporciona bucles foreach ^[11] utilizando la interfaz del iterador STL:

#include <QList> #include <QDebug>  int main () { QList < int > lista ;    lista << 1 << 2 << 3 << 4 << 5 ;           foreach ( int i , lista ) { qDebug () << i ; } }        

Boost , un conjunto de bibliotecas C++ portátiles y gratuitas revisadas por pares, también proporciona bucles foreach: ^[12]

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

El lenguaje C++/CLI propone una construcción similar a C#.

Suponiendo que myArray es una matriz de números enteros:

para cada ( int x en myArray ) { Consola :: WriteLine ( x ); }      

// matrices arrayeach ([ 1 , 2 , 3 , 4 , 5 ],  función ( v ){  writeOutput ( v ); });// opara  ( v  en  [ 1 , 2 , 3 , 4 , 5 ]){  escribirSalida ( v ); }// o// (Solo Railo; no compatible con ColdFusion) letras  =  [ "a" , "b" , "c" , "d" , "e" ]; letras.each ( función ( v ){  writeOutput ( v );  // abcde });// estructuras para  ( k  en  la colección ){  writeOutput ( colección [ k ]); }// ostructEach ( colección ,  función ( k , v ){  writeOutput ( "clave: #k# , valor: #v# ;" ); });// o // (solo Railo; no compatible con ColdFusion) collection.each ( function ( k , v ){  writeOutput ( "key: #k# , value: #v# ;" ); });

<!--- matrices ---> <cfloop  índice = "v"  matriz = " #['a','b','c','d','e']# " >  <cfoutput> # v # </cfoutput> <!--- abcde ---> </cfloop>

CFML identifica incorrectamente el valor como "índice" en esta construcción; la indexvariable recibe el valor real del elemento de la matriz, no su índice.

<!--- estructuras ---> <cfloop  elemento = "k"  colección = " #colección# " >  <cfoutput> # colección [ k ]# </cfoutput> </cfloop>

Common Lisp proporciona la capacidad foreach con la macro dolist :

( lista de tareas ( i ' ( 1 3 5 6 8 10 14 17 )) ( imprimir i ))           

o la potente macro de bucle para iterar sobre más tipos de datos

( bucle para i en ' ( 1 3 5 6 8 10 14 17 ) hacer ( imprimir i ))              

y también con la función mapcar :

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

foreach ( elemento ; conjunto ) { // hacer algo con el elemento }   

o

foreach ( argumento ) { // pasar valor }  

para ( elemento final en algunaColección ) { // hacer algo con el elemento }      

La compatibilidad con Foreach se agregó en Delphi 2005 y utiliza una variable enumeradora que debe declararse en la sección var .

para el enumerador en la colección do begin //haz algo aquí end ;     

La forma de iteración (foreach) de la construcción del bucle Eiffel se introduce mediante la palabra clave across.

En este ejemplo my_listse imprime cada elemento de la estructura:

 a través de mi_lista como ic loop print ( ic . item ) fin       

La entidad local ices una instancia de la clase de biblioteca ITERATION_CURSOR. La característica del cursor itemproporciona acceso a cada elemento de la estructura. ITERATION_CURSORSe pueden crear descendientes de la clase para manejar algoritmos de iteración especializados. Los tipos de objetos que se pueden iterar ( my_listen el ejemplo) se basan en clases que heredan de la clase de biblioteca ITERABLE.

La forma de iteración del bucle Eiffel también se puede utilizar como una expresión booleana cuando la palabra clave loopse reemplaza por all(efectuando cuantificación universal ) o some(efectuando cuantificación existencial ).

Esta iteración es una expresión booleana que es verdadera si todos los elementos my_listtienen conteos mayores a tres:

 en mi_lista como ic todos ic . elemento . recuento > 3 fin        

Lo siguiente es verdadero si al menos un elemento tiene un recuento mayor que tres:

 en mi_lista como ic algún ic . elemento . recuento > 3 fin        

El bucle foreach de Go se puede utilizar para recorrer una matriz, una porción, una cadena, un mapa o un canal.

Usando el formato de dos valores se obtiene el índice/clave (primer elemento) y el valor (segundo elemento):

para índice , valor := rango algunaColección { // Hacer algo con el índice y el valor }      

Usando el formato de un solo valor se obtiene el índice/clave (primer elemento):

para index := range someCollection { // Hacer algo para indexar }     

^[13]

Groovy admite bucles sobre colecciones como matrices, listas y rangos:

def x = [ 1 , 2 , 3 , 4 ] for ( v in x ) // recorre la matriz de 4 elementos x { println v }         for ( v in [ 1 , 2 , 3 , 4 ]) // recorrer una lista literal de 4 elementos { println v }      for ( v en 1 .. 4 ) // recorrer el rango 1..4 { println v }      

Groovy también admite un bucle for de estilo C con un índice de matriz:

para ( i = 0 ; i < x . tamaño (); i ++) { println x [ i ] }         

Las colecciones en Groovy también se pueden iterar utilizando la palabra clave each y un cierre. De manera predeterminada, el bucle ficticio se llama it

x . each { println it } // imprime cada elemento de la matriz x x . each { i -> println i } // equivalente a la línea anterior, solo que el bucle ficticio se llama explícitamente "i"       

Haskell permite realizar bucles sobre listas con acciones monádicasmapM_ usando y forM_( mapM_con sus argumentos invertidos) desde Control.Monad:

mapM_imprimir [ 1 .. 4 ]​  

1234

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

teesstt

También es posible generalizar esas funciones para que funcionen en funtores aplicativos en lugar de mónadas y en cualquier estructura de datos que se pueda recorrer usando traverse( forcon sus argumentos invertidos) y mapM( forMcon sus argumentos invertidos) de Data.Traversable.

para ( valor en iterable ) { trace ( valor ); }     Lambada . iter ( iterable , función ( valor ) traza ( valor ));  

En Java , se introdujo una construcción foreach en Java Development Kit (JDK) 1.5.0. ^[14]

Las fuentes oficiales utilizan varios nombres para esta construcción. Se la conoce como "bucle for mejorado", ^[14] "bucle For-Each" ^[15] y "declaración foreach". ^{[16] [17] : 264}

para ( Tipo elemento : iterableCollection ) { // Hacer algo con el elemento }      

Java también proporciona la API de flujo desde Java 8: ^{[17] : 294–203}

 Lista < Entero > intList = Lista . de ( 1 , 2 , 3 , 4 ); intList . stream (). forEach ( i -> Sistema . out . println ( i ));         

El estándar ECMAScript 6for..of permite la iteración sin índices sobre generadores, matrices y más:

para ( var elemento de la matriz ){ // Hacer cosas }     

Alternativamente, estilo basado en funciones: ^[18]

array . forEach ( item => { // Hacer cosas })   

Para la iteración desordenada sobre las claves de un objeto, JavaScript cuenta con el for...inbucle:

para ( var clave en objeto ) { // Hacer cosas con objeto[clave] }      

Para limitar la iteración a las propiedades propias del objeto, excluyendo aquellas heredadas a través de la cadena de prototipos, a veces es útil agregar una prueba hasOwnProperty(), si el motor JavaScript lo admite (para WebKit/Safari, esto significa "en la versión 3 o posterior").

para ( var clave en objeto ) { si ( objeto.hasOwnProperty ( clave ) ) { // Hacer cosas con objeto[clave ] } }          

ECMAScript 5 proporcionó el método Object.keys para transferir las claves propias de un objeto a una matriz. ^[19]

var book = { nombre : "Un cuento de Navidad" , autor : "Charles Dickens" }; for ( var key of Object . keys ( book )){ alert ( "PropertyName = " key + " Valor de la propiedad = " + book [ key ]); }                  

Fuente: ^[20]

Iterar solo a través de valores de índice numérico:

para  índice ,  valor  en  ipairs ( matriz )  hacer -- hacer algo fin

Iterar a través de todos los valores del índice:

para  índice ,  valor  en  pares ( matriz )  hacer -- hacer algo fin

En Mathematica , Dosimplemente evaluará una expresión para cada elemento de una lista, sin devolver ningún valor.

En [] := Hacer [ hacerAlgoConElemento , { elemento , lista }]   

Es más común utilizar Table, que devuelve el resultado de cada evaluación en una nueva lista.

En [] := lista = { 3 , 4 , 5 };     En [] := Tabla [ elemento ^ 2 , { elemento , lista }] Salida [] = { 9 , 16 , 25 }      

para elemento = matriz %hacer algo fin   

En Mint se admiten bucles For each y poseen la siguiente sintaxis:

para cada elemento de la lista /* 'Haz algo.' */ fin     

El bucle infinitofor (;;) en Mint se puede escribir utilizando un bucle for each y una lista infinitamente larga . ^[21]while (true)

import type /* 'Esta función está asignada a' * 'cada número de índice i de la' * 'lista infinitamente larga.' */ sub identity ( x ) return x end /* 'Lo siguiente crea la lista' * '[0, 1, 2, 3, 4, 5, ..., infinito]' */ infiniteList = list ( identity ) para cada elemento de infiniteList /* 'Hacer algo para siempre.' */ end           

Los bucles Foreach, denominados Fast enumeration , son compatibles a partir de Objective-C 2.0. Se pueden utilizar para iterar sobre cualquier objeto que implemente el protocolo NSFastEnumeration, incluidos NSArray, NSDictionary (itera sobre claves), NSSet, etc.

NSArray * a = [ NSArray new ]; // Se puede sustituir cualquier clase contenedora     for ( id obj in a ) { // Se utiliza tipado dinámico. El tipo de objeto almacenado // en 'a' puede ser desconocido. La matriz puede contener muchos tipos de objetos diferentes.        printf ( "%s \n " , [[ obj description ] UTF8String ]); // Debe usar UTF8String con %s NSLog ( @"%@" , obj ); // Dejar como un objeto }       

Los NSArrays también pueden transmitir un mensaje a sus miembros:

NSArray * a = [ NSArray nuevo ];    [ un makeObjectsPerformSelector : @selector ( printDescription )]; 

Cuando hay bloques disponibles, un NSArray puede ejecutar automáticamente un bloqueo en cada elemento contenido:

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

El tipo de colección que se itera determinará el elemento que se devolverá con cada iteración. Por ejemplo:

NSDictionary * d = [ NSDictionary nuevo ];    para ( id clave en d ) { NSObject * obj = [ d objectForKey : clave ]; // Usamos la clave (única) para acceder al objeto (posiblemente no único). NSLog ( @"%@" , obj ); }            

OCaml es un lenguaje de programación funcional . Por lo tanto, se puede lograr el equivalente de un bucle foreach como función de biblioteca sobre listas y matrices.

Para listas:

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

o en forma corta:

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

Para matrices:

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

o en forma corta:

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

El lenguaje de programación paralela ParaSail admite varios tipos de iteradores, incluido un iterador general "para cada" sobre un contenedor:

var  Con  :  Container < Element_Type >  :=  .. . // ... para  cada  Elem  de  Con  bucle concurrente  // el bucle también puede ser "hacia adelante" o "hacia atrás" o desordenado (el valor predeterminado) // ... hacer algo con Elem fin bucle   

ParaSail también admite filtros en iteradores y la capacidad de hacer referencia tanto a la clave como al valor de un mapa. Aquí se muestra una iteración hacia adelante sobre los elementos de "My_Map" que selecciona solo los elementos cuyas claves están en "My_Set":

var  Mi_Mapa  :  Mapa < Tipo_Clave  =>  Cadena_Universidad ,  Tipo_Valor  =>  Árbol < Entero >>  :=  .. . const  Mi_Conjunto  :  Conjunto < Cadena_Universidad >  :=  [ "abc" ,  "def" ,  "ghi" ];para  cada  [ Str  =>  Tr ]  de  My_Map  { Str  en  My_Set }  bucle hacia adelante  // ... hacer algo con Str o Tr fin bucle  

En Pascal , la norma ISO 10206:1990 introdujo la iteración sobre tipos de conjuntos , de esta manera:

var elt : Tipo de elemento ; eltset : conjunto de ElementType ;      {...}para elt en eltset hacer { ... hacer algo con elt }     

En Perl , foreach (que es equivalente a la abreviación for) se puede utilizar para recorrer los elementos de una lista. La expresión que indica la colección por la que se realizará el bucle se evalúa en el contexto de la lista y cada elemento de la lista resultante se asocia, a su vez, a la variable del bucle.

Ejemplo de lista literal:

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

Ejemplos de matrices:

foreach ( @arr ) { imprimir $_ ; }    

foreach $x ( @arr ) { #$x es el elemento en @arr print $x ; }      

Ejemplo de hash:

foreach $x ( keys %hash ) { print $x . " = " . $hash { $x }; # $x es una clave en %hash y $hash{$x} es su valor }           

Modificación directa de los miembros de la colección:

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

foreach  ( $establecer  como  $valor )  {  // Hacer algo con $valor; }

También es posible extraer claves y valores utilizando la sintaxis alternativa:

foreach  ( $establecer  como  $clave  =>  $valor )  {  echo  " { $clave } tiene un valor de { $valor } " ; }

Modificación directa de los miembros de la colección:

$arr  =  array ( 1 ,  2 ,  3 ); foreach  ( $arr  como  & $valor )  {  // El &, $valor es una referencia al valor original dentro de $arr  $valor ++ ; } // Ahora $arr = array(2, 3, 4);// también funciona con la sintaxis completa foreach  ( $arr  como  $key  =>  & $value )  {  $value ++ ; }

• Más información

para  el artículo  en  iterable_collection :  # Hacer algo con el artículo

La asignación de tuplas de Python, completamente disponible en su bucle foreach, también hace que sea trivial iterar sobre pares (clave, valor) en matrices asociativas :

para  clave ,  valor  en  some_dict . items ():  # Iteración directa en un dict itera en sus claves  # Hacer cosas

Como for ... ines el único tipo de bucle for en Python, el equivalente al bucle "counter" que se encuentra en otros lenguajes es...

para  i  en  rango ( len ( seq )):  # Hacer algo para seq[i]

... aunque el uso de la enumeratefunción se considera más "Pythonic":

para  i ,  elemento  en  enumerate ( seq ):  # Hacer cosas con el elemento  # Posiblemente asignarlo de nuevo a seq[i]

para ( elemento en objeto ) { # Hacer algo con el elemento }    

Como for ... ines el único tipo de forbucle en R, el equivalente al bucle "contador" que se encuentra en otros lenguajes es...

para ( i en seq_along ( objeto )) { # Hacer algo con objeto[[i]] }    

( para ([ conjunto de elementos ]) ( hacer-algo-con -elemento ))    

o utilizando la for-eachfunción Scheme convencional:

( para cada uno hacer algo con una lista )  

do-something-withes una función de un argumento.

En Raku , un lenguaje hermano de Perl, se debe utilizar for para recorrer los elementos de una lista (no se permite foreach ). La expresión que indica la colección sobre la que se realizará el bucle se evalúa en el contexto de la lista, pero no se aplana de manera predeterminada, y cada elemento de la lista resultante, a su vez, tiene un alias con respecto a la(s) variable(s) del bucle.

Ejemplo de lista literal:

por  1 .. 4 { . decir ;}

Ejemplos de matrices:

para  @arr { . decir ;}

El bucle for en su forma de modificador de declaración:

. decir  por  @arr ;

para  @arr -> $x { digamos  $x ;}

para  @arr -> $x , $y { # más de un elemento a la vez  diga  "$x, $y" ;}

Ejemplo de hash:

para  claves  %hash -> $key { decir  "$key: $hash{$key}" ;}

o

para  %hash . kv -> $clave , $valor { decir  "$clave: $valor" ;}

o

para  %hash -> $x { decir  "$x.key(): $x.value()" ; # Paréntesis necesarios para insertar en línea en una cadena entre comillas dobles}

Modificación directa de los miembros de la colección con un bloque doblemente puntiagudo, <-> :

mi  @arr = 1 , 2 , 3 ; para  @arr <-> $x { $x *= 2 ;}# Ahora @arr = 2,4,6;

conjunto . cada hacer | elemento | # hacer algo al elemento fin   

o

para el elemento del conjunto # hacer algo al final del elemento    

Esto también se puede utilizar con un hash.

establecer . cada hacer | clave , valor | # hacer algo a clave # hacer algo a valor fin    

El forbucle tiene la estructura . Implícitamente llama al método IntoIterator::into_iter en la expresión y utiliza el valor resultante, que debe implementar el atributo Iterator. Si la expresión es en sí misma un iterador, el bucle la utiliza directamente a través de una implementación de IntoIterator para todos los Iteradores que devuelven el iterador sin cambios. El bucle llama al método en el iterador antes de ejecutar el cuerpo del bucle. Si devuelve , el valor dentro se asigna al patrón y se ejecuta el cuerpo del bucle; si devuelve , el bucle finaliza.for <pattern> in <expression> { /* optional statements */ }forIterator::nextIterator::nextSome(_)None

deje que mut números = vec! [ 1 , 2 , 3 ];      // Referencia inmutable: para número en & números { // llama a IntoIterator::into_iter(&números) println! ( "{}" , número ); }       para el cuadrado en números .iter ( ) . map ( | x | x * x ) { // números.iter().map(|x|x*x) implementa Iterador println! ( "{}" , cuadrado ); }          // Referencia mutable: para número en & mut números { // llama a IntoIterator::into_iter(&mut números) * número *= 2 ; }         // imprime "[2, 4, 6]": println! ( "{:?}" , números ); // Consume el Vec y crea un Iterador: for number in numbers { // llama a IntoIterator::into_iter(numbers) // ... }      // Errores con "tomar prestado el valor movido": // println!("{:?}", numbers);

// devuelve la lista de elementos modificados items map { x => doSomething ( x ) } items map multiplicarPorDos        para { x <- elementos } produce doSomething ( x ) para { x <- elementos } produce multiplicarPorDos ( x )          // no devuelve nada, solo realiza acciones elementos foreach { x => doSomething ( x ) } elementos foreach println        para { x <- elementos } doSomething ( x ) para { x <- elementos } println ( x )        // ejemplo de coincidencia de patrones en comprensión for (( clave , valor ) <- someMap ) println ( s" $ clave -> $ valor " )     

( para cada uno hacer algo con una lista )  

do-something-withes una función de un argumento.

colección  hacer: [ : elemento |  "hacer algo al elemento" ]

Swift utiliza la construcción for… inpara iterar sobre los miembros de una colección. ^[22]

para cosa en algunaColección { // hacer algo con cosa }     

El bucle for… inse utiliza a menudo con las construcciones de rango cerrado y semiabierto para iterar sobre el cuerpo del bucle una cierta cantidad de veces.

for i in 0. . < 10 { // 0..<10 construye un rango semiabierto, por lo que el cuerpo del bucle // se repite para i = 0, i = 1, …, i = 9. }      for i in 0. . .10 { // 0...10 construye un rango cerrado, por lo que el cuerpo del bucle // se repite para i = 0, i = 1, …, i = 9, i = 10. }      

SystemVerilog admite la iteración sobre cualquier tipo de vector o matriz de cualquier dimensionalidad utilizando la foreachpalabra clave.

Un ejemplo trivial itera sobre una matriz de números enteros:

int matriz_1d [] = '{ 3 , 2 , 1 , 0 };        foreach array_1d [ índice ] $ display ( "array_1d[%0d]: %0d" , índice , array_1d [ índice ]);    

matriz_1d[0]: 3matriz_1d[1]: 2matriz_1d[2]: 1matriz_1d[3]: 0

Un ejemplo más complejo itera sobre una matriz asociativa de matrices de números enteros:

int array_2d [ cadena ][] = '{ "decenas" : '{ 10 , 11 }, "veinte" : '{ 20 , 21 } };              foreach array_2d [ clave , índice ] $ display ( "array_2d[%s,%0d]: %0d" , clave , índice , array_2d [ clave , índice ]);     

matriz_2d[decenas,0]: 10matriz_2d[decenas,1]: 11array_2d[años veinte,0]: 20array_2d[años veinte,1]: 21

Tcl utiliza foreach para iterar sobre listas. Es posible especificar más de una variable iteradora, en cuyo caso se les asignan valores secuenciales de la lista.

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

1 23 45 6

También es posible iterar sobre más de una lista simultáneamente. A continuación, ise supone que los valores de la primera lista son secuenciales y jlos de la segunda son secuenciales:

foreach  i { 1 2 3 } j { a b c } { pone "$i $j" }          

1 un2b3 c

Para cada elemento del enumerable ' Hacer algo con el elemento. Siguiente     

o sin inferencia de tipos

Para cada elemento Como tipo En enumerable ' Hacer algo con el elemento. Siguiente       

Invoque un comando hipotético frobtres veces, dándole un nombre de color cada vez.

C:\> PARA  %% a EN  ( rojo verde azul )  HACER frob %% a

foreach  ( $item  en  $set )  {  # Hacer algo con $item }

De una tubería

$list  |  ForEach -Object  { Escritura-Host  $_ }# o usando los alias $list  |  foreach  { write $_ } $list  |  %  { write $_ }

 <xsl:for-each select= "set" > <!-- hacer algo para los elementos en <set> --> </xsl:for-each>   

^[23]

• Hacer bucle while
• Bucle for
• Bucle While
• Mapa (función de orden superior)