Go (Comando): O que É e Como Funciona | Golang Brasil

O que é Go?

O termo go em Go (Golang) possui dois significados fundamentais que todo desenvolvedor precisa dominar. Primeiro, go é a palavra-chave da linguagem usada para iniciar goroutines — a base de toda a concorrência em Go. Segundo, go é o comando de linha de comando (CLI) que serve como ferramenta principal para compilar, testar, formatar e gerenciar projetos escritos na linguagem.

Entender ambos os usos é essencial para qualquer programador Go, desde iniciantes que estão dando os primeiros passos até profissionais experientes que trabalham com microserviços e deploy em produção. A versatilidade do comando go é uma das razões pelas quais Go é considerada uma linguagem com excelente developer experience — praticamente tudo que você precisa já vem embutido na ferramenta.

A Keyword go para Goroutines

A palavra-chave go é usada antes de uma chamada de função para executá-la como uma goroutine — uma thread leve gerenciada pelo runtime de Go. Essa é a forma fundamental de criar concorrência na linguagem:

package main

import (
    "fmt"
    "time"
)

func processar(nome string) {
    for i := 0; i < 3; i++ {
        fmt.Printf("%s: etapa %d\n", nome, i+1)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    // Inicia goroutine concorrente
    go processar("tarefa-A")
    go processar("tarefa-B")

    // Aguarda as goroutines terminarem
    time.Sleep(500 * time.Millisecond)
    fmt.Println("Concluído")
}

Quando você escreve go processar("tarefa-A"), o runtime de Go agenda essa função para execução concorrente sem bloquear a goroutine principal. O custo de criar uma goroutine é extremamente baixo — apenas alguns kilobytes de stack — o que permite criar milhares ou até milhões delas em um único programa.

Goroutines com funções anônimas

Um padrão muito comum é usar go com funções anônimas, especialmente quando você precisa capturar variáveis do escopo externo:

mensagens := []string{"olá", "mundo", "go"}

for _, msg := range mensagens {
    go func(m string) {
        fmt.Println(m)
    }(msg)
}

Note que passamos msg como parâmetro da função anônima em vez de capturá-la diretamente. Isso evita problemas com closures e variáveis de loop, um cuidado importante especialmente em versões anteriores ao Go 1.22. Para comunicação entre goroutines, utilize channels e, para sincronização, o mutex ou o select.

O Comando go: Visão Geral

O comando go é a ferramenta CLI que acompanha toda instalação de Go. Ele centraliza compilação, testes, gerenciamento de dependências e muito mais. Diferente de muitas linguagens que dependem de ferramentas externas (como Maven para Java ou pip para Python), Go oferece tudo integrado.

go run — Executar Código

O subcomando go run compila e executa um programa Go em um único passo, ideal para desenvolvimento e prototipagem rápida:

# Executar arquivo único
go run main.go

# Executar múltiplos arquivos
go run main.go utils.go

# Executar todo o pacote
go run .

go build — Compilar Binários

O go build compila seu código em um binário executável. Go produz binários estáticos por padrão, sem dependências externas — perfeito para deploy com Docker:

# Compilar binário
go build -o meuapp .

# Cross-compilation para Linux
GOOS=linux GOARCH=amd64 go build -o meuapp-linux .

# Build com otimização PGO
go build -pgo=default.pgo -o meuapp .

A capacidade de cross-compilation é um dos grandes diferenciais de Go. Com variáveis de ambiente GOOS e GOARCH, você compila para qualquer plataforma sem configuração adicional.

go test — Executar Testes

O go test executa testes automatizados, benchmarks e fuzzing:

# Testar pacote atual
go test ./...

# Com cobertura
go test -cover -coverprofile=coverage.out ./...

# Rodar benchmarks
go test -bench=. -benchmem ./...

# Fuzzing
go test -fuzz=FuzzParseInput ./...

go get e go mod — Gerenciar Dependências

O sistema de módulos de Go usa go get para adicionar dependências e go mod para gerenciar o arquivo go.mod:

# Adicionar dependência
go get github.com/gin-gonic/gin@latest

# Inicializar módulo
go mod init github.com/meuusuario/meuprojeto

# Limpar dependências não utilizadas
go mod tidy

# Baixar dependências
go mod download

go fmt e go vet — Qualidade de Código

Go possui formatação e análise estática integradas, eliminando debates sobre estilo de código:

# Formatar código (padrão oficial)
go fmt ./...

# Análise estática para erros comuns
go vet ./...

O go vet detecta erros como chamadas inválidas a fmt.Printf, variáveis não utilizadas em goroutines e outros problemas sutis que o compilador não captura.

go generate — Geração de Código

O go generate executa comandos especificados em comentários //go:generate dentro dos arquivos fonte. É amplamente usado para gerar código a partir de interfaces, mocks para testes e código de serialização:

//go:generate stringer -type=Status
//go:generate mockgen -source=repository.go -destination=mocks/repository_mock.go

type Status int

const (
    Ativo Status = iota
    Inativo
    Pendente
)

go tool pprof — Profiling

O go tool pprof é a ferramenta de profiling integrada que ajuda a identificar gargalos de performance:

# Coletar perfil de CPU
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# Analisar uso de memória
go tool pprof http://localhost:6060/debug/pprof/heap

# Visualizar em formato web
go tool pprof -http=:8080 cpu.prof

go env — Variáveis de Ambiente

O go env exibe e configura as variáveis de ambiente usadas pelo toolchain de Go:

# Ver todas as variáveis
go env

# Ver variável específica
go env GOPATH GOROOT

# Configurar variável
go env -w GOPROXY=https://proxy.golang.org,direct

Go install — Instalar Binários

O go install compila e instala binários no diretório $GOPATH/bin (ou $GOBIN). É a forma recomendada para instalar ferramentas CLI escritas em Go:

# Instalar ferramenta específica
go install golang.org/x/tools/gopls@latest

# Instalar ferramenta do projeto
go install ./cmd/meuapp

Boas Práticas com o Comando go

1. Use go mod tidy regularmente — mantém o go.mod limpo e remove dependências não utilizadas do seu módulo
2. Configure CI com go vet e go test -race — detecta race conditions e erros sutis antes do deploy
3. Aproveite o go build -ldflags — injete versão e data de build nos binários para observabilidade
4. Use go work para monorepos — gerencia múltiplos módulos em um único workspace

Diferença entre go (keyword) e go (comando)

É importante não confundir os dois usos. A keyword go dentro do código Go inicia goroutines para concorrência. O comando go no terminal é a ferramenta CLI que compila, testa e gerencia projetos. Ambos são fundamentais para o ecossistema Go, mas operam em contextos completamente diferentes.

Perguntas Frequentes (FAQ)

O que faz a keyword go em Go?

A keyword go inicia uma goroutine — uma função que executa concorrentemente com outras goroutines. Ao escrever go minhaFuncao(), o runtime de Go agenda a execução dessa função sem bloquear o fluxo principal. É a base da concorrência em Go e permite criar milhares de tarefas simultâneas com custo mínimo de memória.

Qual a diferença entre go run e go build?

O go run compila e executa o programa temporariamente, sem gerar um binário permanente — ideal para desenvolvimento rápido. Já o go build gera um binário executável que pode ser distribuído e executado em qualquer máquina compatível, sem necessidade de ter Go instalado. Para deploy em produção, sempre use go build.

Como gerenciar dependências com go mod?

Use go mod init para criar um novo módulo, go get para adicionar dependências, e go mod tidy para limpar dependências não utilizadas. O arquivo go.mod gerado registra todas as dependências com versões exatas, garantindo builds reproduzíveis. Consulte nosso guia de Go Modules na prática para um tutorial completo.

O que é go vet e quando devo usar?

O go vet é uma ferramenta de análise estática integrada que detecta erros comuns no código Go, como argumentos inválidos em fmt.Printf, uso incorreto de interfaces e problemas com ponteiros. Recomenda-se executar go vet ./... antes de cada commit e como parte da pipeline de CI/CD para manter a qualidade do código.