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

# Go 1.10: Novidades e Recursos

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


# Novidades do Go 1.10: Um Guia Prático

O Go 1.10, lançado em 16 de fevereiro de 2018, trouxe uma série de melhorias e adições à linguagem, focando em desempenho, ferramentas e bibliotecas. Embora não introduza mudanças drásticas na sintaxe da linguagem, essa versão consolidou o ecossistema Go, preparando o terreno para futuras evoluções. Este artigo explora as principais novidades e como elas podem impactar o desenvolvimento em Go.

## Principais Novidades

### Suporte a Vendor no Comando `go test`

Uma das adições mais bem-vindas no Go 1.10 foi o suporte a vendor no comando `go test`. Anteriormente, ao executar testes em um projeto que utilizava vendor, era necessário tomar cuidado para garantir que as dependências vendidas fossem corretamente resolvidas. O Go 1.10 simplificou esse processo, permitindo que o comando `go test` reconhecesse automaticamente as dependências vendidas.

Isso significa que, ao executar `go test ./...` em um projeto com vendor, o Go agora procura pacotes no diretório `vendor` antes de procurar no `GOPATH`. Isso garante que os testes utilizem as versões corretas das dependências, evitando conflitos e inconsistências.

**Exemplo:**

Suponha que você tenha um projeto com a seguinte estrutura:

```
myproject/
├── main.go
├── mypackage/
│   ├── mypackage.go
│   └── mypackage_test.go
├── vendor/
│   └── github.com/example/dependency/
│       └── dependency.go
└── go.mod
```

Antes do Go 1.10, executar `go test ./...` poderia resultar em problemas se a versão da dependência `github.com/example/dependency` no `GOPATH` fosse diferente da versão vendida. Agora, o Go 1.10 resolve essa ambiguidade, utilizando a versão vendida para os testes.

### Cache de Build Aprimorado

O Go 1.10 introduziu um cache de build mais robusto e eficiente. O cache de build armazena os resultados de compilações anteriores, permitindo que o compilador reutilize esses resultados em compilações subsequentes, economizando tempo e recursos.

A principal melhoria no cache de build do Go 1.10 é a capacidade de armazenar em cache informações sobre arquivos que não foram modificados. Isso significa que, se você modificar apenas um pequeno arquivo em um projeto grande, o compilador poderá reutilizar os resultados da compilação dos outros arquivos, acelerando significativamente o processo de build.

Além disso, o Go 1.10 também otimizou a forma como o cache de build é armazenado e gerenciado, reduzindo o espaço em disco necessário e melhorando o desempenho geral.

Para limpar o cache de build, você pode usar o comando:

```bash
go clean -cache
```

Para desabilitar o cache de build, você pode usar a flag `-gcflags=-N -l` ao compilar seu código:

```bash
go build -gcflags="-N -l" main.go
```

### Suporte a Números Complexos em Templates

O Go 1.10 adicionou suporte para formatação de números complexos em templates. Anteriormente, era necessário converter números complexos para strings antes de exibi-los em templates, o que podia ser complicado e propenso a erros.

Com o Go 1.10, você pode usar as ações `{{printf}}` e `{{.}}` para formatar números complexos diretamente em templates. O formato padrão para números complexos é `(real+imaginaryi)`.

**Exemplo:**

```go
package main

import (
	"os"
	"text/template"
)

func main() {
	tmpl, err := template.New("complex").Parse("Número complexo: {{.}}\n")
	if err != nil {
		panic(err)
	}

	complexNumber := complex(1.2, 3.4)
	err = tmpl.Execute(os.Stdout, complexNumber)
	if err != nil {
		panic(err)
	}
}
```

A saída deste programa será:

```
Número complexo: (1.2+3.4i)
```

### Novas Funções na Biblioteca `math/rand`

A biblioteca `math/rand` recebeu algumas adições úteis no Go 1.10. Estas funções facilitam a geração de números aleatórios em diferentes cenários.

*   **`Read(p []byte)`:** Preenche um slice de bytes com números aleatórios. Isso é útil para gerar chaves criptográficas ou outros dados aleatórios.
*   **`Shuffle(n int, swap func(i, j int))`:** Embaralha aleatoriamente uma sequência de elementos, utilizando uma função de troca fornecida pelo usuário. Isso é útil para embaralhar listas ou arrays.

**Exemplo de `Read`:**

```go
package main

import (
	"fmt"
	"math/rand"
)

func main() {
	b := make([]byte, 10)
	_, err := rand.Read(b)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%x\n", b)
}
```

Este código gera 10 bytes aleatórios e os imprime em formato hexadecimal.

**Exemplo de `Shuffle`:**

```go
package main

import (
	"fmt"
	"math/rand"
)

func main() {
	s := []string{"a", "b", "c", "d", "e"}
	rand.Shuffle(len(s), func(i, j int) {
		s[i], s[j] = s[j], s[i]
	})
	fmt.Println(s)
}
```

Este código embaralha a lista de strings `s` aleatoriamente. A saída pode variar a cada execução.

### Pequenas Melhorias no Compilador e Linker

Embora o Go 1.10 não tenha introduzido grandes mudanças no compilador e linker, houve algumas pequenas melhorias que contribuíram para um melhor desempenho e estabilidade.

*   **Otimizações de código:** O compilador foi aprimorado para gerar código mais eficiente em determinadas situações, resultando em programas mais rápidos e com menor consumo de recursos.
*   **Melhorias no tratamento de erros:** O compilador e linker foram atualizados para fornecer mensagens de erro mais claras e informativas, facilitando a identificação e correção de problemas no código.
*   **Redução do tamanho do binário:** Foram feitas otimizações para reduzir o tamanho dos binários gerados pelo compilador, o que pode ser importante para aplicações embarcadas ou com restrições de espaço.

## Melhorias de Performance

O Go 1.10 continuou a tradição de melhorar o desempenho da linguagem. As principais melhorias de performance nesta versão incluem:

*   **Melhorias no Garbage Collector (GC):** O GC foi aprimorado para reduzir a latência e o consumo de memória, resultando em programas mais responsivos e eficientes.
*   **Otimizações no compilador:** O compilador foi otimizado para gerar código mais rápido e eficiente em diversas situações.
*   **Melhorias na biblioteca padrão:** Diversas funções e pacotes na biblioteca padrão foram otimizados para melhorar o desempenho.

Embora as melhorias de performance no Go 1.10 possam não ser tão drásticas quanto em algumas versões anteriores, elas ainda são significativas e podem fazer uma diferença notável em aplicações com alta demanda de desempenho.

## Mudanças na Biblioteca Padrão

Além das novas funções na biblioteca `math/rand`, o Go 1.10 trouxe outras mudanças e adições na biblioteca padrão. Algumas das mudanças mais notáveis incluem:

*   **Novas funções na biblioteca `net/http`:** A biblioteca `net/http` recebeu algumas novas funções e recursos, como suporte para HTTP Trailers e melhorias no tratamento de cookies.
*   **Melhorias na biblioteca `encoding/json`:** A biblioteca `encoding/json` foi aprimorada para lidar com tipos de dados mais complexos e para fornecer mensagens de erro mais informativas.
*   **Adição da biblioteca `runtime/trace`:** A biblioteca `runtime/trace` permite instrumentar o código para coletar informações de rastreamento, auxiliando na análise de desempenho e na identificação de gargalos.

Consulte a documentação oficial para obter uma lista completa de todas as mudanças na biblioteca padrão: [https://go.dev/doc/go1.10](https://go.dev/doc/go1.10)

## Como Atualizar

A atualização para o Go 1.10 é um processo simples e direto. A maneira mais comum de atualizar é utilizando o comando `go get`:

```bash
go get golang.org/dl/go1.10
go1.10 download
go1.10 install
```

Após a instalação, você pode usar o comando `go1.10` para compilar e executar seus programas com o Go 1.10. Para tornar o Go 1.10 a versão padrão do Go, você pode usar o comando:

```bash
go1.10 use
```

Isso atualizará o link simbólico `go` para apontar para o Go 1.10.

Alternativamente, você pode baixar os binários pré-compilados para sua plataforma no site oficial do Go: [https://go.dev/dl/](https://go.dev/dl/)

## Conclusão Prática

O Go 1.10 representou uma evolução importante na linguagem Go, consolidando recursos existentes e introduzindo melhorias que impactam diretamente a produtividade e o desempenho. O suporte a vendor no `go test`, o cache de build aprimorado e as novas funções nas bibliotecas padrão são adições valiosas para qualquer desenvolvedor Go.

Embora não tenha introduzido mudanças radicais na sintaxe da linguagem, o Go 1.10 demonstrou o compromisso da equipe Go em refinar e otimizar a experiência de desenvolvimento, preparando o terreno para futuras inovações. A atualização para o Go 1.10 é altamente recomendada para todos os desenvolvedores Go, pois oferece uma série de benefícios que podem melhorar significativamente a eficiência e a qualidade do seu trabalho.

Ao entender e aproveitar as novidades do Go 1.10, você estará melhor equipado para construir aplicações robustas, eficientes e escaláveis, aproveitando ao máximo o poder e a flexibilidade da linguagem Go.