Iterador

Los iteradores en .NET Framework (es decir, C#) se llaman "enumeradores" y están representados por la IEnumeratorinterfaz. ^{[ 17 ] : 189–190, 344 [ 18 ] : 53–54}IEnumerator proporciona un MoveNext()método, que avanza al siguiente elemento e indica si se ha alcanzado el final de la colección; ^{[ 17 ] : 344 [ 18 ] : 55–56 [ 19 ] : 89} una Currentpropiedad, para obtener el valor del elemento al que apunta actualmente; ^{[ 17 ] : 344 [ 18 ] : 56 [ 19 ] : 89} y un Reset()método opcional, ^{[ 17 ] : 344} para rebobinar el enumerador a su posición inicial. El enumerador apunta inicialmente a un valor especial antes del primer elemento, por lo que MoveNext()se requiere una llamada a para comenzar a iterar.

Los enumeradores se obtienen normalmente llamando al GetEnumerator()método de un objeto que implementa la IEnumerableinterfaz. ^{[ 18 ] : 54–56 [ 19 ] : 54–56} una Currentpropiedad, para obtener el valor del elemento al que apunta actualmente; ^{[ 17 ] : 344 [ 18 ] : 56 [ 19 ] : 89} Las clases contenedoras normalmente implementan esta interfaz. Sin embargo, la instrucción foreach en C# puede operar en cualquier objeto que proporcione dicho método, incluso si no lo implementa IEnumerable( tipado dinámico ). ^{[ 19 ] : 89} Ambas interfaces se ampliaron a versiones genéricas en .NET 2.0 .

A continuación se muestra un uso sencillo de iteradores en C# 2.0:

using System ; using System.Collections.Generic ;// versión explícita IEnumerator < MyType > iter = list . GetEnumerator (); while ( iter . MoveNext ()) { Console . WriteLine ( iter . Current ); }// versión implícita foreach ( MyType value in list ) { Console . WriteLine ( value ); }

C# 2.0 también admite generadores : un método que se declara como que devuelve IEnumerator(o IEnumerable), pero usa la yield returninstrucción " " para producir una secuencia de elementos en lugar de devolver una instancia de objeto, será transformado por el compilador en una nueva clase que implementa la interfaz apropiada.

Los iteradores no existen de forma nativa en C , pero pueden emularse de alguna manera con aritmética de punteros .

A continuación se muestra una lista enlazada intcon iterador.

typedef struct LinkedList { int * valor ; struct LinkedList * siguiente ; } LinkedList ;typedef struct { LinkedList * current ; } LinkedListIterator ;LinkedListIterator list_begin ( LinkedList * head ) { LinkedListIterator it = { head }; return it ; }int * list_next ( LinkedListIterator * it ) { if ( ! it -> current ) { return NULL ; } int * value = & it -> current -> value ; it -> current = it -> current -> next ; return value ; }int main () { // ... for ( LinkedListIterator it = list_begin ( head ); ; ) { int * val = list_next ( & it ); if ( ! val ) { break ; } printf ( "%d \n " , * val ); } }

El lenguaje C++ utiliza ampliamente iteradores en su biblioteca estándar y describe varias categorías de iteradores que difieren en el repertorio de operaciones que permiten. Estas incluyen iteradores hacia adelante , iteradores bidireccionales e iteradores de acceso aleatorio , en orden creciente de posibilidades. Todos los tipos de plantillas de contenedores estándar proporcionan iteradores de una de estas categorías. Los iteradores generalizan los punteros a elementos de un array (que de hecho pueden usarse como iteradores), y su sintaxis está diseñada para asemejarse a la aritmética de punteros de C , donde los operadores `and` se usan para referenciar el elemento al que apunta el iterador y los operadores de aritmética de punteros como `and` se usan para modificar iteradores en el recorrido de un contenedor.*->++

El recorrido mediante iteradores generalmente implica un iterador variable y dos iteradores fijos que delimitan el rango a recorrer. La distancia entre los iteradores, en términos del número de aplicaciones del operador ++necesarias para transformar el límite inferior en el superior, es igual al número de elementos en el rango designado; el número de valores de iterador distintos involucrados es uno más. Por convención, el iterador límite inferior apunta al primer elemento del rango, mientras que el iterador límite superior no apunta a ningún elemento del rango, sino justo más allá del final del mismo. Para recorrer un contenedor completo, el begin()método proporciona el límite inferior y end()el límite superior. Este último no hace referencia a ningún elemento del contenedor, sino que es un valor de iterador válido con el que se puede comparar.

El siguiente ejemplo muestra un uso típico de un iterador.

importar std ;usando std :: vector ;int main () { vector < int > items ; items . push_back ( 5 ); // Agrega el valor entero '5' al vector 'items'. items . push_back ( 2 ); // Agrega el valor entero '2' al vector 'items'. items . push_back ( 9 ); // Agrega el valor entero '9' al vector 'items'.// Iterar a través de 'items'. // 'it' es de tipo vector<int>::iterator for ( auto it = items . begin (), end = items . end (); it != end ; ++ it ) { // E imprimir el valor de 'items' para el índice actual. std :: print ( "{}" , * it ); }// Usando bucles foreach (añadidos en C++11), // se puede hacer lo mismo sin usar ningún iterador explícito: for ( int x : items ) { // Imprime el valor de cada elemento 'x' de 'items'. std :: print ( "{}" , x ); }// Ambos bucles for imprimen "529". }

Los tipos de iteradores son independientes de los tipos de contenedores con los que se utilizan, aunque ambos se suelen usar conjuntamente. La categoría del iterador (y, por lo tanto, las operaciones definidas para él) suele depender del tipo de contenedor; por ejemplo, los arrays o vectores proporcionan iteradores de acceso aleatorio, mientras que los conjuntos (que utilizan una estructura enlazada como implementación) solo proporcionan iteradores bidireccionales. Un mismo tipo de contenedor puede tener más de un tipo de iterador asociado; por ejemplo, el std::vector<T>tipo de contenedor permite el recorrido utilizando punteros (sin procesar) a sus elementos (de tipo T*), o valores de un tipo especial std::vector<T>::iterator, y se proporciona otro tipo para los "iteradores inversos", cuyas operaciones se definen de tal manera que un algoritmo que realiza un recorrido habitual (hacia adelante) en realidad realizará el recorrido en orden inverso cuando se le llame con iteradores inversos. La mayoría de los contenedores también proporcionan un const_iteratortipo separado, para el cual no se definen intencionadamente operaciones que permitan cambiar los valores a los que apuntan.

El recorrido simple de un objeto contenedor o un rango de sus elementos (incluida la modificación de esos elementos a menos que const_iteratorse use un iterador) se puede hacer usando solo iteradores. Pero los tipos de contenedor también pueden proporcionar métodos como inserto eraseque modifican la estructura del contenedor en sí; estos son métodos de la clase contenedor, pero además requieren uno o más valores de iterador para especificar la operación deseada. Si bien es posible tener varios iteradores apuntando al mismo contenedor simultáneamente, las operaciones que modifican la estructura pueden invalidar ciertos valores de iterador (el estándar especifica para cada caso si esto puede ser así); usar un iterador invalidado es un error que dará lugar a un comportamiento indefinido , y tales errores no necesitan ser señalados por el sistema de tiempo de ejecución.

La iteración implícita también es parcialmente compatible con C++ mediante el uso de plantillas de funciones estándar, como std::for_each()y std::copy() . std::accumulate()

Cuando se utilizan, deben inicializarse con iteradores existentes, normalmente beginy end, que definen el rango sobre el que se produce la iteración. Pero posteriormente no se expone ningún objeto iterador explícito a medida que avanza la iteración. Este ejemplo muestra el uso de for_each.

// Cualquier tipo de contenedor estándar de elementos ItemType. ContainerType < ItemType > c ;// Función que procesará cada elemento de la colección. void processItem ( const ItemType & i ) { std :: println ( "{}" , i ); }// Un bucle de iteración for-each. std :: for_each ( c.begin ( ), c.end (), processItem ) ; // usando std::ranges :: for_each ( c , processItem ) ;

Lo mismo se puede lograr usando std::copy, pasando un std::ostream_iteratorvalor como tercer iterador:

using std :: cout ; using std :: ostream_iterator ;std :: copy ( c.begin ( ) , c.end ( ), ostream_iterator <ItemType> ( cout , " \n " ) ) ; // usando std::ranges: std :: ranges :: copy ( c , ostream_iterator <ItemType> ( cout , " \ n " ) );

Desde C++11 , la sintaxis de las funciones lambda permite especificar la operación que se iterará en línea, evitando la necesidad de definir una función con nombre. Aquí hay un ejemplo de iteración for-each usando una función lambda:

ContainerType < ItemType > c ; // Cualquier tipo de contenedor estándar de elementos ItemType.// Un bucle de iteración for-each con una función lambda. std :: for_each ( c.begin ( ), c.end (), []( const ItemType & i ) - > void { std :: println ( "{}" , i ); });// Usando std::ranges: std :: ranges :: for_each ( c , []( const ItemType & i ) -> void { std :: println ( "{}" , i ); });

La sintaxis al estilo Java para iteradores ( Iterator<T>, vs T::iterator) se puede implementar en C++ de la siguiente manera:

importar std ;espacio de nombres { // concepto auxiliar: si tiene iterador plantilla < typename T > concepto Has_iterator = requiere { typename T :: iterador }; }template < typename Iterable > requiere Has_iterator < Iterable > usando Iterator = typename Iterable :: iterator ;// Ahora se puede llamar así:plantilla < typename T > usando Vector = std :: vector < T > ;int main () { Vector <int> v { 1 , 2 , 3 , 4 , 5 } ; for ( Iterator < Vector <int> > it = v.begin ( ); it != v.end ( ) ; ++ it ) { std :: println ( " { }" , * it ) ; } }

Introducida en la versión 1.2 de Java JDK, la java.util.Iteratorinterfaz permite la iteración de clases contenedoras. Cada una Iteratorproporciona un método next()y , ^{[ 20 ] : 294–295} y opcionalmente puede admitir un método ^{[ 20 ] : 262, 266.} Los iteradores son creados por la clase contenedora correspondiente, normalmente por un método llamado . ^{[ 21 ] [ 20 ] : 99 [ 20 ] : 217}hasNext()remove()iterator()

El next()método avanza el iterador y devuelve el valor al que apunta el iterador. El primer elemento se obtiene en la primera llamada a next(). ^{[ 20 ] : 294–295} Para determinar cuándo se han visitado todos los elementos del contenedor hasNext()se utiliza el método de prueba. ^{[ 20 ] : 262} El siguiente ejemplo muestra un uso sencillo de iteradores:

import java.util.Iterator ;Iterador iter = lista.iterador ( ) ; Iterador <MyType> iter = lista.iterador ( ) ; // Iterador iter = lista.iterador ( ) ; antes de J2SE 5.0 while ( iter.hasNext ( ) ) { System.out.print ( iter.next ( ) ) ; if ( iter.hasNext ( ) ) { System.out.print ( " , " ) ; } }

Para demostrar que hasNext()se puede llamar repetidamente, lo usamos para insertar comas entre los elementos, pero no después del último elemento.

Este enfoque no separa adecuadamente la operación de avance del acceso real a los datos. Si el elemento de datos debe usarse más de una vez para cada avance, debe almacenarse en una variable temporal . Cuando se requiere un avance sin acceso a los datos (es decir, para omitir un elemento de datos determinado), el acceso se realiza igualmente, aunque el valor devuelto se ignora en este caso.

Para los tipos de colección que lo admiten, el remove()método del iterador elimina el elemento visitado más recientemente del contenedor, manteniendo el iterador utilizable. Agregar o eliminar elementos llamando a los métodos del contenedor (también desde el mismo hilo ) hace que el iterador sea inutilizable. Intentar obtener el siguiente elemento genera una excepción. También se genera una excepción si no quedan más elementos ( hasNext()si previamente ha devuelto falso).

Además, java.util.Listexiste java.util.ListIteratoruna API similar pero que permite la iteración hacia adelante y hacia atrás, proporciona su índice actual en la lista y permite establecer el elemento de la lista en su posición.

La versión J2SE 5.0 de Java introdujo la Iterableinterfaz para admitir un bucle for( foreach ) mejorado para iterar sobre colecciones y matrices. Iterabledefine el iterator()método que devuelve un Iterator. ^{[ 20 ] : 266} Usando el forbucle mejorado, el ejemplo anterior se puede reescribir como

for ( MyType obj : list ) { System . out . print ( obj ); }

Algunos contenedores también utilizan la Enumerationclase anterior (desde la versión 1.0). Proporciona hasMoreElements()métodos nextElement(), pero no tiene métodos para modificar el contenedor.

En Scala , los iteradores cuentan con un amplio conjunto de métodos similares a los de las colecciones, y pueden utilizarse directamente en bucles `for`. De hecho, tanto los iteradores como las colecciones heredan de un rasgo base común: `<iterador>` scala.collection.TraversableOnce. Sin embargo, debido al amplio conjunto de métodos disponibles en la biblioteca de colecciones de Scala, como map` <iterador>`, `<recopilador>`, `<recopilador>` collect, filteretc., a menudo no es necesario trabajar directamente con iteradores al programar en Scala.

Los iteradores y colecciones de Java se pueden convertir automáticamente en iteradores y colecciones de Scala, respectivamente, simplemente agregando una sola línea.

import scala . collection . JavaConversions . _

al archivo. El JavaConversionsobjeto proporciona conversiones implícitas para ello. Las conversiones implícitas son una característica de Scala: métodos que, cuando son visibles en el ámbito actual, insertan automáticamente llamadas a sí mismos en las expresiones relevantes en el lugar apropiado para que pasen la verificación de tipos cuando de otro modo no la pasarían.

MATLAB admite iteración implícita tanto externa como interna utilizando matrices "nativas" o cellmatrices. En el caso de la iteración externa, donde el usuario es responsable de avanzar el recorrido y solicitar los siguientes elementos, se puede definir un conjunto de elementos dentro de una estructura de almacenamiento de matriz y recorrer los elementos utilizando la forconstrucción de bucle. Por ejemplo,

% Definir una matriz de enteros myArray = [ 1 , 3 , 5 , 7 , 11 , 13 ];para n = myArray % ... hacer algo con n disp ( n ) % Mostrar el número entero en la ventana de comandos fin

Recorre una matriz de enteros usando la forpalabra clave.

En el caso de la iteración interna, donde el usuario puede proporcionar una operación al iterador para que la realice sobre cada elemento de una colección, muchos operadores integrados y funciones de MATLAB se sobrecargan para ejecutarse sobre cada elemento de una matriz y devolver implícitamente una matriz de salida correspondiente. Además, las funciones arrayfuny cellfunse pueden aprovechar para realizar operaciones personalizadas o definidas por el usuario sobre matrices "nativas" y cellmatrices respectivamente. Por ejemplo,

función simpleFun % Define una matriz de enteros myArray = [ 1 , 3 , 5 , 7 , 11 , 13 ];% Realiza una operación personalizada sobre cada elemento myNewArray = arrayfun (@( a ) myCustomFun ( a ), myArray );% Muestra el array resultante en la ventana de comandos myNewArrayfunción outScalar = myCustomFun ( inScalar ) % Simplemente multiplica por 2 outScalar = 2 * inScalar ;

define una función principal simpleFunque aplica implícitamente una subfunción personalizada myCustomFuna cada elemento de una matriz utilizando una función integrada arrayfun.

Alternativamente, puede ser deseable abstraer los mecanismos del contenedor de almacenamiento de matrices del usuario definiendo una implementación personalizada orientada a objetos de MATLAB del Patrón Iterador. Dicha implementación que admite iteración externa se muestra en el elemento de MATLAB Central File Exchange Patrón de diseño: Iterador (comportamiento) . Esto está escrito en la nueva sintaxis de definición de clase introducida con la versión 7.6 (R2008a) del software MATLAB y presenta una realización de matriz unidimensional celldel Tipo de Datos Abstracto (TDA) Lista como mecanismo para almacenar un conjunto heterogéneo (en tipo de datos) de elementos. Proporciona la funcionalidad para el recorrido explícito hacia adelante de la Lista con los hasNext()métodos next()y reset()para usar en un whilebucle.

foreachEl bucle de PHP se introdujo en la versión 4.0 y se hizo compatible con objetos como valores en la versión 4.0 Beta 4. ^{[ 22 ]} Sin embargo, el soporte para iteradores se agregó en PHP  5 mediante la introducción de la interfaz interna ^{[ 23 ]}Traversable . ^{[ 24 ]} Las dos interfaces principales para la implementación en scripts PHP que permiten iterar objetos a través del foreachbucle son Iteratory IteratorAggregate. Esta última no requiere que la clase implementadora declare todos los métodos necesarios, sino que implementa un método de accesogetIterator ( ) que devuelve una instancia de Traversable. La biblioteca estándar de PHP proporciona varias clases para trabajar con iteradores especiales. ^{[ 25 ]} PHP también admite generadores desde la versión 5.5. ^{[ 26 ]}

La implementación más sencilla consiste en envolver un array, lo que puede resultar útil para sugerir tipos y ocultar información .

espacio de nombres Wikipedia\Iterador ;clase final ArrayIterator extiende \Iterator { matriz privada $array ;función pública __construct ( array $array ) { $this -> array = $array ; }public function rewind () : void { echo 'rebobinando' , PHP_EOL ; reset ( $this -> array ); }public function current () { $value = current ( $this -> array ); echo "current: { $value } " , PHP_EOL ; return $value ; }public function key () { $key = key ( $this -> array ); echo "clave: { $key } " , PHP_EOL ; return $key ; }public function next () { $value = next ( $this -> array ); echo "siguiente: { $value } " , PHP_EOL ; return $value ; }public function valid () : bool { $valid = $this -> current () !== false ; echo 'válido: ' , ( $valid ? 'true' : 'false' ), PHP_EOL ; return $valid ; } }

Todos los métodos de la clase de ejemplo se utilizan durante la ejecución de un bucle foreach completo ( foreach ($iterator as $key => $current) {}). Los métodos del iterador se ejecutan en el siguiente orden:

1. $iterator->rewind()Garantiza que la estructura interna comience desde el principio.
2. $iterator->valid()En este ejemplo, devuelve verdadero .
3. $iterator->current()El valor devuelto se almacena en $value.
4. $iterator->key()El valor devuelto se almacena en $key.
5. $iterator->next()avanza al siguiente elemento en la estructura interna.
6. $iterator->valid()Devuelve falso y el bucle se interrumpe.

El siguiente ejemplo ilustra una clase PHP que implementa la Traversableinterfaz, la cual podría encapsularse en una IteratorIteratorclase para procesar los datos antes de que regresen al foreachbucle. Su uso, junto con la MYSQLI_USE_RESULTconstante, permite que los scripts PHP iteren conjuntos de resultados con miles de millones de filas con un consumo mínimo de memoria. Estas características no son exclusivas de PHP ni de sus implementaciones de clases MySQL (por ejemplo, la clase también PDOStatementimplementa la interfaz).Traversable

mysqli_report ( MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT ); $mysqli = new \mysqli ( 'host.example.com' , 'username' , 'password' , 'database_name' );// La clase \mysqli_result que devuelve la llamada al método implementa la interfaz interna Traversable. foreach ( $mysqli -> query ( 'SELECT `a`, `b`, `c` FROM `table`' , MYSQLI_USE_RESULT ) as $row ) { // Actuar sobre la fila devuelta, que es un array asociativo. }

Los iteradores en Python son una parte fundamental del lenguaje y, en muchos casos, pasan desapercibidos, ya que se utilizan implícitamente en la instrucción for` foreach` , en las comprensiones de listas y en las expresiones generadoras . Todos los tipos de colecciones estándar integrados de Python admiten iteración, al igual que muchas clases que forman parte de la biblioteca estándar. El siguiente ejemplo muestra una iteración implícita típica sobre una secuencia:

para cada valor en la secuencia : imprimir ( valor )

Los diccionarios de Python (una forma de matriz asociativa ) también se pueden iterar directamente, cuando se devuelven las claves del diccionario; o items()se puede iterar sobre el método de un diccionario, donde produce pares clave-valor correspondientes como una tupla:

para cada clave en diccionario : valor = diccionario [ clave ] imprimir ( clave , valor )

para clave , valor en diccionario.items ( ) : imprimir ( clave , valor )

Sin embargo, los iteradores pueden usarse y definirse explícitamente. Para cualquier tipo o clase de secuencia iterable, iter()se utiliza la función integrada para crear un objeto iterador. Este objeto iterador puede recorrerse con la next()función, que internamente utiliza el __next__()método, el cual devuelve el siguiente elemento del contenedor. (La afirmación anterior se aplica a Python 3.x. En Python 2.x, el método es equivalente). Se generará next()una excepción cuando no queden más elementos. El siguiente ejemplo muestra una iteración equivalente sobre una secuencia utilizando iteradores explícitos:StopIteration

from typing import Iteratorsecuencia : lista [ int ] = [ 1 , 2 , 3 , 4 ] it : iterador [ int ] = iter ( secuencia ) mientras True : intentar : valor = it.siguiente () # en Python 2.x valor = siguiente ( it ) # en Python 3.x excepto StopIteration : romper imprimir ( valor )

Cualquier clase definida por el usuario puede admitir la iteración estándar (implícita o explícita) definiendo un __iter__()método que devuelva un objeto iterador. Este objeto iterador, a su vez, debe definir un __next__()método que devuelva el siguiente elemento.

Los generadores de Python implementan este protocolo de iteración .

Los iteradores en Raku son una parte fundamental del lenguaje, aunque normalmente los usuarios no tienen que preocuparse por ellos. Su uso está oculto tras las API de iteración, como la forinstrucción, map, grep, la indexación de listas con .[$idx], etc.

El siguiente ejemplo muestra una iteración implícita típica sobre una colección de valores:

mis @valores = 1 , 2 , 3 ; para @valores -> $valor { decir $valor } # SALIDA: # 1 # 2 # 3

Los hashes de Raku también se pueden iterar directamente, lo que produce Pairobjetos clave-valor. kvSe puede invocar un método sobre el hash para iterar sobre la clave y los valores; otro keysmétodo para iterar sobre las claves del hash; y otro valuesmétodo para iterar sobre los valores del hash.

mi %palabra-a-número = 'uno' => 1 , 'dos' => 2 , 'tres' => 3 ; para %palabra-a-número -> $par { decir $par ; } # SALIDA: # tres => 3 # uno => 1 # dos => 2para %word-to-number . kv -> $key , $value { decir "$key: $value" } # SALIDA: # tres: 3 # uno: 1 # dos: 2para %word-to-number . keys -> $key { decir "$key => " ~ %word-to-number { $key }; } # SALIDA: # tres => 3 # uno => 1 # dos => 2

Sin embargo, los iteradores pueden usarse y definirse explícitamente. Para cualquier tipo iterable, existen varios métodos que controlan diferentes aspectos del proceso de iteración. Por ejemplo, iteratorse supone que un método debe devolver un Iteratorobjeto, y otro pull-onemétodo debe generar y devolver el siguiente valor si es posible, o devolver el valor centinelaIterationEnd si no se pueden generar más valores. El siguiente ejemplo muestra una iteración equivalente sobre una colección utilizando iteradores explícitos:

mis @valores = 1 , 2 , 3 ; mi $it := @valores.iterador ; # obtener iterador para @valoresbucle { mi $valor := $it . pull-one ; # obtener el siguiente valor de la iteración last if $valor =:= IterationEnd ; # detenerse si llegamos al final de la iteración say $valor ; } # SALIDA: # 1 # 2 # 3

En Raku, todos los tipos iterables componen el Iterablerol, Iteratorel rol o ambos. El Iterablees bastante simple y solo requiere que iteratorla clase que lo compone implemente. El Iteratores más complejo y proporciona una serie de métodos como pull-one, que permiten una operación de iteración más precisa en varios contextos, como agregar o eliminar elementos, o saltarlos para acceder a otros elementos. Por lo tanto, cualquier clase definida por el usuario puede admitir la iteración estándar componiendo estos roles e implementando los métodos iteratory/o .pull-one

La DNAclase representa una cadena de ADN y la implementa iteratorcomponiendo el Iterablerol. La cadena de ADN se divide en un grupo de trinucleótidos cuando se itera sobre ella:

subconjunto Strand de Str donde { . coincidencia ( /^^ <[ACGT]>+ $$/ ) y . caracteres %% 3 }; clase DNA hace Iterable { tiene $.chain ; método nuevo ( Strand:D $chain ) { self . bendice: : $chain } método iterador ( ADN:D: ){ $.cadena . peine . rotor ( 3 ). iterador } }; para el ADN . nuevo ( 'GATTACATA' ) { . decir } # SALIDA: # (GAT) # (TAC) # (ATA)diga ADN . nuevo ( 'GATTACATA' ). map (*. join ). join ( '-' ); # SALIDA: # GAT-TAC-ATA

La Repeaterclase se compone de los roles Iterabley :Iterator

clase Repeater hace Iterable hace Iterator { tiene Any $.item es requerido ; tiene Int $.times es requerido ; tiene Int $!count = 1 ; multi método nuevo ( $item , $times ) { self . bless: : $item , : $times ; } método iterador { self } método pull-one (--> Mu ){ si $!count <= $!times { $!count += 1 ; return $!item } de lo contrario { devolver Fin de iteración } } } para Repeater.new ( "Hola " , 3 ) { . decir } # SALIDA: # Hola # Hola # Hola

Ruby implementa los iteradores de forma bastante diferente; todas las iteraciones se realizan pasando funciones de devolución de llamada a métodos contenedores. De esta manera, Ruby no solo implementa la iteración básica, sino también varios patrones de iteración como el mapeo de funciones, los filtros y la reducción. Ruby también admite una sintaxis alternativa para el método de iteración básico each; los siguientes tres ejemplos son equivalentes:

( 0 ... 42 ) . cada uno hace | n | pone n fin

...y...

para n en 0 ... 42 pone n fin

o incluso más corto

42 . veces hacer | n | pone n fin

Ruby también puede iterar sobre listas fijas usando Enumerators y llamando a su #nextmétodo o haciendo un for each sobre ellas, como se indicó anteriormente.

Rust utiliza iteradores externos en toda la biblioteca estándar, incluso en su forbucle, que llama implícitamente al next()método de un iterador hasta que se consume. El forbucle más básico, por ejemplo, itera sobre un Rangetipo:

for i in 0 .. 42 { println! ( "{}" , i ); } // Imprime los números del 0 al 41

Específicamente, el forbucle llamará al into_iter()método de un valor, que devuelve un iterador que a su vez proporciona los elementos al bucle. El forbucle (o cualquier método que consuma el iterador) continúa hasta que el next()método devuelve un Nonevalor (las iteraciones que producen elementos devuelven un Some(T)valor, donde Tes el tipo de elemento).

Todas las colecciones proporcionadas por la biblioteca estándar implementan el IntoIteratorrasgo (es decir, definen el into_iter()método). Los iteradores también implementan el Iteratorrasgo, lo que requiere definir el next()método. Además, cualquier tipo que implemente Iteratorrecibe automáticamente una implementación que IntoIteratordevuelve el mismo método.

Los iteradores admiten varios adaptadores ( map(), filter(), skip(), take(), etc.) como métodos proporcionados automáticamente por el Iteratorrasgo.

Los usuarios pueden crear iteradores personalizados creando un tipo que implemente la Iteratorcaracterística. Las colecciones personalizadas pueden implementar la IntoIteratorcaracterística y devolver un tipo de iterador asociado para sus elementos, lo que permite su uso directo en forbucles. A continuación, el Fibonaccitipo implementa un iterador personalizado sin límite:

struct Fibonacci ( u64 , u64 );impl Fibonacci { pub fn new () -> Self { Self ( 0 , 1 ) } }iterador de implementación para Fibonacci { tipo Item = u64 ;fn next ( & mut self ) -> Option < Self :: Item > { let next = self . 0 ; self . 0 = self . 1 ; self . 1 = self . 0 + next ;Algunos ( siguiente ) } }fn main () { let fib = Fibonacci :: new (); for n in fib . skip ( 1 ). step_by ( 2 ). take ( 4 ) { println! ( "{n}" ); } // Imprime 1, 2, 5 y 13 }