Como baixar e instalar o Go 1.18
Go é uma linguagem de programação de código aberto que pode ser usada para criar uma ampla variedade de aplicativos, desde desenvolvimento web até sistemas distribuídos. É amigável ao desenvolvedor, rápido, confiável e fácil de aprender. Go possui uma comunidade grande e ativa que contribui para seu desenvolvimento e fornece muitos pacotes e ferramentas para vários casos de uso.
Em março de 2022, a equipe Go lançou o Go 1.18, que é uma versão massiva que inclui novos recursos, melhorias de desempenho e a maior mudança já feita na linguagem: os genéricos. Neste artigo, exploraremos alguns dos principais recursos e benefícios do Go 1.18 e mostraremos como baixá-lo e instalá-lo em seu computador.
go 1.18 download
Genéricos
Os genéricos são um dos recursos mais solicitados no Go e finalmente estão aqui no Go 1.18. Os genéricos permitem que você escreva código que pode lidar com vários tipos sem se repetir ou usar a interface. Os genéricos funcionam usando tipos parametrizados, que são tipos que possuem um ou mais parâmetros de tipo que podem ser instanciados com tipos diferentes.
Por exemplo, você pode escrever uma função genérica que pode trocar quaisquer dois valores do mesmo tipo:
função swap[T qualquer](a, b *T) *a, *b = *b, *a
Você pode então chamar esta função com diferentes tipos de argumentos:
var x int = 1 var y int = 2 swap[int](&x, &y) // x = 2, y = 1 var s string = "olá" var t string = "mundo" swap[string](&s, &t) // s = "mundo", t = "olá"
Você também pode usar restrições de tipo para restringir os tipos que podem ser usados como parâmetros de tipo. Restrições de tipo são tipos de interface que especificam quais métodos ou operações um parâmetro de tipo deve suportar. Por exemplo, você pode escrever uma função genérica que pode comparar quaisquer dois valores de um tipo comparável:
tipo de interface comparável int func max[T comparável](a, b T) T if a > b return a return b
Você pode então chamar esta função com qualquer tipo comparável:
fmt.Println(max[int](3, 5)) // imprime 5 fmt.Println(max[string]("foo", "bar")) // imprime "foo" fmt.Println(max[bool](true, false)) // imprime o tipo verdadeiro point struct x int y int fmt.Println(max[point](point1,2, point3,4)) // imprime 3,4
Para saber mais sobre genéricos em Go Fuzzing
Fuzzing é uma técnica em que você gera e executa entradas aleatórias em um programa para encontrar bugs que, de outra forma, poderiam passar despercebidos. Fuzzing pode ser especialmente útil para encontrar vulnerabilidades de segurança, como estouros de buffer, injeções de SQL ou ataques de script entre sites.
O Go 1.18 suporta fuzzing em sua cadeia de ferramentas padrão, tornando o Go a primeira grande linguagem de programação a fazê-lo. Você pode usar fuzzing em Go com o comando go, que irá gerar e executar entradas automaticamente para seu alvo fuzz, uma função que recebe um parâmetro *testing.F e um ou mais argumentos fuzzing. O comando go usará a orientação de cobertura para explorar de forma inteligente os caminhos de código de seu alvo fuzz e relatar quaisquer falhas ou pânicos.
Por exemplo, você pode escrever um fuzz target que testa a função Reverse da seção anterior:
func FuzzReverse(f *testing.F) f.Fuzz(func(t *testing.T, s string) r := Reverse(s) if Reverse(r) != s t.Errorf("Reverse(Reverse(%q)) != %q", s, s) )
Você pode então executar este fuzz target com o comando go:
vá testar -fuzz=FuzzReverse
O comando go gerará e executará sequências aleatórias como entradas para o alvo fuzz e relatará quaisquer erros ou travamentos.Você também pode adicionar entradas de corpus semente para fornecer entradas iniciais para o mecanismo fuzzing, usando o método (*testing.F).Add ou colocando arquivos no diretório testdata/fuzz do destino fuzz.
Para aprender mais sobre fuzzing em Go, você pode conferir o [tutorial](^2^) ou a [documentação](^1^). espaços de trabalho
Os espaços de trabalho são um novo recurso do Go 1.18 que simplifica o trabalho com vários módulos em uma única árvore de diretórios. Os espaços de trabalho permitem criar e alternar entre diferentes conjuntos de módulos e dependências sem modificar os arquivos go.mod ou a variável de ambiente GOPATH.
Você pode usar áreas de trabalho em Go com o comando go, que detectará e usará automaticamente o arquivo de configuração da área de trabalho, chamado go.work, se existir no diretório atual ou em qualquer diretório pai. O arquivo go.work contém uma lista de diretivas que especificam os módulos e substituem diretivas que pertencem ao espaço de trabalho.
Por exemplo, você pode criar um arquivo go.work que inclua dois módulos, foo e bar, e substitua a dependência de baz por uma versão local:
go 1.18 diretório ( ./foo ./bar ) substitua example.com/baz => ./baz
Em seguida, você pode executar qualquer comando go no espaço de trabalho, como go build, go test ou go mod aim, e ele usará os módulos e substituirá as diretivas definidas no arquivo go.work. Você também pode alternar entre diferentes áreas de trabalho alterando o diretório atual ou usando o sinalizador -workfile.
Para saber mais sobre espaços de trabalho em Go, você pode ler a [proposta] ou a [postagem do blog].
Melhorias de desempenho
O Go 1.18 também traz melhorias significativas de desempenho para diferentes arquiteturas e plataformas. Algumas das melhorias notáveis são:
A nova convenção de chamada baseada em registro para x86-64, que reduz o uso da pilha e melhora a qualidade da geração de código.
O novo algoritmo de análise de escape, que reduz as alocações de heap e a pressão da coleta de lixo.
O novo mecanismo de preempção simultâneo, que melhora a latência e a capacidade de resposta das goroutines.
As novas otimizações do compilador, como desenrolamento de loop, redução de força e eliminação de código morto.
As novas otimizações de tempo de execução, como acesso mais rápido ao mapa, declarações de deferimento e conversões de interface.
Você pode medir e comparar o desempenho do seu código Go com benchmarks, que são testes especiais que executam um código repetidamente e medem quanto tempo leva. Você pode escrever benchmarks com o pacote testing, usando o método (*testing.B).Run ou a função Benchmark. Você pode executar benchmarks com o comando go test, usando o sinalizador -bench para especificar quais benchmarks executar.
Por exemplo, você pode escrever um benchmark que mede o desempenho da função Reverse da seção anterior:
func BenchmarkReverse(b *testing.B) for i := 0; i
Você pode então executar este benchmark com o comando go test:
go test -bench = BenchmarkReverse
O comando go test relatará o número de iterações e o tempo por iteração para o benchmark. Você também pode usar o sinalizador -benchmem para relatar as estatísticas de alocação de memória para o benchmark.
Para otimizar seu código Go para melhor desempenho, você pode seguir algumas práticas recomendadas, como:
Evite alocações de heap desnecessárias e use sync.Pool para reutilizar objetos.
Evite conversões de tipo desnecessárias e use asserções de tipo em vez de reflexão.
Evite valores de interface desnecessários e use tipos concretos quando possível.
Evite chamadas de função desnecessárias e use funções ou métodos embutidos quando possível.
Evite loops desnecessários e use expressões de intervalo ou fatia quando possível.
Para saber mais sobre melhorias de desempenho no Go 1.18, você pode conferir as [notas da versão] ou o [wiki de desempenho].
Conclusão
Neste artigo, abordamos alguns dos principais recursos e benefícios do Go 1.18, como genéricos, fuzzing, espaços de trabalho e melhorias de desempenho. Também mostramos como baixar e instalar o Go 1.18 em seu computador e como usar alguns dos novos recursos com exemplos. Esperamos que você tenha gostado deste artigo e aprendido algo novo sobre o Go 1.18.
Se você quiser experimentar o Go 1.18, pode baixá-lo do [site oficial] ou usar um playground online como o [Go Playground]. Você também pode encontrar mais recursos e tutoriais sobre Go em [golang.org] ou [golang.dev]. Se você tiver algum comentário ou pergunta sobre o Go 1.18, poderá ingressar na [comunidade Go] em várias plataformas, como Slack, Reddit, Twitter ou GitHub. Codificação feliz!
perguntas frequentes
Quais são alguns dos Quais são algumas das principais mudanças no Go 1.18?
O Go 1.18 apresenta algumas alterações importantes que podem afetar seu código existente ou exigir que você atualize suas dependências. Algumas das mudanças de quebra são:
A remoção do sinalizador -i dos comandos go build e go install, que foi descontinuado no Go 1.10.
A remoção da variável de ambiente GO111MODULE, que foi descontinuada no Go 1.17.
A remoção do tipo os/exec.LookPathError, que foi descontinuado no Go 1.13.
A remoção das funções reflect.AppendSlice e reflect.CopySlice, que foram descontinuadas no Go 1.15.
A remoção do valor de erro math/big.ErrNaN, que foi descontinuado no Go 1.14.
Para saber mais sobre as alterações recentes no Go 1.18, você pode ler o [documento de compatibilidade] ou as [notas de versão].
Como posso usar módulos no Go 1.18?
Os módulos são a maneira padrão de gerenciar dependências e versões em Go. Módulos são coleções de pacotes Go que são identificados por um caminho de módulo e uma versão. Você pode usar módulos no Go 1.18 com o comando go mod, que fornece vários subcomandos para criar, atualizar, verificar e publicar módulos.
Para usar os módulos no Go 1.18, você precisa criar um arquivo go.mod no diretório raiz do seu módulo, que contém a declaração do módulo e as diretivas require e replace. A declaração do módulo especifica o caminho do módulo, que geralmente é o caminho de importação do seu repositório. A diretiva require especifica as dependências do seu módulo e suas versões. A diretiva replace permite substituir uma dependência por outro módulo ou diretório local.
Por exemplo, você pode criar um arquivo go.mod para o módulo foo que depende dos módulos bar e baz:
módulo example.com/foo go 1.18 require ( example.com/bar v1.2.3 example.com/baz v0.9.0 )
Você pode então usar o comando go mod para baixar, atualizar, organizar, verificar ou vender suas dependências. Você também pode usar áreas de trabalho para gerenciar vários módulos em uma única árvore de diretório.
Para saber mais sobre os módulos no Go 1.18, você pode ler a [referência dos módulos] ou o [wiki dos módulos].
Como posso usar o teste no Go 1.18?
O teste é uma parte essencial do desenvolvimento e manutenção de software de alta qualidade. O teste em Go é suportado pelo pacote de teste, que fornece uma estrutura para escrever e executar testes, benchmarks e exemplos. Você pode usar o teste no Go 1.18 com o comando go test, que encontrará e executará automaticamente testes, benchmarks e exemplos em seu pacote ou módulo.
Para usar o teste no Go 1.18, você precisa criar um arquivo com um sufixo _test.go que contenha suas funções de teste, funções de referência ou funções de exemplo. As funções de teste têm a função de assinatura TestXxx(t *testing.T), em que Xxx é qualquer string alfanumérica que não comece com uma letra minúscula. As funções de referência têm a função de assinatura BenchmarkXxx(b *testing.B), em que Xxx é qualquer string alfanumérica que não comece com uma letra minúscula. As funções de exemplo têm a função de assinatura ExampleXxx(), onde Xxx é qualquer string alfanumérica que não comece com uma letra minúscula ou uma string vazia.
Por exemplo, você pode criar um arquivo chamado foo_test.go que contém uma função de teste, uma função de benchmark e uma função de exemplo para o pacote foo:
package foo_test import ( "fmt" "testing" "example.com/foo" ) func TestFoo(t *testing.T) // escreva seu código de teste aqui func BenchmarkFoo(b *testing.B) // escreva seu código de benchmark aqui func ExampleFoo() // escreva seu código de exemplo aqui fmt.Println(foo.Foo()) // Saída: foo
Você pode usar o comando go test para executar seus testes, benchmarks ou exemplos:
vá testar -v exemplo.com/foo
O comando go test relatará os resultados de seus testes, benchmarks ou exemplos. Você também pode usar sinalizadores para especificar quais testes, benchmarks ou exemplos devem ser executados ou para alterar o formato de saída ou verbosidade.
Para saber mais sobre o teste no Go 1.18, você pode ler a [visão geral do teste] ou o [tutorial do teste].
Como posso usar a depuração no Go 1.18?
A depuração é um processo de localização e correção de erros ou bugs em seu código. A depuração é um processo de localização e correção de erros ou bugs em seu código. A depuração em Go é suportada por várias ferramentas e técnicas, como registro, teste, rastreamento, criação de perfil e depuração interativa. Você pode usar a depuração no Go 1.18 com o comando go, que fornece vários subcomandos e sinalizadores para depurar seu código. Uma das ferramentas de depuração mais comuns em Go é o pacote log, que fornece uma maneira simples e eficiente de imprimir mensagens na saída padrão ou em um arquivo. Você pode usar o pacote log para imprimir mensagens com diferentes níveis de gravidade, como log.Print, log.Fatal ou log.Panic. Você também pode usar o pacote de log para personalizar o formato e o destino de suas mensagens, como log.SetFlags, log.SetOutput ou log.SetPrefix. Outra ferramenta de depuração em Go é o pacote testing, que já discutimos na seção anterior.O pacote de teste permite escrever e executar testes, benchmarks e exemplos para o seu código e relatar quaisquer falhas ou pânicos. Você também pode usar o pacote testing para escrever subtestes e subbenchmarks, que são testes aninhados ou benchmarks que compartilham configuração comum e código de desmontagem. Você também pode usar o pacote testing para escrever funções auxiliares, que são funções que executam tarefas comuns para seus testes ou benchmarks e não contam como falhas de teste. Uma ferramenta de depuração mais avançada em Go é o pacote trace, que fornece uma maneira de coletar e analisar os rastros de execução do seu programa. Rastreamentos de execução são registros detalhados de eventos que ocorrem durante a execução de seu programa, como criação de goroutine, bloqueio, agendamento, chamadas de sistema, coleta de lixo etc. Em seguida, você pode usar o comando go tool trace para visualizar e analisar os rastreamentos de execução em um navegador da web. Outra ferramenta de depuração avançada em Go é o pacote pprof, que fornece uma maneira de coletar e analisar perfis de desempenho do seu programa. Perfis de desempenho são amostras estatísticas de eventos que ocorrem durante a execução de seu programa, como uso de CPU, alocação de memória, uso de heap, bloqueio de goroutine etc. Você pode então usar o comando go tool pprof para visualizar e analisar os perfis de desempenho em vários formatos. Uma ferramenta de depuração mais interativa em Go é o depurador delve, que é uma ferramenta de terceiros que permite inspecionar e manipular o estado de seu programa em tempo de execução. Você pode usar o delve para definir pontos de interrupção, observar variáveis, avaliar expressões, percorrer o código, etc. Você também pode usar o delve para depurar testes ou benchmarks com o sinalizador -test.Você pode instalar o delve com o comando go get:
acesse github.com/go-delve/delve/cmd/dlv
Você pode usar o delve para depurar seu programa com o comando dlv:
dlv debug exemplo.com/foo
Para saber mais sobre depuração no Go 1.18, você pode ler a [visão geral da depuração] ou o [tutorial de depuração]. Como posso usar a documentação no Go 1.18?
A documentação é uma parte importante do desenvolvimento e manutenção de software. A documentação em Go é suportada pela ferramenta godoc, que extrai e gera documentação a partir do código-fonte Go. Você pode usar a documentação no Go 1.18 com o comando godoc, que fornece vários subcomandos e sinalizadores para visualizar e servir a documentação.
Para usar a documentação no Go 1.18, você precisa escrever comentários que sigam algumas convenções para que o godoc os reconheça como documentação. A convenção mais comum é escrever um comentário que comece com o nome do item que está sendo documentado, como um pacote, uma função, um tipo, uma variável ou uma constante. Por exemplo:
// O pacote foo fornece algumas funções úteis para trabalhar com strings. pacote foo // Reverse retorna uma versão invertida de s. func Reverse(s string) string // escreva seu código aqui
Você pode então usar o comando godoc para visualizar ou servir a documentação do seu pacote ou módulo:
godoc example.com/foo // imprime a documentação para stdout godoc -http=:6060 // entrega a documentação em localhost:6060
O comando godoc exibirá ou servirá a documentação no formato HTML por padrão. Você também pode usar sinalizadores para alterar o formato ou estilo de saída.
Para saber mais sobre a documentação no Go 1.18, você pode ler a [godoc overview] ou o [godoc tutorial].
0517a86e26
Comments