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

Saída:

open Nofile.txt: O sistema não pode encontrar o arquivo especificado. filename <nil> Cannot divide by 0! (Using Builtin Errors) Cannot divide by 0! (Using Custom Errors)

Aula 24 - Tutorial Golang - Errors