Go é uma linguagem de programação popular que cresceu em popularidade por causa de sua eficácia, velocidade e eficiência. No entanto, erros podem acontecer durante as fases de desenvolvimento e execução, assim como em qualquer outra linguagem de programação. Lidar com erros de forma eficaz é essencial para garantir a confiabilidade e a estabilidade de seus programas Go.
Este artigo examinará vários métodos e procedimentos recomendados para gerenciar erros em Go.
Lidar com erros em Golang
Em Go, você pode lidar com erros através dos métodos abaixo mencionados:
- Função Nova()
- Função Errorf()
- Tratamento de erro explícito
- Adiar, entrar em pânico e recuperar
- Erro de empacotamento
1: Função New()
A linguagem Go fornece a Novo() função para gerenciar erros. Essa função, disponível no pacote interno errors, permite que os desenvolvedores criem mensagens de erro personalizadas para seus programas. Ao utilizar o Novo() função, os desenvolvedores podem lidar com erros de forma eficaz e fornecer mensagens de erro significativas para os usuários.
pacote principal
importar 'erros'
importar 'fmt'
verificação de função ( string de nome ) erro {
nError := erros.Novo ( 'Nome inválido' )
se nome ! = 'Linux' {
retornar nErro
}
retornar nada
}
função principal ( ) {
nome := 'Linux'
erro := verificar ( nome )
se errar ! = zero {
fmt.Println ( errar )
} outro {
fmt.Println ( 'Nome válido' )
}
}
O código acima usa o Novo() checkName função para ver se a string Linux corresponde ao nome dado. A função produz um erro com a mensagem Nome inválido se o nome não for Linux . A função retorna nil para mostrar que não houve erro se o nome for igual a Linux .
A variável de nome é definida como Linux na chamada da função principal para o checkName função, que também recebe a variável name como argumento. A função principal imprime a mensagem de erro se o checkName função retorna um erro. A função principal imprime o Nome válido se o checkName função retorna zero.
Saída
2: Função Errorf()
O Errof() função em Go nos permite lidar com erros também. Errof() nos dá a opção de formatar a mensagem de erro. Ao importar o pacote fmt, os desenvolvedores podem utilizá-lo para personalizar mensagens de erro para atender às suas necessidades. Errof() agiliza e melhora a eficiência do gerenciamento e transmissão de erros em Go.
pacote principalimportar 'fmt'
função div ( n1, n2 você ) erro {
se n2 == 0 {
retornar fmt.Errorf ( '%d / %d \n Não é possível dividir um número por zero' , n1, n2 )
}
retornar nada
}
função principal ( ) {
erro := div ( 42 , 0 )
se errar ! = zero {
fmt.Printf ( 'erro: %s' , errar )
} outro {
fmt.Println ( 'Divisão válida' )
}
}
No código acima, o div A função aceita duas entradas inteiras, n1 e n2, e se n2 for zero, ela produzirá um erro. A função produz um erro com uma mensagem que contém os valores de n1 e n2 se n2 for zero. A função retorna nil para mostrar que não houve erro se n2 não for zero.
Os erros que div retorna são salvos na variável err quando a função principal executa div com os valores 42 e 0. A função principal usa fmt.Printf para exibir a mensagem de erro se a função div retornar um erro. A função principal imprime Divisão válida se a função div retornar nil.
Saída
3: Tratamento de erros explícitos
Go incentiva o gerenciamento explícito de erros em comparação com outras linguagens de programação, que frequentemente dependem de exceções. Essa abordagem incentiva os desenvolvedores a usar instruções if para verificar erros explicitamente, em vez de depender de blocos try-catch. Ao fazer isso, é mais provável que os erros sejam encontrados e corrigidos adequadamente. Para facilitar isso, Go fornece o se errar != nil declaração, que permite aos desenvolvedores verificar erros após a execução de uma função e tomar as ações apropriadas com base no resultado. Com tratamento explícito de erros, Go oferece uma abordagem mais estruturada e confiável para o gerenciamento de erros.
pacote principalimportar 'fmt'
Função dividir ( a, b float64 ) ( float64, erro ) {
se b == 0 {
retornar 0 , fmt.Errorf ( 'não pode dividir por zero' )
}
retornar a / b, nada
}
função principal ( ) {
resultado, erro := divide ( 13 , 3 )
se errar ! = zero {
fmt.Printf ( 'Erro: %v \n ' , errar )
} outro {
fmt.Printf ( 'Resultado: %f \n ' , resultado )
}
resultado, errar = dividir ( 23 , 0 )
se errar ! = zero {
fmt.Printf ( 'Erro: %v \n ' , errar )
} outro {
fmt.Printf ( 'Resultado: %f \n ' , resultado )
}
}
Nesta ilustração, a função de divisão é usada para dividir dois valores. A saída é o resultado de fazê-lo. Se o segundo número for 0, a função produzirá um erro com uma mensagem de erro distinta.
Divide é chamado duas vezes na função principal: uma vez com entradas válidas e uma vez com entradas inválidas. o, se erro != nulo A instrução é usada para determinar se ocorreu um erro toda vez que a função de divisão é utilizada. Uma mensagem de erro é impressa se ocorrer. Caso contrário, o resultado é impresso.
Saída
4: Adiar, entrar em pânico e recuperar
Golang também fornece o adiar declaração, que é usada para executar uma função após a conclusão de um programa ou um bloco de código específico. O adiar declaração é freqüentemente usada em conjunto com o recuperar função para capturar e recuperar de erros de pânico em tempo de execução. Quando ocorre um erro de pânico em tempo de execução, o recuperar A função é usada para recuperar da condição de erro e evitar que o programa falhe. Isso é útil para tarefas de limpeza, como fechar arquivos, fechar conexões de rede ou liberar recursos. Ao adiar essas tarefas, você garante que elas sejam executadas mesmo se ocorrer um erro.
O pânico é usado para interromper a execução normal do programa quando ocorre um erro inesperado, enquanto recuperar é usado para lidar com o pânico e continuar a execução do programa.
pacote principalimportar 'fmt'
func recoveryFromPanic ( ) {
se r := recuperar ( ) ; r ! = zero {
fmt.Println ( 'Recuperado do pânico:' , r )
}
}
Função dividir ( x,y float64 ) float64 {
adiar a recuperação do pânico ( )
se e == 0 {
pânico ( 'não pode dividir por zero' )
}
retornar x / e
}
função principal ( ) {
fmt.Println ( dividir ( 13 , 3 ) )
fmt.Println ( dividir ( 23 , 0 ) )
}
No código acima, a função divide é usada para dividir dois valores de ponto flutuante. A saída é o resultado de fazê-lo. Uma mensagem de erro personalizada é gerada pela função se o segundo número for zero. A instrução defer é usada para invocar o recuperar do pânico função. O recuperar do pânico A função detectará um pânico que aconteceu dentro da função de divisão e imprimirá um erro se isso acontecer.
Divide é chamado duas vezes na função principal: uma vez com entradas válidas e uma vez com entradas inválidas. O fmt.Println A função imprime a saída da função sempre que a função de divisão é executada. O recuperar do pânico A função detectará um pânico se isso acontecer e imprimirá um erro se isso acontecer.
Saída
Após detectar o erro, o programa se recuperou do pânico e continuou rodando. No entanto, o código entrou em pânico e não retornou um valor na segunda chamada para dividir, por isso retornou zero.
5: Quebra de erro
Go também inclui um recurso conhecido como Erro ao agrupar , que permite adicionar contexto adicional a uma mensagem de erro. Isso é útil para registrar problemas ou fornecer mais detalhes em mensagens de erro. Isso pode ser feito criando um tipo de erro que incorpore o erro original e o contexto adicional.
pacote principalimportar 'erros'
importar 'fmt'
função principal ( ) {
se erro := barra ( ) ; errar ! = zero {
fmt.Println ( errar )
}
}
Função dividir ( a, b float64 ) ( float64, erro ) {
se b == 0 {
retornar 0 , erros. Novo ( 'divisão por zero' )
}
retornar a / b, nada
}
barra de funções ( ) ( erro erro ) {
_, errar = dividir ( 42 , 0 )
se errar ! = zero {
retornar fmt.Errorf ( 'falha ao calcular: %w' , errar )
}
retornar nada
}
No código acima, a função divide calcula a proporção de dois números neste exemplo e gera um erro se o segundo valor for zero. A função de barra chama a função de divisão e, em seguida, envolve o erro que dividir retorna em um novo erro com uma mensagem que inclui a mensagem de erro original usando a função fmt.Errorf. A função bar é chamada pela função principal, que também imprime os erros que retorna.
Saída
Conclusão
O desenvolvimento de software deve incluir Manipulação de erros , e Golang tem várias funções e métodos integrados para fazer isso normalmente. Esses mecanismos permitem que os desenvolvedores detectem e se recuperem de erros, evitem travamentos de programas e forneçam mensagens de erro informativas aos usuários finais. Usando esses mecanismos de tratamento de erros de forma eficaz, os desenvolvedores podem criar aplicativos de software robustos, confiáveis e eficientes.