Variables en Rust

Una variable es simplemente un nombre que le das a un valor para poder usarlo más tarde. Imagínala como una caja con etiqueta: metes algo dentro, escribes un nombre en la caja y, a partir de ahí, usas ese nombre en lugar de repetir el valor por todas partes.

Crear una variable

En Rust creas una variable con la palabra clave let:

fn main() {
    let age = 30;
    println!("Mi edad es {age}");
}

Salida:

Mi edad es 30

▶ Pruébalo tú mismo

Veamos esa línea por partes:

• let: le dice a Rust “voy a crear una variable nueva”.
• age: el nombre que elegimos.
• =: asigna el valor de la derecha al nombre de la izquierda.
• 30: el valor que guardamos.

El {age} dentro de println! imprime el valor de la variable. Esto se llama interpolación de cadenas: Rust cambia {age} por lo que contenga age.

Rust adivina el tipo por ti

Todo valor en Rust tiene un tipo (un número entero, texto, true/false, etc.). Quizá pienses que tienes que declarar ese tipo, pero normalmente no hace falta: Rust mira el valor y lo deduce solo. A esto se le llama inferencia de tipos.

fn main() {
    let score = 95;        // Rust deduce que es un entero
    let name = "Ferris";   // Rust deduce que es texto
    let is_active = true;  // Rust deduce que es un booleano
    println!("{name}: {score}, activo = {is_active}");
}

Salida:

Ferris: 95, activo = true

▶ Pruébalo tú mismo

Si alguna vez quieres ser explícito, puedes escribir el tipo después de dos puntos:

let score: i32 = 95; // i32 = un entero de 32 bits

Nota

i32 solo significa “un número entero que cabe en 32 bits”. No te preocupes todavía por los tipos exactos: los vemos a fondo en Tipos de datos. Por ahora, dejar que Rust los deduzca está perfecto.

Las variables son inmutables por defecto

Esta es la parte que sorprende a quienes vienen de otros lenguajes: en Rust, una vez que le das un valor a una variable, no puedes cambiarlo por defecto. “Inmutable” significa simplemente que no se puede cambiar.

Este código no compila:

fn main() {
    let count = 1;
    count = 2; // ❌ error: no se puede asignar dos veces a una variable inmutable
    println!("{count}");
}

El compilador te detiene con un mensaje claro:

error[E0384]: cannot assign twice to immutable variable `count`

Es decir: no puedes asignar dos veces un valor a la variable inmutable count.

¿Por qué un lenguaje haría esto a propósito? Porque muchos errores vienen de valores que cambian cuando no lo esperabas. Al hacer que las cosas no se puedan cambiar a menos que tú lo pidas, Rust hace que tu código sea más predecible. Es una ventaja, no una limitación.

Hacer que una variable se pueda cambiar con mut

Cuando de verdad necesitas que un valor cambie, añade la palabra clave mut (abreviatura de mutable, es decir, que se puede cambiar):

fn main() {
    let mut count = 1;
    println!("Antes: {count}");

    count = 2; // ✅ ahora sí está permitido, gracias a `mut`
    println!("Después: {count}");
}

Salida:

Antes: 1
Después: 2

▶ Pruébalo tú mismo

Consejo

Un buen hábito: empieza sin mut. Añádelo solo cuando el compilador se queje de que intentas cambiar un valor. Así tus variables siguen siendo inmutables, salvo las que de verdad necesitan cambiar.

Shadowing: reutilizar el mismo nombre

Rust te deja declarar una variable nueva con el mismo nombre que una anterior. Esto se llama shadowing (sombreado): la nueva “le hace sombra” a la anterior:

fn main() {
    let x = 5;
    let x = x + 1;   // una x nueva, basada en la x anterior -> 6
    let x = x * 2;   // otra x nueva -> 12
    println!("x vale {x}");
}

Salida:

x vale 12

▶ Pruébalo tú mismo

Se parece a mut, pero no es lo mismo:

• mut cambia el valor de la misma variable.
• Shadowing crea una variable totalmente nueva que reutiliza el nombre, y hasta puede ser de otro tipo.

El shadowing es útil cuando quieres transformar un valor pero seguir usando el mismo nombre:

fn main() {
    let spaces = "   ";        // texto
    let spaces = spaces.len(); // ahora es un número (cuántos espacios hay)
    println!("Número de espacios: {spaces}");
}

Salida:

Número de espacios: 3

▶ Pruébalo tú mismo

Constantes

Una constante es un valor que nunca cambia y que queda fijado al compilar. La declaras con const en lugar de let, y tienes que escribir el tipo:

const MAX_SCORE: u32 = 100;

fn main() {
    println!("La puntuación máxima es {MAX_SCORE}");
}

Salida:

La puntuación máxima es 100

▶ Pruébalo tú mismo

Por convención, las constantes se escriben en UPPER_SNAKE_CASE. Así se comparan con las variables normales:

	Variable con let	Constante con const
¿Puede cambiar?	Solo con mut	Nunca
¿Hace falta el tipo?	Opcional (se deduce)	Obligatorio
Estilo de nombre	snake_case	UPPER_SNAKE_CASE
Dónde se permite	Dentro de funciones	En cualquier sitio, incluso fuera de funciones

Usa una constante para valores que de verdad son fijos, como los segundos que tiene un minuto o un límite máximo.

Reglas para los nombres

• Usa snake_case: palabras en minúscula unidas con guiones bajos, como user_name o total_price.
• Los nombres pueden tener letras, números y guiones bajos, pero no pueden empezar por un número.
• Elige nombres que se entiendan: age es mejor que a.

Errores típicos de principiante

• Olvidar mut cuando necesitas cambiar un valor → cannot assign twice to immutable variable.
• Usar una variable antes de crearla → en Rust, el let tiene que ir primero.
• Variables sin usar generan un aviso (warning). Si lo haces a propósito, pon un guion bajo delante del nombre: let _unused = 5;.

Práctica

1. Sube de nivel

Crea una variable level que empiece en 1. Imprímela, súbela en 1 dos veces e imprímela después de cada cambio, para obtener Nivel 1, Nivel 2 y Nivel 3. Pista: un valor que cambia necesita mut, y level = level + 1; le suma uno.

Ver solución

fn main() {
    let mut level = 1;
    println!("Nivel {level}");

    level = level + 1;
    println!("Nivel {level}");

    level = level + 1;
    println!("Nivel {level}");
}

Salida:

Nivel 1
Nivel 2
Nivel 3

▶ Pruébalo tú mismo

2. De minutos a segundos

Declara una constante SECONDS_PER_MINUTE con el valor 60. Empieza con let time = 5; (en minutos) y luego haz shadowing de time para que guarde la misma duración en segundos. Imprime Son 300 segundos. Pista: el nuevo time se puede construir a partir del anterior: let time = time * ...;.

Ver solución

const SECONDS_PER_MINUTE: u32 = 60;

fn main() {
    let time = 5; // minutos
    let time = time * SECONDS_PER_MINUTE; // un `time` nuevo, ahora en segundos
    println!("Son {time} segundos");
}

Salida:

Son 300 segundos

▶ Pruébalo tú mismo

No hace falta mut: el segundo let crea una variable totalmente nueva que reutiliza el nombre. Además, aquí Rust deduce que time es un u32, porque se multiplica por la constante u32.

Resumen

• Crea variables con let; normalmente Rust deduce el tipo por ti.
• Las variables son inmutables por defecto: añade mut para poder cambiarlas.
• El shadowing vuelve a declarar un nombre con let y crea una variable nueva (que puede cambiar de tipo).
• Las constantes (const) nunca cambian, siempre necesitan un tipo y se escriben en UPPER_SNAKE_CASE.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. Por defecto, ¿puedes volver a asignar un valor a una variable let en Rust?

Sí, siempre No, a menos que se declare con mut Solo si es un número

2. ¿Qué es el shadowing en Rust?

Declarar una variable nueva con let que reutiliza un nombre existente Esconder una variable de otras funciones Hacer que una variable sea privada

3. Según esta página, ¿qué convención de nombres usan las variables en Rust?

camelCase PascalCase snake_case

Puntuación: 0 / 3

Para leer más

• Variables and Mutability: The Rust Book (en inglés): el capítulo oficial sobre let, mut, las constantes y por qué la inmutabilidad es la opción por defecto.
• Shadowing: The Rust Book (en inglés): más sobre en qué se diferencia el shadowing de mut, incluido el cambio de tipo de un valor.
• Variable Bindings: Rust by Example (en inglés): ejemplos cortos y ejecutables, con continuaciones sobre mutabilidad y sobre ámbito y shadowing.
• Constants: Rust by Example (en inglés): const (y su primo static) en un programa pequeño.
• Palabra clave let: documentación de la biblioteca estándar (en inglés): todo lo que puede hacer let, para cuando quieras el panorama completo.