Learn Rust Coding · Lección

Result y el operador ?

Propagar errores

Result y el operador ? es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

El tipo Result

Result<T, E> representa una operación que puede completarse correctamente con Ok(T) o fallar con Err(E). Es el tipo principal de Rust para gestionar errores.

fn main() {
    let parsed: Result<i32, _> = "42".parse::<i32>();
    println!("{:?}", parsed);
}

Coincidencias sobre Result

Puede gestionar explícitamente ambos resultados con match.

fn main() {
    match "oops".parse::<i32>() {
        Ok(n) => println!("got {n}"),
        Err(e) => println!("error: {e}"),
    }
}

Devolver Result

Las funciones que pueden fallar devuelven un Result, lo que permite que quien las llama decida cómo gestionar los errores.

fn halve(n: i32) -> Result<i32, String> {
    if n % 2 == 0 {
        Ok(n / 2)
    } else {
        Err("odd number".to_string())
    }
}

fn main() {
    println!("{:?}", halve(10));
    println!("{:?}", halve(7));
}

El operador ?

El operador ? desenvuelve un valor Ok o devuelve Err de forma temprana desde la función. Sustituye el código detallado de coincidencia y devolución.

fn double_str(s: &str) -> Result<i32, std::num::ParseIntError> {
    let n = s.parse::<i32>()?;
    Ok(n * 2)
}

fn main() {
    println!("{:?}", double_str("21"));
    println!("{:?}", double_str("x"));
}

Encadenar con ?

Varios pasos que pueden fallar se leen con claridad cuando se encadenan con ?; el primer error detiene los pasos restantes.

fn sum_two(a: &str, b: &str) -> Result<i32, std::num::ParseIntError> {
    let x = a.parse::<i32>()?;
    let y = b.parse::<i32>()?;
    Ok(x + y)
}

fn main() {
    println!("{:?}", sum_two("3", "4"));
}

? en main

main puede devolver Result, por lo que ? también funciona allí. Un Err devuelto termina el programa con un código de salida distinto de cero.

fn main() -> Result<(), std::num::ParseIntError> {
    let n: i32 = "100".parse()?;
    println!("parsed {n}");
    Ok(())
}

Métodos útiles de Result

Combinadores prácticos:

unwrap_or(default) — valor o alternativa
map — transforma el valor Ok
map_err — transforma el error
is_ok / is_err — comprueban la variante

fn main() {
    let n = "x".parse::<i32>().unwrap_or(-1);
    println!("{n}");
}

De Option a Result

Convierta un Option en un Result con ok_or para que ? pueda propagar un error significativo.

fn first_char(s: &str) -> Result<char, String> {
    let c = s.chars().next().ok_or("empty string".to_string())?;
    Ok(c)
}

fn main() {
    println!("{:?}", first_char("hi"));
    println!("{:?}", first_char(""));
}

Cómo convierte errores ?

Cuando los tipos de error difieren, ? llama a From::from para convertir el error al tipo de error declarado por la función. Esto permite gestionar errores de forma ergonómica entre distintas capas.

Evitar unwrap en producción

unwrap y expect provocan un panic cuando reciben Err. Son adecuados para ejemplos y pruebas, pero en código real es preferible usar ? o una gestión explícita para que los fallos puedan recuperarse.

Encadenar con and_then

and_then ejecuta el siguiente paso que puede fallar solo si el anterior se completó correctamente, pasando el valor de uno a otro.

fn main() {
    let result = "8"
        .parse::<i32>()
        .and_then(|n| Ok(n * 2));
    println!("{:?}", result);
}

Comprobación rápida

¿Qué hace el operador ? cuando se aplica a un Result que es Err?

Resumen

Ha aprendido a gestionar errores mediante Result:

Result<T, E> modela el éxito o el fallo
? desenvuelve Ok o devuelve Err de forma temprana
? funciona en funciones y en main que devuelven Result
Los combinadores como map, map_err, unwrap_or y ok_or resultan útiles
Evite unwrap en producción

Preguntas frecuentes

¿La lección «Result y el operador ?» es gratis?

Sí — el texto completo de «Result y el operador ?» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Result y el operador ?»?

Propagar errores Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Result y el operador ?»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Result y el operador ?
thiserror
anyhow
Conversión de errores

← Volver a Learn Rust Coding