Uma das características mais úteis da linguagem de programação Go é a forma como ela lida com os erros. Ao invés de usar uma metodologia Try/Catch como outras linguagens de programação, Go trata os erros como valores normais de retorno.
Criando módulos simples e aplicando algumas regras de registo, podemos produzir mensagens de erro úteis para capturar todo o tipo de excepções durante o processo de desenvolvimento.
Neste artigo, vamos cobrir algumas das formas mais básicas que o Golang encontra e lida com estas excepções.
Golang Basic Error Handling
Podemos capturar erros em Go usando simples instruções if/then que verificam as condições onde os parâmetros necessários não são cumpridos.
Vejamos um módulo básico que podemos criar para verificar se uma string inclui ou não um valor.
Criar um pacote chamado “olá” e importar os módulos padrão “erros” e “fmt” para reconhecer erros e texto formatado:
package helloimport ("errors""fmt")Então podemos criar um módulo que irá retornar uma string de texto para uma variável nomeada.
func Hello(name string) (string, error) {if name == "" {return "", errors.New("No name was given")}O acima verifica se uma string em branco é retornada para a variável “name”, que então retorna um novo erro com algum texto especificado. Esta é a nossa condição de erro. Uma condição de erro verifica se o erro em si existe.
Se a condição não for preenchida (isto é, não há erro), retornamos o valor que corresponde à variável “name” especificada:
message := fmt.Sprintf("Hi, %v. Welcome!", name)return message, nil}Nota que retorna a mensagem e o valor “nil”, o que significa que não há erro. Isto diz ao programa de chamada que a função processada sem erro.
Agora vamos ver como podemos chamar este pacote em um script real.
Vamos criar um novo script, chamado test.go
Como é normal com Golang, um script deve começar definindo o pacote como “principal”. Depois importamos os pacotes “fmt” e “log”, juntamente com o nosso pacote “olá” criado, como mostrado abaixo:
package mainimport ("fmt""log""yoursite.com/hello")Below definimos a nossa função principal, definimos algumas propriedades para o nosso logger criar um prefixo fácil de entender, e (por razões de segurança) criamos uma flag para que não mostremos a hora, o arquivo fonte e o número da linha.
func main() {log.SetPrefix("Hello: ")log.SetFlags(0)Next, vamos especificar uma mensagem a ser exibida:
message, err := hello.Hello("")Finalmente, vamos ver se existe um erro verificando se “err” não é igual a “nil”. Se este for o caso, imprimimos a mensagem para o console e saímos.
if err != nil {log.Fatal(err)}Se não houver condição de erro, simplesmente imprimimos a mensagem que foi definida em nosso pacote hello.
fmt.Println(message)}Para testar isso, podemos executar o código como ele é. Assim que o fizermos, devemos obter um resultado que se pareça com isto:
>go run test.gogreetings: No name was givenexit status 1Se desejarmos modificar o nosso script test.go, introduza algo como isto:
message, err := hello.Hello("John")A nossa saída deve então ser parecida com isto:
>go run test.goHi, John. Welcome!Outro tipo de mensagem de erro que podemos retornar é:
fmt.Errorf – isto irá formatar uma string de acordo com as regras da Printf.
Handling Integers in Golang
Of course, os erros de string são apenas um tipo de erro. Com Golang error handling, há vários outros erros que você pode verificar no seu código. Um em particular que você deve saber é sobre erros numéricos.
O tratamento de inteiros é simples para Go. Aqui está como funciona:
Dizemos que temos erros numéricos, como se tivéssemos de dividir por zero. Primeiro criamos uma função “Divisão”, que divide duas variáveis x por y. Para a primeira parte da nossa condição if/then, precisamos ter certeza de que y não é igual a zero:
func Division(x int, y int) (int, error) {if y == 0 {return 0, errors.New("Thou shalt not divide by zero!")} else {return (x / y), nil}}Esta é a função principal. Agora, você pode passar-lhe duas variáveis. Neste exemplo, usaremos 12 e 0.
func main() {if result, err := Division(12, 0); err != nil {fmt.Println("We got an error: ", err)} else {fmt.Println("The answer is", result)}}Você receberá então uma mensagem que diz algo como:
“Temos um erro: Você não deve dividir por zero!”
Este é apenas um exemplo de como você pode usar o tratamento de erros Golang para encontrar erros numéricos. Realmente, com as funções certas, você pode encontrar vários erros por conta própria via Golang.
Finding HTTP Status Errors
Com Golang, você pode trazer à tona os erros de status HTTP se uma API que estamos chamando entregar um.
Here’s how:
Primeiro, vamos importar um novo pacote, “net/http”:
import ( "fmt" "log" "net/http")Na nossa função principal, chame um aplicativo (por exemplo, um website) e registre quaisquer erros. Sabemos que pedidos bem sucedidos se enquadram no intervalo 2xx, então crie um status respectivo que encontre quaisquer erros HTTP que estejam fora deste intervalo. Você pode fazer isso da seguinte maneira:
func main() { resp, err := http.Get("https://example.com") if err != nil { log.Fatal(err) } fmt.Println("HTTP Response Status:", resp.StatusCode, http.StatusText(resp.StatusCode)) if resp.StatusCode >= 200 && resp.StatusCode Como pode ver, a nossa função principal está definida para
>= 200 && resp.StatusCode <= 299
que irá verificar se algum pedido HTTP se enquadra dentro do intervalo 2xx. Se o pedido não atender a esta condição, ele mostrará uma mensagem de erro.
Com apenas um módulo, você pode rapidamente reunir todas as informações necessárias para encontrar e corrigir o seu código Golang.
Resumo
Este guia apenas risca a superfície sobre como a linguagem Go é projetada para lidar com erros. Entretanto, conceitos básicos como verificar a existência de uma string, como levantar uma condição de erro se uma declaração numérica ilógica for apresentada e como verificar os códigos de status HTTP de uma resposta são todos excelentes lugares para começar a sua jornada de monitoramento de erros Golang.
Não tem tempo para verificar e usar essas técnicas de manuseio de erros Golang manualmente? É aí que ferramentas como o Monitoramento de Erros de Freio Aéreo vêm a calhar. Com o Monitoramento de Erros de Freio Aéreo, você será capaz de encontrar erros rapidamente sem a necessidade de criar módulos individuais. Experimente o Airbrake Error Monitoring gratuitamente por 30 dias para erros ilimitados e eventos de desempenho.