Resumo dos Destaques dos Fundamentos de Go

Cada item de destaque das 9 páginas desta seção, reunido em uma única página e agrupado pela página de origem.

Como os Programas Go São Estruturados: Pacotes, main e a Toolchain

• Apenas o pacote main produz um executável e deve definir o ponto de entrada func main()
• go build percorre as importações a partir de main e compila cada pacote necessário para o cache de compilação
• Nomes exportados começam com maiúscula; identificadores minúsculos são privados do pacote
• O compilador rejeita importações de internal/ de fora do módulo para encapsulamento
• O linker realiza a eliminação de código morto em nível de função para minimizar o tamanho do binário
• Funções init rodam antes de main na ordem de dependência para registro e configuração

Noções Básicas dos Fundamentos de Go

• O pacote main marca executáveis; go run . compila sem deixar um binário
• Use := apenas dentro de funções; var funciona no nível do pacote
• Tipos numéricos têm o valor padrão 0; bool para false; ponteiros, slices e mapas para nil
• iota reinicia a cada bloco const e incrementa uma vez por linha
• Iterar sobre strings com range retorna o índice de byte e a rune; len conta bytes, não runes
• append pode realocar quando a capacidade do array subjacente é excedida

Variáveis, Constantes e Escopo

• A declaração curta := é idiomática em funções; var e const pertencem ao nível do pacote
• Valores const devem ser computáveis em tempo de compilação: literais, aritmética ou sequências iota
• O escopo é lexical; blocos internos sombreiam nomes externos, mas nomes de nível de pacote cruzam arquivos
• Variáveis de loop pré-1.22 em closures de goroutine capturam uma única variável mutável; passe como parâmetro
• Variáveis e importações não utilizadas falham na compilação; use sublinhado _ para descartar intencionalmente
• Declarações curtas := reutilizam nomes apenas no mesmo bloco quando pelo menos um é novo

Valores Zero e Inicialização

• Tipos Go têm valores zero: numérico 0, bool false, string vazia, refs nil
• Go idiomático aproveita os valores zero para que structs sejam utilizáveis sem inicialização
• Slices nil adicionam e retornam comprimento zero, mas mapas nil entram em pânico na escrita
• Canais nil bloqueiam para sempre no envio, corrija com make ou verificação nil
• O valor zero de sync.Mutex está destravado e pronto para uso imediato
• Valor de interface nil é diferente de nil se contiver um nil tipado, verifique explicitamente

Tipos Numéricos, Strings, Runes e Slices de Bytes

• Use []byte para dados binários e []rune para operações indexadas por caractere
• len(s) conta bytes UTF-8, não caracteres; use utf8.RuneCountInString em vez disso
• O tamanho de int e uint depende da plataforma; use tipos dimensionados para serialização
• Iterar sobre strings com range retorna o índice de byte e o valor da rune
• Truncar com int32 envolve silenciosamente valores grandes; verifique os limites antes de converter
• Compare floats com épsilon, não ==; 0.1+0.2 falha devido à perda de precisão

Arrays, Slices e Mapas em Resumo

• Arrays são tipos de tamanho fixo; slices são cabeçalhos de referência com ponteiro, len, cap
• Mapas iteram em ordem indefinida; ordene as chaves se precisar de ordenação consistente
• append cresce dobrando a capacidade quando len é igual a cap, potencialmente realocando
• Mutações de slice são visíveis para os chamadores, pois os cabeçalhos compartilham o armazenamento do array subjacente
• Mapas nil entram em pânico na atribuição; use make para inicializar antes de escrever em um mapa
• A surpresa do alias append sobrescreve elementos existentes; use slice completo ou copy para corrigir

Structs, Embedding e Promoção de Campos

• O embedding promove campos e métodos exportados para o tipo externo sem herança
• Colisão de nomes na struct externa sombreia campos do tipo embutido, use Type.Field para acessar
• Recebedor de ponteiro embutido nil entra em pânico em chamadas de método promovidas sem inicialização
• Campos promovidos são achatados na codificação JSON por padrão, nomeie campos ou ajuste tags
• Múltiplos tipos embutidos com o mesmo campo criam acesso ambíguo que requer qualificador
• Embutir structs auxiliares não exportadas impede a exposição indesejada da superfície a partir da composição

Ponteiros e o Operador Endereço-de

• Use ponteiros para compartilhar mutação entre funções sem duplicar dados
• Endereço-de & e desreferência * permitem o uso de ponteiros; sem aritmética de ponteiros
• A desreferência de ponteiro nil entra em pânico; proteja com p != nil antes de usar *p
• Use recebedores de ponteiro em métodos quando precisar modificar o recebedor
• A análise de escape decide a alocação na pilha vs. heap, não o uso do operador &
• Evite o uso excessivo de ponteiros; cópias de structs pequenas são mais rápidas que indireção

Melhores Práticas dos Fundamentos de Go

• Pré-aloque slices com make([]T, 0, n) para reduzir alocações em loops intensivos
• Inicialize mapas com make ou literais; nunca atribua a mapas nil
• len(string) conta bytes, não caracteres; use utf8.RuneCountInString para texto visível ao usuário
• Sempre atribua o resultado de append, pois ele pode retornar um novo cabeçalho de slice
• Use recebedores de ponteiro para mutação, recebedores de valor para tipos imutáveis
• Identificadores em maiúsculas são uma promessa de compatibilidade; exporte apenas o que os chamadores precisam