miércoles 11 septiembre 2024

Cómo usar un iterator en Rust

En Rust, un iterator (iterador) es una estructura que permite recorrer secuencias de datos, como elementos de un array o de un vector, uno a la vez. Los iteradores no consumen los datos inmediatamente; en su lugar, se pueden encadenar operaciones para procesarlos de forma perezosa hasta que sean consumidos. Esto hace que los iteradores sean eficientes y flexibles.

Los iteradores en Rust implementan el trait Iterator, que requiere que se defina el método next. Este método retorna el siguiente valor de la secuencia o None si no hay más elementos.

Creación de un iterator

Una forma común de crear un iterador es utilizando el método .iter() en colecciones como vectores o arrays:

let numeros = vec![1, 2, 3, 4];
let mut iter = numeros.iter();

println!("{:?}", iter.next()); // Imprime Some(1)
println!("{:?}", iter.next()); // Imprime Some(2)

Métodos comunes de los iterators

Rust ofrece muchos métodos útiles para trabajar con iteradores. Algunos de los más comunes son:

1. map()

Transforma cada elemento del iterador aplicando una función.

let numeros = vec![1, 2, 3];
let doblados: Vec<i32> = numeros.iter().map(|x| x * 2).collect();
println!("{:?}", doblados); // Imprime [2, 4, 6]

2. filter()

Filtra los elementos del iterador basándose en una condición.

let numeros = vec![1, 2, 3, 4, 5];
let pares: Vec<i32> = numeros.iter().filter(|&&x| x % 2 == 0).collect();
println!("{:?}", pares); // Imprime [2, 4]

3. for_each()

Ejecuta una función sobre cada elemento del iterador sin producir una colección nueva.

let numeros = vec![1, 2, 3];
numeros.iter().for_each(|x| println!("{}", x)); // Imprime 1, 2, 3

4. fold()

Acumula un valor aplicando una función a cada elemento del iterador, comenzando con un valor inicial.

let numeros = vec![1, 2, 3, 4];
let suma = numeros.iter().fold(0, |acc, x| acc + x);
println!("{}", suma); // Imprime 10

Ejemplos de iteradores personalizados

Puedes crear tus propios iteradores implementando el trait Iterator. A continuación, un ejemplo de un iterador simple que genera una secuencia:

struct Contador {
    actual: u32,
    maximo: u32,
}

impl Iterator for Contador {
    type Item = u32;

    fn next(&mut self) -> Option<u32> {
        if self.actual < self.maximo {
            self.actual += 1;
            Some(self.actual)
        } else {
            None
        }
    }
}

let mut contador = Contador { actual: 0, maximo: 5 };

while let Some(num) = contador.next() {
    println!("{}", num); // Imprime 1, 2, 3, 4, 5
}

Referencia oficial

Para obtener más información sobre los iteradores en Rust, visita la documentación oficial de Rust.

Etiquetas:

rust

Creado por:

Jorge García

Fullstack developer