--- title: "Go 1.24: Novidades e Recursos" url: "https://golang.com.br/blog/go-1-24/" markdown_url: "https://golang.com.br/blog/go-1-24.MD" description: "Go 1.24 traz generic type aliases completos, swiss tables no runtime (maps mais rápidos), melhorias no crypto/tls e weak pointers. Resumo completo das mudanças." date: "2025-02-11" author: "Golang Brasil" --- # Go 1.24: Novidades e Recursos Go 1.24 traz generic type aliases completos, swiss tables no runtime (maps mais rápidos), melhorias no crypto/tls e weak pointers. Resumo completo das mudanças. # Go 1.24: O Que Há de Novo Nesta Versão A versão 1.24 da linguagem Go foi lançada em 11 de fevereiro de 2025, trazendo consigo uma série de aprimoramentos e novas funcionalidades que visam otimizar o desenvolvimento e a performance das aplicações Go. Esta versão foca em melhorias na biblioteca padrão, otimizações no compilador e no garbage collector, além de adicionar suporte experimental para novas funcionalidades da linguagem. Este artigo detalha as principais mudanças e como elas impactam o dia a dia do desenvolvedor Go. ## Principais Novidades do Go 1.24 Go 1.24 apresenta um conjunto significativo de adições e melhorias. As seções a seguir destacam as mais relevantes. ### Melhorias no Garbage Collector (GC) O garbage collector (GC) do Go continua a ser uma área de foco para otimização. No Go 1.24, foram implementadas melhorias significativas para reduzir a latência do GC e melhorar a utilização da CPU durante a coleta de lixo. Essas melhorias são particularmente notáveis em aplicações com alta alocação de memória e alta taxa de mutação de dados. As mudanças incluem: * **Otimização da fase de varredura:** O algoritmo de varredura foi otimizado para reduzir o tempo gasto na identificação de objetos não referenciados. * **Paralelização aprimorada:** O processo de coleta de lixo foi ainda mais paralelizado, permitindo que o GC utilize melhor os recursos da CPU, especialmente em sistemas com múltiplos núcleos. * **Redução da pausa:** A duração das pausas do GC foi reduzida, minimizando o impacto na performance da aplicação. Essas otimizações resultam em uma experiência mais fluida para os usuários e em uma utilização mais eficiente dos recursos do sistema. ### Expansão do `slices` Package O pacote `slices`, introduzido em versões anteriores, recebeu novas funcionalidades para facilitar a manipulação de slices. Essas adições visam reduzir a necessidade de escrever código repetitivo e melhorar a legibilidade do código. As novas funções incluem: * `slices.Compact[E comparable](s []E) []E`: Remove elementos duplicados adjacentes de um slice, retornando um novo slice com os elementos únicos. ```go package main import ( "fmt" "slices" ) func main() { s := []int{1, 1, 2, 3, 3, 3, 4, 5, 5} unique := slices.Compact(s) fmt.Println(unique) // Output: [1 2 3 4 5] } ``` * `slices.CompactFunc[E any](s []E, eq func(E, E) bool) []E`: Similar ao `Compact`, mas permite especificar uma função de comparação para determinar se dois elementos são considerados duplicados. ```go package main import ( "fmt" "slices" ) type Person struct { Name string Age int } func main() { people := []Person{ {Name: "Alice", Age: 30}, {Name: "Alice", Age: 30}, {Name: "Bob", Age: 25}, {Name: "Charlie", Age: 35}, {Name: "Charlie", Age: 35}, } uniquePeople := slices.CompactFunc(people, func(a, b Person) bool { return a.Name == b.Name && a.Age == b.Age }) fmt.Println(uniquePeople) // Output: [{Alice 30} {Bob 25} {Charlie 35}] } ``` * `slices.Max[E constraints.Ordered](x []E) E`: Retorna o maior elemento de um slice. * `slices.Min[E constraints.Ordered](x []E) E`: Retorna o menor elemento de um slice. * `slices.IsSorted[E constraints.Ordered](x []E) bool`: Verifica se um slice está ordenado. ```go package main import ( "fmt" "slices" "golang.org/x/exp/constraints" ) func main() { numbers := []int{3, 1, 4, 1, 5, 9, 2, 6} maxNumber := slices.Max(numbers) minNumber := slices.Min(numbers) isSorted := slices.IsSorted(numbers) fmt.Println("Max:", maxNumber) // Output: Max: 9 fmt.Println("Min:", minNumber) // Output: Min: 1 fmt.Println("Is Sorted:", isSorted) // Output: Is Sorted: false slices.Sort(numbers) isSorted = slices.IsSorted(numbers) fmt.Println("Is Sorted (after sort):", isSorted) // Output: Is Sorted (after sort): true } func Max[E constraints.Ordered](x []E) E { if len(x) == 0 { var zero E return zero // Or panic, depending on desired behavior } m := x[0] for _, v := range x[1:] { if v > m { m = v } } return m } func Min[E constraints.Ordered](x []E) E { if len(x) == 0 { var zero E return zero // Or panic, depending on desired behavior } m := x[0] for _, v := range x[1:] { if v < m { m = v } } return m } func IsSorted[E constraints.Ordered](x []E) bool { for i := 1; i < len(x); i++ { if x[i] < x[i-1] { return false } } return true } ``` Essas adições ao pacote `slices` tornam a manipulação de slices mais eficiente e concisa. ### Suporte Aprimorado para WebAssembly (Wasm) O Go 1.24 continua a aprimorar o suporte para WebAssembly (Wasm), permitindo que desenvolvedores construam aplicações Go que podem ser executadas em navegadores e outros ambientes Wasm. As melhorias incluem: * **Melhor performance:** O compilador Go foi otimizado para gerar código Wasm mais eficiente, resultando em aplicações mais rápidas e responsivas. * **Suporte para novas funcionalidades Wasm:** O Go 1.24 adiciona suporte para novas funcionalidades da especificação Wasm, permitindo que desenvolvedores aproveitem os recursos mais recentes da plataforma. * **Facilidade de integração:** A integração do Go com o ecossistema Wasm foi simplificada, facilitando a construção e o deploy de aplicações Go em ambientes Wasm. Essas melhorias tornam o Go uma opção ainda mais atraente para o desenvolvimento de aplicações web e outras aplicações que se beneficiam da portabilidade e segurança do Wasm. ### Melhorias no Tratamento de Erros Embora não haja uma mudança radical no tratamento de erros, o Go 1.24 traz algumas melhorias sutis que tornam o código mais legível e fácil de manter. Uma dessas melhorias é a introdução de novas funções no pacote `errors` para facilitar a criação de erros com contexto adicional. Por exemplo, a função `errors.Join` permite concatenar múltiplos erros em um único erro, preservando a informação de cada erro individual. Isso é útil em cenários onde várias operações podem falhar e é importante reportar todos os erros ao invés de apenas o primeiro. ```go package main import ( "errors" "fmt" ) func operation1() error { return errors.New("operation 1 failed") } func operation2() error { return errors.New("operation 2 failed") } func main() { err1 := operation1() err2 := operation2() combinedErr := errors.Join(err1, err2) if combinedErr != nil { fmt.Println("Combined error:", combinedErr) // Output: Combined error: operation 1 failed // operation 2 failed } } ``` Além disso, a função `errors.As` foi aprimorada para lidar melhor com erros encapsulados, facilitando a identificação da causa raiz de um erro. ## Melhorias de Performance Além das melhorias no garbage collector, o Go 1.24 inclui outras otimizações de performance que beneficiam uma ampla gama de aplicações. * **Otimizações no compilador:** O compilador Go foi otimizado para gerar código mais eficiente, resultando em aplicações mais rápidas e com menor consumo de memória. * **Melhorias na biblioteca padrão:** Diversas funções da biblioteca padrão foram otimizadas para melhorar a performance, incluindo funções de manipulação de strings, operações de I/O e algoritmos de ordenação. * **Suporte para novas instruções da CPU:** O compilador Go agora pode aproveitar novas instruções da CPU para otimizar o desempenho de determinadas operações, como cálculos vetoriais e criptografia. Essas otimizações de performance, combinadas com as melhorias no garbage collector, resultam em aplicações Go mais rápidas, eficientes e responsivas. ## Mudanças na Biblioteca Padrão Além das adições ao pacote `slices`, o Go 1.24 traz outras mudanças na biblioteca padrão que merecem destaque. * **Novas funções no pacote `net/http`:** O pacote `net/http` recebeu novas funções para facilitar a manipulação de cookies, headers e outros aspectos do protocolo HTTP. * **Melhorias no pacote `encoding/json`:** O pacote `encoding/json` foi aprimorado para lidar melhor com tipos de dados complexos e para oferecer maior controle sobre o processo de serialização e deserialização. * **Novas funções no pacote `time`:** O pacote `time` recebeu novas funções para facilitar a manipulação de fusos horários e para realizar cálculos com datas e horários. Estas mudanças na biblioteca padrão tornam o desenvolvimento de aplicações Go mais fácil e produtivo. ## Como Atualizar para o Go 1.24 A atualização para o Go 1.24 é um processo simples e direto. A maneira mais comum de atualizar é utilizando o comando `go install`. 1. **Verifique a versão atual:** ```bash go version ``` 2. **Atualize para a versão mais recente:** ```bash go install golang.org/dl/go1.24@latest go1.24 download ``` 3. **Use a nova versão:** ```bash go1.24 version ``` Para utilizar o Go 1.24 como a versão padrão, você pode definir o alias: ```bash alias go=go1.24 ``` Ou, se preferir, configurar a variável de ambiente `GOROOT`: ```bash export GOROOT=$HOME/sdk/go1.24 export PATH=$GOROOT/bin:$PATH ``` Outra opção é baixar o binário pré-compilado do site oficial [https://go.dev/dl/](https://go.dev/dl/) e seguir as instruções de instalação para sua plataforma. Após a atualização, é recomendável recompilar suas aplicações para aproveitar as novas otimizações de performance e garantir a compatibilidade com as mudanças na linguagem e na biblioteca padrão. ## Conclusão Prática O Go 1.24 representa um passo significativo na evolução da linguagem Go. Com melhorias no garbage collector, adições ao pacote `slices`, suporte aprimorado para WebAssembly e otimizações de performance, esta versão oferece aos desenvolvedores Go as ferramentas necessárias para construir aplicações mais rápidas, eficientes e robustas. A atualização para o Go 1.24 é altamente recomendada para todos os desenvolvedores Go, pois permite aproveitar os benefícios das novas funcionalidades e otimizações. Além disso, manter-se atualizado com as versões mais recentes do Go garante a compatibilidade com as bibliotecas e frameworks mais recentes, além de receber correções de bugs e vulnerabilidades de segurança. Ao adotar o Go 1.24, os desenvolvedores podem esperar uma experiência de desenvolvimento mais produtiva e um desempenho aprimorado de suas aplicações Go. É importante consultar as notas de lançamento completas em [https://go.dev/doc/go1.24](https://go.dev/doc/go1.24) para obter uma visão detalhada de todas as mudanças e novidades desta versão.