En muchos lenguajes de programación, la existencia de null representa la ausencia de un valor. Sin embargo, intentar acceder a un valor null cuando se espera un objeto real suele provocar errores críticos que detienen la ejecución del programa. Tony Hoare, el creador de la idea de null, la describió como “el error de mil millones de dólares” debido a la enorme cantidad de errores causados por este concepto.

Rust soluciona esto eliminando null por completo y sustituyéndolo por el tipo Option<T>. Este es un enum definido por la biblioteca estándar con dos variantes: Some(T), que envuelve un valor de tipo T, y None, que representa la ausencia del mismo.

La magia de Option<T> reside en que la posibilidad de que un valor sea inexistente queda grabada en el tipo de dato. Si una función devuelve Option<String>, el compilador no te permitirá usar ese valor como si fuera un String directamente; te obligará a verificar primero si es Some o None. Esto hace que la programación sea mucho más segura. Si decides ignorar esta seguridad usando el método .unwrap(), el programa lanzará un panic (un error fatal) si el valor resulta ser None.

struct Perfil {
    // El campo bio puede contener un String o puede no existir
    bio: Option<String>,
}

struct Usuario {
    nombre: String,
    perfil: Perfil,
}

fn main() {
    // Caso 1: El usuario tiene una biografía
    let usuario1 = Usuario {
        nombre: String::from("Alice"),
        perfil: Perfil { 
            bio: Some(String::from("Programadora de Rust")) 
        },
    };

    // Caso 2: El usuario NO tiene biografía (None)
    let usuario2 = Usuario {
        nombre: String::from("Bob"),
        perfil: Perfil { 
            bio: None 
        },
    };

    // 1. Uso de match para manejar la ausencia de forma segura
    match usuario1.perfil.bio {
        Some(texto) => println!("Bio de {}: {}", usuario1.nombre, texto),
        None => println!("{} no tiene una bio definida.", usuario1.nombre),
    }

    match usuario2.perfil.bio {
        Some(texto) => println!("Bio de {}: {}", usuario2.nombre, texto),
        None => println!("{} no tiene una bio definida.", usuario2.nombre),
    }

    // 2. Uso de un valor por defecto con unwrap_or
    // Si bio es None, se usa el texto "Sin descripción"
    let bio_bob = usuario2.perfil.bio.as_deref().unwrap_or("Sin descripción");
    println!("Resumen de {}: {}", usuario2.nombre, bio_bob);

    // 3. Transformación segura con map
    // map solo ejecuta la función si el valor es Some
    let bio_mayus: Option<String> = usuario1.perfil.bio.map(|b| b.to_uppercase());
    println!("Bio de {} en mayúsculas: {:?}", usuario1.nombre, bio_mayus);
}

Explicación del Código

  • struct Perfil y struct Usuario: Se definen estructuras donde bio es de tipo Option<String>. Esto indica explícitamente que la biografía es opcional.
  • usuario1 y usuario2: Son instancias de Usuario. En usuario1, bio se inicializa con Some(String::from(...)), mientras que en usuario2 se usa None.
  • match usuario1.perfil.bio: Es la forma más segura de extraer el valor. El compilador comprueba que se hayan cubierto todos los casos: Some(texto) para extraer el contenido y None para el caso vacío.
  • usuario2.perfil.bio.as_deref().unwrap_or(...): El método unwrap_or permite obtener el valor contenido en Some o, en caso de que sea None, devolver el valor por defecto proporcionado (en este caso, "Sin descripción").
  • usuario1.perfil.bio.map(|b| b.to_uppercase()): El método map aplica una función (transformar a mayúsculas) únicamente si el valor es Some. Si fuera None, map simplemente devolvería None sin ejecutar la función, evitando errores.
  • bio_mayus: Debido al uso de map, su tipo resultante es Option<String>.

N° 39