Nivel 1 · Fundamentos· Lección 9 de 10 · 20 min
Manejo de errores
Pánicos para los bugs, Result para los fallos que esperas, y el operador de interrogación que hace indolora la propagación.
Dos clases de fallo
Rust no tiene excepciones. Separa los fallos en dos clases y da a cada una su propio mecanismo.
- Bugs: un índice fuera de los límites, un invariante roto, «esto no puede pasar». Estos entran en pánico (panic): el hilo deshace la pila y, en un programa típico, el proceso termina con un mensaje.
- Fallos esperados: falta un archivo, la entrada está mal formada, se cae una conexión. Estos son valores normales de tipo
Result, y el sistema de tipos obliga a quien llama a ocuparse de ellos.
Pánicos
fn main() {
let v = vec![1, 2, 3];
let index = v.len() + 2;
println!("about to fail");
println!("{}", v[index]); // entra en pánico: índice fuera de los límites
}
Puedes provocar un pánico a propósito con panic!("mensaje"), y varias macros lo hacen por ti: assert!, assert_eq!, unreachable!, todo!. Un pánico no es comportamiento indefinido: es una parada controlada.
Result<T, E>
enum Result<T, E> {
Ok(T),
Err(E),
}
Toda operación que puede fallar devuelve uno:
fn main() {
let good: Result<i32, _> = "42".parse::<i32>();
let bad = "forty-two".parse::<i32>();
println!("{good:?}\n{bad:?}");
match "17".parse::<u8>() {
Ok(n) => println!("parsed {n}"),
Err(e) => println!("failed: {e}"),
}
}
El compilador avisa si ignoras un Result, así que los fallos no pueden colarse sin que nadie los vea.
Propagar con ?
La mayoría de las funciones no pueden hacer nada útil con un error salvo pasarlo hacia arriba. El operador ? hace exactamente eso:
use std::num::ParseIntError;
fn parse_pair(s: &str) -> Result<(i32, i32), ParseIntError> {
let (a, b) = s.split_once(',').unwrap_or((s, "0"));
let a = a.trim().parse::<i32>()?; // si es Err, lo devuelve desde parse_pair
let b = b.trim().parse::<i32>()?;
Ok((a, b))
}
fn main() {
println!("{:?}", parse_pair("3, 4"));
println!("{:?}", parse_pair("3, four"));
}
expr? significa: si es Ok(v), se evalúa a v; si es Err(e), devuelve Err(e.into()) ahora mismo. Es una marca visible, de un solo carácter, en cada punto donde la función puede salir antes de tiempo.
? también funciona con Option en las funciones que devuelven Option.
Definir tu propio tipo de error
Cuando una función puede fallar de varias formas, descríbelas con un enum:
use std::fmt;
#[derive(Debug)]
enum ConfigError {
Missing(String),
Invalid { key: String, value: String },
}
impl fmt::Display for ConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
ConfigError::Missing(k) => write!(f, "missing key `{k}`"),
ConfigError::Invalid { key, value } => write!(f, "`{value}` is not valid for `{key}`"),
}
}
}
impl std::error::Error for ConfigError {}
fn port(line: &str) -> Result<u16, ConfigError> {
let value = line
.strip_prefix("port=")
.ok_or_else(|| ConfigError::Missing("port".into()))?;
value.parse().map_err(|_| ConfigError::Invalid {
key: "port".into(),
value: value.into(),
})
}
fn main() {
for line in ["port=8080", "host=x", "port=eighty"] {
match port(line) {
Ok(p) => println!("port {p}"),
Err(e) => println!("error: {e}"),
}
}
}
ok_or_else convierte un Option en un Result; map_err convierte un tipo de error en otro. El nivel 2 muestra cómo el trait From y los crates thiserror y anyhow eliminan la mayor parte de este código repetitivo.
main puede devolver un Result
use std::error::Error;
use std::fs;
fn main() -> Result<(), Box<dyn Error>> {
let text = fs::read_to_string("definitely-missing.txt")?;
println!("{} bytes", text.len());
Ok(())
}
Box<dyn Error> significa «cualquier tipo de error». Es una buena elección para programas pequeños. Si main devuelve Err, el programa imprime el error y termina con un código de salida distinto de cero.
unwrap y expect
Los dos extraen el valor de éxito o entran en pánico. Úsalos cuando el fallo sería un bug, y prefiere expect con un mensaje que explique por qué no puede fallar:
fn main() {
let ip: std::net::IpAddr = "127.0.0.1"
.parse()
.expect("hard-coded address is valid");
println!("{ip}");
}
Una regla práctica: las bibliotecas devuelven Result y dejan que decida quien llama; las aplicaciones deciden en el nivel más alto; unwrap es para prototipos, pruebas e imposibilidades demostrables.
Ejercicios
- Escribe
fn safe_div(a: f64, b: f64) -> Result<f64, String>que falle al dividir por cero. - Escribe
fn sum_numbers(s: &str) -> Result<i32, std::num::ParseIntError>que sume enteros separados por espacios, usando?dentro de un buclefor. - Amplía
ConfigErrorcon una varianteOutOfRange(u32)y haz queportla devuelva para valores superiores a 65535.
Solución del 2
fn sum_numbers(s: &str) -> Result<i32, std::num::ParseIntError> {
let mut total = 0;
for word in s.split_whitespace() {
total += word.parse::<i32>()?;
}
Ok(total)
}
fn main() {
println!("{:?}", sum_numbers("1 2 3"));
println!("{:?}", sum_numbers("1 two 3"));
}
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Qué hace el operador
?cuando se aplica a unErr(e)?2.¿Cuándo es
panic!la herramienta adecuada?3.¿Qué debe cumplirse para usar
?sobre unResultdentro de una función?