0Pricing
Learn Rust Coding · Lección

Iteradores personalizados

Implementar Iterator

Iteradores personalizados es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 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.

crear su propio iterador

No está limitado a los iteradores integrados. Al implementar el trait Iterator en su propio tipo, este obtiene gratuitamente todos los adaptadores y consumidores.

Solo debe proporcionar el tipo Item y un método next.

una estructura Counter

Comience con una estructura que almacene el estado del iterador. Un contador sencillo solo necesita un valor actual.

struct Counter {
    count: u32,
}

fn main() {
    let c = Counter { count: 0 };
    println!("start at {}", c.count);
}

implementar next

Implemente Iterator para la estructura. Establezca type Item y escriba después next para avanzar el estado y devolver Some hasta alcanzar una condición de parada; después, devuelva None.

struct Counter { count: u32 }

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let mut c = Counter { count: 0 };
    println!("{:?}", c.next());
    println!("{:?}", c.next());
}

usarlo en un bucle for

Una vez que existe next, su tipo funciona en un bucle for, igual que cualquier iterador estándar.

struct Counter { count: u32 }

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 5 { self.count += 1; Some(self.count) } else { None }
    }
}

fn main() {
    for n in (Counter { count: 0 }) {
        print!("{} ", n);
    }
    println!();
}

adaptadores y consumidores gratuitos

Como ha implementado un método, ahora puede utilizar todo el conjunto de herramientas de iteradores. Aquí sumamos los cuadrados de valores emparejados de dos contadores.

struct Counter { count: u32 }

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 5 { self.count += 1; Some(self.count) } else { None }
    }
}

fn main() {
    let total: u32 = Counter { count: 0 }.map(|x| x * 2).sum();
    println!("{}", total);
}

un método constructor

Añada una función new para que los usuarios no tengan que acceder directamente a los campos internos. Es más limpio y le permite mantener el campo privado.

struct Counter { count: u32 }

impl Counter {
    fn new() -> Counter { Counter { count: 0 } }
}

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 3 { self.count += 1; Some(self.count) } else { None }
    }
}

fn main() {
    let v: Vec<u32> = Counter::new().collect();
    println!("{:?}", v);
}

un iterador de Fibonacci

Los iteradores pueden mantener un estado más complejo. Un generador de Fibonacci conserva los dos últimos valores y los actualiza en cada llamada a next.

struct Fib { a: u64, b: u64 }

impl Iterator for Fib {
    type Item = u64;
    fn next(&mut self) -> Option<u64> {
        let current = self.a;
        self.a = self.b;
        self.b = current + self.b;
        Some(current)
    }
}

fn main() {
    let fib = Fib { a: 0, b: 1 };
    let seq: Vec<u64> = fib.take(8).collect();
    println!("{:?}", seq);
}

los iteradores infinitos son válidos

El iterador de Fibonacci nunca devuelve None: es infinito. Esto es seguro porque la evaluación perezosa hace que los valores se produzcan solo cuando se solicitan. Use take para limitarlo.

struct Fib { a: u64, b: u64 }

impl Iterator for Fib {
    type Item = u64;
    fn next(&mut self) -> Option<u64> {
        let c = self.a;
        self.a = self.b;
        self.b = c + self.b;
        Some(c)
    }
}

fn main() {
    let big = Fib { a: 0, b: 1 }.nth(20);
    println!("{:?}", big);
}

iterar sobre un tipo envoltorio

A menudo se implementa Iterator en una estructura auxiliar que toma prestados sus datos. Aquí, un stepper produce cada segundo número de un rango almacenado en su interior.

struct EvenUpTo { current: u32, max: u32 }

impl Iterator for EvenUpTo {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.current > self.max { return None; }
        let value = self.current;
        self.current += 2;
        Some(value)
    }
}

fn main() {
    let evens: Vec<u32> = (EvenUpTo { current: 0, max: 10 }).collect();
    println!("{:?}", evens);
}

¿por qué crear iteradores personalizados?

Los iteradores personalizados permiten transmitir valores sin reservar una colección completa, modelar secuencias infinitas o calculadas y ofrecer a los usuarios una interfaz familiar y componible.

Un pequeño método next desbloquea todo el ecosistema.

consejos de diseño

Mantenga el estado mínimo, devuelva None exactamente una vez al final —o nunca en los iteradores infinitos— y evite realizar trabajo costoso dentro de next para que la evaluación perezosa siga siendo eficiente.

comprobación rápida

Implementar el trait Iterator.

repaso

Ha creado iteradores personalizados:

  • Almacene el estado en una estructura y, después, use impl Iterator
  • Defina type Item y escriba next
  • Obtiene al instante adaptadores y consumidores de forma gratuita
  • Los iteradores pueden ser finitos o infinitos; use take para limitar los infinitos

Preguntas frecuentes

¿La lección «Iteradores personalizados» es gratis?

Sí — el texto completo de «Iteradores personalizados» 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 «Iteradores personalizados»?

Implementar Iterator 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 4 de 4.

¿Cuánto tiempo toma la lección «Iteradores personalizados»?

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

  1. El trait Iterator
  2. map, filter, collect
  3. Adaptadores y consumidores
  4. Iteradores personalizados
← Volver a Learn Rust Coding