---
title: "Cheatsheet Go: Sintaxe Básica e Tipos"
url: "https://golang.com.br/cheatsheet/sintaxe-basica/"
markdown_url: "https://golang.com.br/cheatsheet/sintaxe-basica.MD"
description: "Referência rápida da sintaxe Go: variáveis, tipos de dados, constantes, operadores, controle de fluxo e funções. Exemplos prontos para copiar e colar."
date: "2026-05-12"
author: "Golang Brasil"
---

# Cheatsheet Go: Sintaxe Básica e Tipos

Referência rápida da sintaxe Go: variáveis, tipos de dados, constantes, operadores, controle de fluxo e funções. Exemplos prontos para copiar e colar.


# Sintaxe Básica do Go — Referência Rápida

Esta página é uma referência rápida da sintaxe fundamental do Go. Use como cola para consultas do dia a dia. Para um tutorial passo a passo, veja [Go para Iniciantes](/aprenda/go-para-iniciantes/) ou [Primeiros Passos com Go](/aprenda/primeiros-passos/).

---

## Variáveis

| Forma | Sintaxe | Onde funciona |
|-------|---------|---------------|
| Declaração explícita | `var nome string = "Ana"` | Qualquer escopo |
| Tipo inferido | `var idade = 30` | Qualquer escopo |
| Declaração curta | `nome := "Ana"` | Apenas dentro de funções |
| Múltiplas | `var a, b int = 1, 2` | Qualquer escopo |
| Bloco var | `var ( ... )` | Qualquer escopo |
| Zero value | `var x int` → `0` | Qualquer escopo |

```go
package main

import "fmt"

func main() {
	// Declaração curta (mais comum)
	nome := "Go"
	versao := 1.26

	// Declaração explícita
	var ativo bool = true

	// Bloco de variáveis
	var (
		host  string = "localhost"
		porta int    = 8080
	)

	fmt.Println(nome, versao, ativo, host, porta)
}
```

O **zero value** é o valor padrão de cada tipo: `0` para numéricos, `""` para strings, `false` para bool e `nil` para ponteiros, slices, maps, channels e interfaces. Veja mais em [variáveis no glossário](/glossario/variable/).

---

## Constantes

```go
package main

import "fmt"

const Pi = 3.14159

const (
	StatusOK       = 200
	StatusNotFound = 404
)

// iota: enumerador auto-incrementado
const (
	Domingo = iota // 0
	Segunda        // 1
	Terca          // 2
	Quarta         // 3
)

func main() {
	fmt.Println(Pi, StatusOK, Domingo, Segunda)
}
```

Constantes em Go são avaliadas em tempo de compilação. Veja [constantes no glossário](/glossario/constant/) para mais detalhes.

---

## Tipos de Dados

### Tipos Numéricos

| Tipo | Tamanho | Faixa |
|------|---------|-------|
| `int8` | 8 bits | -128 a 127 |
| `int16` | 16 bits | -32.768 a 32.767 |
| `int32` | 32 bits | -2¹⁵ a 2³¹-1 |
| `int64` | 64 bits | -2⁶³ a 2⁶³-1 |
| `int` | 32 ou 64 bits | Depende da plataforma |
| `uint8` (`byte`) | 8 bits | 0 a 255 |
| `uint16` | 16 bits | 0 a 65.535 |
| `uint32` | 32 bits | 0 a 2³²-1 |
| `uint64` | 64 bits | 0 a 2⁶⁴-1 |
| `float32` | 32 bits | IEEE-754 |
| `float64` | 64 bits | IEEE-754 (padrão) |
| `complex64` | 64 bits | float32 + float32 |
| `complex128` | 128 bits | float64 + float64 |

### Outros Tipos Básicos

| Tipo | Descrição |
|------|-----------|
| `bool` | `true` ou `false` |
| `string` | Sequência de bytes UTF-8, imutável |
| `byte` | Alias para `uint8` |
| `rune` | Alias para `int32`, representa um code point Unicode |

Veja mais sobre [runes](/glossario/rune/) e [strings](/glossario/string/) no glossário.

---

## Operadores

### Aritméticos

| Operador | Descrição | Exemplo |
|----------|-----------|---------|
| `+` | Soma | `5 + 3` → `8` |
| `-` | Subtração | `5 - 3` → `2` |
| `*` | Multiplicação | `5 * 3` → `15` |
| `/` | Divisão | `10 / 3` → `3` (inteiros) |
| `%` | Módulo | `10 % 3` → `1` |

### Comparação

| Operador | Descrição |
|----------|-----------|
| `==` | Igual |
| `!=` | Diferente |
| `<`, `>` | Menor / Maior |
| `<=`, `>=` | Menor ou igual / Maior ou igual |

### Lógicos

| Operador | Descrição |
|----------|-----------|
| `&&` | E (AND) |
| `\|\|` | OU (OR) |
| `!` | NÃO (NOT) |

### Bitwise

| Operador | Descrição |
|----------|-----------|
| `&` | AND |
| `\|` | OR |
| `^` | XOR |
| `<<` | Shift left |
| `>>` | Shift right |
| `&^` | AND NOT (bit clear) |

---

## Controle de Fluxo

### if / else

```go
package main

import "fmt"

func main() {
	x := 42

	if x > 0 {
		fmt.Println("positivo")
	} else if x < 0 {
		fmt.Println("negativo")
	} else {
		fmt.Println("zero")
	}

	// if com inicialização (idiomático em Go)
	if v := calcular(); v > 100 {
		fmt.Println("acima de 100:", v)
	}
}

func calcular() int { return 150 }
```

O padrão `if err != nil` é a base do [tratamento de erros em Go](/aprenda/golang-erros/). Veja também os [erros comuns](/erros/) para referência.

### switch

```go
package main

import "fmt"

func main() {
	dia := "terça"

	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")
	}

	// Switch sem expressão (substitui if/else if)
	nota := 85
	switch {
	case nota >= 90:
		fmt.Println("A")
	case nota >= 80:
		fmt.Println("B")
	case nota >= 70:
		fmt.Println("C")
	default:
		fmt.Println("F")
	}
}
```

Em Go, cada `case` tem `break` implícito. Use `fallthrough` se precisar continuar para o próximo case.

### for (o único loop)

```go
package main

import "fmt"

func main() {
	// for clássico
	for i := 0; i < 5; i++ {
		fmt.Print(i, " ")
	}

	// estilo "while"
	n := 1
	for n < 100 {
		n *= 2
	}

	// loop infinito
	// for { break }

	// range sobre slice
	frutas := []string{"maçã", "banana", "uva"}
	for i, fruta := range frutas {
		fmt.Printf("%d: %s\n", i, fruta)
	}

	// range ignorando índice
	for _, fruta := range frutas {
		fmt.Println(fruta)
	}
}
```

Para iterar sobre maps e channels, veja o [cheatsheet de slices, maps e structs](/cheatsheet/slices-maps-structs/) e o [cheatsheet de concorrência](/cheatsheet/concorrencia/).

---

## Funções

```go
package main

import (
	"errors"
	"fmt"
)

// Função simples
func soma(a, b int) int {
	return a + b
}

// Múltiplos retornos (idiomático para erros)
func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("divisão por zero")
	}
	return a / b, nil
}

// Retornos nomeados
func limites(nums []int) (min, max int) {
	min, max = nums[0], nums[0]
	for _, n := range nums {
		if n < min {
			min = n
		}
		if n > max {
			max = n
		}
	}
	return
}

// Variadic (número variável de argumentos)
func somaAll(nums ...int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}

// Função como valor
var dobro = func(x int) int { return x * 2 }

func main() {
	fmt.Println(soma(3, 4))
	fmt.Println(divide(10, 3))
	fmt.Println(limites([]int{3, 1, 4, 1, 5}))
	fmt.Println(somaAll(1, 2, 3, 4, 5))
	fmt.Println(dobro(21))
}
```

Funções em Go são cidadãs de primeira classe — podem ser atribuídas a variáveis, passadas como argumentos e retornadas de outras funções. Veja [func no glossário](/glossario/func/).

---

## Ponteiros

```go
package main

import "fmt"

func main() {
	x := 42
	p := &x    // p é um ponteiro para x
	fmt.Println(*p)  // 42 — desreferencia o ponteiro
	*p = 100
	fmt.Println(x)   // 100 — x foi alterado via ponteiro
}

func incrementar(val *int) {
	*val++
}
```

| Operação | Sintaxe | Descrição |
|----------|---------|-----------|
| Endereço | `&x` | Obtém ponteiro para x |
| Desreferência | `*p` | Acessa valor apontado |
| Tipo ponteiro | `*int` | Ponteiro para int |
| Zero value | `nil` | Ponteiro não inicializado |

Cuidado com o [nil pointer dereference](/erros/nil-pointer-dereference/) — um dos erros mais comuns em Go. Veja também [ponteiros no glossário](/glossario/pointer/).

---

## Defer

```go
package main

import (
	"fmt"
	"os"
)

func main() {
	f, err := os.Open("arquivo.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close() // executa quando main() retorna

	// usar f normalmente...
}
```

`defer` empilha chamadas (LIFO) e é essencial para liberar recursos. Veja [defer no glossário](/glossario/defer/) e [panic/recover](/glossario/recover/) para tratamento avançado.

---

## Pacotes e Imports

```go
package main

import (
	"fmt"
	"math"
	"strings"
)

func main() {
	fmt.Println(math.Sqrt(16))
	fmt.Println(strings.ToUpper("hello"))
}
```

| Sintaxe | Descrição |
|---------|-----------|
| `import "fmt"` | Import simples |
| `import ( ... )` | Import agrupado |
| `import . "fmt"` | Importa tudo para o escopo atual |
| `import _ "pkg"` | Importa apenas pelo side effect (init) |
| `import alias "pkg"` | Importa com alias |

Variáveis e funções declaradas e não usadas causam erro de compilação — veja [declared and not used](/erros/declared-not-used/) e [undefined variable](/erros/undefined-variable-function/).

Para gerenciar dependências, veja o [guia de Go Modules](/aprenda/go-modules/) e [Go Modules na prática](/aprenda/go-modules-na-pratica/). Se quiser comparar a sintaxe de Go com outras linguagens de sistemas, confira os guias de <a href="https://rustlang.com.br/blog/" target="_blank" rel="noopener noreferrer" onclick="umami.track('portfolio-site-click', { destination: 'rustlang.com.br' })">Rust</a> e <a href="https://ziglang.com.br/" target="_blank" rel="noopener noreferrer" onclick="umami.track('portfolio-site-click', { destination: 'ziglang.com.br' })">Zig</a>.

---

## Veja Também

- [Cheatsheet: Concorrência](/cheatsheet/concorrencia/) — Goroutines, channels e sync
- [Cheatsheet: Slices, Maps e Structs](/cheatsheet/slices-maps-structs/) — Estruturas de dados
- [Cheatsheet: Strings e Formatação](/cheatsheet/strings-formatacao/) — fmt, strconv e strings
- [Cheatsheet: Testes e Debug](/cheatsheet/testing-debug/) — Testing e profiling
- [Como Aprender Go](/aprenda/como-aprender-go/) — Guia completo de estudo
- [Roadmap Go 2026](/aprenda/roadmap-go-2026/) — Caminho de aprendizagem