Tratamento de Erros Básico

Parte da seção Fundamentos do Journey de GO da Coddy — lição 108 de 109.

Tratamento Básico de Erros é um padrão fundamental em Go, onde você verifica erros após operações que podem falhar.

Vamos aprender como lidar com erros em Go criando uma função de divisão simples que retorna um erro ao dividir por zero:

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

Esta função retorna dois valores: o resultado da divisão e um erro. Se o divisor for zero, ela retorna uma mensagem de erro em vez de tentar a divisão.

Agora, vamos ver como usar esta função e lidar com quaisquer erros potenciais:

result, err := divide(10, 0)
    
if err != nil {
    fmt.Println("Error occurred:", err)
    return // Interromper a execução ou tratar o erro
}
    
fmt.Println("Result:", result)

Após executar este código, verificamos se ocorreu um erro usando a condição if err != nil. Como tentamos dividir por zero, a função retorna um erro e o seguinte será exibido na tela:

Error occurred: division by zero

Este padrão de retornar um erro como o último valor de retorno e verificá-lo imediatamente é muito comum em Go. Ele permite que seu programa lide com falhas de forma graciosa em vez de encerrar inesperadamente.

Desafio

Fácil

Neste desafio, você praticará o tratamento básico de erros em Go. Você tem uma função que divide dois números, mas a divisão por zero causa um erro de tempo de execução. Sua tarefa é adicionar o tratamento de erros para evitar esse travamento.

O código já possui uma função que retorna tanto um resultado quanto um erro. Você precisa verificar se há um erro antes de usar o resultado.

Folha de consulta

Em Go, funções que podem falhar retornam um erro como o último valor de retorno:

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

Verifique se há erros usando if err != nil:

result, err := divide(10, 0)
    
if err != nil {
    fmt.Println("Error occurred:", err)
    return // Interrompe a execução ou trata o erro
}
    
fmt.Println("Result:", result)

Este padrão permite que os programas lidem com falhas de forma graciosa em vez de travar.

Experimente você mesmo

package main

import (
	"errors"
	"fmt"
)

// Esta função divide x por y e retorna um erro se y for zero
func divide(x, y float64) (float64, error) {
	if y == 0 {
		return 0, errors.New("cannot divide by zero")
	}
	return x / y, nil
}

func main() {
	// Valores de teste
	numerator := 10.0
	denominator := 0.0
	
	// Chama a função divide
	result, err := divide(numerator, denominator)
	
	// TODO: Verifique se err não é nil (se há um erro)
	// Se houver um erro, imprima-o usando fmt.Println(err)
	// Caso contrário, imprima o resultado usando fmt.Printf("Result: %.2f\n", result)
	
	// Remova esta linha e implemente o tratamento de erro adequado acima
	fmt.Printf("Result: %.2f\n", result)
}