--- title: "Go 1.8: Novidades e Recursos" url: "https://golang.com.br/blog/go-1-8/" markdown_url: "https://golang.com.br/blog/go-1-8.MD" description: "Descubra as principais novidades do Go 1.8, incluindo novos recursos, melhorias de performance e mudancas na biblioteca padrao." date: "2017-02-16" author: "Golang Brasil" --- # Go 1.8: Novidades e Recursos Descubra as principais novidades do Go 1.8, incluindo novos recursos, melhorias de performance e mudancas na biblioteca padrao. # Go 1.8: O Que Há de Novo? Go 1.8, lançado em 16 de fevereiro de 2017, trouxe uma série de melhorias significativas para a linguagem, tanto em termos de desempenho quanto de funcionalidades da biblioteca padrão. Esta versão focou em otimizações de performance, suporte a plugins, contexto em `net/http` e uma série de adições e correções menores. Vamos explorar as principais novidades e mudanças desta versão. ## Plugins Uma das adições mais notáveis do Go 1.8 é o suporte a plugins. Plugins permitem estender a funcionalidade de um programa Go em tempo de execução, carregando código compilado separadamente. Isso oferece uma grande flexibilidade, permitindo que você adicione ou modifique o comportamento de um programa sem recompilá-lo. ### Como Funcionam Plugins são bibliotecas compartilhadas compiladas com um modo especial ( `-buildmode=plugin` ). Esses plugins exportam símbolos que podem ser acessados pelo programa principal. O pacote `plugin` na biblioteca padrão fornece as ferramentas para carregar e interagir com esses plugins. ### Exemplo Primeiro, criamos um plugin simples que exporta uma função: ```go // plugin.go package main import "fmt" var V int var S string func F() { fmt.Printf("Hello, number %d, string %s\n", V, S) } func main() {} // Necessário para construir como plugin ``` Para compilar este código como um plugin, usamos o seguinte comando: ```bash go build -buildmode=plugin -o plugin.so plugin.go ``` Agora, podemos carregar e usar este plugin em nosso programa principal: ```go // main.go package main import ( "fmt" "plugin" ) func main() { p, err := plugin.Open("plugin.so") if err != nil { panic(err) } v, err := p.Lookup("V") if err != nil { panic(err) } s, err := p.Lookup("S") if err != nil { panic(err) } f, err := p.Lookup("F") if err != nil { panic(err) } *v.(*int) = 7 *s.(*string) = "Plugin!" f.(func())() // Hello, number 7, string Plugin! } ``` Este exemplo demonstra como carregar um plugin, acessar variáveis e funções exportadas e utilizá-las no programa principal. ### Considerações * Plugins são uma ferramenta poderosa, mas requerem cuidado. A compatibilidade entre o programa principal e o plugin depende da versão do Go e das bibliotecas utilizadas. * O uso de plugins pode complicar o processo de build e deploy, pois é necessário garantir que os plugins estejam disponíveis no ambiente de execução. ## Context em `net/http` Go 1.8 introduziu o uso de `context.Context` em `net/http`, permitindo um controle mais preciso sobre o ciclo de vida das requisições HTTP. Isso facilita o cancelamento de operações em andamento e a propagação de metadados entre handlers. ### Como Funciona A função `http.Request` agora inclui um campo `Context`. Este contexto é derivado do contexto do servidor e pode ser usado para cancelar operações ou armazenar valores específicos da requisição. ### Exemplo ```go package main import ( "context" "fmt" "net/http" "time" ) func main() { http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { ctx := r.Context() fmt.Println("Handler iniciado") defer fmt.Println("Handler finalizado") select { case <-time.After(2 * time.Second): fmt.Fprintf(w, "Requisição completada") case <-ctx.Done(): err := ctx.Err() fmt.Println("Requisição cancelada:", err) http.Error(w, err.Error(), http.StatusInternalServerError) } }) server := &http.Server{ Addr: ":8080", } go func() { time.Sleep(1 * time.Second) // Simula o cancelamento da requisição // Isso não funciona diretamente a partir do main, // mas ilustra o conceito de cancelamento. // Em um cenário real, o cancelamento viria de um cliente. // Para testar, você precisaria de um cliente HTTP que // suportasse cancelamento. // server.Shutdown(context.Background()) // Alternativamente, você pode usar um client http com timeout. }() fmt.Println("Servidor rodando em :8080") server.ListenAndServe() } ``` Neste exemplo, o handler HTTP verifica se o contexto da requisição foi cancelado. Se o contexto for cancelado antes que a requisição seja completada, um erro é retornado ao cliente. Este exemplo ilustra o conceito, mas para testar o cancelamento, você precisaria de um cliente HTTP que suporte cancelamento de requisições. ### Benefícios * **Cancelamento:** Permite cancelar requisições longas ou operações que não são mais necessárias. * **Propagação de Metadados:** Facilita a passagem de informações entre handlers, como IDs de rastreamento ou informações de autenticação. * **Melhor Controle:** Oferece um controle mais granular sobre o ciclo de vida das requisições HTTP. ## Melhorias de Performance Go 1.8 trouxe diversas otimizações de performance, incluindo melhorias no garbage collector, no compilador e na biblioteca padrão. ### Garbage Collector O garbage collector (GC) foi aprimorado para reduzir a latência e o uso de memória. As principais mudanças incluem: * **Coleta Concorrente:** Mais trabalho de coleta é feito concorrentemente com a execução do programa, reduzindo as pausas. * **Melhor Uso de Memória:** O GC aloca e gerencia a memória de forma mais eficiente, reduzindo o footprint geral. Essas melhorias resultaram em uma redução significativa nas pausas do GC, tornando o Go 1.8 mais adequado para aplicações de alta performance e baixa latência. ### Compilador O compilador Go também recebeu otimizações, resultando em código mais eficiente e tempos de compilação mais rápidos. Essas otimizações incluem: * **Inlining:** Mais funções são inlined, reduzindo o overhead de chamadas de função. * **Otimização de Loop:** Loops são otimizados para melhorar o desempenho. * **Redução de Alocações:** O compilador tenta reduzir o número de alocações de memória, o que melhora o desempenho e reduz a pressão no GC. ### Biblioteca Padrão Diversas funções na biblioteca padrão foram otimizadas, incluindo funções de string, I/O e criptografia. Essas otimizações, embora pequenas individualmente, contribuem para um aumento geral no desempenho das aplicações Go. ## Mudanças na Biblioteca Padrão Além das melhorias de performance, Go 1.8 introduziu várias mudanças e adições na biblioteca padrão. ### `net/http` * Como mencionado anteriormente, a introdução do `context.Context` em `net/http` foi uma mudança significativa. * Adição de `http.MaxBytesReader` para limitar o tamanho do corpo das requisições. ```go // Exemplo de uso de http.MaxBytesReader r.Body = http.MaxBytesReader(w, r.Body, maxBytes) ``` ### `sort` * Adição de `sort.Slice`, que permite ordenar slices de qualquer tipo sem a necessidade de implementar a interface `sort.Interface`. ```go // Exemplo de uso de sort.Slice people := []struct { Name string Age int }{ {"Alice", 25}, {"Bob", 30}, {"Charlie", 20}, } sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age }) fmt.Println(people) // [{Charlie 20} {Alice 25} {Bob 30}] ``` ### `text/template` e `html/template` * Melhorias no tratamento de erros e na segurança dos templates. ### `crypto/tls` * Adição de suporte para TLS 1.3 (experimental). ### Outras Mudanças * Diversas correções de bugs e melhorias menores em outros pacotes da biblioteca padrão. * Melhorias na ferramenta `go vet`. ## Como Atualizar Para atualizar para Go 1.8, você pode usar o comando `go get`: ```bash go get golang.org/dl/go1.8 go1.8 download go1.8 use ``` Este comando baixa e instala o Go 1.8 em seu sistema. Após a instalação, você pode usar o comando `go version` para verificar se a atualização foi bem-sucedida. É importante notar que, ao atualizar para uma nova versão do Go, é recomendável testar suas aplicações para garantir que não haja problemas de compatibilidade. Embora Go mantenha um forte compromisso com a retrocompatibilidade, algumas mudanças podem exigir ajustes no seu código. ## Conclusão Prática Go 1.8 representou um passo importante na evolução da linguagem, trazendo melhorias significativas em performance, funcionalidades e segurança. A introdução de plugins, o suporte a `context.Context` em `net/http` e as otimizações no garbage collector e no compilador tornaram o Go 1.8 uma versão atraente para desenvolvedores que buscam alta performance e flexibilidade. Embora a versão seja antiga, entender as mudanças introduzidas no Go 1.8 ajuda a compreender a evolução da linguagem e as decisões de design que moldaram as versões subsequentes. A adição de plugins, por exemplo, abriu novas possibilidades para extensibilidade e modularidade, enquanto a integração de `context.Context` em `net/http` melhorou o controle sobre o ciclo de vida das requisições HTTP. Ao considerar a atualização para uma versão mais recente do Go, é importante avaliar as mudanças e melhorias introduzidas em cada versão e testar suas aplicações para garantir a compatibilidade. As notas de lançamento do Go (como esta: [https://go.dev/doc/go1.8](https://go.dev/doc/go1.8)) são um recurso valioso para entender as mudanças e tomar decisões informadas sobre a atualização.