Aula 24 – Tutorial Golang – Errors

Aula 24 – Tutorial Golang – Errors

Tutorial Golang - Errors

Tutorial Golang – Errors

Página principal do blog

Todas as aulas desse curso

Aula 23                        Aula 25

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook.

Sigam o Código Fluente no Instagram e no TikTok.

Código Fluente no Pinterest.

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

PIX Nubank

Se quiser copiar o código do PIX:

00020126580014BR.GOV.BCB.PIX013643c5f950-535b-4658-b91f-1f1d135fe4105204000053039865802BR5925Antonio Cavalcante de Pau6009SAO PAULO61080540900062070503***6304946B

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)

É isso pessoal, fico por aqui!

Até mais. 🙂

Página principal do blog

Todas as aulas desse curso

Aula 23                        Aula 25

página do Código Fluente no
Facebook

Sigam o Código Fluente no Instagram e no TikTok.

Esse é o link do código fluente no Pinterest

Meus links de afiliados:

Hostinger

Digital Ocean

One.com

Obrigado e bons estudos. 😉

About The Author
-

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>