Learn Rust Coding · Lección

Iteración sobre colecciones

for e iteradores

Iteración sobre colecciones 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.

Bucle con for

El bucle for es la forma más sencilla de visitar cada elemento de una colección.

fn main() {
    let nums = vec![1, 2, 3];
    for n in &nums {
        println!("{}", n);
    }
}

Recorrer rangos

Los rangos producen una secuencia que puede recorrer. 1..5 no incluye el extremo; 1..=5 sí lo incluye.

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

El método iter

Al llamar a .iter() se crea un iterador que proporciona referencias a cada elemento. Los iteradores son perezosos hasta que se consumen.

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

Tres formas de iterar

Los vectores ofrecen tres formas de iteración:

iter() — proporciona &T (préstamo).
iter_mut() — proporciona &mut T (préstamo mutable).
into_iter() — proporciona T (adquiere la propiedad).

fn main() {
    let v = vec![1, 2, 3];
    for x in v.into_iter() {
        println!("owned {}", x);
    }
}

Transformar con map

map aplica un cierre a cada elemento y produce un iterador nuevo. Use collect para reunir los resultados.

fn main() {
    let v = vec![1, 2, 3];
    let squared: Vec<i32> = v.iter().map(|x| x * x).collect();
    println!("{:?}", squared);
}

Seleccionar con filter

filter conserva solo los elementos para los que el cierre devuelve true.

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let odds: Vec<i32> = v.into_iter().filter(|x| x % 2 == 1).collect();
    println!("{:?}", odds);
}

Agregar con sum y count

Los métodos consumidores reducen un iterador a un único valor, como sum, count, max y min.

fn main() {
    let v = vec![4, 8, 15, 16];
    let total: i32 = v.iter().sum();
    let how_many = v.iter().count();
    println!("sum {} count {}", total, how_many);
}

Encadenar adaptadores

Los métodos de los iteradores pueden encadenarse en una secuencia clara. Cada paso transforma el flujo antes del consumidor final.

fn main() {
    let v = vec![1, 2, 3, 4, 5, 6];
    let result: i32 = v.iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * 10)
        .sum();
    println!("{}", result);
}

enumerate para obtener índices

enumerate empareja cada elemento con su índice y produce tuplas (index, value).

fn main() {
    let letters = vec!['a', 'b', 'c'];
    for (i, ch) in letters.iter().enumerate() {
        println!("{}: {}", i, ch);
    }
}

Iterar un HashMap

Los iteradores también funcionan con mapas. El bucle produce tuplas de clave y valor.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("a", 1);
    m.insert("b", 2);
    for (k, v) in &m {
        println!("{} -> {}", k, v);
    }
}

for frente a los métodos de iterador

Un bucle for sencillo es ideal para efectos secundarios, como imprimir. Los adaptadores de iterador (map, filter, sum) son especialmente útiles para transformar datos en un valor nuevo.

fn main() {
    let v = vec![2, 4, 6];
    let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();
    for x in &doubled {
        println!("{}", x);
    }
}

Comprobación rápida

Recuerde la función de los adaptadores de iterador.

Repaso

Iterar colecciones en Rust:

for x in &collection para bucles sencillos.
iter, iter_mut e into_iter controlan los préstamos.
Adaptadores: map, filter y enumerate.
Consumidores: collect, sum, count y max.

fn main() {
    let prices = vec![10, 25, 40];
    let with_tax: Vec<i32> = prices.iter().map(|p| p + p / 5).collect();
    let total: i32 = with_tax.iter().sum();
    println!("{:?} total {}", with_tax, total);
}

Preguntas frecuentes

¿La lección «Iteración sobre colecciones» es gratis?

Sí — el texto completo de «Iteración sobre colecciones» 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 «Iteración sobre colecciones»?

for e iteradores 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 «Iteración sobre colecciones»?

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

Vectores
Strings y &str
HashMaps
Iteración sobre colecciones

← Volver a Learn Rust Coding