FerrousPath

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

  1. Escribe un programa que convierta una temperatura en grados Fahrenheit (guardada en una variable) a Celsius e imprima ambas con un decimal ({:.1}).
  2. Declara una tupla con tu nombre, tu edad y tu altura en metros, desestructúrala e imprime una frase.
  3. 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. 1.¿Qué ocurre al compilar let x = 5; x = 6;?

  2. 2.¿Cuál es el tipo de x en let x = 2.0;?

  3. 3.En una compilación debug, ¿qué hace let x: u8 = 255; let y = x + 1; en tiempo de ejecución?

Términos clave de esta lección

¿Has terminado la lección y los ejercicios?