Sombreado
Vincular variables de nuevo
Sombreado 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.
¿Qué es el shadowing?
Shadowing significa declarar una variable nueva con el mismo nombre que otra anterior. La nueva vinculación «oculta» la anterior.
Para hacerlo, repita let con el mismo nombre.
fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("x is {}", x);
}El shadowing no es mutabilidad
El shadowing crea una variable completamente nueva. Esto difiere de mut, que reutiliza la misma variable.
Como cada let es una vinculación nueva, los valores incluso pueden tener tipos diferentes.
fn main() {
let y = 10; // immutable
let y = y + 5; // new binding, also immutable
println!("y is {}", y);
}Cambiar tipos mediante shadowing
Un uso potente del shadowing es reutilizar un nombre mientras se cambia su tipo.
Aquí se analiza una cadena para convertirla en un número utilizando el mismo nombre.
fn main() {
let spaces = " ";
let spaces = spaces.len();
println!("count is {}", spaces);
}Por qué mut no puede cambiar el tipo
Con mut puede cambiar el valor, pero no el tipo.
Esto no compilaría:
let mut spaces = " ";spaces = spaces.len();— error de incompatibilidad de tipos.
El sombreado evita este problema porque crea una variable nueva.
fn main() {
let mut count = 3;
count = 4; // ok, same type
println!("{}", count);
}Sombreado en ámbitos internos
Una variable puede ocultarse dentro de un bloque interno. Cuando termina el bloque, el enlace externo vuelve a estar visible.
fn main() {
let n = 1;
{
let n = n * 10;
println!("inner {}", n);
}
println!("outer {}", n);
}Transformación paso a paso
El sombreado permite transformar un valor en varios pasos conservando un único nombre claro.
fn main() {
let input = "42";
let input: i32 = input.trim().parse().unwrap();
let input = input * 2;
println!("result {}", input);
}El sombreado conserva la inmutabilidad
Cada enlace sombreado permanece inmutable. Después de una transformación, conserva la seguridad de la inmutabilidad sin tener que inventar nombres nuevos como x2 o x_temp.
fn main() {
let price = 100;
let price = price - 20; // discount applied
let price = price + 5; // shipping added
println!("final price {}", price);
}Sombreado con lógica diferente
Puede calcular el valor nuevo de la forma que quiera, incluso mediante llamadas a funciones o expresiones.
fn main() {
let text = "hello";
let text = text.to_uppercase();
println!("{}", text);
}Evitar confusiones
El sombreado resulta útil, pero abusar de él puede confundir a quienes lean el código. Úselo cuando cada paso sea una transformación clara del mismo concepto, no solo para reutilizar nombres al azar.
fn main() {
let raw = " Rust ";
let raw = raw.trim(); // clean version
println!("[{}]", raw);
}Resumen: sombreado frente a reasignación
Hay dos formas de asignar un valor nuevo a un nombre:
- Sombreado: volver a usar
let x = ...;— crea una variable nueva, puede cambiar el tipo y permanece inmutable. - Reasignación:
x = ...;conmut— utiliza la misma variable y exige el mismo tipo.
fn main() {
let val = "7";
let val: i32 = val.parse().unwrap(); // shadow + type change
let mut val = val;
val += 1; // reassign, same type
println!("{}", val);
}Un ejemplo práctico
Leer y convertir datos del usuario es un caso clásico para usar sombreado: puede conservar el nombre significativo age mientras el tipo cambia de texto a número.
fn main() {
let age = "25";
let age: u32 = age.parse().unwrap();
let age = age + 1; // next birthday
println!("next year you will be {}", age);
}Comprobación rápida
Determine qué diferencia el sombreado del uso de mut.
Resumen
Sombreado en Rust:
- Repita
letcon el mismo nombre para crear un enlace nuevo. - El enlace nuevo puede tener un tipo diferente.
- Cada valor sombreado permanece inmutable.
- Se diferencia de
mut, que modifica la misma variable y conserva su tipo.
fn main() {
let data = "100";
let data: i32 = data.parse().unwrap();
let data = data / 4;
println!("final {}", data);
}Preguntas frecuentes
¿La lección «Sombreado» es gratis?
Sí — el texto completo de «Sombreado» 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 «Sombreado»?
Vincular variables de nuevo 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 «Sombreado»?
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.