Nivel 1 · Fundamentos· Lección 2 de 10 · 20 min
Variables y tipos
Enlaces, mutabilidad, sombreado y los tipos escalares y compuestos con los que se construye cualquier programa.
Los enlaces son inmutables por defecto
let enlaza un nombre con un valor. Salvo que digas lo contrario, ese enlace (binding) no se puede reasignar.
fn main() {
let x = 5;
println!("x = {x}");
x = 6; // ❌ error[E0384]: no se puede asignar dos veces a una variable inmutable
println!("x = {x}");
}
Añade mut para permitir la mutación:
fn main() {
let mut count = 0;
count += 1;
count += 1;
println!("count = {count}");
}
¿Por qué este valor por defecto? La mayoría de los valores no cambian después de crearse, y quien lee el código y no ve un mut lo sabe con certeza. La mutabilidad pasa a ser algo que llama la atención.
Sombreado
Puedes declarar un enlace nuevo con el mismo nombre. El anterior queda sombreado (shadowed), no modificado, y el nuevo puede tener un tipo distinto.
fn main() {
let input = " 42 ";
let input = input.trim(); // sigue siendo un &str, pero sin espacios
let input: i32 = input.parse().unwrap(); // ahora es un i32
println!("{}", input + 1);
}
El sombreado es idiomático para este tipo de refinamiento paso a paso. Evita nombres como input_str, input_trimmed, input_num.
Constantes
const MAX_CONNECTIONS: u32 = 1_000;
fn main() {
println!("{MAX_CONNECTIONS}");
}
Una const debe llevar anotación de tipo y un valor calculable en tiempo de compilación. Se inserta directamente allí donde se usa. Los guiones bajos en los literales numéricos solo sirven para facilitar la lectura.
Tipos escalares
| Clase | Tipos | Notas |
|---|---|---|
| Enteros con signo | i8 i16 i32 i64 i128 isize |
i32 es el tipo por defecto |
| Enteros sin signo | u8 u16 u32 u64 u128 usize |
usize indexa las colecciones |
| Coma flotante | f32 f64 |
f64 es el tipo por defecto |
| Booleano | bool |
true o false; no es un entero |
| Carácter | char |
Un valor escalar Unicode de 4 bytes, no un byte |
Rust infiere los tipos donde puede y nunca convierte implícitamente entre tipos numéricos. Usa as para una conversión que puede truncar, o From/TryFrom para conversiones que dicen si pueden fallar.
fn main() {
let a: i32 = 7;
let b: f64 = 2.0;
// let c = a / b; // ❌ no compilaría: los tipos no coinciden
let c = a as f64 / b; // conversión explícita
let big: i64 = i64::from(a); // sin pérdida, no puede fallar
let small = u8::try_from(300i32); // puede fallar: devuelve un Result
println!("{c} {big} {small:?}");
let heart = '❤';
println!("{heart} is {} bytes as a char", std::mem::size_of::<char>());
}
Desbordamiento de enteros
El desbordamiento es un error que Rust se niega a dejar pasar en silencio. En las compilaciones debug, la aritmética que desborda entra en pánico. En las compilaciones release da la vuelta (complemento a dos). Cuando quieras un comportamiento concreto, dilo:
fn main() {
let x: u8 = 250;
println!("{:?}", x.checked_add(10)); // None
println!("{}", x.wrapping_add(10)); // 4
println!("{}", x.saturating_add(10)); // 255
println!("{:?}", x.overflowing_add(10)); // (4, true)
}
Tipos compuestos
Una tupla agrupa un número fijo de valores de tipos posiblemente distintos. Un array contiene un número fijo de valores de un mismo tipo; su longitud forma parte de su tipo.
fn main() {
let point: (i32, i32, &str) = (3, -4, "origin-ish");
let (x, y, label) = point; // desestructuración
println!("{label}: {x}, {y}; first field again: {}", point.0);
let primes: [u32; 5] = [2, 3, 5, 7, 11];
let zeros = [0u8; 16]; // dieciséis ceros
println!("{} {} {}", primes[0], primes.len(), zeros.len());
let unit = (); // la tupla vacía, llamada «unit»: el tipo de «nada interesante»
println!("{unit:?}");
}
Indexar un array fuera de sus límites se comprueba. Con un índice constante el compilador lo rechaza; con un índice calculado en tiempo de ejecución el programa entra en pánico en lugar de leer memoria que no le pertenece. Esa comprobación es una de las formas en que Rust cumple la promesa de la lección 1.
Inferencia de tipos
La inferencia de Rust mira cómo se usa un valor, no solo cómo se crea:
fn main() {
let mut numbers = Vec::new(); // aquí aún no se conoce el tipo de los elementos…
numbers.push(1u64); // …se decide aquí
let parsed = "17".parse::<u8>().unwrap(); // el «turbofish» nombra el tipo de destino
println!("{numbers:?} {parsed}");
}
Cuando el compilador dice type annotations needed, te está diciendo que nada en el código fija el tipo. Añade una anotación en el let o usa el turbofish ::<T>.
Ejercicios
- Escribe un programa que convierta una temperatura en grados Fahrenheit (guardada en una variable) a Celsius e imprima ambas con un decimal (
{:.1}). - Declara una tupla con tu nombre, tu edad y tu altura en metros, desestructúrala e imprime una frase.
- Predice la salida y después ejecuta:
let x = 5; let x = x * 2; { let x = x + 1; println!("{x}"); } println!("{x}");
Solución del 3
Imprime 11 y después 10. La x interior sombrea a la exterior solo dentro del bloque; cuando el bloque termina, el enlace exterior (10) vuelve a ser visible.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Qué ocurre al compilar
let x = 5; x = 6;?2.¿Cuál es el tipo de
xenlet x = 2.0;?3.En una compilación debug, ¿qué hace
let x: u8 = 255; let y = x + 1;en tiempo de ejecución?