Learn Rust Coding · Lección

map, filter, collect

Transformar secuencias

map, filter, collect es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 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.

Transformación de secuencias

Tres métodos realizan la mayor parte del trabajo en los pipelines de iteradores: map transforma cada elemento, filter conserva algunos elementos y collect reúne los resultados en una colección.

Juntos sustituyen muchos bucles manuales por cadenas breves y fáciles de leer.

map: una entrada, una salida

map aplica un cierre a cada elemento y produce el valor transformado. El número de elementos se mantiene; solo cambian sus valores.

Es perezoso, por lo que el cierre solo se ejecuta cuando se consume el iterador.

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

map puede cambiar el tipo

El tipo de salida de map no tiene que coincidir con el de entrada. Aquí convertimos números en cadenas.

Esto hace que map sea perfecto para convertir datos de una forma a otra.

fn main() {
    let nums = vec![1, 2, 3];
    let labels: Vec<String> = nums.iter().map(|x| format!("n{}", x)).collect();
    println!("{:?}", labels);
}

filter: conserve lo que necesite

filter recibe un cierre que devuelve bool. Se conservan los elementos para los que devuelve true; el resto se descarta.

El cierre recibe una referencia, por lo que a menudo debe desreferenciarla con * o usar pattern matching.

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

Encadenamiento de map y filter

Puede encadenar adaptadores libremente. El orden importa: cada elemento pasa por la cadena de arriba abajo.

Aquí conservamos los números pares y después elevamos al cuadrado los que quedan.

fn main() {
    let result: Vec<i32> = (1..=6)
        .filter(|x| x % 2 == 0)
        .map(|x| x * x)
        .collect();
    println!("{:?}", result);
}

collect en un Vec

collect consume un iterador y construye una colección. Como son posibles muchos tipos de colección, normalmente debe anotar el tipo de destino.

La sintaxis turbofish collect::<Vec<_>>() es una alternativa a anotar la variable.

fn main() {
    let squares = (1..=4).map(|x| x * x).collect::<Vec<i32>>();
    println!("{:?}", squares);
}

collect en un String

collect no se limita a los vectores. Un iterador de char puede recopilarse en un String.

Rust usa el tipo de destino para decidir cómo ensamblar los elementos.

fn main() {
    let shouted: String = "hello".chars().map(|c| c.to_ascii_uppercase()).collect();
    println!("{}", shouted);
}

collect en un HashMap

Un iterador de tuplas clave-valor puede recopilarse en un HashMap. Empareje los elementos con zip o cree tuplas en un map.

Es una forma clara de construir búsquedas a partir de dos secuencias paralelas.

use std::collections::HashMap;

fn main() {
    let map: HashMap<i32, i32> = (1..=3).map(|x| (x, x * x)).collect();
    println!("{:?}", map.get(&2));
}

Combinación de los tres

Un pipeline típico se lee como una frase: tome los elementos, fíltrelos, transfórmelos y recopílelos.

Aquí conservamos las palabras de más de tres letras y las convertimos a mayúsculas.

fn main() {
    let words = vec!["hi", "rust", "go", "code"];
    let kept: Vec<String> = words
        .into_iter()
        .filter(|w| w.len() > 3)
        .map(|w| w.to_uppercase())
        .collect();
    println!("{:?}", kept);
}

filter_map: filtrar y transformar a la vez

filter_map aplica un cierre que devuelve Option. Some(v) se conserva y se desenvuelve; None se descarta.

Resulta especialmente útil al analizar datos, cuando algunas entradas pueden no ser válidas.

fn main() {
    let inputs = vec!["1", "two", "3"];
    let nums: Vec<i32> = inputs
        .into_iter()
        .filter_map(|s| s.parse::<i32>().ok())
        .collect();
    println!("{:?}", nums);
}

Por qué funciona este patrón

Los pipelines de map/filter/collect son declarativos: indican qué quiere, no cómo recorrer los elementos. Evitan errores de desfase de uno y estados mutables intermedios.

Además, gracias a la pereza, no se crean vectores temporales entre los pasos.

Comprobación rápida

Compruebe lo que sabe sobre la transformación de secuencias.

Resumen

Ya puede construir pipelines de iteradores reales:

map transforma cada elemento y puede cambiar su tipo
filter conserva los elementos cuyo predicado es true
collect reúne los resultados en Vec, String, HashMap y más
filter_map filtra y transforma en un solo paso mediante Option

Preguntas frecuentes

¿La lección «map, filter, collect» es gratis?

Sí — el texto completo de «map, filter, collect» 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 «map, filter, collect»?

Transformar secuencias 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 2 de 4.

¿Cuánto tiempo toma la lección «map, filter, collect»?

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