Go para Iniciantes: Primeiros Passos em 2026

Resposta rápida: para começar com Go para iniciantes, instale a versão estável em go.dev/dl, confira com go version, crie um módulo (go mod init), rode um Hello World com go run . e, em seguida, suba um servidor HTTP com net/http. Em cerca de 15 minutos você já tem um programa compilando e respondendo no navegador — sem framework e sem configuração mágica.

Este guia é o ponto de entrada prático do golang.com.br: instalação atualizada, o menor programa possível, variáveis, controle de fluxo, funções com erro, um servidor HTTP local e o caminho natural para o curso gratuito de Go, o roadmap de 12 semanas e a trilha de API REST. Se você só quer o atalho de instalação + Hello World, use também primeiros passos com Go.

O que você vai ter ao final

Por que Go faz sentido para quem está começando

Go (muita gente ainda digita “Golang” nas buscas) nasceu no Google para escrever software de rede e infraestrutura com menos cerimônia. Para iniciantes, três coisas pesam mais que benchmarks:

1. Sintaxe pequena — poucas palavras-chave, um jeito principal de fazer loop (for), formatador oficial (go fmt).
2. Ferramentas no kit — compilar, testar, formatar e baixar dependências vêm com a linguagem (go, go test, go mod).
3. Binário único — você gera um executável e roda em servidor, container ou CI sem runtime pesado.

No Brasil, Go aparece com frequência em backend, fintechs, marketplaces, cloud e plataforma. O volume de vagas júnior é menor que o de JavaScript ou Java, mas a linguagem é uma segunda stack forte para quem já programa e quer serviços mais previsíveis. Para decidir se vale o investimento, leia vale a pena aprender Go em 2026 e confira vagas Go e empresas que usam Go.

1. Instale o Go (Windows, macOS e Linux)

A fonte oficial é sempre go.dev/dl. No momento da publicação deste site, o card de versão aponta Go 1.26.5 — use a estável mais recente listada no site oficial se a página de download já tiver avançado.

Windows

1. Baixe o instalador .msi em go.dev/dl.
2. Execute o instalador (o PATH costuma ser configurado automaticamente).
3. Abra um novo PowerShell ou terminal e rode:

go version

macOS

# Homebrew
brew install go

go version

Alternativa: baixe o pacote oficial em go.dev/dl e siga o instalador.

Linux

Prefira o tarball oficial (as versões dos repositórios da distro costumam atrasar):

# Exemplo — ajuste a URL pela versão atual em go.dev/dl
curl -LO https://go.dev/dl/go1.26.5.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.26.5.linux-amd64.tar.gz

# Adicione ao ~/.bashrc ou ~/.zshrc
export PATH=$PATH:/usr/local/go/bin

Recarregue o shell (source ~/.bashrc) e confira:

go version
# go version go1.26.5 linux/amd64

Editor

Qualquer editor serve. VS Code + extensão oficial Go (ou GoLand) dá autocomplete, gopls e debug. No começo, o importante é conseguir rodar go run no terminal.

2. Crie o módulo e o Hello World

Go moderno usa módulos (go.mod). Esqueça o antigo GOPATH como pasta obrigatória de código.

mkdir hello-go && cd hello-go
go mod init exemplo.com/hello

Crie main.go:

package main

import "fmt"

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

Execute:

go run .
# Olá, Go!

Ou compile um binário:

go build -o hello .
./hello

O que cada linha significa

Se o compilador reclamar de import não usado ou variável não usada, isso é intencional: Go recusa código morto cedo. Guarde a cheatsheet de sintaxe aberta nos primeiros dias.

3. Variáveis, tipos e zero values

package main

import "fmt"

func main() {
	var nome string = "Maria"
	var idade int = 25
	cidade := "São Paulo" // declaração curta (mais comum dentro de funções)

	fmt.Println(nome, idade, cidade)

	var contador int // zero value = 0
	var ativo bool   // zero value = false
	fmt.Println(contador, ativo)
}

Tipos que você vai usar o tempo todo:

Go não faz conversão implícita entre tipos numéricos: int e int64 são distintos. Isso evita surpresas e força clareza.

4. if, for e switch (sem while)

Só existe for — ele cobre contador, condição e loop infinito.

package main

import "fmt"

func main() {
	idade := 18
	if idade >= 18 {
		fmt.Println("maior de idade")
	} else {
		fmt.Println("menor de idade")
	}

	for i := 0; i < 3; i++ {
		fmt.Println("contador:", i)
	}

	n := 0
	for n < 3 { // estilo while
		fmt.Println("n:", n)
		n++
	}

	switch cidade := "São Paulo"; cidade {
	case "São Paulo", "Campinas":
		fmt.Println("SP")
	default:
		fmt.Println("outra")
	}
}

5. Funções e o padrão de erro

Funções são de primeira classe. O idioma mais importante de Go é retornar (resultado, error) e checar err != nil na hora — sem exceções silenciosas.

package main

import (
	"fmt"
	"errors"
)

func soma(a, b int) int {
	return a + b
}

func divide(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("divisão por zero")
	}
	return a / b, nil
}

func main() {
	fmt.Println(soma(5, 3))

	resultado, err := divide(10, 2)
	if err != nil {
		fmt.Println("erro:", err)
		return
	}
	fmt.Println(resultado)
}

Quando o código crescer, leia o guia de erros em Go e a página de interfaces. Para bugs clássicos de compilação, a seção erros lista mensagens frequentes com correção.

6. Seu primeiro servidor HTTP (a meta dos 15 minutos)

O seo_title desta página promete chegar num servidor HTTP — e a stdlib entrega isso sem framework:

package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, Gopher!")
	})

	log.Println("ouvindo em http://localhost:8080")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		log.Fatal(err)
	}
}

Rode:

go run .

Abra http://localhost:8080 no navegador. Você acabou de:

• registrar uma rota com HandleFunc;
• escrever a resposta no http.ResponseWriter;
• bloquear o processo em ListenAndServe até Ctrl+C.

Mini API JSON (passo seguinte natural)

package main

import (
	"encoding/json"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
	})

	log.Fatal(http.ListenAndServe(":8080", nil))
}

A partir daqui, o caminho de backend no site é claro: API REST com Go, Go para backend, PostgreSQL com Go e, em produção, middleware e Chi.

7. Comandos que você vai digitar todo dia

Detalhes de módulos: Go Modules na prática. Testes: testes em Go.

8. Exercícios (faça antes de pular para o framework)

1. Programa que imprime de 1 a 20 e marca os pares.
2. Função ehPrimo(n int) bool com testes mentais (2, 3, 4, 17).
3. Calculadora de linha de comando: go run . soma 2 3.
4. Servidor HTTP com duas rotas: / e /hora (use time.Now()).
5. Endpoint /eco que devolve o query param ?msg= em JSON.

Se travar num erro do compilador, busque a mensagem em erros comuns de Go — várias páginas existem só para isso.

9. Trilha recomendada depois deste guia

Ordem que funciona para a maioria dos iniciantes no mercado brasileiro de backend:

1. Fundamentos — este guia + primeiros passos + cheatsheet.
2. Mapa de estudo — como aprender Go e roadmap Go 2026.
3. Curso modular — curso Golang gratuito.
4. HTTP de verdade — API REST em Go.
5. Qualidade — testes e erros.
6. Concorrência — concorrência em Go.
7. Mercado — perguntas de entrevista, salários e vagas.

Quem vem de outra linguagem pode comparar stacks em Go vs Python, Go vs Java e Go vs Node sem abandonar o que já sabe.

Erros comuns de quem está começando

• Usar GOPATH como se fosse 2017 — trabalhe com módulos (go.mod) na pasta do projeto.
• Ignorar err — _ = algo() esconde falha; cheque ou documente por que é seguro ignorar.
• Instalar Go só pelo apt antigo — confira go version e prefira o tarball oficial.
• Pular direto para Gin/Echo — entenda net/http primeiro; frameworks ficam mais claros depois.
• Não formatar — rode go fmt ./... (ou deixe o editor fazer) antes de pedir ajuda.
• Copiar tutorial com versão 1.18 e travar em features novas — confira a versão local; generics e o toolchain evoluíram desde então.

Recursos oficiais (em inglês) e material em português

• Tour of Go — tutorial interativo no navegador.
• Go by Example — snippets curtos.
• Documentação oficial — e o guia local de documentação Go em português.
• Comunidade: comunidade Go no Brasil e eventos.

Conclusão

Go para iniciantes não exige framework, Docker nem microsserviço no primeiro dia. Exige um go version limpo, um main.go honesto e a curiosidade de abrir localhost:8080. Com Hello World, variáveis, funções com error e um handler HTTP, você já tem a base que o mercado espera antes de falar em Chi, PostgreSQL ou Kubernetes.

Continue no como aprender Go, monte a primeira API em API REST com Go e, quando quiser medir o mercado, olhe salários de desenvolvedor Go e as vagas abertas.