Variáveis e constantes

Nomeando valores

Todo programa trabalha com valores. Alguns desses valores mudam enquanto o programa executa — um contador que incrementa, um status que passa de pendente para completo. Outros nunca mudam — um número máximo de tentativas, o valor de pi, o nome de uma aplicação.

Go oferece duas ferramentas para nomear valores: variáveis para coisas que mudam, e constantes para coisas que não mudam.

Variáveis

Uma variável é um espaço de armazenamento com nome. Seu valor pode ser reatribuído a qualquer momento durante a execução do programa.

A keyword var

A forma mais explícita de declarar uma variável é com a keyword var, seguida do nome, do tipo e, opcionalmente, de um valor inicial:

var age int          // declarada com zero value: 0
var name string      // zero value: ""
var active bool      // zero value: false
var score int = 100  // declarada com valor explícito

Quando você declara uma variável sem atribuir um valor, Go a inicializa com seu zero value — o valor padrão para aquele tipo. Todo tipo tem um: 0 para inteiros, 0.0 para floats, false para booleanos, "" para strings. Não existe variável não inicializada em Go.

Se você fornecer um valor inicial, Go consegue inferir o tipo — não é necessário declará-lo explicitamente:

var age = 30           // inferido como int
var greeting = "Hello" // inferido como string

Short variable declaration

Dentro de uma função, você pode omitir tanto o var quanto o tipo usando o operador :=. Ele declara e inicializa a variável em um único passo:

age := 30
greeting := "Hello"
isActive := true

O tipo é sempre inferido do lado direito. Short declarations são a forma mais comum de declaração de variável em Go — são concisas e mantêm as funções legíveis.

Uma restrição importante: := não pode ser usado em package level. Ele só é válido dentro de funções.

package main

counter := 0 // compile error: não está dentro de uma função

func main() {
    counter := 0 // correto
}

Reatribuição e reutilização do :=

:= exige que ao menos uma variável do lado esquerdo seja nova. Isso permite reutilizá-lo ao declarar uma nova variável junto com uma já existente:

x := 10
x, y := 20, 30 // válido: y é nova, x é reatribuído

Se todas as variáveis do lado esquerdo já existem, use = para reatribuição:

x := 10
x = 20 // reatribuição, não uma nova declaração

Múltiplas variáveis

Você pode declarar múltiplas variáveis em uma única linha:

var x, y, z int = 1, 2, 3
a, b := "hello", true

Ou agrupá-las em um bloco var — comum para declarações relacionadas no topo de uma função ou em package level:

var (
    host    = "localhost"
    port    = 8080
    timeout = 30
)

Package-level vs function-level

Variáveis podem ser declaradas em dois escopos:

Variáveis package-level são declaradas fora de qualquer função. Elas são acessíveis em todo o package e inicializadas antes de main executar.

Variáveis function-level são declaradas dentro de uma função. Elas existem apenas durante aquela chamada de função e são invisíveis fora dela.

package main

var serverHost = "localhost" // package-level

func connect() {
    port := 5432 // function-level
    fmt.Println(serverHost, port)
}

Constantes

Uma constante é um valor com nome que não pode mudar após ser definido. Ela não é uma variável com proteção — é avaliada inteiramente em tempo de compilação e nunca ocupa um espaço de memória em runtime.

A keyword const

Constantes são declaradas com const:

const maxRetries = 3
const appName = "MyApp"
const pi = 3.14159265358979

Assim como variáveis, constantes suportam declarações agrupadas:

const (
    maxRetries = 3
    timeout    = 30
    appName    = "MyApp"
)

O que pode ser uma constante

Nem todo valor se qualifica como constante. O compilador precisa ser capaz de determinar seu valor antes de o programa executar. Valores válidos incluem:

• Literais booleanos: true, false
• Literais inteiros, float e complex
• Literais string e rune
• Expressões avaliáveis em tempo de compilação: 1 << 8, 2 * 3.14, 1 < 2
• Chamadas a certas funções built-in: len, cap, real, imag, complex

const bufferSize = 1 << 8  // 256
const isDebug = false
const greeting = "Hello"
const alwaysTrue = 1 < 2   // avaliado em compile time — true

Chamadas a funções que produzem valores em runtime — como ler um arquivo ou chamar time.Now() — não podem ser usadas como constantes.

Typed e untyped constants

Constantes em Go existem em duas formas: typed e untyped.

Uma typed constant carrega um tipo explícito e só pode ser atribuída diretamente a uma variável daquele mesmo tipo:

const maxRetries int = 3

var x int   = maxRetries // correto
var y int64 = maxRetries // compile error: não pode usar maxRetries como int64

Uma untyped constant não tem tipo fixo. Ela carrega um kind (inteiro, float, string ou booleano) e se adapta ao tipo esperado no ponto de uso:

const maxRetries = 3 // untyped integer constant

var x int     = maxRetries // correto
var y int64   = maxRetries // correto — adapta para int64
var z float64 = maxRetries // correto — adapta para float64

iota

Quando você precisa de uma sequência de constantes inteiras relacionadas, Go fornece o iota — um contador que começa em zero e incrementa em um a cada entrada no bloco:

const (
    Sunday    = iota // 0
    Monday           // 1
    Tuesday          // 2
    Wednesday        // 3
    Thursday         // 4
    Friday           // 5
    Saturday         // 6
)

iota é resetado para zero no início de cada novo bloco const. É a forma idiomática de definir enumerações em Go.

Variáveis vs constantes

Tanto variáveis quanto constantes podem ser declaradas em package level ou function level, e ambas suportam declarações agrupadas com chaves. As diferenças são mais significativas do que parecem:

A regra sobre variáveis não utilizadas merece destaque: uma variável local declarada mas nunca referenciada é um erro de compilação. Constantes são sempre isentas — podem existir puramente para documentação ou uso futuro sem que o compilador objete.