Valores Zero e Inicialização

Q: Um slice nil é o mesmo que um slice vazio?

Ambos têm len 0 e funcionam com append. Eles diferem para == nil, codificação JSON e algumas APIs que tratam nil especialmente.

Q: Quando devo usar make em vez de var?

Use make quando precisar de um mapa, canal não nil, ou um slice com len/cap específicos. var s []int é bom quando você apenas usará append.

Q: new aloca na heap?

new(T) retorna um ponteiro para armazenamento zerado. A análise de escape decide pilha vs heap; new não força a alocação na heap por si só.

Q: Qual é o valor zero de uma interface?

Um valor de interface nil não tem tipo dinâmico nem valor. Um ponteiro nil tipado atribuído a uma interface não é igual a uma interface nil.

Q: Como os valores zero de array diferem dos de slice?

var a [3]int são três zeros na pilha ou na struct. var s []int é um cabeçalho nil sem array de suporte até make ou append.

Q: E os valores zero para time.Time?

O zero de time.Time é 1º de janeiro de 1 d.C. UTC - raramente um sentinela útil. Use ponteiros ou verificações time.Time.IsZero().

Q: Como inicializo structs aninhadas?

Campos aninhados não mencionados permanecem zero dentro de Inner.

Todo tipo Go tem um valor zero: o valor que uma variável contém antes de você atribuir qualquer coisa.

Projetar com valores zero em mente leva a APIs mais simples e menos verificações de nil.

Resumo

Declarar com var ou alocar com new/make sem dados extras produz o valor zero do tipo.

Tipos numéricos são 0, bool é false, strings são "", e tipos de referência (ponteiros, slices, mapas, canais, funções, interfaces) são nil.

Go idiomático frequentemente torna o valor zero útil, para que os chamadores possam inicializar uma struct com zero e usá-la imediatamente.

Receita

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

package main
 
import "fmt"
 
type Config struct {
    Host string
    Port int
}
 
func main() {
    var cfg Config          // zero: Host "", Port 0
    cfg.Host = "localhost"
    cfg.Port = 8080
 
    nums := make([]int, 0, 8) // slice vazio, não-nil
    fmt.Println(cfg, nums == nil)
}

Quando usar isso:

Prefira structs inicializadas com zero quando os padrões são seguros (sync.Mutex, muitas structs de configuração).
Use make para slices, mapas e canais quando precisar de um valor pronto para uso e não nil.
Use literais compostos T{...} quando os padrões não forem suficientes.
Documente quando o zero for inválido para que os chamadores saibam definir os campos necessários.

Exemplo Funcional

package main
 
import (
    "bytes"
    "fmt"
)
 
type Buffer struct {
    buf bytes.Buffer
    ok  bool
}
 
func (b *Buffer) WriteString(s string) {
    if !b.ok {
        b.buf = *bytes.NewBuffer(nil)
        b.ok = true
    }
    b.buf.WriteString(s)
}
 
func (b Buffer) String() string {
    if !b.ok {
        return ""
    }
    return b.buf.String()
}
 
func main() {
    var b Buffer // valor zero utilizável: String() retorna ""
    b.WriteString("hello")
    fmt.Println(b.String())
 
    m := make(map[string]int)
    m["a"] = 1
 
    var sl []int // slice nil
    sl = append(sl, 2)
    fmt.Println(m, sl)
}

O que isso demonstra:

O valor zero da struct é utilizável com métodos auxiliares que protegem a inicialização preguiçosa.
make(map[K]V) retorna um mapa vazio, não nil, pronto para atribuição.
Slices nil funcionam com append e len/cap retornam 0.
Incorporar bytes.Buffer mudaria o comportamento do valor zero - projete os campos deliberadamente.

Mergulho Profundo

Como Funciona

var x T aloca armazenamento e define os bits como zero para o tipo T.
new(T) retorna *T apontando para armazenamento inicializado com zero (raramente necessário em comparação com &T{}).
make aplica-se apenas a slices, mapas e canais; ele aloca a estrutura interna.
Literais compostos T{v} ou &T{v} definem campos explicitamente, deixando outros em zero.

Valores Zero por Tipo

Tipo	Valor zero	Utilizável sem inicialização?
`int`, `float`, `complex`	`0`	Sim
`bool`	`false`	Sim
`string`	`""`	Sim
`pointer`, `func`, `interface`	`nil`	Apenas após verificações de nil
`slice`	`nil`	Sim para `len`, `append`, `range`
`map`	`nil`	Não para atribuição - causa pânico
`channel`	`nil`	Não para envio/recebimento - bloqueia ou causa pânico
`struct`	cada campo zero	Depende dos tipos de campo

Padrões de Inicialização

Padrão	Exemplo	Quando
Zero + definir campos	`var c Config; c.Port = 8080`	Poucos campos, padrões seguros
Literal composto	`Config{Host: "x"}`	Valores conhecidos na criação
`make`	`make([]int, 0, n)`	Pré-alocar capacidade
Função construtora	`NewServer(cfg)`	Validação ou invariantes necessários

Notas Go

import "sync"
 
// O valor zero de Mutex é um mutex destravado - pronto para uso
var mu sync.Mutex
mu.Lock()
 
// Prefira &T{} em vez de new(T) para structs quando você pode adicionar campos mais tarde
srv := &Server{}

Armadilhas

Escrever em mapa nil - var m map[string]int; m["k"] = 1 causa pânico. Correção: m = make(map[string]int) ou um literal de mapa antes da atribuição.
Enviar em canal nil - Bloqueia para sempre em select ou causa deadlock. Correção: make(chan T) ou proteja com verificação de nil.
Interface nil vs nil tipado - var p *T; var i interface{} = p faz i != nil ser verdadeiro enquanto p == nil. Correção: retorne tipos concretos ou verifique o nil tipado explicitamente.
Esperar que a porta zero signifique "aleatório" - Zero int pode ser inválido para APIs de rede. Correção: use ponteiros *int ou net.JoinHostPort com validação.
Zero de slice vs literal vazio - var s []int e s := []int{} diferem para JSON (null vs []). Correção: escolha intencionalmente para semântica de serialização.
Confusão com new - new(T) retorna *T para zeros; muitos guias de estilo preferem &T{} para structs. Correção: use literais compostos para clareza.

Alternativas

Alternativa	Usar Quando	Não Usar Quando
Struct de valor zero	Mutexes, configurações simples	Campos necessários não têm um padrão sensato
`make` + append	Construindo slices dinamicamente	Arrays pequenos fixos são suficientes
Campos ponteiro `*int`	Distinguir não definido de zero	Todos os campos se tornariam ponteiros (ruído)
Builder/construtor	Validação complexa	Structs simples com 2-3 campos

FAQs

Qual é o valor zero de uma struct?

Cada campo é definido para seu próprio valor zero recursivamente.

Para struct{ A int; B string }, isso é 0 e "".

Um slice nil é o mesmo que um slice vazio?

Ambos têm len 0 e funcionam com append.

Eles diferem para == nil, codificação JSON e algumas APIs que tratam nil especialmente.

Quando devo usar make em vez de var?

Use make quando precisar de um mapa, canal não nil, ou um slice com len/cap específicos.

var s []int é bom quando você apenas usará append.

new aloca na heap?

new(T) retorna um ponteiro para armazenamento zerado.

A análise de escape decide pilha vs heap; new não força a alocação na heap por si só.

Posso comparar structs que contêm slices?

Structs são comparáveis apenas se todos os campos forem comparáveis.

Slices, mapas e funções tornam as structs não comparáveis.

Qual é o valor zero de uma interface?

Um valor de interface nil não tem tipo dinâmico nem valor.

Um ponteiro nil tipado atribuído a uma interface não é igual a uma interface nil.

Como os valores zero de array diferem dos de slice?

var a [3]int são três zeros na pilha ou na struct.

var s []int é um cabeçalho nil sem array de suporte até make ou append.

Construtores sempre devem substituir valores zero?

Apenas quando invariantes são necessários (nome não vazio, porta positiva).

Muitos tipos da biblioteca padrão (bytes.Buffer, sync.Mutex) são projetados para uso com valor zero.

E os valores zero para time.Time?

O zero de time.Time é 1º de janeiro de 1 d.C. UTC - raramente um sentinela útil.

Use ponteiros ou verificações time.Time.IsZero().

Como inicializo structs aninhadas?

type Outer struct{ Inner Inner }
o := Outer{Inner: Inner{Field: 1}}

Campos aninhados não mencionados permanecem zero dentro de Inner.

Os cabeçalhos de mapa e slice são copiados na atribuição?

A atribuição copia o cabeçalho; o armazenamento de suporte é compartilhado.

Inicialize uma vez e passe com cuidado para evitar compartilhamento não intencional.

O Go zera a memória por segurança?

O Go zera alocações por segurança em muitos caminhos, mas não confie nisso para segredos criptográficos.

Sobrescreva buffers sensíveis explicitamente quando necessário.

Relacionados

Variáveis, Constantes e Escopo - var vs := no momento da declaração
Arrays, Slices e Mapas em Destaque - coleções nil vs vazias
Ponteiros e o Operador Endereço-de - ponteiros nil e inicialização
Structs, Embedding e Promoção de Campo - padrões de literais de struct

Links Relacionados Externos

Effective Go - Guia oficial para escrever Go claro e idiomático.
A Tour of Go - Introdução interativa oficial ao Go.
Go by Example - Exemplos de código práticos anotados.
The Go Programming Language (ebook) - Donovan & Kernighan.
Learning Go (2nd Edition) - Jon Bodner.

Versões Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - 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).

Projetar com valores zero em mente leva a APIs mais simples e menos verificações de nil.

Resumo

Declarar com var ou alocar com new/make sem dados extras produz o valor zero do tipo.

Tipos numéricos são 0, bool é false, strings são "", e tipos de referência (ponteiros, slices, mapas, canais, funções, interfaces) são nil.

Go idiomático frequentemente torna o valor zero útil, para que os chamadores possam inicializar uma struct com zero e usá-la imediatamente.

Receita

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

package main
 
import "fmt"
 
type Config struct {
    Host string
    Port int
}
 
func main() {
    var cfg Config          // zero: Host "", Port 0
    cfg.Host = "localhost"
    cfg.Port = 8080
 
    nums := make([]int, 0, 8) // slice vazio, não-nil
    fmt.Println(cfg, nums == nil)
}

Quando usar isso:

Prefira structs inicializadas com zero quando os padrões são seguros (sync.Mutex, muitas structs de configuração).
Use make para slices, mapas e canais quando precisar de um valor pronto para uso e não nil.
Use literais compostos T{...} quando os padrões não forem suficientes.
Documente quando o zero for inválido para que os chamadores saibam definir os campos necessários.

Exemplo Funcional

package main
 
import (
    "bytes"
    "fmt"
)
 
type Buffer struct {
    buf bytes.Buffer
    ok  bool
}
 
func (b *Buffer) WriteString(s string) {
    if !b.ok {
        b.buf = *bytes.NewBuffer(nil)
        b.ok = true
    }
    b.buf.WriteString(s)
}
 
func (b Buffer) String() string {
    if !b.ok {
        return ""
    }
    return b.buf.String()
}
 
func main() {
    var b Buffer // valor zero utilizável: String() retorna ""
    b.WriteString("hello")
    fmt.Println(b.String())
 
    m := make(map[string]int)
    m["a"] = 1
 
    var sl []int // slice nil
    sl = append(sl, 2)
    fmt.Println(m, sl)
}

O que isso demonstra:

O valor zero da struct é utilizável com métodos auxiliares que protegem a inicialização preguiçosa.
make(map[K]V) retorna um mapa vazio, não nil, pronto para atribuição.
Slices nil funcionam com append e len/cap retornam 0.
Incorporar bytes.Buffer mudaria o comportamento do valor zero - projete os campos deliberadamente.

Mergulho Profundo

Como Funciona

var x T aloca armazenamento e define os bits como zero para o tipo T.
new(T) retorna *T apontando para armazenamento inicializado com zero (raramente necessário em comparação com &T{}).
make aplica-se apenas a slices, mapas e canais; ele aloca a estrutura interna.
Literais compostos T{v} ou &T{v} definem campos explicitamente, deixando outros em zero.

Valores Zero por Tipo

Tipo	Valor zero	Utilizável sem inicialização?
`int`, `float`, `complex`	`0`	Sim
`bool`	`false`	Sim
`string`	`""`	Sim
`pointer`, `func`, `interface`	`nil`	Apenas após verificações de nil
`slice`	`nil`	Sim para `len`, `append`, `range`
`map`	`nil`	Não para atribuição - causa pânico
`channel`	`nil`	Não para envio/recebimento - bloqueia ou causa pânico
`struct`	cada campo zero	Depende dos tipos de campo

Padrões de Inicialização

Padrão	Exemplo	Quando
Zero + definir campos	`var c Config; c.Port = 8080`	Poucos campos, padrões seguros
Literal composto	`Config{Host: "x"}`	Valores conhecidos na criação
`make`	`make([]int, 0, n)`	Pré-alocar capacidade
Função construtora	`NewServer(cfg)`	Validação ou invariantes necessários

Notas Go

import "sync"
 
// O valor zero de Mutex é um mutex destravado - pronto para uso
var mu sync.Mutex
mu.Lock()
 
// Prefira &T{} em vez de new(T) para structs quando você pode adicionar campos mais tarde
srv := &Server{}

Armadilhas

Escrever em mapa nil - var m map[string]int; m["k"] = 1 causa pânico. Correção: m = make(map[string]int) ou um literal de mapa antes da atribuição.
Enviar em canal nil - Bloqueia para sempre em select ou causa deadlock. Correção: make(chan T) ou proteja com verificação de nil.
Interface nil vs nil tipado - var p *T; var i interface{} = p faz i != nil ser verdadeiro enquanto p == nil. Correção: retorne tipos concretos ou verifique o nil tipado explicitamente.
Esperar que a porta zero signifique "aleatório" - Zero int pode ser inválido para APIs de rede. Correção: use ponteiros *int ou net.JoinHostPort com validação.
Zero de slice vs literal vazio - var s []int e s := []int{} diferem para JSON (null vs []). Correção: escolha intencionalmente para semântica de serialização.
Confusão com new - new(T) retorna *T para zeros; muitos guias de estilo preferem &T{} para structs. Correção: use literais compostos para clareza.

Alternativas

Alternativa	Usar Quando	Não Usar Quando
Struct de valor zero	Mutexes, configurações simples	Campos necessários não têm um padrão sensato
`make` + append	Construindo slices dinamicamente	Arrays pequenos fixos são suficientes
Campos ponteiro `*int`	Distinguir não definido de zero	Todos os campos se tornariam ponteiros (ruído)
Builder/construtor	Validação complexa	Structs simples com 2-3 campos

FAQs

Qual é o valor zero de uma struct?

Cada campo é definido para seu próprio valor zero recursivamente.

Para struct{ A int; B string }, isso é 0 e "".

Um slice nil é o mesmo que um slice vazio?

Ambos têm len 0 e funcionam com append.

Eles diferem para == nil, codificação JSON e algumas APIs que tratam nil especialmente.

Quando devo usar make em vez de var?

Use make quando precisar de um mapa, canal não nil, ou um slice com len/cap específicos.

var s []int é bom quando você apenas usará append.

new aloca na heap?

new(T) retorna um ponteiro para armazenamento zerado.

A análise de escape decide pilha vs heap; new não força a alocação na heap por si só.

Posso comparar structs que contêm slices?

Structs são comparáveis apenas se todos os campos forem comparáveis.

Slices, mapas e funções tornam as structs não comparáveis.

Qual é o valor zero de uma interface?

Um valor de interface nil não tem tipo dinâmico nem valor.

Um ponteiro nil tipado atribuído a uma interface não é igual a uma interface nil.

Como os valores zero de array diferem dos de slice?

var a [3]int são três zeros na pilha ou na struct.

var s []int é um cabeçalho nil sem array de suporte até make ou append.

Construtores sempre devem substituir valores zero?

Apenas quando invariantes são necessários (nome não vazio, porta positiva).

Muitos tipos da biblioteca padrão (bytes.Buffer, sync.Mutex) são projetados para uso com valor zero.

E os valores zero para time.Time?

O zero de time.Time é 1º de janeiro de 1 d.C. UTC - raramente um sentinela útil.

Use ponteiros ou verificações time.Time.IsZero().

Como inicializo structs aninhadas?

type Outer struct{ Inner Inner }
o := Outer{Inner: Inner{Field: 1}}

Campos aninhados não mencionados permanecem zero dentro de Inner.

Os cabeçalhos de mapa e slice são copiados na atribuição?

A atribuição copia o cabeçalho; o armazenamento de suporte é compartilhado.

Inicialize uma vez e passe com cuidado para evitar compartilhamento não intencional.

O Go zera a memória por segurança?

O Go zera alocações por segurança em muitos caminhos, mas não confie nisso para segredos criptográficos.

Sobrescreva buffers sensíveis explicitamente quando necessário.

Relacionados

Variáveis, Constantes e Escopo - var vs := no momento da declaração
Arrays, Slices e Mapas em Destaque - coleções nil vs vazias
Ponteiros e o Operador Endereço-de - ponteiros nil e inicialização
Structs, Embedding e Promoção de Campo - padrões de literais de struct

Links Relacionados Externos

Effective Go - Guia oficial para escrever Go claro e idiomático.
A Tour of Go - Introdução interativa oficial ao Go.
Go by Example - Exemplos de código práticos anotados.
The Go Programming Language (ebook) - Donovan & Kernighan.
Learning Go (2nd Edition) - Jon Bodner.

Versões Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - 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).

Valores Zero e Inicialização

Buscar na documentação

Valores Zero e Inicialização