Manuseio de exceção em rubi

Manipulação de exceções refere -se ao processo de previsão e definição de maneiras de lidar com erros levantados em um programa durante a execução. Um erro, na maioria dos casos, refere -se a um evento ou ocorrência inesperada durante a execução do programa. Por exemplo, pode ocorrer um erro ao ler um arquivo devido ao arquivo não existente ou ao usuário não ter a permissão certa para ler ou gravar no arquivo.

Este tutorial mostrará como implementar o manuseio de exceções em Ruby usando os blocos de aumento e resgate.

Uso básico

A maioria das linguagens de programação implementa o manuseio de exceções usando o bloco de tentativa e captura. No entanto, como tudo o mais em Ruby, as palavras -chave são mais descritivas.

Podemos expressar a sintaxe geral como mostrado abaixo:

começar
Raisexception
# Aumente a ecxepção
Exceção de resgate
# bloco de resgate
fim

Anexamos o bloco de manuseio de exceção em uma declaração de início e final. Dentro dessas declarações, definimos os blocos de aumento e resgate.

No aumento, definimos a exceção, que podemos criar manualmente ou fazer com que o intérprete de rubi o gere. Por padrão, o parâmetro para o bloco de aumento é o RuntimeError

Em seguida é o bloco de resgate. Como o nome sugere, esse bloco chega ao resgate quando ocorre uma exceção. Assume o controle da execução do programa.

Ruby comparará a exceção levantada do bloco Raise contra os parâmetros passados ​​para o bloco de resgate. Se a exceção for do mesmo tipo ou superclasse, ela aciona o bloco de resgate.

Exemplo de manuseio de exceção em rubi

Podemos implementar um exemplo simples para ilustrar como o manuseio de exceções funciona em Ruby:

def err_me
começar
coloca "Olá!"
Levante "Tipo de string"
resgatar
coloca "não importa, estou consertado!"
fim
fim
err_me

No exemplo acima, definimos uma função com um bloco de exceção.

Aumentamos manualmente uma exceção, que interrompe o fluxo de execução do programa e entra no bloco de resgate. Isso executa as ações no bloco neste caso, uma declaração de put e saídas.

Se você adicionar qualquer bloco de código imediatamente após o aumento e antes do bloco de resgate, eles não executam porque o bloco de resgate lida imediatamente com o fluxo do programa.

Por padrão, o bloco de resgate usa o parâmetro StandardError. No entanto, existem outros tipos de erros em Ruby, incluindo.

1. Erro de sintaxe
2. Ioerror
3. Regexperror
4. ThreadError
5. ZerodivisionError
6. Nomethoderror
7. IndexError
8. NameError
9. TypeError

E mais.

Para aumentar e lidar com um tipo de erro específico, podemos passá -lo para o bloco de aumento como um parâmetro. Aqui está um exemplo:

começar
RaiseZerodivisionError
resgate => Exceção
coloca exceção.mensagem
coloca exceção.Backtrace.inspecionar
fim

No exemplo acima, criamos um zerodivisionError. Em seguida, entramos no bloco de resgate, que imprime o tipo de exceção específico e traça a fonte.

A saída resultante é:

$ Ruby Err Mandling.rb
ZerodivisionError
["ERRA-MANDLING.RB: 2: em '' "]

Outros blocos de exceção

Além do principal bloco de aumento e resgate, Ruby também nos fornece outros blocos que podemos implementar para lidar com erros.

Eles incluem:

Bloco de repetição

O bloco de repetição é usado para executar novamente o bloco de resgate depois de aumentar a exceção. Aqui está um exemplo:

começar
Levante ZerodivisionError
coloca "eu não corro 😢"
resgate => Exceção
coloca "#exceção.Mensagem me fez morrer ⚰️ "
tente novamente
fim

Se executarmos o código acima, ele imprimirá a mensagem dentro do bloco de resgate. Ele encontrará o bloco de repetição, que pulará no bloco de resgate.

Um caso de uso comum de blocos de tentativa está investigando erros usando força bruta. Um exemplo seria continuar recarregando uma página quando a conexão estiver baixa até que o erro resolva.

CUIDADO: Tenha cuidado ao usar o bloco de repetição, porque é uma fonte comum de loops infinitos.

Garanta o bloco

Se você programou em outro idioma como o Python, provavelmente está familiarizado com o bloco finalmente. O bloco Garantir em Ruby tem um desempenho semelhante ao bloco finalmente em outras linguagens de programação.

O bloco Garantir sempre é executado no final do código. Independentemente de a exceção elevada ter sido tratada corretamente ou a execução do programa termina, ela sempre é executada ou executa.

Aqui está um exemplo:

começar
Levante ZerodivisionError
coloca "eu não corro 😢"
resgate => Exceção
coloca "#exceção.Mensagem me fez morrer ⚰️ "
garantir
coloca "eu sempre vou correr 🚀"
fim

Nesse caso, o código acima imprimirá uma mensagem de exceção e finalmente executará o bloco Garantir.

ZerodivisisionError me fez morrer ⚰️
Eu sempre vou correr 🚀

Else bloco

Se nenhuma exceção for levantada, podemos implementar um bloco para fazer uma ação usando a instrução ELS.

Por exemplo:

começar
resgate => Exceção
coloca "#exceção.Mensagem me fez morrer ⚰️ "
outro
Presos "confie em mim, eu corri com sucesso 😀"
garantir
coloca "e eu sempre vou correr 🚀"
fim

O bloco else é colocado entre o resgate e garantir o bloco. No exemplo acima, você notará que está faltando um bloco de aumento, o que faz com que o bloco seja executado.

Aqui está um exemplo de saída:

Confiar meu, Eu corri com sucesso 😀

E eu sempre vou correr 🚀

Manipulação de exceção leve

Os blocos de aumento e resgate são uma maneira útil de executar uma ação quando ocorre um erro. No entanto, como o manuseio de erros cria um rastreamento de pilha para ajudar na depuração, ele pode facilmente se tornar problemático em seu programa. É aqui que entram os blocos de captura e arremesso.

Para implementar um bloco de lanchonete, você começa definindo o rótulo usando a palavra-chave Catch. Depois que Ruby encontra um bloco de arremesso que faz referência ao bloco de captura, ele para a execução e pula para o bloco de captura.

Vamos usar um exemplo para ilustrar este conceito. Considere o ninho bagunçado mostrado no código abaixo:

Catch (: kill_me_now) fazer
Langs = ["Python", "Ruby", "C ++", "C#"]
foriinlangssdo
para índice em 1… 5
se índice == 3
ifi == "c#"
coloca "depois do arremesso, nada vai correr!'"
jogue (: kill_me_now)
coloca "eu sou c#"
fim
fim
fim
fim
fim
coloca "oh garoto! Isso foi longo!"

Começamos usando a palavra -chave Catch e passamos a etiqueta dentro de um par de parênteses. Depois de executar o código, ele executará todos os loops aninhados e as declarações até que encontre a declaração de arremesso que referenciando a captura.

Isso encerrará imediatamente a execução e sairá de volta ao nível da declaração de captura.

Aqui está um exemplo de saída:

Após o arremesso, nada vai correr!'
Oh garoto! Isso foi longo!

Conclusão

Este tutorial mostrou como implementar o tratamento de erros no Ruby usando os blocos de aumento e resgate.