Aula 24 – Tutorial Golang – Errors
Aula 24 – Tutorial Golang – Errors
Tutorial Golang – Errors
Pacote Programador Fullstack
Página principal do blog
Todas as aulas desse curso
Aula 23 Aula 25
Redes Sociais:
Meus links de afiliados:
Hostinger
Digital Ocean
One.com
Melhore seu NETWORKING
https://digitalinnovation.one/
Participe de comunidades de desenvolvedores:
Fiquem a vontade para me adicionar ao linkedin.
E também para me seguir no https://github.com/toticavalcanti.
Código final da aula:
https://github.com/toticavalcanti
Canais do Youtube
Toti:
Toti
Backing Track / Play-Along
Código Fluente
Putz!
PIX para doações
PIX Nubank
Aula 24 – Tutorial Golang – Errors
Errors
O error é um tipo de interface integrado em Go.
Uma variável de erro representa qualquer valor que possa se descrever como uma string.
Declaração da interface de erro:
type error interface {
Error() string
}
A interface consiste em uma única função, Error(), que retorna uma mensagem de erro em string.
Uso
Go não oferece suporte para blocos try-and-catch convencional para tratamento de erros, ao invés disso, quando algo inesperado acontece, ele retorna um erro.
A interface de erro é usada para representar a condição de erro.
Um valor nulo significa que não ocorreu nenhum erro.
Para gerar erros personalizados, podemos implementar a interface de erro em uma estrutura, conforme nossos requisitos.
type DivZero struct{}
func (myerr *DivZero) Error() string{
return "Cannot divide by 0!"
}
O pacote errors
Para gerar erros personalizados, precisamos definir uma estrutura que implemente a interface de erro.
Esta é uma tarefa bastante tediosa.
Para evitar a definição de estruturas para tratamento de erros, Go fornece o pacote de erros integrado.
Teremos então, duas funções divide, uma que vai usar a nossa struct de erro personalizado, a divide_using_custom(), e a outra que vai usar o pacote errors do Go,a divide_using_builtin().
// using builtin "errors" --> Using Builtin Errors
func divide_using_builtin(x int, y int) (int, error) {
if y == 0 {
return -1, errors.New("Cannot divide by 0! (Using Builtin Errors)")
}
return x / y, nil
}
// using custom DivZero "errors" --> Using Custom Errors
func divide_using_custom(x int, y int) (int, error) {
if y == 0 {
return -1, myerr
}
return x / y, nil
}Código Completo
package main
import (
"errors"
"fmt"
"os"
)
//custom error --> struct
type DivZero struct{}
func (myerr *DivZero) Error() string {
return "Cannot divide by 0! (Using Custom Errors)"
}
var myerr = &DivZero{}
// using builtin "errors" --> Using Builtin Errors
func divide_using_builtin(x int, y int) (int, error) {
if y == 0 {
return -1, errors.New("Cannot divide by 0! (Using Builtin Errors)")
}
return x / y, nil
}
// using custom DivZero "errors" --> Using Custom Errors
func divide_using_custom(x int, y int) (int, error) {
if y == 0 {
return -1, myerr
}
return x / y, nil
}
func main() {
// basic use --> trying to open non existing file
filename, err := os.Open("Nofile.txt")
if err != nil {
fmt.Println(err)
}
fmt.Println("filename", filename) //comes out as
answer, err := divide_using_builtin(5, 0)
if err != nil {
// Handle the error!
fmt.Println(err)
} else {
// No errors!
fmt.Println(answer)
}
answer, err = divide_using_custom(5, 0)
if err != nil {
// Handle the error with custom error!
fmt.Println(myerr)
} else {
// No errors!
fmt.Println(answer)
}
}
No exemplo acima, exploramos todas as opções associadas ao uso do tipo erro.
Começamos tentando abrir um arquivo que não existe.
O erro é lançado e a mensagem é impressa:
open Nofile.txt: O sistema não pode encontrar o arquivo especificado.
Depois o fmt.Println(“filename”, filename) imprime:
filename <nil>
O <nil> é porque o arquivo Nofile.txt não existe, ele tenta abrir, não encontra o arquivo e retorna nil.
Em seguida, passamos para os erros personalizados.
A exceção de divisão por zero é tratada usando errors.New().
Por fim, criamos um struct DivZero.
A função println() chama automaticamente sua função Error() e a mensagem de erro é impressa.
E pra executar é só entrar na pasta onde tá o arquivo errors.go
go run errors.go
