Go Academy · Aula

A interface error

Retorne e verifique errors de forma idiomática

A interface error é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

A filosofia de erros de Go

Go trata erros como valores, não como exceções. As funções retornam um error como último valor de retorno. O chamador deve verificá-lo explicitamente:

package main
import ("fmt"; "strconv")

func main() {
    n, err := strconv.Atoi("abc")
    if err != nil {
        fmt.Println("error:", err)  // handle it
        return
    }
    fmt.Println(n)
}

A interface error

O error integrado é uma interface simples:

// Built into Go — no import needed
type error interface {
    Error() string
}

// Any type with Error() string satisfies it
// nil means no error

Retorno de erros

As funções que podem falhar retornam (value, error). Retorne nil quando não houver erro:

package main
import ("fmt"; "errors")

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

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Println(result)
}

O padrão if err != nil

A verificação if err != nil é o idioma mais comum de Go. Sempre trate os erros — não os ignore:

package main
import ("fmt"; "os")

func main() {
    f, err := os.Open("config.json")
    if err != nil {
        fmt.Println("open error:", err)
        return
    }
    defer f.Close()
    // use f...
    _ = f
}

errors.New — valores de erro simples

errors.New cria um erro simples com uma mensagem fixa:

package main
import ("fmt"; "errors")

var ErrNotFound = errors.New("not found")

func findByID(id int) (string, error) {
    data := map[int]string{1: "Alice"}
    v, ok := data[id]
    if !ok {
        return "", ErrNotFound
    }
    return v, nil
}

func main() {
    _, err := findByID(99)
    fmt.Println(err) // not found
}

fmt.Errorf — mensagens de erro formatadas

fmt.Errorf cria erros com contexto a partir de strings formatadas:

package main
import "fmt"

func openConfig(path string) error {
    // Add context to the error message
    return fmt.Errorf("openConfig %s: file not found", path)
}

func main() {
    err := openConfig("/etc/app/config.yaml")
    fmt.Println(err)
    // openConfig /etc/app/config.yaml: file not found
}

Erros sentinela

Erros sentinela são valores de erro no nível do pacote usados para comparação de identidade:

package main
import ("fmt"; "errors")

var (
    ErrTimeout    = errors.New("timeout")
    ErrPermission = errors.New("permission denied")
)

func doRequest() error { return ErrTimeout }

func main() {
    err := doRequest()
    if errors.Is(err, ErrTimeout) {
        fmt.Println("request timed out — retrying")
    }
}

Ignorar erros é um erro

Go exige que você use todas as variáveis declaradas — mas ignorar erros com _ compila sem problemas e é um erro comum que deve ser evitado:

package main
import "os"

func bad() {
    os.Remove("temp.txt") // silently ignores error — bad practice
}

func good() error {
    if err := os.Remove("temp.txt"); err != nil {
        return err  // propagate
    }
    return nil
}

Contexto do erro: adicionando informações

Ao propagar erros pela pilha de chamadas, adicione um contexto que descreva qual operação falhou:

package main
import "fmt"

func readConfig(path string) ([]byte, error) {
    return nil, fmt.Errorf("readConfig: %w", fmt.Errorf("file %s not found", path))
}

func setup() error {
    _, err := readConfig("/etc/app.cfg")
    if err != nil {
        return fmt.Errorf("setup: %w", err) // wrap with context
    }
    return nil
}

func main() {
    err := setup()
    fmt.Println(err) // setup: readConfig: file /etc/app.cfg not found
}

Vários retornos de erro

As funções podem retornar erros de vários pontos de falha. Verifique cada um:

package main
import ("fmt"; "strconv")

func parseRange(minStr, maxStr string) (int, int, error) {
    min, err := strconv.Atoi(minStr)
    if err != nil { return 0, 0, fmt.Errorf("min: %w", err) }
    max, err := strconv.Atoi(maxStr)
    if err != nil { return 0, 0, fmt.Errorf("max: %w", err) }
    if min > max { return 0, 0, fmt.Errorf("min %d > max %d", min, max) }
    return min, max, nil
}

func main() {
    lo, hi, err := parseRange("1", "10")
    if err != nil { fmt.Println(err); return }
    fmt.Println(lo, hi)
}

Verificação rápida

O que significa um valor de retorno de erro nulo em Go?

Recapitulação: a interface error

Conceitos principais do tratamento de erros:

Error é uma interface integrada: Error() string
Retorne (value, error) — nil significa sucesso
errors.New para erros simples, fmt.Errorf para erros formatados
Sempre verifique if err != nil
Adicione contexto ao propagar erros pela pilha
Nunca ignore erros silenciosamente

Perguntas Frequentes

A aula “A interface error” é grátis?

Sim — o texto completo de “A interface error” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “A interface error”?

Retorne e verifique errors de forma idiomática Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “A interface error”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy