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

# Go 1.15: Novidades e Recursos

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


# Novidades do Go 1.15: Um Guia Detalhado

A versão 1.15 do Go, lançada em 11 de agosto de 2020, trouxe um conjunto significativo de melhorias e adições à linguagem. Focada na performance, segurança e usabilidade, esta versão consolidou o Go como uma ferramenta poderosa para o desenvolvimento de software moderno. Este artigo explora as principais mudanças e seus impactos práticos.

## Compilador e Runtime

### Melhorias no Garbage Collector (GC)

O Go 1.15 aprimorou significativamente o garbage collector. A principal mudança reside na otimização do agendamento do GC, reduzindo a latência e o overhead. Isso é particularmente notável em aplicações com alta alocação de memória.

*   **Agendamento Otimizado:** O agendamento do GC agora considera o tempo gasto em GC em ciclos anteriores, ajustando a frequência de execução para minimizar a latência.
*   **Redução da Latência:** A latência do GC foi reduzida em até 20% em alguns casos, resultando em uma experiência mais responsiva para aplicações interativas.

Essas melhorias tornam o Go 1.15 ainda mais adequado para aplicações sensíveis à latência e sistemas de alta performance.

### Aperfeiçoamentos no Linker

O linker no Go 1.15 recebeu melhorias significativas, resultando em tempos de linkagem mais rápidos, especialmente para programas grandes. Essas otimizações incluem:

*   **Paralelização:** O linker agora aproveita melhor o paralelismo, distribuindo o trabalho entre múltiplos núcleos da CPU.
*   **Otimização do Layout de Memória:** Melhorias no layout de memória reduziram o tamanho dos binários e melhoraram o desempenho em tempo de execução.

Essas mudanças são cruciais para projetos grandes, onde os tempos de linkagem podem ser um gargalo significativo no processo de desenvolvimento.

### Suporte a X.509 Common Name Deprecado

Para aumentar a segurança, o Go 1.15 desabilitou o suporte ao uso do campo Common Name em certificados X.509 por padrão. Este campo tem sido considerado obsoleto e inseguro há algum tempo. Agora, o Go exige que os certificados usem o Subject Alternative Name (SAN) para validação de nomes de domínio.

Para reabilitar o suporte ao Common Name (não recomendado, apenas para compatibilidade com sistemas legados), você pode definir a variável de ambiente `GODEBUG=x509ignoreCN=0`.

```bash
export GODEBUG=x509ignoreCN=0
```

É altamente recomendado migrar para o uso de SANs em vez de depender do Common Name.

## Mudanças na Biblioteca Padrão

### Novas Funções para Manipulação de Time

A biblioteca `time` recebeu novas funções para facilitar a manipulação de fusos horários (time zones) e horários específicos.

*   **`time.Parse(layout, value string)`:** Essa função facilita a conversão de strings em valores `time.Time` com base em um layout específico.

```go
package main

import (
	"fmt"
	"time"
)

func main() {
	dataString := "2023-10-27 10:30:00"
	layout := "2006-01-02 15:04:05" // Layout Go para a data e hora

	dataTime, err := time.Parse(layout, dataString)
	if err != nil {
		fmt.Println("Erro ao fazer o parse:", err)
		return
	}

	fmt.Println("Data e hora:", dataTime)
}
```

### Suporte a TLS 1.3 Aprimorado

O Go 1.15 continuou a fortalecer o suporte a TLS 1.3, o protocolo de segurança mais recente para comunicação criptografada. As melhorias incluem:

*   **Desempenho Otimizado:** Implementações mais eficientes de algoritmos criptográficos usados em TLS 1.3.
*   **Segurança Aprimorada:** Correções de bugs e melhorias na segurança para mitigar vulnerabilidades.

O suporte a TLS 1.3 é fundamental para garantir a segurança das comunicações em rede.

### Novas Funções na Biblioteca `io/fs` (Experimental)

A biblioteca `io/fs` foi introduzida como experimental, oferecendo uma interface abstrata para sistemas de arquivos. Isso permite que o código interaja com diferentes tipos de sistemas de arquivos de forma genérica, sem depender de implementações específicas.

```go
package main

import (
	"fmt"
	"io/fs"
	"os"
)

func main() {
	err := fs.WalkDir(os.DirFS("."), ".", func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		fmt.Println(path)
		return nil
	})
	if err != nil {
		fmt.Println(err)
	}
}
```

Este exemplo usa `fs.WalkDir` para percorrer o sistema de arquivos a partir do diretório atual.

### Mudanças na Biblioteca `crypto/x509`

A biblioteca `crypto/x509` teve mudanças significativas para reforçar a segurança. Como mencionado anteriormente, o suporte ao `CommonName` foi desativado por padrão. Além disso, foram adicionadas novas opções para configurar a validação de certificados.

```go
package main

import (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"log"
	"net/http"
)

func main() {
	certPool, err := x509.SystemCertPool()
	if err != nil {
		log.Fatalf("Falha ao carregar o sistema de certificados: %v", err)
	}

	tlsConfig := &tls.Config{
		RootCAs: certPool,
	}

	client := &http.Client{
		Transport: &http.Transport{
			TLSClientConfig: tlsConfig,
		},
	}

	resp, err := client.Get("https://example.com")
	if err != nil {
		log.Fatalf("Falha ao fazer a requisição: %v", err)
	}
	defer resp.Body.Close()

	fmt.Println("Requisição bem-sucedida!")
}
```

Este exemplo demonstra como configurar um cliente HTTP com um pool de certificados raiz para validar certificados TLS.

## Melhorias de Performance

Além das melhorias no GC e no linker, o Go 1.15 também introduziu otimizações em outras áreas, resultando em um desempenho geral aprimorado.

*   **Otimização de Funções Inline:** O compilador agora é mais agressivo na inlining de funções, reduzindo o overhead de chamadas de função.
*   **Melhorias na Alocação de Memória:** Otimizações na alocação de memória reduziram o overhead e melhoraram a eficiência.

Essas melhorias, embora sutis individualmente, contribuem para um aumento geral no desempenho das aplicações Go.

## Gerenciamento de Módulos (Go Modules)

O Go 1.15 continuou a aprimorar o suporte a Go Modules, o sistema de gerenciamento de dependências padrão do Go.

*   **Melhorias no Cache de Módulos:** O cache de módulos foi otimizado para reduzir o tempo de download e verificação de dependências.
*   **Suporte a Módulos Privados:** Melhorias foram feitas para suportar o uso de módulos privados em ambientes corporativos.

Go Modules simplifica o gerenciamento de dependências, tornando mais fácil construir e manter projetos Go.

## Como Atualizar para o Go 1.15

A atualização para o Go 1.15 é um processo simples. Primeiro, certifique-se de ter o Go instalado corretamente. Em seguida, execute o seguinte comando:

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

Este comando baixará e instalará o Go 1.15. Para usar esta versão, você pode usar o comando `go1.15`.  Para torná-lo o padrão, você pode definir o `PATH` ou usar `go install std`.

```bash
export PATH=$PATH:$(go env GOROOT)/bin
```

Verifique a versão instalada:

```bash
go version
```

Certifique-se de que a saída mostre `go version go1.15`.

## Considerações sobre Compatibilidade

Embora o Go seja conhecido por sua forte compatibilidade com versões anteriores, é importante estar ciente de algumas mudanças que podem exigir ajustes no código existente.

*   **X.509 Common Name:** Se você estiver usando certificados X.509 que dependem do Common Name, precisará migrar para o uso de SANs ou habilitar temporariamente o suporte ao Common Name (não recomendado).
*   **Dependências:** Verifique se suas dependências são compatíveis com o Go 1.15. Se encontrar problemas, atualize as dependências para as versões mais recentes.

Em geral, a atualização para o Go 1.15 deve ser relativamente simples, mas é sempre bom testar o código após a atualização para garantir que tudo funcione corretamente.

## Conclusão

O Go 1.15 representa um passo significativo na evolução da linguagem. As melhorias no garbage collector, linker, segurança e biblioteca padrão tornam o Go uma escolha ainda mais atraente para uma ampla gama de aplicações. Ao atualizar para o Go 1.15, você pode aproveitar esses benefícios e garantir que suas aplicações estejam executando com o máximo de desempenho e segurança. Consulte as [release notes oficiais](https://go.dev/doc/go1.15) para uma lista completa de mudanças e detalhes adicionais. A adoção desta versão contribui para a construção de software mais robusto e eficiente.