Manejo de errores en Rust con varios enfoques

Los errores son inevitables y pueden ocurrir por varias razones, desde una entrada de usuario no válida hasta fallas en la red, mal funcionamiento del hardware o errores de programación. El manejo de errores es el proceso de detección, notificación y recuperación de dichos errores para evitar bloqueos del programa o corrupción de datos.

El manejo efectivo de errores es fundamental en Rust. Le permite crear aplicaciones robustas y confiables que pueden manejar errores y fallas inesperados. Los mecanismos de manejo de errores de Rust le permiten desarrollar programas resistentes y seguros que son más fáciles de mantener.

Los tipos de errores en Rust

Rust tiene un sistema de tipos enriquecido que puede usar para manejar los errores con soltura, según sus tipos. Los beneficios del rico sistema de tipo de error de Rust sobre los enfoques tradicionales de manejo de errores no pueden subestimarse. El sistema de tipo de error proporciona

seguridad de tipos mejorada, composición, expresividad y depuración.

Aquí hay una lista de tipos de errores comunes en Rust:

• El estándar:: io:: error El tipo representa errores de E/S, como archivo no encontrado, permiso denegado o final de archivo alcanzado.
• El std:: num:: ParseIntError El tipo representa los errores que se producen en las operaciones de análisis de cadenas a enteros.
• El std:: opción:: NingunoError type representa errores al desenvolver opciones vacías.
• El std:: resultado:: Resultado type es un tipo de resultado genérico que puede usar para representar cualquier error.

Cada tipo de error tiene su propio conjunto de métodos y características para manejarlo de manera específica.

Aquí hay un ejemplo de manejo de errores en Rust para una operación de lectura de archivos:

usar std:: fs:: Archivo;
usar std:: io:: Leer;
fnleer_archivo(camino: &calle) -> Resultado<Cadena, estándar:: io:: Error> {
dejarmudo archivo = Archivo:: abrir (ruta)?;
dejarmudo contenidos = Cadena::nuevo();
 archivo.leer_en_cadena(&mudo contenido)?;
De acuerdo(contenido)
}

El leer_archivo La función lee el contenido del archivo en la ruta especificada y lo devuelve como una cadena. devuelve un estándar:: io:: error si la operación de abrir o leer el archivo falla. El ? El operador propaga el error y devuelve el error como un Resultado.

Mecanismos de manejo de errores en Rust

Una característica clave que contribuye a la seguridad de Rust son sus mecanismos de manejo de errores. Hay cuatro mecanismos principales de manejo de errores en Rust: el Resultado Escribe el Opción Escribe el ¡pánico! macro y el Error rasgo.

Los tipos Result y Option permiten el manejo estructurado de errores. ¡Puedes usar el pánico! macro para manejar errores irrecuperables. El rasgo Error le permite definir tipos de error personalizados y manejo de errores personalizado.

El tipo de resultado

El Resultado type es un tipo incorporado que representa el resultado de una operación que puede fallar. Tiene dos variantes: la De acuerdo variante, que representa el éxito y contiene un valor, y Errar, que representa un error y contiene un valor de error.

Así es como puede usar el tipo de resultado para abrir un archivo y leer su contenido:

usar std:: fs:: Archivo;
usar estándar:: io:: preludio::*;
fnleer_archivo(ruta de archivo: &calle) -> Resultado<Cadena, estándar:: io:: Error> {
dejarmudo archivo = Archivo:: abrir (file_path)?;
dejarmudo contenidos = Cadena::nuevo();
 archivo.leer_en_cadena(&mudo contenido)?;
De acuerdo(contenido)
}
fnprincipal() {
dejar resultado = leer_archivo("archivo.txt");
fósforo resultado {
De acuerdo(contenido) => imprimir!("{}", contenidos),
Errar(e) => imprimir!("Error: {}", e),
 }
}

El leer_archivo La función toma la ruta del archivo y devuelve un Resultado error. Si la operación de lectura o apertura del archivo falla, la función devuelve el Errar valor. De lo contrario, la función devuelve el De acuerdo valor. En el principal función, la fósforo declaración maneja el Resultado value e imprime el resultado dependiendo de la situación de la operación del archivo.

El tipo de opción

El Opción type es un tipo incorporado que representa la presencia o ausencia de un valor. El Opción El tipo tiene dos variantes. Alguno representa un valor y Ninguno representa la ausencia de un valor.

Así es como puede usar el Opción type para recuperar el primer elemento de un vector.

fnobtener_primer_elementoClon>(ver: Vec) -> Opción {
si vec.está_vacío() {
Ninguno
 } demás {
Alguno(vec.first().unwrap().clone())
 }
}
fnprincipal() {
dejar vec = vec![1, 2, 3];
dejar resultado = obtener_primer_elemento (vec);
fósforo resultado {
Alguno(elemento) => imprimir!("{}", elemento),
Ninguno => imprimir!("El vector está vacío".),
 }
}

El obtener_primer_elemento función devuelve un Opción tipo. Si el vector está vacío, la función devuelve Ninguno; de lo contrario, la función devuelve Alguno que contiene el primer elemento del vector. En el principal función, la fósforo declaración maneja el Opción valor. Si el Opción evalúa a Alguno, la función imprime el primer elemento. De lo contrario, la función imprime un mensaje que indica que el vector está vacío.

¡El pánico! Macro

El ¡pánico! macro proporciona funcionalidad para manejar errores irrecuperables en Rust. Al llamar al ¡pánico! macro, imprime un mensaje de error y finaliza el programa.

Aquí hay un ejemplo del uso de panic! macro para indicar que una función tiene argumentos no válidos.

fndividir(dividendo: f64, divisor: f64) -> f64 {
si divisor == 0.0 {
¡pánico!("El divisor no puede ser cero".);
 }
 dividendo / divisor
}
fnprincipal() {
dejar resultado = dividir(4.0, 0.0);
imprimir!("{}", resultado);
}

El dividir la función comprueba si el divisor es cero; si el divisor es cero, la función llama al ¡pánico! macro con un mensaje de error; de lo contrario, la función calcula y devuelve el resultado

El principal función llama a la función dividir con argumentos no válidos para activar el ¡pánico! macro.

Aquí está el mensaje de error:

El rasgo de error

El Error El rasgo es un rasgo incorporado que define el comportamiento de los tipos de error. El Error El rasgo proporciona funcionalidad para definir tipos de error personalizados y manejo de errores personalizado.

Este es un ejemplo de cómo definir un tipo de error personalizado que representa un error de archivo no encontrado.

usar estándar:: error:: Error;
usar estándar:: fmt;
usar std:: io:: Leer;
#[derivar (Depurar)]
estructuraArchivo no encontrado(Cadena);
impl fmt:: Pantalla para Archivo no encontrado {
fnfmt(&ser, f: &mudo fmt:: Formateador) -> fmt::Resultado {
¡escribir!(F, "Archivo no encontrado: {}", ser.0)
 }
}
impl Error para Archivo no encontrado {}
fnleer_archivo(ruta de archivo: &calle) -> Resultado<Cadena, Caja<dinámico Error>> {
dejarmudo file = std:: fs:: File:: open (file_path).map_err(|e| FileNotFound(¡formato!("{}", e)))?;
dejarmudo contenidos = Cadena::nuevo();
 archivo.leer_en_cadena(&mudo contenido)?;
De acuerdo(contenido)
}
fnprincipal() {
dejar resultado = leer_archivo("archivo.txt");
fósforo resultado {
De acuerdo(contenido) => imprimir!("{}", contenidos),
Errar(e) => imprimir!("Error: {}", e),
 }
}

El tipo de error personalizado es el Archivo no encontrado estructura El tipo contiene una ruta de archivo y el Archivo no encontrado tipo implementa el Mostrar rasgo para devolver mensajes de error fáciles de usar y el Error rasgo para indicar que se trata de un tipo de error.

En el leer_archivo función, la Archivo no encontrado tipo de error representa un error de archivo no encontrado, y el map_err El método convierte el error std:: io:: en un error FileNotFound. Finalmente, la caja type permite que la función devuelva cualquier tipo que implemente el rasgo Error.

El principal función llama a la leer_archivo función con la ruta del archivo y, si encuentra el archivo, imprime su contenido en la consola. De lo contrario, imprime el mensaje de error.

Este es el resultado de un archivo que no existe:

Puede confiar en el modelo de propiedad de Rust para la seguridad del programa

Junto con el magnífico mecanismo de manejo de errores de Rust, Rust también utiliza un modelo de propiedad que ayuda a garantizar que sus programas estén seguros en la memoria.

Rust asegura las reglas de propiedad con un comprobador de préstamos en tiempo de compilación antes de que se ejecute su programa.