Closures
Funciones anónimas
Closures 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.
¿Qué es un closure?
Un closure es una función anónima que puede almacenar en una variable y llamar más adelante. Se escribe con barras verticales alrededor de los parámetros.
fn main() {
let add_one = |x| x + 1;
println!("{}", add_one(4));
}Sintaxis de los closures
Los parámetros se escriben entre |...|, seguidos del cuerpo. Si consta de una sola expresión, no hacen falta llaves.
|x| x + 1— un parámetro.|a, b| a + b— dos parámetros.
fn main() {
let multiply = |a, b| a * b;
println!("{}", multiply(3, 5));
}Closures de varias líneas
Si contiene más de una sentencia, encierre el cuerpo entre llaves, igual que en una función.
fn main() {
let describe = |n: i32| {
let doubled = n * 2;
println!("{} doubled is {}", n, doubled);
};
describe(7);
}Capturar el entorno
A diferencia de una función común, un closure puede capturar variables del ámbito circundante y utilizarlas en su interior.
fn main() {
let factor = 10;
let scale = |x| x * factor;
println!("{}", scale(5));
}Inferencia de tipos en closures
Normalmente, los closures infieren los tipos de sus parámetros y de retorno según cómo se utilicen, por lo que las anotaciones son opcionales.
Puede agregar tipos para aportar claridad cuando sea necesario.
fn main() {
let greet = |name: &str| -> String {
format!("Hello, {}!", name)
};
println!("{}", greet("Rust"));
}Closures como argumentos
Muchos métodos estándar aceptan un closure. Por ejemplo, map aplica un closure a cada elemento.
fn main() {
let nums = vec![1, 2, 3];
let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
println!("{:?}", doubled);
}Filtrar con closures
El método filter conserva únicamente los elementos para los que el closure devuelve true.
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);
}Almacenar closures
Los closures tienen tipos anónimos únicos, pero puede almacenarlos en una variable y reutilizarlos.
fn main() {
let is_even = |n: i32| n % 2 == 0;
println!("{} {}", is_even(4), is_even(7));
}Closures frente a funciones
Diferencias:
- Las funciones no pueden capturar variables circundantes; los closures sí.
- Los closures son anónimos y normalmente breves.
- Los tipos de los closures suelen inferirse.
fn main() {
let base = 100;
let bonus = |earned: i32| earned + base;
println!("{}", bonus(25));
}Devolver valores calculados
Combine closures con iteradores para calcular resultados mediante una canalización clara y expresiva.
fn main() {
let nums = vec![10, 20, 30];
let total: i32 = nums.iter().map(|x| x + 1).sum();
println!("total {}", total);
}Los closures capturan por referencia
De forma predeterminada, un closure toma prestadas las variables capturadas. Después puede seguir leyéndolas fuera del closure, siempre que solo se hayan tomado prestadas.
fn main() {
let name = String::from("Ada");
let printer = || println!("Name: {}", name);
printer();
println!("still usable: {}", name);
}Comprobación rápida
Recuerde una capacidad fundamental de los closures.
Resumen
Closures en Rust:
- Funciones anónimas escritas como
|params| body. - Pueden capturar variables de su entorno.
- Sus tipos normalmente se infieren.
- Se usan ampliamente con métodos de iteradores como
mapyfilter.
fn main() {
let tax = 0.2;
let with_tax = |price: f64| price * (1.0 + tax);
println!("{}", with_tax(50.0));
}Preguntas frecuentes
¿La lección «Closures» es gratis?
Sí — el texto completo de «Closures» 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 «Closures»?
Funciones anónimas 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 «Closures»?
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.