Variáveis, Constantes e Escopo

Go oferece várias maneiras de introduzir nomes, cada uma com regras de escopo e restrições de tempo de compilação diferentes.

Saber qual forma usar mantém o código legível e evita bugs sutis de fechamento de loop.

Resumo

Variáveis armazenam valores em tempo de execução; constantes são fixas em tempo de compilação.

Escopo é léxico: blocos internos podem sombrear nomes externos, mas nomes no nível do pacote são visíveis entre arquivos do mesmo pacote.

Declaração curta (:=) é a escolha idiomática dentro de funções, enquanto var e const funcionam no nível do pacote.

iota gera sequências de constantes relacionadas sem numeração manual.

Receita

Cartão de referência rápida - pronto para copiar e colar.

package main
 
import "fmt"
 
const Version = "1.0.0"
 
var defaultPort = 8080
 
func main() {
    host := "localhost"
    port := defaultPort
    fmt.Println(host, port, Version)
}

Quando usar isso:

• Use := para locais dentro de funções quando a inferência de tipo for clara.
• Use var no nível do pacote ou quando precisar de um valor zero explícito sem atribuição.
• Use const para valores que não devem mudar e para enumerações iota.
• Use escopo de bloco intencionalmente; evite sombrear nomes exportados acidentalmente.

Exemplo de Trabalho

package main
 
import "fmt"
 
const (
    StatusPending = iota
    StatusActive
    StatusDone
)
 
var registry = map[string]int{}
 
func main() {
    for _, name := range []string{"ada", "grace"} {
        registry[name] = StatusPending
    }
 
    // Armadilha de closure: capture a variável do loop por parâmetro, não por referência.
    for _, name := range []string{"ada", "grace"} {
        go greet(name)
    }
 
    fmt.Println(registry)
}
 
func greet(name string) {
    fmt.Println("hello", name)
}

O que isso demonstra:

• Constantes iota para estados ordenados sem números mágicos.
• var no nível do pacote para estado mutável compartilhado (use com cuidado).
• := local de função dentro de main.
• Passar name como parâmetro para greet evita o clássico bug de closure de variável de loop.

Mergulho Profundo

Como Funciona

• Nomes são vinculados em tempo de compilação; locais e imports não utilizados são erros.
• Variáveis no nível do pacote inicializam antes de main na ordem de dependência entre pacotes.
• Valores const devem ser computáveis em tempo de compilação (literais, aritmética em constantes, iota).
• Declaração curta de variável := reutiliza nomes no mesmo bloco apenas quando pelo menos um nome à esquerda é novo.

Formulários de Declaração em Resumo

Escopo e Sombreamento

Notas Go

// iota com máscaras de bits
const (
    FlagRead  = 1 << iota
    FlagWrite
    FlagExec
)
 
// Tipo explícito na primeira const define o tipo para o bloco
const (
    KB int = 1 << (10 * iota)
    MB
    GB
)

Armadilhas

• Variável de loop em closures de goroutine - go func() { fmt.Println(i) }() captura um i mutável. Correção: passe i como parâmetro ou copie i := i dentro do corpo do loop (Go 1.22+ cria variáveis por iteração em for range).
• Sombreamento com := - x := 1 dentro de um bloco interno esconde o x externo e pode confundir leitores. Correção: use nomes distintos ou atribua x = 1 ao reutilizar a variável externa.
• Variáveis não utilizadas - Locais declarados mas não lidos falham na compilação. Correção: remova-os ou use _ para descartes intencionais.
• := no nível do pacote - Declaração curta é ilegal fora de funções. Correção: use var ou const no escopo do pacote.
• Estouro de const não tipado - Constantes não tipadas se adaptam a diferentes tipos numéricos (const x = 1). Valores grandes atribuídos a int8 podem truncar silenciosamente em algumas conversões. Correção: use constantes tipadas ou conversão explícita com verificações de limites.
• Globais mutáveis no nível do pacote - Fácil de criar acoplamento oculto e condições de corrida. Correção: prefira passar dependências explicitamente ou proteja com primitivas de sincronização.

Alternativas

FAQs

if err := do(); err != nil {
    // err existe apenas nesta cadeia if/else
}

Relacionados

• Valores Zero e Inicialização - O que var fornece sem inicializador
• Ponteiros e o Operador de Endereço - Passando e mutando valores nomeados
• Fundamentos de Go - Básico - Tour rápido de trechos de declaração
• Fundamentos de Go - Melhores Práticas - Hábitos de nomenclatura e estado no nível do pacote

Links Externos Relacionados

• A Tour of Go - Introdução interativa oficial ao Go.
• Especificação da Linguagem Go - A referência formal da linguagem.
• Effective Go - Guia oficial para escrever Go claro e idiomático.
• Get Programming with Go (Manning) - Nathan Youngman & Roger Peppé.
• Learning Go (2nd Edition, O'Reilly) - Jon Bodner na O'Reilly.

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