---
title: "Primeiros Passos com Go"
url: "https://golang.com.br/aprenda/primeiros-passos/"
markdown_url: "https://golang.com.br/aprenda/primeiros-passos.MD"
description: "Tutorial de 5 minutos para começar com Go: download, instalação, GOPATH, primeiro programa Hello World e seu primeiro servidor HTTP. Guia para iniciantes completos."
date: "2026-01-30"
author: ""
---

# Primeiros Passos com Go

Tutorial de 5 minutos para começar com Go: download, instalação, GOPATH, primeiro programa Hello World e seu primeiro servidor HTTP. Guia para iniciantes completos.


# 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)

```bash
# 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

```bash
# Com Homebrew
brew install go

# Ou baixe de https://go.dev/dl/
```

### Windows

Baixe o instalador MSI em [go.dev/dl](https://go.dev/dl/) e execute.

### Verificando a Instalação

```bash
go version
# go version go1.23.4 linux/amd64
```

## 2. Seu Primeiro Programa

Crie um arquivo `hello.go`:

```go
package main

import "fmt"

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

Execute:

```bash
go run hello.go
# Olá, Mundo!
```

## 3. Entendendo o Código

```go
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:

```bash
# 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

```go
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

```go
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)

```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

```go
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

```go
// 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

1. [Tour of Go](https://go.dev/tour/) — tutorial interativo oficial
2. [Go by Example](https://gobyexample.com/) — exemplos práticos
3. [Effective Go](https://go.dev/doc/effective_go) — boas práticas
4. [Perguntas de Entrevista Go](/aprenda/perguntas-entrevista-go/) — prepare-se para entrevistas

---

*Última atualização: Janeiro 2026*