Primeiros Passos com Go
Go (também chamado de Golang) é uma linguagem de programação criada pelo Google em 2009. É conhecida por sua simplicidade, performance e excelente suporte para programação concorrente.
Por Que Aprender Go?
- Simples de aprender — sintaxe clara e mínima
- Rápido — compila para código nativo
- Concorrência nativa — goroutines e channels
- Ótimo tooling — formatter, linter, test runner incluídos
- Mercado aquecido — salários competitivos no Brasil
1. Instalando Go
Linux (Ubuntu/Debian)
# Baixar Go (substitua pela versão mais recente)
wget https://go.dev/dl/go1.23.4.linux-amd64.tar.gz
# Extrair para /usr/local
sudo tar -C /usr/local -xzf go1.23.4.linux-amd64.tar.gz
# Adicionar ao PATH (adicione ao ~/.bashrc ou ~/.zshrc)
export PATH=$PATH:/usr/local/go/bin
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin
macOS
# Com Homebrew
brew install go
# Ou baixe de https://go.dev/dl/
Windows
Baixe o instalador MSI em go.dev/dl e execute.
Verificando a Instalação
go version
# go version go1.23.4 linux/amd64
2. Seu Primeiro Programa
Crie um arquivo hello.go:
package main
import "fmt"
func main() {
fmt.Println("Olá, Mundo!")
}
Execute:
go run hello.go
# Olá, Mundo!
3. Entendendo o Código
package main // Todo arquivo Go pertence a um pacote
// "main" é especial: é o ponto de entrada
import "fmt" // Importamos o pacote "fmt" para I/O formatado
func main() { // func define uma função
fmt.Println("...") // Println imprime uma linha
}
4. Criando um Projeto
Go usa módulos para gerenciar dependências:
# Criar diretório do projeto
mkdir meu-projeto
cd meu-projeto
# Inicializar módulo Go
go mod init meu-projeto
# Criar main.go
touch main.go
Estrutura típica de projeto:
meu-projeto/
├── go.mod # Definição do módulo e dependências
├── go.sum # Checksums das dependências
├── main.go # Ponto de entrada
├── internal/ # Código privado do projeto
└── pkg/ # Código público/reutilizável
5. Variáveis e Tipos
package main
import "fmt"
func main() {
// Declaração explícita
var nome string = "Go Brasil"
var idade int = 16
// Declaração curta (inferência de tipo)
linguagem := "Go"
ano := 2024
// Múltiplas variáveis
x, y := 10, 20
// Constantes
const PI = 3.14159
fmt.Println(nome, idade, linguagem, ano, x, y, PI)
}
Tipos Básicos
| Tipo | Descrição | Exemplo |
|---|---|---|
bool | Booleano | true, false |
string | Texto | "olá" |
int, int8, int32, int64 | Inteiros | 42 |
uint, uint8, uint32, uint64 | Inteiros sem sinal | 42 |
float32, float64 | Ponto flutuante | 3.14 |
byte | Alias para uint8 | |
rune | Alias para int32 (Unicode) | '中' |
6. Estruturas de Controle
If/Else
if x > 10 {
fmt.Println("maior que 10")
} else if x > 5 {
fmt.Println("maior que 5")
} else {
fmt.Println("menor ou igual a 5")
}
// Com declaração curta
if n := calcular(); n > 0 {
fmt.Println("positivo")
}
For (único loop em Go)
// Loop tradicional
for i := 0; i < 10; i++ {
fmt.Println(i)
}
// While-style
for x < 100 {
x *= 2
}
// Infinito
for {
// break para sair
}
// Range (iteração)
for i, v := range slice {
fmt.Println(i, v)
}
Switch
switch dia {
case "segunda", "terça", "quarta", "quinta", "sexta":
fmt.Println("dia útil")
case "sábado", "domingo":
fmt.Println("fim de semana")
default:
fmt.Println("dia inválido")
}
7. Funções
// Função simples
func somar(a, b int) int {
return a + b
}
// Múltiplos retornos
func dividir(a, b float64) (float64, error) {
if b == 0 {
return 0, fmt.Errorf("divisão por zero")
}
return a / b, nil
}
// Retornos nomeados
func retangulo(largura, altura float64) (area, perimetro float64) {
area = largura * altura
perimetro = 2 * (largura + altura)
return // retorno implícito
}
Próximos Passos
- Tour of Go — tutorial interativo oficial
- Go by Example — exemplos práticos
- Effective Go — boas práticas
- Perguntas de Entrevista Go — prepare-se para entrevistas
Última atualização: Janeiro 2026