Há mais de uma maneira de lidar com erros no Rust, portanto, considere todas as opções.

Erros são inevitáveis ​​e podem ocorrer por vários motivos, desde entrada inválida do usuário até falhas de rede, mau funcionamento de hardware ou erros de programação. O tratamento de erros é o processo de detecção, relatório e recuperação de tais erros para evitar travamentos do programa ou corrupção de dados.

O tratamento eficaz de erros é crítico no Rust. Ele permite criar aplicativos robustos e confiáveis ​​que podem lidar com erros e falhas inesperados. Os mecanismos de tratamento de erros do Rust permitem que você desenvolva programas resilientes e seguros que são mais fáceis de manter.

Os tipos de erros no Rust

Rust tem um sistema de tipo rico que você pode usar para lidar com erros com proficiência, de acordo com seus tipos. Os benefícios do rico sistema de tipo de erro do Rust em relação às abordagens tradicionais de tratamento de erros não podem ser subestimados. O sistema de tipo de erro fornece segurança de tipo melhorada, composição, expressividade e depuração.

Aqui está uma lista de tipos de erros comuns no Rust:

  • O std:: io:: Erro type representa erros de E/S, como arquivo não encontrado, permissão negada ou fim do arquivo atingido.
  • O std:: num:: ParseIntError type representa erros que ocorrem em operações de análise de strings para números inteiros.
  • O std:: opção:: NoneError type representa erros de desdobramento de opções vazias.
  • O std:: resultado:: resultado type é um tipo Result genérico que você pode usar para representar qualquer erro.

Cada tipo de erro tem seu próprio conjunto de métodos e características para tratá-lo de maneiras específicas.

Aqui está um exemplo de tratamento de erros no Rust para uma operação de leitura de arquivo:

usar std:: fs:: Arquivo;
usar std:: io:: Ler;
fnread_file(caminho: &str) -> Resultado<Corda, std:: io:: Erro> {
deixarmudo arquivo = Arquivo:: abrir (caminho)?;
deixarmudo conteúdo = Corda::novo();
 file.read_to_string(&mudo conteúdo)?;
OK(conteúdo)
}

O read_file A função lê o conteúdo do arquivo no caminho especificado e o retorna como uma string. Ele retorna um std:: io:: Erro se a operação de abertura ou leitura do arquivo falhar. O ? operador propaga o erro e retorna o erro como um Resultado.

Mecanismos de tratamento de erros em Rust

Um recurso importante que contribui para a segurança do Rust são seus mecanismos de tratamento de erros. Existem quatro mecanismos principais de tratamento de erros no Rust: o Resultado digite o Opção digite o pânico! macro e o Erro característica.

Os tipos Result e Option permitem o tratamento estruturado de erros. Você pode usar o pânico! macro para lidar com erros irrecuperáveis. A característica Error permite definir tipos de erro customizados e tratamento de erro customizado.

O tipo de resultado

O Resultado type é um tipo interno que representa o resultado de uma operação que pode falhar. Possui duas variantes: a OK variante, que representa sucesso e contém um valor, e Errar, que representa falha e contém um valor de erro.

Veja como você pode usar o tipo Result para abrir um arquivo e ler seu conteúdo:

usar std:: fs:: Arquivo;
usar std:: io:: prelúdio::*;
fnread_file(caminho de arquivo: &str) -> Resultado<Corda, std:: io:: Erro> {
deixarmudo arquivo = Arquivo:: aberto (arquivo_caminho)?;
deixarmudo conteúdo = Corda::novo();
 file.read_to_string(&mudo conteúdo)?;
OK(conteúdo)
}


fnprincipal() {
deixar resultado = read_file("arquivo.txt");
corresponder resultado {
OK(conteúdo) => println!("{}", conteúdo),
Errar(e) => println!("Erro: {}", e),
 }
}

O read_file função pega o caminho do arquivo e retorna um Resultado erro. Se a operação de leitura ou abertura do arquivo falhar, a função retorna o Errar valor. Caso contrário, a função retorna o OK valor. No principal função, o corresponder declaração lida com o Resultado value e imprime o resultado dependendo da situação da operação do arquivo.

O tipo de opção

O Opção type é um tipo interno que representa a presença ou ausência de um valor. O Opção tipo tem duas variantes. Alguns representa um valor e Nenhum representa a ausência de um valor.

Veja como você pode usar o Opção digite para recuperar o primeiro elemento de um vetor.

fnget_first_elementClone>(vec: vec) -> Opção {
se vec.is_empty() {
Nenhum
 } outro {
Alguns(vec.first().unwrap().clone())
 }
}
fnprincipal() {
deixar vec = você![1, 2, 3];
deixar resultado = get_first_element (vec);
corresponder resultado {
Alguns(elemento) => println!("{}", elemento),
Nenhum => println!("O vetor está vazio."),
 }
}

O get_first_element função retorna um Opção tipo. Se o vetor estiver vazio, a função retorna Nenhum; caso contrário, a função retorna Alguns contendo o primeiro elemento do vetor. No principal função, o corresponder declaração lida com o Opção valor. Se o Opção avalia para Alguns, a função imprime o primeiro elemento. Caso contrário, a função imprime uma mensagem indicando que o vetor está vazio.

O pânico! Macro

O pânico! macro fornece funcionalidade para lidar com erros irrecuperáveis ​​no Rust. Ao ligar para o pânico! macro, ele imprime uma mensagem de erro e encerra o programa.

Aqui está um exemplo de uso do pânico! macro para indicar que uma função tem argumentos inválidos.

fndividir(dividendo: f64, divisor: f64) -> f64 {
se divisor == 0.0 {
pânico!("O divisor não pode ser zero.");
 }
 dividendo / divisor
}
fnprincipal() {
deixar resultado = divide(4.0, 0.0);
println!("{}", resultado);
}

O dividir a função verifica se o divisor é zero; se o divisor for zero, a função chama o pânico! macro com uma mensagem de erro; caso contrário, a função calcula e retorna o resultado

O principal chama a função de divisão com argumentos inválidos para acionar o pânico! macro.

Aqui está a mensagem de erro:

O traço de erro

O Erro trait é uma característica interna que define o comportamento dos tipos de erro. O Erro trait fornece funcionalidade para definir tipos de erros personalizados e tratamento de erros personalizados.

Aqui está um exemplo de definição de um tipo de erro personalizado que representa um erro de arquivo não encontrado.

usar padrão:: erro:: Erro;
usar padrão:: fmt;
usar std:: io:: Ler;
#[derivar (depurar)]
estruturaArquivo não encontrado(Corda);


implicar fmt:: Exibição para Arquivo não encontrado {
fnfmt(&auto, f: &mudo fmt:: Formatador) -> fmt::Resultado {
escrever!(f, "Arquivo não encontrado: {}", auto.0)
 }
}


implicar Erro para Arquivo não encontrado {}


fnread_file(caminho de arquivo: &str) -> Resultado<Corda, Caixa<din Erro>> {
deixarmudo file = std:: fs:: File:: open (file_path).map_err(|e| FileNotFound(formatar!("{}", e)))?;
deixarmudo conteúdo = Corda::novo();
 file.read_to_string(&mudo conteúdo)?;
OK(conteúdo)
}


fnprincipal() {
deixar resultado = read_file("arquivo.txt");
corresponder resultado {
OK(conteúdo) => println!("{}", conteúdo),
Errar(e) => println!("Erro: {}", e),
 }
}

O tipo de erro personalizado é o Arquivo não encontrado struct. O tipo contém um caminho de arquivo e o Arquivo não encontrado tipo implementa o Mostrar trait para retornar mensagens de erro amigáveis ​​e o Erro trait para indicar que este é um tipo de erro.

No read_file função, o Arquivo não encontrado tipo de erro representa um erro de arquivo não encontrado e o map_err O método converte o std:: io:: Error em um erro FileNotFound. Finalmente, a Caixa type permite que a função retorne qualquer tipo que implemente o atributo Error.

O principal função chama o read_file função com o caminho do arquivo e, se encontrar o arquivo, imprime seu conteúdo no console. Caso contrário, imprime a mensagem de erro.

Aqui está o resultado para um arquivo que não existe:

Você pode confiar no modelo de propriedade da Rust para segurança do programa

Juntamente com o magnífico mecanismo de tratamento de erros do Rust, o Rust também utiliza um modelo de propriedade que ajuda a garantir que seus programas sejam seguros para a memória.

Rust garante as regras de propriedade com um verificador de empréstimo em tempo de compilação antes de seu programa ser executado.