Como você declara variáveis e quais são os tipos básicos do Go?

Question

Accepted Answer

Go é estaticamente tipado com várias maneiras de declarar variáveis. A mais comum é a **declaração curta** `:=`, que infere o tipo. Os tipos básicos do Go cobrem números, strings, booleanos e muito mais.

## Declarando variáveis

```go
var x int = 42        // full form: explicit type and value
var y = 42            // type inferred → int
var z int             // declared, ZERO-valued (z = 0)

name := "Ann"         // short declaration (:=) — infers type, INSIDE functions only
count := 10

var a, b = 1, "two"   // multiple at once
const Pi = 3.14159     // constant (compile-time)
```

`:=` é a maneira idiomatic dentro de funções — concisa com inferência de tipo. `var` é usada no nível de pacote e quando você quer um tipo explícito ou apenas o valor zero.

## Os tipos básicos

```go
// integers
int, int8, int16, int32, int64     // signed (int is platform-sized, usually 64-bit)
uint, uint8, ..., uint64           // unsigned
byte                                // alias for uint8
rune                                // alias for int32 — a Unicode code point

// floating point
float32, float64                    // float64 is the default for decimals

// others
string                              // immutable UTF-8 text
bool                               // true / false
complex64, complex128              // complex numbers
```

## Valores zero — sem variáveis "não inicializadas"

```go
var i int       // 0
var f float64   // 0.0
var s string    // "" (empty)
var b bool      // false
var p *int      // nil
```

Uma característica crucial do Go: toda variável declarada recebe um **valor zero** sensato automaticamente — não há valores indefinidos/garbage. Isso torna o código mais seguro e significa que você pode frequentemente pular a inicialização explícita.

## Conversões de tipo são explícitas

```go
var i int = 42
var f float64 = float64(i)   // MUST convert explicitly — no implicit coercion
var u uint = uint(f)
// i + f  → ❌ compile error: mismatched types
```

Go requer conversões de tipo **explícitas** — nunca mistura tipos implicitamente, prevenindo uma classe de bugs sutis.

## Por que isso importa

Compreender as declarações de variáveis e tipos do Go é fundamental para escrever qualquer código em Go.

A declaração curta idiomatic `:=` com inferência mantém o código conciso, enquanto `var` e constantes servem seus propósitos.

A **garantia de valor zero** (toda variável é inicializada com segurança) é uma característica distintiva e importante do Go que elimina bugs de variáveis não inicializadas e molda padrões idiomáticos (por exemplo, uma struct com valor zero geralmente é utilizável).

E a insistência do Go em **conversões de tipo explícitas** (sem coerção implícita) é uma escolha deliberada de segurança que previne o tipo de bug numérico silencioso que outras linguagens permitem.

Conhecer os tipos básicos (especialmente `rune` para Unicode, `byte`, e que `int`/`float64` são os padrões) é conhecimento essencial do dia a dia.