Nesta aula, você aprenderá a instalar o Go, configurar o ambiente de desenvolvimento e verificar se tudo está funcionando corretamente. O Go é uma linguagem moderna e eficiente, e ter um ambiente bem configurado é essencial para aproveitar ao máximo suas ferramentas. Vamos cobrir desde a instalação até a configuração do editor VSCode, passando pelo entendimento do GOPATH e dos módulos.

Se você já tem experiência com outras linguagens, notará que o Go tem um gerenciamento de dependências simples e eficiente. Vamos explorar isso em detalhes.

Instalando o Go

A instalação do Go é simples e suporta os principais sistemas operacionais: Windows, macOS e Linux. Recomenda-se baixar a versão oficial do site https://go.dev/dl/. Escolha o pacote adequado para seu sistema (por exemplo, .msi para Windows, .pkg para macOS, .tar.gz para Linux).

Após o download, execute o instalador e siga as instruções. No Linux, você pode extrair o arquivo tar.gz em /usr/local e adicionar o diretório /usr/local/go/bin ao PATH. Exemplo:

rm -rf /usr/local/go && tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

No Windows, o instalador cuida do PATH automaticamente. No macOS, o pacote .pkg também configura o PATH. Após a instalação, abra um terminal e execute go version para confirmar a instalação.

GOPATH e Go Modules

O GOPATH é um conceito histórico do Go que define o diretório de trabalho para projetos Go. Antes das versões 1.11, todos os projetos deviam estar dentro do GOPATH (geralmente $HOME/go). Com a introdução dos Go Modules (a partir do Go 1.11), esse requisito foi flexibilizado. Hoje, você pode criar projetos em qualquer diretório, desde que tenha um arquivo go.mod.

Os Go Modules permitem gerenciar dependências de forma declarativa. Para iniciar um novo módulo, use go mod init nome-do-modulo. Isso cria um arquivo go.mod que define o módulo e suas dependências. Exemplo:

mkdir meu-projeto
cd meu-projeto
go mod init github.com/meu-usuario/meu-projeto

Isso gera:

module github.com/meu-usuario/meu-projeto

go 1.22

Para adicionar dependências, basta importar pacotes no código e executar go mod tidy para baixá-las. O arquivo go.sum registra os checksums para segurança.

VSCode e ferramentas

O Visual Studio Code (VSCode) é um editor popular para Go, graças à extensão oficial Go (gopls). Instale o VSCode e, em seguida, vá até a aba de extensões (Ctrl+Shift+X) e pesquise por "Go". Instale a extensão fornecida pela Go Team at Google.

Após a instalação, abra um projeto Go e o VSCode sugerirá instalar ferramentas adicionais como gopls (servidor de linguagem), dlv (depurador), staticcheck (linter), entre outras. Aceite a instalação. Essas ferramentas fornecem autocompletar, navegação, formatação automática e análise de código.

Para configurar o VSCode, você pode ajustar as configurações do Go (Ctrl+Shift+P, "Preferences: Open Settings (JSON)"). Exemplo de configurações úteis:

{
  "go.useLanguageServer": true,
  "go.formatTool": "gofumpt",
  "go.lintTool": "staticcheck",
  "go.delveConfig": {
    "dlvLoadConfig": {
      "maxStringLen": 256,
      "maxArrayValues": 64
    }
  }
}

Isso melhora a experiência de desenvolvimento, garantindo código limpo e bem formatado.

Verificando a instalação

Para verificar se tudo está funcionando, crie um programa simples "Hello, World!". Crie um arquivo main.go com o seguinte conteúdo:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

No terminal, execute go run main.go. Você deve ver a saída Hello, World!. Se isso funcionar, a instalação está correta.

Além disso, teste o depurador: coloque um breakpoint na linha do fmt.Println e execute dlv debug (ou use o atalho F5 no VSCode). O depurador deve parar no breakpoint.

Por fim, execute go env para ver as variáveis de ambiente do Go. Verifique se GOPATH e GOROOT estão configurados corretamente.

Boas práticas

Mantenha o Go atualizado: sempre baixe a versão estável mais recente. Use go mod tidy regularmente para manter o go.mod limpo. Evite usar o GOPATH antigo; prefira módulos. Configure o VSCode para formatar automaticamente ao salvar (editor.formatOnSave).

Referências

Exercícios

  1. Instale o Go no seu sistema operacional e verifique a versão com go version. Qual versão foi instalada?

    2. ✓ Resposta: A versão instalada deve ser algo como go1.22.0 (ou a mais recente). Execute go version e veja a saída.
  2. Crie um novo módulo Go chamado hello e escreva um programa que imprima seu nome.

    3. ✓ Resposta: 
    mkdir hello
cd hello
go mod init hello
// Crie main.go:
package main
import "fmt"
func main() {
    fmt.Println("Seu nome")
}
    Execute com go run main.go.
  3. Configure o VSCode com a extensão Go e instale as ferramentas recomendadas (gopls, dlv, staticcheck). Liste quais ferramentas foram instaladas.

    4. ✓ Resposta: As ferramentas comuns são: gopls, dlv, staticcheck, goimports, gofumpt, golint. Você pode ver a lista no output do VSCode ao instalar.
  4. Verifique as variáveis de ambiente do Go executando go env. Identifique o valor de GOPATH e GOROOT.

    5. ✓ Resposta: Exemplo de saída: GOPATH="/home/usuario/go" e GOROOT="/usr/local/go". Os valores podem variar conforme o sistema.
  5. Use o depurador (dlv) para executar o programa do exercício 2 passo a passo. Coloque um breakpoint na linha do fmt.Println e explique o que acontece.

    6. ✓ Resposta: Ao executar dlv debug e depois continue, o programa para no breakpoint. Você pode inspecionar variáveis, executar linha a linha com next e ver a saída no terminal. O depurador ajuda a entender o fluxo do programa.