Option en Rust

Rust no tiene null. Si un valor puede faltar, eso se dice directamente en el tipo, usando Option. Al principio parece un trámite de más, pero elimina una categoría entera de errores: la famosa “referencia nula”, que ha provocado incontables fallos en otros lenguajes.

Cómo es Option

Option es un enum con dos variantes:

enum Option<T> {
    Some(T), // hay un valor
    None,    // no hay valor
}

De hecho, ya lo has visto: .get() en un vector y .get() en un HashMap devuelven un Option.

Crear un Option

fn main() {
    let has_value: Option<i32> = Some(5);
    let no_value: Option<i32> = None;

    println!("{:?}", has_value);
    println!("{:?}", no_value);
}

Salida:

Some(5)
None

▶ Pruébalo tú mismo

Manejar un Option con match

La forma segura de sacar el valor es con match. Rust te obliga a cubrir los dos casos, así que no puedes olvidarte sin querer del caso en el que falta el valor:

fn main() {
    let age: Option<i32> = Some(30);

    match age {
        Some(value) => println!("La edad es {value}"),
        None => println!("No se indicó la edad"),
    }
}

▶ Pruébalo tú mismo

Un ejemplo más realista

fn find_user(id: u32) -> Option<&'static str> {
    if id == 1 {
        Some("Alice")
    } else {
        None
    }
}

fn main() {
    match find_user(1) {
        Some(name) => println!("Encontrado: {name}"),
        None => println!("Usuario no encontrado"),
    }

    match find_user(99) {
        Some(name) => println!("Encontrado: {name}"),
        None => println!("Usuario no encontrado"),
    }
}

Salida:

Encontrado: Alice
Usuario no encontrado

▶ Pruébalo tú mismo

En lugar de devolver null o lanzar una excepción cuando no encuentra al usuario, es el propio tipo de retorno de la función el que avisa a quien la llama: “puede que no encuentre nada”. Y el compilador no le deja ignorar esa posibilidad.

Atajos: unwrap_or y unwrap

En los casos sencillos, un match completo puede parecer demasiado. Hay un par de atajos:

fn main() {
    let age: Option<i32> = None;

    let value = age.unwrap_or(0); // si no hay valor, usa 0
    println!("{value}");
}

▶ Pruébalo tú mismo

También existe .unwrap(), que te da el valor directamente, pero provoca un panic (el programa se detiene) si es None:

let age: Option<i32> = Some(30);
let value = age.unwrap(); // aquí no hay problema, porque age es Some

Precaución

En código real, usa .unwrap() solo cuando estés seguro de que el valor es Some: por ejemplo, en pruebas rápidas o en ejemplos como los de esta página. En código de producción, es mejor usar match, unwrap_or o el operador ? (lo verás en la siguiente página), para que un valor que falta no tumbe todo tu programa.

Práctica

1. El primer número par

Escribe fn first_even(numbers: &[i32]) -> Option<i32>, que devuelva el primer número par del slice, o None si no hay ninguno. Imprime el resultado para [3, 7, 8, 10] con match, y para [1, 3, 5] con .unwrap_or(0). Pista: recorre el slice y haz return Some(n) en cuanto n % 2 == 0; después del bucle, devuelve None.

Ver solución

fn first_even(numbers: &[i32]) -> Option<i32> {
    for &n in numbers {
        if n % 2 == 0 {
            return Some(n);
        }
    }
    None
}

fn main() {
    match first_even(&[3, 7, 8, 10]) {
        Some(n) => println!("Primer par: {n}"),
        None => println!("No hay números pares"),
    }

    let fallback = first_even(&[1, 3, 5]).unwrap_or(0);
    println!("Con valor por defecto: {fallback}");
}

Salida:

Primer par: 8
Con valor por defecto: 0

▶ Pruébalo tú mismo

2. Buscar un ajuste

Crea un HashMap de ajustes que solo contenga "volumen" con el valor 80. Después recorre las claves "volumen" y "brillo" e imprime el valor si existe, o un mensaje de “no configurado” si no existe. Pista: .get(key) sobre un HashMap devuelve un Option, así que puedes usar match directamente sobre él.

Ver solución

use std::collections::HashMap;

fn main() {
    let mut settings = HashMap::new();
    settings.insert("volumen", 80);

    for key in ["volumen", "brillo"] {
        match settings.get(key) {
            Some(value) => println!("{key} = {value}"),
            None => println!("{key} no está configurado"),
        }
    }
}

Salida:

volumen = 80
brillo no está configurado

▶ Pruébalo tú mismo

Resumen

• Option<T> representa un valor que puede estar o no estar. Rust no tiene null.
• Some(value) contiene algo; None significa que no hay nada.
• match es la forma segura de manejar los dos casos: el compilador no te deja olvidar ninguno.
• .unwrap_or(default) te da un valor de respaldo; .unwrap() provoca un panic si el valor es None, así que úsalo con moderación.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. ¿Qué usa Rust en lugar de null para un valor que puede faltar?

Un tipo especial NullPointer Un String vacío Option<T>

2. ¿Qué pasa si llamas a .unwrap() sobre un valor None?

Provoca un panic Devuelve un valor por defecto Vuelve a devolver None sin decir nada

3. ¿Qué hace age.unwrap_or(0) cuando age es None?

Provoca un panic con un error Usa 0 como valor de respaldo Convierte None en Some(0) para siempre

4. ¿Por qué match se considera la forma segura de sacar el valor de un Option?

Es más rápido que unwrap Convierte None en un valor por defecto automáticamente El compilador te obliga a manejar tanto Some como None

5. ¿Cuáles de los métodos mencionados en esta página ya devuelven un Option?

.push() en un vector .get() en un vector o en un HashMap .len() en un String

Puntuación: 0 / 5

Para leer más

• El enum Option y sus ventajas frente a los valores nulos — El libro de Rust (en inglés): la explicación oficial de por qué Rust usa Option en lugar de null.
• std::option — documentación de la biblioteca estándar (en inglés): un repaso de todo lo que puedes hacer con un Option, incluidos métodos útiles como map, and_then e is_some.
• Option & unwrap — Rust by Example (en inglés): ejemplos cortos y ejecutables de match, unwrap y de cuándo se produce un panic.
• Option<T> — documentación de std (en inglés): la lista completa de métodos, cada uno con un pequeño ejemplo que puedes copiar.