---
title: "Documentação Go em Português: Como Ler, Buscar e Usar no Dia a Dia"
url: "https://golang.com.br/aprenda/documentacao-go/"
markdown_url: "https://golang.com.br/aprenda/documentacao-go.MD"
description: "Guia prático da documentação Go: como usar pkg.go.dev, go doc, documentação da standard library, exemplos, módulos, comandos e links para aprender Golang em português."
date: "2026-05-17"
author: "Golang Brasil"
---

# Documentação Go em Português: Como Ler, Buscar e Usar no Dia a Dia

Guia prático da documentação Go: como usar pkg.go.dev, go doc, documentação da standard library, exemplos, módulos, comandos e links para aprender Golang em português.


A **documentação Go** é uma das maiores vantagens da linguagem. Go foi desenhada para ter uma biblioteca padrão forte, comandos consistentes e uma cultura de exemplos pequenos. Isso significa que, em vez de depender de dezenas de posts desatualizados, você consegue resolver muita coisa lendo a referência oficial, executando exemplos e usando o próprio terminal.

O problema para quem está começando é saber **onde procurar**. Existe `go.dev/doc`, existe `pkg.go.dev`, existe `go doc`, existem páginas antigas do blog oficial, existem propostas, issues, release notes e exemplos embutidos nos pacotes. Este guia organiza esse mapa em português: o que cada fonte resolve, como pesquisar melhor, quais pacotes ler primeiro e como transformar documentação em prática.

Se você ainda está no início da trilha, comece pelo [tutorial Go em português](/aprenda/) e pelo guia [Go para iniciantes](/aprenda/go-para-iniciantes/). Depois volte aqui para aprender a usar a documentação como ferramenta diária.

## O mapa rápido da documentação Go

Use esta regra simples:

- **go.dev/doc**: documentação oficial de alto nível, instalação, tutorial, especificação, release notes e guias da linguagem.
- **pkg.go.dev**: referência dos pacotes, funções, tipos, exemplos e módulos publicados.
- **go doc**: consulta local pelo terminal, rápida para pacotes já instalados ou da standard library.
- **go help**: ajuda dos comandos do toolchain, como `go test`, `go mod`, `go build`, `go env` e `go vet`.
- **blog oficial do Go**: explicações mais longas sobre decisões, versões e recursos importantes.

Na prática, `pkg.go.dev` responde “como uso este pacote?”; `go help` responde “como uso este comando?”; e `go.dev/doc` responde “qual é o modelo mental correto da linguagem?”.

## Como usar pkg.go.dev sem se perder

O `pkg.go.dev` é a referência de pacotes do ecossistema Go. Para qualquer pacote, ele mostra documentação, tipos exportados, funções, métodos, exemplos, versão do módulo, licença e import path.

Exemplo: ao abrir `pkg.go.dev/net/http`, você encontra:

- o caminho correto de importação: `import "net/http"`;
- funções como `ListenAndServe`, `HandleFunc` e `NewRequest`;
- tipos como `Client`, `Request`, `Response`, `Handler` e `Server`;
- exemplos executáveis quando o pacote tem testes de exemplo;
- links para o código-fonte.

O ponto mais importante: em Go, nomes com letra maiúscula são exportados. A documentação pública mostra principalmente funções, tipos e métodos exportados. Se você não encontra uma função na documentação, talvez ela seja interna ao pacote ou não faça parte da API pública.

Quando pesquisar, prefira consultas específicas:

```text
site:pkg.go.dev net/http Client timeout
site:pkg.go.dev encoding/json Decoder DisallowUnknownFields
site:pkg.go.dev context WithTimeout example
```

Isso evita cair em respostas genéricas e leva direto para a referência.

## go doc: documentação direto no terminal

O comando `go doc` é subestimado. Ele permite consultar documentação sem abrir o navegador:

```bash
go doc fmt
go doc fmt.Println
go doc net/http.Client
go doc context.WithTimeout
```

Para listar mais detalhes de um pacote:

```bash
go doc -all net/http
```

Para ver código-fonte junto da documentação:

```bash
go doc -src strings.Builder
```

Esse fluxo é ótimo quando você está programando e quer confirmar assinatura, comentário ou comportamento sem quebrar o ritmo. Combine com `go env GOPATH`, `go list` e `go test` para investigar módulos maiores.

## Pacotes da standard library que todo iniciante deve conhecer

A biblioteca padrão é grande, mas você não precisa ler tudo. Para ser produtivo em backend, CLI e automação, comece por estes pacotes:

| Pacote | Para que serve |
|---|---|
| `fmt` | formatação de strings e saída no terminal |
| `strings` | manipulação de texto |
| `strconv` | conversão entre strings e números |
| `errors` | criação e comparação de erros |
| `context` | cancelamento, timeout e escopo de requisição |
| `net/http` | servidores e clientes HTTP |
| `encoding/json` | leitura e escrita de JSON |
| `time` | datas, durações, timers e deadlines |
| `os` | arquivos, variáveis de ambiente e processos |
| `io` | leitura e escrita por streams |
| `testing` | testes unitários e benchmarks |
| `log/slog` | logs estruturados para produção |

Depois aprofunde conforme o projeto: `database/sql` para banco de dados, `sync` para concorrência, `regexp` para expressões regulares, `embed` para arquivos embutidos e `flag` para CLIs.

## Documentação dos comandos Go

A documentação da linguagem não é só pacote. O toolchain também é parte central do dia a dia. Estes comandos aparecem em quase todo projeto:

```bash
go mod init exemplo.com/app   # cria um módulo
go mod tidy                   # sincroniza dependências
go run .                      # executa o programa
go test ./...                 # roda testes
go fmt ./...                  # formata código
go vet ./...                  # aponta problemas suspeitos
go build ./...                # compila pacotes
```

Para entender um comando em detalhe, use:

```bash
go help mod
go help testflag
go help build
go help packages
```

Se o seu problema é dependência, leia também [Go Modules na prática](/aprenda/go-modules-na-pratica/). Se é teste, vá para [testes em Go](/aprenda/testes-go/) e depois para [TDD e CI/CD com Go](/tutoriais/go-tdd-ci-cd/).

## Como ler documentação quando você ainda não sabe inglês técnico

A documentação oficial de Go é majoritariamente em inglês. Você não precisa traduzir palavra por palavra. Procure os padrões:

- **Package**: explica a finalidade do pacote.
- **func**: função exportada.
- **type**: tipo exportado, como struct ou interface.
- **method**: função ligada a um tipo.
- **Example**: exemplo executável.
- **Deprecated**: API antiga; evite em código novo.
- **Since**: versão do Go em que aquele recurso apareceu.

Quando encontrar um pacote novo, leia nesta ordem:

1. parágrafo inicial do pacote;
2. exemplos;
3. tipos principais;
4. funções de criação, como `NewClient`, `NewRequest` ou `NewEncoder`;
5. notas de erro, concorrência e compatibilidade.

Esse método funciona melhor do que tentar memorizar tudo. Go favorece APIs pequenas; a documentação fica mais útil quando você lê com um problema concreto em mãos.

## Exemplo prático: descobrindo como fazer uma requisição HTTP

Imagine que você quer chamar uma API externa. Em vez de procurar um tutorial aleatório, vá ao pacote `net/http` e procure por `Client`, `NewRequestWithContext` e `Do`.

Um esqueleto seguro fica assim:

```go
package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://example.com", nil)
    if err != nil {
        panic(err)
    }

    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    fmt.Println(resp.StatusCode)
}
```

A documentação mostra as peças; a prática junta contexto, timeout, cliente e tratamento de erro. Para transformar isso em uma aplicação completa, siga o guia de [API REST com Go](/aprenda/api-rest-go/).

## Checklist de documentação antes de copiar código

Antes de copiar um snippet de blog, GitHub ou IA, cheque:

- o pacote ainda é mantido?
- a função está marcada como `Deprecated`?
- a API existe na versão de Go que você usa?
- o exemplo trata erro?
- há timeout ou cancelamento quando envolve rede?
- há teste ou exemplo oficial parecido?
- o import path é o mesmo do módulo atual?

Esse checklist evita bugs comuns: cliente HTTP sem timeout, erro ignorado, pacote antigo, dependência desnecessária e uso de API experimental sem perceber.

## Próximo passo

Use a documentação como parte da rotina: escreva código, leia a assinatura, rode teste, ajuste. Para continuar a trilha em português, siga estes caminhos:

- [Go para iniciantes](/aprenda/go-para-iniciantes/) para fundamentos;
- [Go Modules na prática](/aprenda/go-modules-na-pratica/) para dependências;
- [Cheatsheet Go](/cheatsheet/) para consulta rápida;
- [Logging estruturado com slog](/blog/slog-go-logging-estruturado/) para produção;
- [Effective Go em 2026](/blog/effective-go-2026/) para separar fundamentos clássicos de práticas modernas;
- [Vagas Go no Brasil](/vagas/) para conectar estudo com mercado.

A documentação Go é curta por design. Quanto mais você usa `pkg.go.dev`, `go doc` e `go help`, menos depende de receitas soltas e mais rápido consegue ler código Go real em empresas brasileiras.