O Conceito de Erros

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

Em Go, erros são valores que indicam que algo deu errado. Go lida com erros explicitamente em vez de usar exceções.

Vamos criar uma função que pode produzir um erro ao dividir números:

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

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

Agora, vamos usar nossa função e tratar quaisquer erros potenciais:

result, err := divide(10, 0)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

Após executar este código, veremos uma mensagem de erro na tela porque tentamos dividir por zero:

Error: cannot divide by zero

Isso demonstra o padrão de tratamento de erros do Go: verifique se ocorreu um erro (err != nil) e então tome a ação apropriada. Se nenhum erro ocorreu, podemos usar o resultado com segurança.

Desafio

Fácil

Neste desafio, você praticará o trabalho com erros em Go. Você criará uma função que divide dois números e retorna um erro se a divisão por zero for tentada.

Sua tarefa é:

Complete a função divide que recebe dois inteiros e retorna o quociente deles e um erro.
Se o divisor for zero, retorne 0 e um erro com a mensagem "division by zero".
Se a divisão for válida, retorne o resultado e nil para o erro.
Na função main, chame divide com os valores fornecidos e trate quaisquer erros adequadamente.

Este exercício demonstra como as funções em Go comumente retornam um resultado e um erro, e como verificar e tratar esses erros.

Folha de consulta

Em Go, erros são valores que indicam que algo deu errado. Go trata erros explicitamente em vez de usar exceções.

Funções que podem falhar retornam dois valores: o resultado e um erro potencial:

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

Para tratar erros, verifique se o erro não é nil:

result, err := divide(10, 0)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

Use errors.New() para criar novas mensagens de erro e retorne nil quando nenhum erro ocorrer.

Experimente você mesmo

package main
import (
    "errors"
    "fmt"
)
// divide divide a por b e retorna o resultado
// Se b for 0, retorna um erro
func divide(a, b int) (int, error) {
    // TODO: Implementar a função divide
    // Se b for 0, retornar 0 e um erro com a mensagem "division by zero"
    // Caso contrário, retornar a/b e nil para o erro

}
func main() {
    // Primeiro caso de teste
    a, b := 10, 2
    result, err := divide(a, b)
    if err != nil {
        fmt.Printf("Error: %s\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }

    // Segundo caso de teste
    a, b = 8, 0
    result, err = divide(a, b)
    if err != nil {
        fmt.Printf("Error: %s\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }
}