Learn Rust Coding · Lección

Variables, mutabilidad y sombreado

Comprenda cómo declarar variables, gestionar la mutabilidad y utilizar el sombreado para redefinir variables con flexibilidad.

Variables, mutabilidad y sombreado es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 de 3. 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 3 lecciones en total.

Introducción a las variables de Rust

¡Bienvenido! En Rust, las variables son fundamentales para almacenar datos. Son como cajas etiquetadas donde guarda la información que su programa necesita.

Rust pone mucho énfasis en la seguridad, y esto comienza con la forma en que gestiona las variables. Aprenderá a declararlas, controlar si pueden cambiar y hasta «redefinirlas» de maneras ingeniosas.

Declaración de variables con `let`

Para crear una variable en Rust, usamos la palabra clave let. Esto asigna un nombre a un valor. Rust suele inferir el tipo, por lo que no siempre es necesario especificarlo.

Pruebe a ejecutar este sencillo ejemplo:

fn main() {
  let apples = 5;
  println!("I have {} apples.", apples);
}

Inmutabilidad predeterminada de Rust

Un concepto clave de Rust es que las variables son inmutables de forma predeterminada. Una vez que asigna un valor a una variable, no puede cambiarlo posteriormente.

Esto puede parecer restrictivo, pero ayuda a prevenir errores y hace que su código sea más seguro y fácil de analizar, especialmente en la programación concurrente.

Cómo hacer que las variables sean mutables con `mut`

Si necesita que el valor de una variable cambie, puede hacerla mutable explícitamente usando la palabra clave mut antes del nombre de la variable.

Esto indica a Rust y a los demás desarrolladores que el valor de esta variable está destinado a cambiar.

fn main() {
  let mut score = 100;
  println!("Initial score: {}", score);

  score = 150; // We can change it now!
  println!("New score: {}", score);
}

Cuándo usar `mut`

Aunque mut es potente, es recomendable usarlo solo cuando sea necesario. Dé prioridad a la inmutabilidad de forma predeterminada.

Use mut para contadores, variables de estado o valores que realmente deban actualizarse.
Si un valor nunca cambia después de su asignación inicial, manténgalo inmutable (sin mut).
Claridad: marcar explícitamente una variable como mut hace más clara la intención de su código.

Definición de constantes con `const`

Las constantes son tipos especiales de variables inmutables. Se declaran con la palabra clave const en lugar de let y siempre deben tener su tipo anotado explícitamente.

Las constantes solo pueden establecerse con expresiones constantes, no con el resultado de una llamada a una función ni con ningún valor que solo pueda calcularse durante la ejecución.

fn main() {
  const MAX_USERS: u32 = 10_000; // Type annotation is required!
  println!("Max users allowed: {}", MAX_USERS);
}

Variables `let` frente a constantes `const`

Estas son las diferencias principales entre las variables let y las constantes const:

Mutabilidad: las variables let son inmutables de forma predeterminada, pero pueden hacerse mutables con mut. Las constantes const son siempre inmutables.
Declaración: let usa let. const usa const.
Anotación de tipo: las variables let suelen poder inferir su tipo. Las constantes const deben tener el tipo especificado.
Ámbito: las constantes const pueden declararse en cualquier ámbito, incluido el ámbito global.

Introducción al sombreado

Rust permite declarar una nueva variable con el mismo nombre que una variable anterior. Esto se denomina sombreado.

La nueva variable «oculta» a la anterior, lo que significa que cualquier código posterior verá el valor de la nueva variable. La variable anterior sigue existiendo en la memoria, pero ya no se puede acceder a ella directamente.

fn main() {
  let x = 5;
  println!("First x: {}", x); // Outputs 5

  let x = x + 1; // 'x' is shadowed by a new 'x'
  println!("Second x: {}", x); // Outputs 6

  { // Inner scope
    let x = x * 2; // 'x' is shadowed again
    println!("Inner x: {}", x); // Outputs 12
  }
  println!("Outer x: {}", x); // Outputs 6 (inner x is out of scope)
}

Sombreado para la conversión de tipos

Un uso potente del sombreado consiste en transformar el valor de una variable e incluso su tipo, manteniendo el mismo nombre. Esto es habitual cuando necesita analizar una cadena y convertirla en un número.

En lugar de crear un nombre de variable nuevo (por ejemplo, string_val y después num_val), puede reutilizar el mismo nombre.

fn main() {
  let spaces = "   ";
  println!("Spaces string: '{}'", spaces);

  // Shadow 'spaces' with a new variable that holds its length
  let spaces = spaces.len();
  println!("Spaces count: {}", spaces);
}

Comprobación rápida: variables y mutabilidad

Considere el siguiente código de Rust. ¿Cuál será el valor final de y que se imprimirá en la consola?

Repaso de variables, mutabilidad y sombreado

¡Buen trabajo! Ha aprendido los conceptos esenciales de las variables en Rust:

Use let para declarar variables, que son inmutables de forma predeterminada.
Añada mut para hacer que una variable sea mutable, lo que permite cambiar su valor.
Use const para las constantes, que siempre son inmutables y requieren anotaciones de tipo.
El sombreado permite declarar una nueva variable con el mismo nombre, reemplazando la anterior. Esto resulta útil para las conversiones de tipos.

A continuación, profundizaremos en los distintos tipos de datos primitivos de Rust.

Preguntas frecuentes

¿La lección «Variables, mutabilidad y sombreado» es gratis?

Sí — el texto completo de «Variables, mutabilidad y 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 3 lecciones en total.

¿Qué aprenderé en «Variables, mutabilidad y sombreado»?

Comprenda cómo declarar variables, gestionar la mutabilidad y utilizar el sombreado para redefinir variables con flexibilidad. 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 1 de 3.

¿Cuánto tiempo toma la lección «Variables, mutabilidad y 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.

Todas las lecciones de este curso

← Volver a Learn Rust Coding