Manuseio de erros na ferrugem

O tratamento de erros é praticamente a segunda coisa mais comum para um programador, exceto cometer erros, é claro. Como desenvolvedor, você encontrará cenários onde precisa esperar um erro e criar ação se isso acontecer.

Embora o compilador implemente o tratamento de erros padrão, é bom entender como lidar com erros para a lógica personalizada. O manuseio de erros impedirá que seu programa retorne a saída indesejada ou terminando anormalmente.

Vamos explorar como lidar com erros na linguagem de programação de ferrugem.

Tipos de erro de ferrugem

Existem dois tipos de erros na ferrugem:

1. Erros recuperáveis
2. Erros irrecuperáveis

Erros irrecuperáveis

Erros irrecuperáveis ​​se referem aos tipos de erros que fazem com que um programa morra ou saia de forma anormal. Um exemplo seria acessar um índice fora de limite em uma matriz.

Ferrugem usa o pânico! macro para lidar com erros irrecuperáveis. Suponha que o compilador encontre o pânico! Macro em seu código. Ele imprime as mensagens especificadas, limpa a pilha e encerra o programa.

O pânico! A macro é muito útil quando você encontra erros dos quais o programa não pode se recuperar.

Pegue um programa simples fornecido abaixo que ilustra como usar a macro de pânico:

fn main ()
pânico!("Eu estou morto!!");

Depois de executar o código anterior, você deve obter uma saída como mostrado abaixo:

Chamando pânico! faz com que o programa saia e imprima o método de pânico especificado.

Voltando um pânico

A ferrugem nos permite voltar à fonte de erro usando a variável de ambiente rust_backtrace. Backtracing refere -se a uma lista de funções que foram chamadas antes do erro ocorrer.

Veja o exemplo fornecido abaixo:

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

No exemplo anterior, estamos tentando ler um índice de matriz fora dos limites. Isso deve fazer com que o programa entre em pânico e sai.

Uma saída de exemplo de saída é fornecida abaixo:

Como você pode ver na saída, o compilador nos diz que podemos usar a variável de ambiente rust_backtrace para obter o backtrace do erro.

Podemos fazer isso usando o seguinte comando:

$ Rust_backtrace = 1 carga de carga

Isso deve retornar a saída de backtrace como:

Isso deve retornar uma saída detalhada de como o erro aconteceu em seu código. Para uma opção totalmente detalhada, você pode usar o rust_backtrace = completo.

Erros recuperáveis

Normalmente, você raramente precisará lidar com erros irrecuperáveis. Para lidar.

Vamos tomar o seguinte programa simples tentando abrir um arquivo:

usestd :: fs :: arquivo;
fnmain ()
Deixe o arquivo = arquivo :: aberto ("Olá.TXT");
println!(":?", arquivo);

O código anterior tenta abrir um arquivo inexistente. A execução do programa fornecida acima deve retornar como:

Err (OS Code: 2, Kind: Notfound, Mensagem: "O sistema não consegue encontrar o arquivo especificado.")

No entanto, podemos definir a ação que queremos se o arquivo não existir. Um exemplo é mostrado abaixo:

usestd :: fs :: arquivo;
fnmain ()
Deixe o arquivo = arquivo :: aberto ("Olá.TXT");
FILHO COM MAIXO
Ok (arquivo) =>
println!("Arquivo encontrado: :?", arquivo)
,
Err (_error) =>
println!("arquivo não encontrado")

Aqui, usamos o operador de correspondência para verificar se o arquivo retornou um erro ou ok. Então, tomamos as ações para cada caso.

Também podemos usar o método esperado para criar detalhes de manuseio de erros personalizados.

Por exemplo:

usestd :: fs :: arquivo;
fnmain ()
Deixe o arquivo = arquivo :: aberto ("Olá.TXT")
.Espere ("Ocorreu o erro ao ler o arquivo de leitura");

O método espera, que chamará a macro de pânico em um erro, é encontrada ao abrir o arquivo.

Fechamento

Este tutorial abrangeu os fundamentos do tratamento de erros na linguagem de programação da ferrugem. Além disso, este guia discutiu os dois tipos de erros: erros recuperáveis ​​e erros irrecuperáveis. Esperamos que você tenha achado este artigo útil. Verifique os outros artigos de dica do Linux para obter mais dicas e informações.