Manejo de errores en óxido

El manejo de errores es prácticamente la segunda cosa más común para un programador, excepto cometer errores, por supuesto. Como desarrollador, encontrará escenarios en los que debe esperar un error y crear acción si sucede.

Aunque el compilador implementará el manejo de errores predeterminado, es bueno comprender cómo manejar los errores para la lógica personalizada. El manejo de errores evitará que su programa devuelva la salida no deseada o termine anormalmente.

Explore cómo manejar los errores en el lenguaje de programación de óxido.

Tipos de error de óxido

Hay dos tipos de errores en Rust:

1. Errores recuperables
2. Errores irrecuperables

Errores irrecuperables

Los errores irrecuperables se refieren a los tipos de errores que hacen que un programa muera o salga anormalmente. Un ejemplo sería acceder a un índice fuera de límite en una matriz.

El óxido usa el pánico! Macro para manejar errores irrecuperables. Supongamos que el compilador encuentra el pánico! macro en su código. Imprime los mensajes especificados, limpia la pila y termina el programa.

El pánico! La macro es muy útil cuando encuentra errores de los cuales el programa no puede recuperarse.

Tome un programa simple proporcionado a continuación que ilustra cómo usar la macro de pánico:

fn main ()
pánico!("Estoy muerto!!");

Una vez que ejecute el código anterior, debe obtener una salida como se muestra a continuación:

Llamar pánico! hace que el programa salga e imprima el método de pánico especificado.

Retrasar un pánico

Rust nos permite retroceder la fuente de error utilizando la variable de entorno Rust_Backtrace. El retroceso se refiere a una lista de funciones que se han llamado antes de que ocurriera el error.

Tome el ejemplo proporcionado a continuación:

fn main ()
dejar vec = vec![1,2,3,4,5];
println!("", Vec [5]);

En el ejemplo anterior, estamos intentando leer un índice de matriz fuera de los límites. Esto debería hacer que el programa se asuste y salga.

Se proporciona un ejemplo de salida de salida a continuación:

Como puede ver en la salida, el compilador nos dice que podemos usar la variable de entorno Rust_BackTrace para obtener el camino de retroceso del error.

Podemos hacer esto usando el siguiente comando:

$ Rust_backTrace = 1 carrera de carga

Esto debería devolver la salida de retroceso como:

Esto debería devolver una salida detallada de cómo ocurrió el error en su código. Para una opción completamente detallada, puede usar Rust_BackTrace = Full.

Errores recuperables

Por lo general, rara vez necesitará manejar errores irrecuperables. Para manejar errores recuperables en óxido, usamos el enum de resultado, que contiene dos variantes: ok y errar.

Tomemos el siguiente programa simple intentando abrir un archivo:

usestd :: fs :: archivo;
fnmain ()
dejar archivo = archivo :: abrir ("Hola.TXT");
println!(":?", archivo);

El código anterior intenta abrir un archivo inexistente. Ejecutar el programa proporcionado anteriormente debe regresar como:

Err (OS código: 2, Kind: NotFound, Mensaje: "El sistema no puede encontrar el archivo especificado.")

Sin embargo, podemos definir la acción que queremos si el archivo no existe. A continuación se muestra un ejemplo:

usestd :: fs :: archivo;
fnmain ()
dejar archivo = archivo :: abrir ("Hola.TXT");
Archivo de coincidencia
Ok (archivo) =>
println!("archivo encontrado: :?", archivo)
,
Err (_error) =>
println!("archivo no encontrado")

Aquí, usamos el operador de coincidencia para verificar si el archivo devolvió un error o OK. Luego, tomamos las acciones para cada caso.

También podemos usar el método EXPERSE para crear detalles de manejo de errores personalizados.

Por ejemplo:

usestd :: fs :: archivo;
fnmain ()
dejar archivo = archivo :: abrir ("Hola.TXT")
.Espere ("Se produjo un error al leer el archivo");

Se encuentra el método ESPEZ, que llamará a la macro de pánico en un error, al abrir el archivo.

Clausura

Este tutorial cubrió los fundamentos del manejo de errores en el lenguaje de programación de óxido. Además, esta guía discutió los dos tipos de errores: errores recuperables y errores irrecuperables. Esperamos que hayas encontrado este artículo útil. Consulte los otros artículos de Sugerencia de Linux para obtener más consejos e información.