Instalando Go e entendendo o workspace

1. Instalação do Go no seu sistema operacional

O primeiro passo para começar com Go é instalar o compilador e as ferramentas necessárias. Acesse o site oficial go.dev/dl e baixe o instalador adequado para seu sistema operacional.

Windows: Execute o instalador MSI e siga o assistente. O Go será instalado em C:\Go por padrão, e o PATH será configurado automaticamente.

macOS: Use o pacote .pkg ou, alternativamente, instale via Homebrew:

brew install go

Linux: Baixe o arquivo .tar.gz e extraia em /usr/local:

wget https://go.dev/dl/go1.21.5.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz

Após a instalação, verifique se tudo funcionou corretamente:

go version

Você deverá ver algo como go version go1.21.5 linux/amd64.

2. Configurando variáveis de ambiente essenciais

O Go depende de algumas variáveis de ambiente para funcionar corretamente. As principais são:

GOROOT: Aponta para o diretório onde o Go foi instalado. Geralmente é configurado automaticamente, mas você pode defini-lo manualmente:

export GOROOT=/usr/local/go

GOPATH: Define o diretório de trabalho do Go. Por padrão, é $HOME/go. Você pode alterá-lo:

export GOPATH=$HOME/go

PATH: Deve incluir tanto o diretório do compilador quanto o diretório de binários:

export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

GOBIN: Opcionalmente, define onde os binários compilados serão armazenados:

export GOBIN=$GOPATH/bin

Para tornar essas configurações permanentes, adicione-as ao arquivo ~/.bashrc, ~/.zshrc ou equivalente.

3. Estrutura do workspace tradicional (GOPATH mode)

Antes dos módulos (Go Modules), todo projeto Go precisava seguir uma estrutura rígida dentro do GOPATH. O workspace clássico possui três diretórios principais:

$GOPATH/
├── src/    # Código-fonte dos projetos
├── pkg/    # Pacotes compilados e bibliotecas
└── bin/    # Executáveis gerados

src: Cada projeto fica em $GOPATH/src/nome-do-projeto. Por exemplo, um projeto chamado meuapp estaria em $GOPATH/src/meuapp.

pkg: Armazena pacotes compilados em formato .a, organizados por arquitetura e sistema operacional.

bin: Contém os executáveis gerados pelo comando go install.

Exemplo de estrutura de projeto no modo GOPATH:

// $GOPATH/src/meuapp/main.go
package main

import "fmt"

func main() {
    fmt.Println("Olá, Go!")
}

Para compilar e instalar:

cd $GOPATH/src/meuapp
go install

O binário será gerado em $GOPATH/bin/meuapp.

4. Entendendo o módulo Go (Go Modules)

A partir do Go 1.11, os módulos (Go Modules) foram introduzidos para resolver limitações do GOPATH puro, como a impossibilidade de versionar dependências e a rigidez da estrutura de diretórios.

Para iniciar um novo módulo:

mkdir meu-modulo
cd meu-modulo
go mod init github.com/seuusuario/meu-modulo

Isso cria um arquivo go.mod com o seguinte conteúdo:

module github.com/seuusuario/meu-modulo

go 1.21

O go.mod é o coração do módulo. Ele identifica o módulo, especifica a versão do Go e lista as dependências externas. Quando você importa um pacote externo e executa go mod tidy, o arquivo é atualizado automaticamente.

Exemplo prático:

// main.go
package main

import (
    "fmt"
    "rsc.io/quote"
)

func main() {
    fmt.Println(quote.Go())
}

go mod tidy

O go.mod será atualizado para incluir rsc.io/quote e seu go.sum será criado para verificar a integridade das dependências.

5. Organizando pacotes dentro do workspace

Com Go Modules, você pode organizar seu código em pacotes dentro do mesmo módulo. Cada pacote é um diretório contendo arquivos .go com a mesma declaração package.

Estrutura de exemplo:

meu-modulo/
├── main.go
├── go.mod
├── go.sum
└── utils/
    └── math.go

// utils/math.go
package utils

// Soma retorna a soma de dois inteiros
func Soma(a, b int) int {
    return a + b
}

// main.go
package main

import (
    "fmt"
    "github.com/seuusuario/meu-modulo/utils"
)

func main() {
    resultado := utils.Soma(10, 20)
    fmt.Println("Resultado:", resultado)
}

Regras de visibilidade: Identificadores que começam com letra maiúscula são exportados (públicos). Identificadores com letra minúscula são privados ao pacote.

// utils/math.go
package utils

// Soma é exportado (maiúsculo)
func Soma(a, b int) int {
    return a + b
}

// subtrai é privado (minúsculo)
func subtrai(a, b int) int {
    return a - b
}

6. Ferramentas essenciais do ecossistema Go

O Go vem com ferramentas poderosas que facilitam o desenvolvimento:

go build: Compila o projeto e gera um binário executável:

go build -o meuapp

go run: Compila e executa o código sem gerar um binário permanente:

go run main.go

go fmt: Formata automaticamente o código seguindo o padrão oficial:

go fmt ./...

go vet: Analisa o código em busca de suspeitas de erros:

go vet ./...

go test: Executa testes unitários:

go test ./...

Exemplo de uso prático com um projeto:

# Desenvolvimento rápido
go run main.go

# Preparando para produção
go build -o meuapp .
./meuapp

# Mantendo qualidade
go fmt ./...
go vet ./...

7. Dicas práticas e resolução de problemas comuns

Erro: "go: command not found"
Verifique se o PATH está configurado corretamente:

export PATH=$PATH:/usr/local/go/bin

Erro: "cannot find package"
Certifique-se de que está usando módulos e que o go.mod está presente. Execute go mod tidy para baixar dependências.

Gerenciando múltiplos módulos
Você pode usar o replace no go.mod para trabalhar com módulos locais:

module github.com/meuapp

go 1.21

require github.com/minhalib v0.0.0

replace github.com/minhalib => ../minhalib

Diagnosticando configurações
Use go env para ver todas as variáveis de ambiente:

go env GOPATH GOROOT GOBIN

Problema comum: versão do Go desatualizada
Sempre verifique a versão mais recente e atualize regularmente:

go version
# Se necessário, baixe a nova versão em go.dev/dl

Dica de organização: Mesmo com módulos, mantenha projetos em $GOPATH/src para evitar confusão com ferramentas antigas.

Referências