---
title: "Go 1.11: Novidades e Recursos"
url: "https://golang.com.br/blog/go-1-11/"
markdown_url: "https://golang.com.br/blog/go-1-11.MD"
description: "Descubra as principais novidades do Go 1.11, incluindo novos recursos, melhorias de performance e mudancas na biblioteca padrao."
date: "2018-08-24"
author: "Golang Brasil"
---

# Go 1.11: Novidades e Recursos

Descubra as principais novidades do Go 1.11, incluindo novos recursos, melhorias de performance e mudancas na biblioteca padrao.


# Novidades do Go 1.11: Uma Análise Detalhada

A versão 1.11 do Go, lançada em 24 de agosto de 2018, introduziu mudanças significativas na linguagem, com destaque para o suporte experimental a módulos, melhorias no compilador e na biblioteca padrão. Esta versão marcou um passo importante na evolução do Go, facilitando o gerenciamento de dependências e oferecendo novas ferramentas para os desenvolvedores.

## Suporte Experimental a Módulos

A principal novidade do Go 1.11 foi a introdução do suporte experimental a módulos. Antes dos módulos, o gerenciamento de dependências em Go era frequentemente realizado através de ferramentas externas como `dep` ou utilizando a convenção de colocar o código dentro do `$GOPATH`. Os módulos visavam simplificar e padronizar esse processo.

### O que são Módulos?

Módulos são coleções de pacotes Go que são versionados juntos. Um módulo é definido por um arquivo `go.mod` localizado no diretório raiz do módulo. Este arquivo declara o caminho do módulo e suas dependências.

### Como Criar um Módulo

Para criar um módulo, basta inicializá-lo com o comando `go mod init`:

```bash
go mod init example.com/meuprojeto
```

Este comando cria um arquivo `go.mod` com o seguinte conteúdo inicial:

```go
module example.com/meuprojeto

go 1.11
```

O `module` declara o caminho do módulo, que geralmente corresponde ao repositório onde o código será armazenado. O `go` especifica a versão do Go utilizada.

### Gerenciando Dependências

Quando você importa um pacote que não faz parte da biblioteca padrão ou de um módulo local, o Go automaticamente adiciona a dependência ao arquivo `go.mod`. Por exemplo, se você importar o pacote `github.com/gorilla/mux`, o Go irá atualizar o `go.mod` e criar um arquivo `go.sum` para garantir a integridade das dependências:

```go
package main

import (
	"fmt"
	"net/http"

	"github.com/gorilla/mux"
)

func main() {
	r := mux.NewRouter()
	r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, World!")
	})
	http.ListenAndServe(":8080", r)
}
```

Após executar o código acima (ou um comando como `go build` ou `go run`), o arquivo `go.mod` será atualizado para:

```go
module example.com/meuprojeto

go 1.11

require github.com/gorilla/mux v1.8.0 // indirect
```

E o arquivo `go.sum` conterá hashes criptográficos para verificar a integridade do módulo `github.com/gorilla/mux`.

### Comandos Úteis para Módulos

*   `go mod tidy`: Remove dependências não utilizadas e adiciona dependências faltantes.
*   `go mod vendor`: Copia as dependências para um diretório `vendor`.
*   `go mod download`: Baixa as dependências para o cache do módulo.
*   `go mod graph`: Imprime o grafo de dependências do módulo.
*   `go mod verify`: Verifica se as dependências baixadas não foram modificadas.

### Benefícios dos Módulos

*   **Gerenciamento de Versões:** Permite especificar versões exatas das dependências, evitando problemas de incompatibilidade.
*   **Reproducibilidade:** Garante que o mesmo código seja construído da mesma forma em diferentes ambientes.
*   **Remoção do `$GOPATH`:** Elimina a necessidade de colocar o código dentro do `$GOPATH`, facilitando o desenvolvimento em múltiplos projetos.
*   **Integração com o Ecossistema Go:** Simplifica a utilização de bibliotecas e ferramentas Go.

### Considerações sobre o Suporte Experimental

É importante lembrar que o suporte a módulos no Go 1.11 era experimental. Isso significa que a API dos módulos poderia mudar em versões futuras. No entanto, a introdução dos módulos foi um passo crucial para melhorar o gerenciamento de dependências em Go, e a maioria dos projetos Go modernos utiliza módulos.

## Melhorias no Compilador

O Go 1.11 trouxe melhorias no compilador, resultando em um pequeno aumento no desempenho e na redução do tamanho dos binários gerados. Essas melhorias foram obtidas através de otimizações no processo de compilação e na geração de código. Embora as melhorias de desempenho não fossem drásticas, elas contribuíram para tornar o Go uma linguagem ainda mais eficiente.

### Otimizações de Inline

O compilador passou a realizar mais otimizações de inline, substituindo chamadas de função por seu corpo diretamente no código. Isso pode reduzir a sobrecarga associada às chamadas de função e melhorar o desempenho, especialmente para funções pequenas e frequentemente chamadas.

### Melhorias na Alocação de Memória

Houve também melhorias na forma como o compilador aloca memória, resultando em um uso mais eficiente da memória e, consequentemente, em um melhor desempenho. Essas melhorias foram particularmente notáveis em programas que alocam e liberam memória com frequência.

## Mudanças na Biblioteca Padrão

A biblioteca padrão do Go 1.11 recebeu algumas adições e modificações, incluindo suporte para novas funcionalidades e melhorias em pacotes existentes.

### Pacote `net/http`

O pacote `net/http` recebeu algumas melhorias, incluindo suporte para o cabeçalho `Server-Timing`. Este cabeçalho permite que os servidores web transmitam informações de tempo para os clientes, auxiliando na análise de desempenho do lado do cliente.

Exemplo de como adicionar o cabeçalho `Server-Timing`:

```go
package main

import (
	"fmt"
	"net/http"
	"time"
)

func handler(w http.ResponseWriter, r *http.Request) {
	start := time.Now()
	fmt.Fprintln(w, "Hello, World!")
	duration := time.Since(start)

	w.Header().Set("Server-Timing", fmt.Sprintf("app;dur=%d", duration.Milliseconds()))
}

func main() {
	http.HandleFunc("/", handler)
	http.ListenAndServe(":8080", nil)
}
```

Neste exemplo, o cabeçalho `Server-Timing` é adicionado à resposta HTTP, informando o tempo de execução da função `handler`.

### Pacote `syscall`

O pacote `syscall` foi atualizado para incluir novas chamadas de sistema, permitindo que os programas Go interajam com o sistema operacional de forma mais direta. Isso pode ser útil para implementar funcionalidades específicas do sistema operacional ou para otimizar o desempenho em determinadas situações.

### Pacote `testing`

O pacote `testing` recebeu algumas melhorias, incluindo suporte para subtestes e subbenchmarks. Isso permite que os testes e benchmarks sejam organizados de forma mais granular, facilitando a identificação e correção de problemas.

Exemplo de subtestes:

```go
package main

import (
	"testing"
)

func TestMath(t *testing.T) {
	t.Run("Add", func(t *testing.T) {
		result := 2 + 2
		if result != 4 {
			t.Errorf("2 + 2 = %d; want 4", result)
		}
	})

	t.Run("Subtract", func(t *testing.T) {
		result := 5 - 3
		if result != 2 {
			t.Errorf("5 - 3 = %d; want 2", result)
		}
	})
}
```

Neste exemplo, a função `TestMath` define dois subtestes, `Add` e `Subtract`, que testam diferentes operações matemáticas.

## Como Atualizar para o Go 1.11

Para atualizar para o Go 1.11, você pode seguir os seguintes passos:

1.  **Baixe a versão mais recente do Go 1.11** no site oficial: [https://go.dev/dl/](https://go.dev/dl/)
2.  **Instale a nova versão** seguindo as instruções fornecidas para o seu sistema operacional.
3.  **Configure as variáveis de ambiente** `GOROOT` e `PATH` para apontar para a nova instalação do Go.
4.  **Verifique a versão do Go** executando o comando `go version` no terminal.

```bash
go version
```

Se a saída mostrar `go version go1.11 <seu sistema operacional>/<sua arquitetura>`, a atualização foi bem-sucedida.

### Migrando para Módulos

Se você estiver utilizando uma versão anterior do Go e deseja migrar para módulos, siga os seguintes passos:

1.  **Crie um arquivo `go.mod`** no diretório raiz do seu projeto utilizando o comando `go mod init <caminho do módulo>`.
2.  **Execute o comando `go mod tidy`** para adicionar as dependências ao arquivo `go.mod`.
3.  **Verifique o arquivo `go.mod`** para garantir que todas as dependências estejam corretas.
4.  **Remova o diretório `vendor`** (se existir) e qualquer ferramenta de gerenciamento de dependências legada.

## Conclusão Prática

O Go 1.11 representou um marco importante na evolução da linguagem, com a introdução do suporte experimental a módulos. Essa funcionalidade simplificou o gerenciamento de dependências e tornou o desenvolvimento em Go mais fácil e eficiente. Além disso, as melhorias no compilador e na biblioteca padrão contribuíram para tornar o Go uma linguagem ainda mais poderosa e versátil. Embora o suporte a módulos fosse experimental, ele pavimentou o caminho para o sistema de módulos que é amplamente utilizado hoje. A atualização para o Go 1.11 trouxe benefícios significativos para os desenvolvedores Go, e a migração para módulos é altamente recomendada para projetos novos e existentes. As melhorias de performance, embora modestas, foram bem-vindas e demonstram o compromisso da equipe Go em otimizar a linguagem. As mudanças na biblioteca padrão, como o suporte ao cabeçalho `Server-Timing`, forneceram novas ferramentas para os desenvolvedores web. Em resumo, o Go 1.11 foi uma versão importante que contribuiu para a crescente popularidade e adoção do Go.