Noções Básicas da Filosofia Go

10 exemplos para você começar com a Filosofia Go - 7 básicos e 3 intermediários.

Pré-requisitos

Go 1.26.x instalado (go version).
Nenhum módulo de terceiros necessário para estes trechos - todos usam a biblioteca padrão.

Exemplos Básicos

1. `main` Mínimo - Clareza em Primeiro Lugar

Go favorece um ponto de entrada curto que conecta dependências e executa.

package main
 
import "fmt"
 
func main() {
    fmt.Println("entregue programas pequenos e legíveis")
}

package main marca um executável; código de biblioteca usa outros nomes de pacotes.
Um main óbvio mantém o fluxo de inicialização fácil de auditar durante incidentes.
A lógica de negócios pertence a pacotes que você pode testar sem iniciar um processo.

Relacionado: Por que Go Existe - os objetivos de design por trás deste layout

2. Tratamento Explícito de Erros

Erros são valores retornados ao lado de resultados, não exceções lançadas.

package main
 
import (
    "fmt"
    "os"
)
 
func readConfig(path string) ([]byte, error) {
    return os.ReadFile(path)
}
 
func main() {
    data, err := readConfig("config.yaml")
    if err != nil {
        fmt.Fprintf(os.Stderr, "ler configuração: %v\n", err)
        os.Exit(1)
    }
    fmt.Printf("carregado %d bytes\n", len(data))
}

Chamadores lidam com falhas no local de chamada - rastros de pilha não são o fluxo de controle padrão.
if err != nil é repetitivo por design; mantém os caminhos de falha visíveis na revisão.
Envolver com fmt.Errorf("ler configuração: %w", err) preserva as causas para logs.

Relacionado: Simplicidade como uma Restrição Deliberada no Design de API - por que as APIs retornam erros simples

3. Pequena Interface no Local de Chamada

Go define interfaces onde elas são consumidas, não onde os tipos são declarados.

package notify
 
import "context"
 
type Sender interface {
    Send(ctx context.Context, msg string) error
}
 
func Deliver(ctx context.Context, s Sender, msg string) error {
    return s.Send(ctx, msg)
}

Interfaces permanecem minúsculas - muitas vezes um ou dois métodos - para que os fakes sejam triviais em testes.
Tipos concretos não precisam "implementar" nada explicitamente; a satisfação é implícita.
Este padrão favorece a composição e desencoraja árvores de herança profundas.

4. Goroutine para Trabalho Concorrente

Concorrência é um recurso de primeira classe da linguagem, não apenas uma preocupação de biblioteca.

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch := make(chan string, 1)
    go func() {
        time.Sleep(50 * time.Millisecond)
        ch <- "done"
    }()
    fmt.Println(<-ch)
}

go inicia uma função concorrentemente; o runtime a agenda em threads do SO.
Canais passam dados entre goroutines e expressam transferência de propriedade.
Sempre saiba como uma goroutine sai - vazamentos aparecem como crescimento de memória e FD.

Relacionado: Por que Go Existe - modelo de concorrência inspirado em CSP

5. `defer` para Limpeza Confiável

Defer registra a limpeza que é executada quando a função circundante retorna.

package main
 
import (
    "fmt"
    "os"
)
 
func writeTemp() error {
    f, err := os.CreateTemp("", "demo-*.txt")
    if err != nil {
        return err
    }
    defer func() {
        f.Close()
        os.Remove(f.Name())
    }()
    _, err = f.WriteString("hello")
    return err
}
 
func main() {
    if err := writeTemp(); err != nil {
        panic(err)
    }
    fmt.Println("ok")
}

defer emparelha aquisição com liberação, mesmo quando existem múltiplos caminhos de retorno.
Defers executam LIFO na saída da função - útil para bloqueios e arquivos aninhados.
Prefira defer em vez de duplicação manual de limpeza em funções longas.

6. Biblioteca Padrão em Vez de Proliferação de Frameworks

Go envia "baterias incluídas" para HTTP, JSON, TLS e testes na ferramenta que você já possui.

package main
 
import (
    "encoding/json"
    "net/http"
)
 
type Health struct {
    Status string `json:"status"`
}
 
func main() {
    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        _ = json.NewEncoder(w).Encode(Health{Status: "ok"})
    })
    http.ListenAndServe(":8080", nil)
}

net/http é capaz de produção para muitos serviços antes de você recorrer a Gin, Echo ou chi.
Menos dependências significam superfícies de auditoria menores e go test mais rápidos em CI.
Frameworks ainda ajudam quando você precisa de roteamento, vinculação ou ecossistemas de middleware opinativos.

Relacionado: Domínios de Destino do Go - padrões de nuvem nativa

7. Testes Orientados por Tabela Codificam Expectativas da Equipe

Testes documentam o comportamento como linhas de dados, correspondendo à preferência do Go por explicitude.

package mathx
 
import "testing"
 
func Add(a, b int) int { return a + b }
 
func TestAdd(t *testing.T) {
    cases := []struct {
        a, b, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, tc := range cases {
        if got := Add(tc.a, tc.b); got != tc.want {
            t.Fatalf("Add(%d,%d)=%d, want %d", tc.a, tc.b, got, tc.want)
        }
    }
}

Testes de tabela escalam para casos extremos sem blocos de asserção copiar-colar.
go test é o ponto de entrada universal de CI - nenhum executor de teste adicional é necessário.
Casos de falha se nomeiam através dos dados, o que auxilia na revisão de código.

Exemplos Intermediários

8. `context.Context` nas Fronteiras da API

Cancelamento e prazos se propagam através de serviços no estilo Go.

package fetch
 
import (
    "context"
    "io"
    "net/http"
    "time"
)
 
func Get(ctx context.Context, url string) ([]byte, error) {
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        return nil, err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}
 
func GetWithTimeout(url string, d time.Duration) ([]byte, error) {
    ctx, cancel := context.WithTimeout(context.Background(), d)
    defer cancel()
    return Get(ctx, url)
}

Contexto é o primeiro parâmetro padrão para APIs vinculadas a I/O.
Pais cancelam filhos quando clientes desconectam ou prazos expiram.
Passar context.Background() apenas no main ou harness de teste mais externo mantém as árvores coerentes.

Relacionado: Domínios de Destino do Go - fronteiras de serviços distribuídos

9. Aceite Interfaces, Retorne Structs

Funções públicas dependem de interfaces estreitas; construtores expõem tipos concretos.

package storage
 
import "context"
 
type Store interface {
    Put(ctx context.Context, key string, value []byte) error
}
 
type FileStore struct {
    dir string
}
 
func NewFileStore(dir string) *FileStore {
    return &FileStore{dir: dir}
}
 
func (f *FileStore) Put(ctx context.Context, key string, value []byte) error {
    // implementação omitida
    return nil
}
 
func Save(ctx context.Context, s Store, key string, value []byte) error {
    return s.Put(ctx, key, value)
}

Chamadores de Save mockam Store sem importar os detalhes internos de FileStore.
Construtores (NewFileStore) documentam a inicialização válida em um único local.
Esta é a alternativa idiomática para frameworks de DI pesados em fábrica.

Relacionado: Simplicidade como uma Restrição Deliberada no Design de API - moldando APIs de pacotes estáveis

10. Esboço de Decisão - Quando Não Usar Go por Padrão

A filosofia inclui saber onde outra linguagem se destaca.

// Go se destaca: CLI binária estática com flags e subcomandos.
// Considere Rust: desempenho adjacente a firmware sem GC.
// Considere Python: ciência de dados exploratória com iteração em notebooks.
// Considere JVM: integrações empresariais maduras que sua equipe já opera.
 
package main
 
import "fmt"
 
func main() {
    fmt.Println("escolha Go quando a velocidade da equipe e a operabilidade dominarem o ADR")
}

Combine a linguagem com o risco dominante: limite de latência, pool de talentos, pacotes do ecossistema ou ferramentas de conformidade.
Go é um forte padrão para serviços de rede - não um martelo universal.
Documente a decisão em um ADR para que futuras equipes herdem o raciocínio.

Relacionado: Quando Go é a Ferramenta Errada - contraexemplos concretos | Go vs Rust - compensações de sistemas

Versões da Pilha: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, go fix modernizadores - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).

Pré-requisitos

Go 1.26.x instalado (go version).
Nenhum módulo de terceiros necessário para estes trechos - todos usam a biblioteca padrão.

Exemplos Básicos

1. `main` Mínimo - Clareza em Primeiro Lugar

Go favorece um ponto de entrada curto que conecta dependências e executa.

package main
 
import "fmt"
 
func main() {
    fmt.Println("entregue programas pequenos e legíveis")
}

package main marca um executável; código de biblioteca usa outros nomes de pacotes.
Um main óbvio mantém o fluxo de inicialização fácil de auditar durante incidentes.
A lógica de negócios pertence a pacotes que você pode testar sem iniciar um processo.

Relacionado: Por que Go Existe - os objetivos de design por trás deste layout

2. Tratamento Explícito de Erros

Erros são valores retornados ao lado de resultados, não exceções lançadas.

package main
 
import (
    "fmt"
    "os"
)
 
func readConfig(path string) ([]byte, error) {
    return os.ReadFile(path)
}
 
func main() {
    data, err := readConfig("config.yaml")
    if err != nil {
        fmt.Fprintf(os.Stderr, "ler configuração: %v\n", err)
        os.Exit(1)
    }
    fmt.Printf("carregado %d bytes\n", len(data))
}

Chamadores lidam com falhas no local de chamada - rastros de pilha não são o fluxo de controle padrão.
if err != nil é repetitivo por design; mantém os caminhos de falha visíveis na revisão.
Envolver com fmt.Errorf("ler configuração: %w", err) preserva as causas para logs.

Relacionado: Simplicidade como uma Restrição Deliberada no Design de API - por que as APIs retornam erros simples

3. Pequena Interface no Local de Chamada

Go define interfaces onde elas são consumidas, não onde os tipos são declarados.

package notify
 
import "context"
 
type Sender interface {
    Send(ctx context.Context, msg string) error
}
 
func Deliver(ctx context.Context, s Sender, msg string) error {
    return s.Send(ctx, msg)
}

Interfaces permanecem minúsculas - muitas vezes um ou dois métodos - para que os fakes sejam triviais em testes.
Tipos concretos não precisam "implementar" nada explicitamente; a satisfação é implícita.
Este padrão favorece a composição e desencoraja árvores de herança profundas.

4. Goroutine para Trabalho Concorrente

Concorrência é um recurso de primeira classe da linguagem, não apenas uma preocupação de biblioteca.

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch := make(chan string, 1)
    go func() {
        time.Sleep(50 * time.Millisecond)
        ch <- "done"
    }()
    fmt.Println(<-ch)
}

go inicia uma função concorrentemente; o runtime a agenda em threads do SO.
Canais passam dados entre goroutines e expressam transferência de propriedade.
Sempre saiba como uma goroutine sai - vazamentos aparecem como crescimento de memória e FD.

Relacionado: Por que Go Existe - modelo de concorrência inspirado em CSP

5. `defer` para Limpeza Confiável

Defer registra a limpeza que é executada quando a função circundante retorna.

package main
 
import (
    "fmt"
    "os"
)
 
func writeTemp() error {
    f, err := os.CreateTemp("", "demo-*.txt")
    if err != nil {
        return err
    }
    defer func() {
        f.Close()
        os.Remove(f.Name())
    }()
    _, err = f.WriteString("hello")
    return err
}
 
func main() {
    if err := writeTemp(); err != nil {
        panic(err)
    }
    fmt.Println("ok")
}

defer emparelha aquisição com liberação, mesmo quando existem múltiplos caminhos de retorno.
Defers executam LIFO na saída da função - útil para bloqueios e arquivos aninhados.
Prefira defer em vez de duplicação manual de limpeza em funções longas.

6. Biblioteca Padrão em Vez de Proliferação de Frameworks

Go envia "baterias incluídas" para HTTP, JSON, TLS e testes na ferramenta que você já possui.

package main
 
import (
    "encoding/json"
    "net/http"
)
 
type Health struct {
    Status string `json:"status"`
}
 
func main() {
    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        _ = json.NewEncoder(w).Encode(Health{Status: "ok"})
    })
    http.ListenAndServe(":8080", nil)
}

net/http é capaz de produção para muitos serviços antes de você recorrer a Gin, Echo ou chi.
Menos dependências significam superfícies de auditoria menores e go test mais rápidos em CI.
Frameworks ainda ajudam quando você precisa de roteamento, vinculação ou ecossistemas de middleware opinativos.

Relacionado: Domínios de Destino do Go - padrões de nuvem nativa

7. Testes Orientados por Tabela Codificam Expectativas da Equipe

Testes documentam o comportamento como linhas de dados, correspondendo à preferência do Go por explicitude.

package mathx
 
import "testing"
 
func Add(a, b int) int { return a + b }
 
func TestAdd(t *testing.T) {
    cases := []struct {
        a, b, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, tc := range cases {
        if got := Add(tc.a, tc.b); got != tc.want {
            t.Fatalf("Add(%d,%d)=%d, want %d", tc.a, tc.b, got, tc.want)
        }
    }
}

Testes de tabela escalam para casos extremos sem blocos de asserção copiar-colar.
go test é o ponto de entrada universal de CI - nenhum executor de teste adicional é necessário.
Casos de falha se nomeiam através dos dados, o que auxilia na revisão de código.

Exemplos Intermediários

8. `context.Context` nas Fronteiras da API

Cancelamento e prazos se propagam através de serviços no estilo Go.

package fetch
 
import (
    "context"
    "io"
    "net/http"
    "time"
)
 
func Get(ctx context.Context, url string) ([]byte, error) {
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        return nil, err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}
 
func GetWithTimeout(url string, d time.Duration) ([]byte, error) {
    ctx, cancel := context.WithTimeout(context.Background(), d)
    defer cancel()
    return Get(ctx, url)
}

Contexto é o primeiro parâmetro padrão para APIs vinculadas a I/O.
Pais cancelam filhos quando clientes desconectam ou prazos expiram.
Passar context.Background() apenas no main ou harness de teste mais externo mantém as árvores coerentes.

Relacionado: Domínios de Destino do Go - fronteiras de serviços distribuídos

9. Aceite Interfaces, Retorne Structs

Funções públicas dependem de interfaces estreitas; construtores expõem tipos concretos.

package storage
 
import "context"
 
type Store interface {
    Put(ctx context.Context, key string, value []byte) error
}
 
type FileStore struct {
    dir string
}
 
func NewFileStore(dir string) *FileStore {
    return &FileStore{dir: dir}
}
 
func (f *FileStore) Put(ctx context.Context, key string, value []byte) error {
    // implementação omitida
    return nil
}
 
func Save(ctx context.Context, s Store, key string, value []byte) error {
    return s.Put(ctx, key, value)
}

Chamadores de Save mockam Store sem importar os detalhes internos de FileStore.
Construtores (NewFileStore) documentam a inicialização válida em um único local.
Esta é a alternativa idiomática para frameworks de DI pesados em fábrica.

Relacionado: Simplicidade como uma Restrição Deliberada no Design de API - moldando APIs de pacotes estáveis

10. Esboço de Decisão - Quando Não Usar Go por Padrão

A filosofia inclui saber onde outra linguagem se destaca.

// Go se destaca: CLI binária estática com flags e subcomandos.
// Considere Rust: desempenho adjacente a firmware sem GC.
// Considere Python: ciência de dados exploratória com iteração em notebooks.
// Considere JVM: integrações empresariais maduras que sua equipe já opera.
 
package main
 
import "fmt"
 
func main() {
    fmt.Println("escolha Go quando a velocidade da equipe e a operabilidade dominarem o ADR")
}

Combine a linguagem com o risco dominante: limite de latência, pool de talentos, pacotes do ecossistema ou ferramentas de conformidade.
Go é um forte padrão para serviços de rede - não um martelo universal.
Documente a decisão em um ADR para que futuras equipes herdem o raciocínio.

Relacionado: Quando Go é a Ferramenta Errada - contraexemplos concretos | Go vs Rust - compensações de sistemas

Versões da Pilha: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, go fix modernizadores - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).

Noções Básicas da Filosofia Go

Buscar na documentação

Noções Básicas da Filosofia Go