Neste post, vamos explorar uma mudança pequena, mas poderosa, que chegou no Go 1.26: o built-in new() agora aceita uma expressão como valor inicial. Pode parecer um detalhe, mas simplifica inicializações e abre espaço para padrões de código mais elegantes.

O que é o built-in new()?

O new() é uma função built-in que aloca memória para um tipo e retorna um ponteiro inicializado com o valor zero do tipo. Historicamente, você só podia passar um tipo para new().

Como era antes (Go 1.25 e anteriores)

Antes, se você quisesse alocar memória e inicializar com um valor específico, tinha duas opções:

// Opção 1: alocar e depois atribuir
p := new(int)
*p = 42

// Opção 2: usar composição literal com &
p := &int{42}  // Só funciona com tipos estruturados

Para tipos simples como int, string, você era forçado a alocar e depois atribuir, o que gerava duas linhas desnecessárias.

A novidade no Go 1.26

No Go 1.26, new() agora aceita uma expressão como argumento. Veja:

// Antes (Go 1.25)
p := new(int)
*p = 42

// Agora (Go 1.26)
p := new(42)

Simples e direto. O new() aloca memória para um int e inicializa com 42 em uma única operação.

Exemplos práticos

Com tipos primitivos

// Ponteiro para string
name := new("Tiago")
fmt.Println(*name)  // Output: Tiago

// Ponteiro para float64
price := new(99.99)
fmt.Println(*price)  // Output: 99.99

// Ponteiro para bool
active := new(true)
fmt.Println(*active)  // Output: true

Com tipos estruturados

type User struct {
    Name string
    Age  int
}

// Antes
u := new(User)
u.Name = "Alice"
u.Age = 30

// Agora
u := new(User{Name: "Alice", Age: 30})

Com arrays e slices

// Ponteiro para array inicializado
arr := new([5]int{1, 2, 3, 4, 5})
fmt.Println(arr[0])  // Output: 1

// Ponteiro para slice inicializado
sl := new([]int{10, 20, 30})
fmt.Println((*sl)[1])  // Output: 20

Por que isso importa?

1. Menos linhas, mais clareza

Alocar e inicializar em uma operação deixa a intenção mais clara. Você não precisa de duas linhas para algo que é conceitualmente uma operação única.

2. Padrões idiomáticos simplificados

Alguns padrões comuns no Go agora ficam mais elegantes. Por exemplo, criar um ponteiro para um valor literal é agora trivial:

// Útil em configurações ou testes
config := new(Config{
    Timeout: 30 * time.Second,
    Retries: 3,
})

3. Menos erros de inicialização

Ao fazer tudo em uma operação, você reduz a chance de esquecer a inicialização:

// Risco de esquecer a inicialização
p := new(int)
// oops, esqueci de inicializar

// Com a nova sintaxe, é obrigatório pensar nisso
p := new(0)  // claro e direto

Quando usar?

Essa feature é mais útil em cenários onde você precisa de um ponteiro (passando para funções que esperem *T, ou para garantir identidade), mas quer inicializar com um valor específico.

// Função que espera um ponteiro
func UpdateUser(u *User) error {
    u.LastUpdate = time.Now()
    return db.Save(u)
}

// Agora você pode fazer em uma linha
err := UpdateUser(new(User{Name: "Bob", Age: 25}))

Conclusão

A nova sintaxe do new() no Go 1.26 é um exemplo perfeito de como mudanças pequenas podem melhorar a experiência de desenvolvimento. Não é uma revolução, mas torna o código mais limpo e reduz o boilerplate em inicializações comuns.

Se você trabalha com muitos ponteiros ou precisa alocar e inicializar valores em uma operação, essa é uma mudança bem-vinda. Vale a pena testar no seu próximo projeto com Go 1.26.

---

Gostou do conteúdo?

• ✅ Inscreva-se na newsletter para receber mais dicas práticas sobre Go diretamente no seu e-mail!
• 🚀 Conheça a Imersão Golang e leve seus conhecimentos em Go para o próximo nível!

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.