Learn Rust Coding · Lección

Adaptadores y consumidores

Encadenar operaciones

Adaptadores y consumidores es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 3 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.

Dos tipos de métodos

Los métodos de los iteradores se dividen en dos grupos:

Adaptadores: devuelven un iterador nuevo y son perezosos (map, filter, take)
Consumidores: ejecutan el iterador y producen un valor final (sum, collect, for_each)

Cada pipeline contiene cero o más adaptadores seguidos exactamente de un consumidor.

take: limitar el número

take(n) produce como máximo n elementos y después se detiene. Es un adaptador, por lo que sigue siendo perezoso.

Funciona incluso con iteradores infinitos: solo toma lo que se solicita.

fn main() {
    let first_three: Vec<i32> = (1..).take(3).collect();
    println!("{:?}", first_three);
}

skip: ignorar los primeros elementos

skip(n) descarta los primeros n elementos y produce el resto. Combínelo con take para obtener una ventana de la parte central.

fn main() {
    let window: Vec<i32> = (1..=10).skip(3).take(4).collect();
    println!("{:?}", window);
}

enumerate: asociar un índice

enumerate produce tuplas (index, value), empezando a contar desde cero. Es la forma idiomática de obtener posiciones sin un contador manual.

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

zip: recorrer dos iteradores juntos

zip empareja elementos de dos iteradores. Se detiene cuando se agota el más corto.

Resulta útil para combinar datos paralelos, como nombres y puntuaciones.

fn main() {
    let names = vec!["Ana", "Ben"];
    let ages = vec![30, 25];
    for (name, age) in names.iter().zip(ages.iter()) {
        println!("{} is {}", name, age);
    }
}

rev: invertir el orden

rev produce los elementos de atrás hacia delante. Requiere un iterador de doble extremo, como los que proporcionan los rangos y los slices.

fn main() {
    let backwards: Vec<i32> = (1..=5).rev().collect();
    println!("{:?}", backwards);
}

chain: unir dos iteradores

chain ejecuta el primer iterador hasta completarlo y después continúa con el segundo, como si fueran una sola secuencia.

fn main() {
    let joined: Vec<i32> = (1..=3).chain(10..=12).collect();
    println!("{:?}", joined);
}

fold: construir un único valor

fold es el consumidor general. Comienza con un acumulador y combina cada elemento con él mediante un cierre.

Muchos consumidores, como sum, son casos particulares de fold.

fn main() {
    let product = (1..=5).fold(1, |acc, x| acc * x);
    println!("5! = {}", product);
}

any y all: consumidores booleanos

any devuelve true si al menos un elemento satisface el predicado; all devuelve true únicamente si todos lo satisfacen.

Ambos aplican evaluación con cortocircuito: se detienen en cuanto conocen la respuesta.

fn main() {
    let nums = vec![2, 4, 6, 7];
    println!("{}", nums.iter().all(|x| x % 2 == 0));
    println!("{}", nums.iter().any(|x| x % 2 != 0));
}

find y position

find devuelve el primer elemento que coincide con un predicado como un Option. position devuelve, en su lugar, el índice de la primera coincidencia.

Ambos aplican cortocircuito al encontrar la primera coincidencia.

fn main() {
    let nums = vec![1, 3, 5, 8, 9];
    println!("{:?}", nums.iter().find(|&&x| x % 2 == 0));
    println!("{:?}", nums.iter().position(|&x| x % 2 == 0));
}

diseñar pipelines

Construya pipelines encadenando adaptadores y terminándolos con un consumidor. Manténgalos legibles: una operación por línea.

Como los adaptadores son perezosos, incluso las cadenas largas solo recorren los datos una vez.

comprobación rápida

Adaptadores frente a consumidores.

repaso

Ha explorado cómo encadenar operaciones:

Los adaptadores (take, skip, enumerate, zip, rev, chain) siguen siendo perezosos
Los consumidores (fold, any, all, find, position) completan el trabajo
Los consumidores booleanos y de búsqueda aplican cortocircuito
Cada pipeline consta de adaptadores seguidos de un consumidor

Preguntas frecuentes

¿La lección «Adaptadores y consumidores» es gratis?

Sí — el texto completo de «Adaptadores y consumidores» 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 «Adaptadores y consumidores»?

Encadenar operaciones 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 3 de 4.

¿Cuánto tiempo toma la lección «Adaptadores y consumidores»?

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