Learn Rust Coding · Lección

El trait Iterator

next y evaluación perezosa

El trait Iterator es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué es un iterador?

Un iterador es cualquier elemento que produce una secuencia de valores, uno cada vez. En Rust, los iteradores son la forma idiomática de procesar colecciones como vectores, rangos y slices.

Todo el concepto se basa en un único trait: Iterator. Una vez que un tipo lo implementa, obtiene decenas de métodos útiles de forma gratuita.

El trait Iterator

El trait Iterator tiene un método obligatorio, next, y un tipo asociado, Item:

type Item — el tipo de valor producido
fn next(&mut self) -> Option<Self::Item> — devuelve el siguiente valor

Devuelve Some(value) mientras queden valores y después None cuando termina.

fn main() {
    let v = vec![10, 20, 30];
    let mut it = v.iter();
    println!("{:?}", it.next());
    println!("{:?}", it.next());
    println!("{:?}", it.next());
    println!("{:?}", it.next());
}

next devuelve Option

Cada llamada a next avanza el iterador y le entrega un Option. Some contiene un valor real; None indica el final.

Observe que next recibe &mut self: al llamarlo cambia el estado interno, por lo que la siguiente llamada devuelve un valor diferente.

fn main() {
    let mut it = (1..4).into_iter();
    while let Some(n) = it.next() {
        println!("got {}", n);
    }
    println!("done");
}

Los iteradores son perezosos

Crear un iterador no hace nada por sí solo. No se calcula ningún valor hasta que algo lo solicita. Esto se denomina pereza.

En el siguiente ejemplo, el cierre map nunca se ejecuta porque nunca consumimos el iterador.

fn main() {
    let nums = vec![1, 2, 3];
    let _doubled = nums.iter().map(|x| {
        println!("mapping {}", x);
        x * 2
    });
    println!("nothing printed above this line");
}

Consumir activa el trabajo

Para que un iterador perezoso se ejecute realmente, debe consumirlo. Un bucle for es el consumidor más sencillo: llama a next repetidamente hasta obtener None.

Ahora el mismo cierre map se ejecuta para cada elemento.

fn main() {
    let nums = vec![1, 2, 3];
    for x in nums.iter().map(|x| x * 2) {
        println!("value {}", x);
    }
}

Tres formas de iterar

Las colecciones ofrecen tres métodos que producen iteradores:

iter() — produce &T (préstamos)
iter_mut() — produce &mut T (préstamos mutables)
into_iter() — produce T (toma la propiedad)

fn main() {
    let mut v = vec![1, 2, 3];
    for x in v.iter_mut() {
        *x += 10;
    }
    println!("{:?}", v);
}

Los bucles for usan into_iter

Cuando escribe directamente for x in collection, Rust llama a into_iter(), que consume la colección.

Después de este bucle no puede volver a usar v porque se movió al iterador.

fn main() {
    let v = vec![String::from("a"), String::from("b")];
    for s in v {
        println!("{}", s);
    }
    // v is no longer usable here
}

Los rangos son iteradores

Un rango como 0..5 es un iterador que produce 0, 1, 2, 3, 4. El extremo final es exclusivo. Use 0..=5 para un rango inclusivo.

Los rangos son ideales para bucles de conteo sin tener que llevar un índice manualmente.

fn main() {
    for i in 0..5 {
        print!("{} ", i);
    }
    println!();
    for i in 1..=3 {
        print!("{} ", i);
    }
    println!();
}

count: un consumidor sencillo

count consume todo el iterador y devuelve cuántos elementos produjo. Es uno de los muchos adaptadores consumidores.

Como consume el iterador, no puede reutilizarlo después.

fn main() {
    let total = (1..=100).count();
    println!("there are {} numbers", total);
}

sum: combinación en un valor

sum suma todos los elementos y devuelve un único valor. A menudo debe anotar el tipo de destino para que Rust sepa qué producir.

Esto es más conciso y claro que un bucle acumulador manual.

fn main() {
    let total: i32 = (1..=5).sum();
    println!("sum is {}", total);
}

Por qué son importantes los iteradores

Los iteradores ofrecen componibilidad: puede encadenar operaciones pequeñas para crear pipelines claros. Además, tienen coste cero: el compilador los optimiza para que sean tan rápidos como los bucles escritos a mano.

Dominar next, la pereza y el consumo es la base de todo lo que sigue.

Comprobación rápida

Ponga a prueba su comprensión del trait Iterator.

Resumen

Ha aprendido los fundamentos de los iteradores de Rust:

El trait Iterator solo necesita next y un tipo Item
next devuelve Some(value) y después None
Los iteradores son perezosos: no hacen nada hasta que se consumen
iter, iter_mut e into_iter controlan los préstamos y la propiedad
Los consumidores como for, count y sum ejecutan el trabajo

Preguntas frecuentes

¿La lección «El trait Iterator» es gratis?

Sí — el texto completo de «El trait Iterator» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «El trait Iterator»?

next y evaluación perezosa Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «El trait Iterator»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding