Golang

Variáveis, tipos primitivos e declaração curta

Nathan Geeksman 4 visualizações

Artigo 03 — Variáveis, tipos primitivos e declaração curta

Curso: Dominando Go em 1 Ano Prof. Ricardo Matos Módulo 1 — Fundamentos da Linguagem

O sistema de tipos do Go é sua primeira linha de defesa

Go é uma linguagem estaticamente tipada. Isso significa que o tipo de cada variável é conhecido em tempo de compilação, e o compilador rejeita qualquer operação que viole as regras de tipos antes mesmo do programa ser executado. Esse comportamento elimina uma classe inteira de erros que em linguagens dinamicamente tipadas só aparecem em produção.

Ao mesmo tempo, Go oferece inferência de tipos — em muitos casos você não precisa escrever o tipo explicitamente, pois o compilador consegue deduzi-lo a partir do valor atribuído. O resultado é um código seguro sem ser verboso.

Declarando variáveis com var

A forma mais explícita de declarar uma variável em Go usa a palavra-chave var:

package main

import "fmt"

func main() {
    var nome string
    var idade int
    var altura float64
    var ativo bool

    nome = "Ricardo"
    idade = 35
    altura = 1.78
    ativo = true

    fmt.Println(nome, idade, altura, ativo)
}

Quando uma variável é declarada sem valor inicial, Go automaticamente atribui o valor zero do tipo correspondente:

  • int → 0
  • float64 → 0.0
  • string → "" (string vazia)
  • bool → false
  • ponteiros, slices, maps, funções → nil

Esse comportamento é intencional e previsível. Em Go não existe o conceito de variável "não inicializada" com valor indefinido — toda variável tem um valor zero bem definido.

Declaração com valor inicial

É possível declarar e inicializar na mesma linha:

var nome string = "Ricardo"
var idade int = 35

Quando o valor inicial é fornecido, o tipo pode ser omitido — o compilador infere:

var nome = "Ricardo"   // inferido como string
var idade = 35         // inferido como int
var altura = 1.78      // inferido como float64
var ativo = true       // inferido como bool

A declaração curta com :=

Dentro de funções, a forma mais comum e idiomática de declarar variáveis em Go é o operador :=. Ele declara e inicializa ao mesmo tempo, com inferência de tipo automática:

package main

import "fmt"

func main() {
    nome := "Ricardo"
    idade := 35
    altura := 1.78
    ativo := true

    fmt.Println(nome, idade, altura, ativo)
}

O := só pode ser usado dentro de funções. No escopo de pacote (fora de funções), apenas var é permitido. Essa é uma regra que confunde iniciantes — vale fixá-la desde já.

Outro detalhe importante: o := exige que pelo menos uma das variáveis do lado esquerdo seja nova. O código abaixo compila porque b é nova, mesmo que a já exista:

a := 10
a, b := 20, 30  // válido: b é nova
fmt.Println(a, b)

Declaração múltipla

Go permite declarar várias variáveis de uma vez, o que é útil para agrupar variáveis relacionadas:

var (
    servidor string = "localhost"
    porta    int    = 5432
    ssl      bool   = true
)

Ou com declaração curta:

x, y, z := 10, 20, 30
fmt.Println(x, y, z)

Constantes com const

Quando um valor não deve mudar durante a execução do programa, use const em vez de var:

const Pi = 3.14159
const MaxTentativas = 5
const NomeDaAplicacao = "MinhaAPI"

Constantes em Go são avaliadas em tempo de compilação. Elas podem ser de tipos numéricos, string ou bool. Não é possível usar o resultado de uma função como valor de constante — o valor precisa ser conhecido antes da execução.

O identificador iota

Go oferece um recurso elegante para criar sequências de constantes inteiras relacionadas, chamado iota. Dentro de um bloco const, iota começa em zero e incrementa a cada linha:

const (
    Domingo = iota  // 0
    Segunda         // 1
    Terca           // 2
    Quarta          // 3
    Quinta          // 4
    Sexta           // 5
    Sabado          // 6
)

fmt.Println(Domingo, Segunda, Sabado) // 0 1 6

É possível usar expressões com iota:

const (
    KB = 1 << (10 * (iota + 1))  // 1024
    MB                            // 1048576
    GB                            // 1073741824
)

Tipos primitivos em detalhe

Go possui um conjunto rico de tipos numéricos, o que permite escolher o mais adequado para cada situação.

Inteiros com sinal:

var a int8   = 127          // -128 a 127
var b int16  = 32767        // -32768 a 32767
var c int32  = 2147483647
var d int64  = 9223372036854775807
var e int    = 100          // tamanho depende da arquitetura (32 ou 64 bits)

Inteiros sem sinal:

var a uint8  = 255
var b uint16 = 65535
var c uint32 = 4294967295
var d uint64 = 18446744073709551615
var e uint   = 100

Ponto flutuante:

var f32 float32 = 3.14
var f64 float64 = 3.141592653589793

Na prática, float64 é o tipo padrão para números decimais em Go. Use float32 apenas quando o consumo de memória for uma preocupação concreta.

Números complexos:

var c1 complex64  = 1 + 2i
var c2 complex128 = 3.5 + 4.2i

Booleano:

var verdadeiro bool = true
var falso bool = false

String:

var saudacao string = "Olá, mundo"

Strings em Go são imutáveis e codificadas em UTF-8 por padrão. Isso significa que caracteres como ã, ç e é são tratados corretamente sem nenhuma configuração adicional.

byte e rune:

var b byte = 'A'    // alias para uint8, representa um byte
var r rune = 'ã'    // alias para int32, representa um ponto Unicode

A distinção entre byte e rune é importante ao trabalhar com strings que contêm caracteres multibyte. Um caractere ã, por exemplo, ocupa 2 bytes em UTF-8, mas corresponde a um único rune.

Conversão de tipos

Go não faz conversões implícitas entre tipos numéricos. Toda conversão precisa ser explícita:

var inteiro int = 42
var flutuante float64 = float64(inteiro)
var pequeno int8 = int8(inteiro)

fmt.Println(inteiro, flutuante, pequeno)

Tentar somar um int com um float64 diretamente causa erro de compilação. Isso é intencional: o compilador força o programador a ser explícito sobre o que está fazendo.

var a int = 10
var b float64 = 3.5

// Isso causa erro:
// resultado := a + b

// Correto:
resultado := float64(a) + b
fmt.Println(resultado) // 13.5

A variável em branco _

Go exige que toda variável declarada seja usada. Caso contrário, o compilador emite um erro. Para os casos em que você precisa descartar um valor — por exemplo, quando uma função retorna múltiplos valores e você só precisa de alguns — use o identificador especial _:

package main

import "fmt"

func coordenadas() (float64, float64) {
    return -23.55, -46.63
}

func main() {
    latitude, _ := coordenadas()
    fmt.Println("Latitude:", latitude)
}

O _ não é uma variável de verdade — é um destino de descarte. Valores atribuídos a ele são ignorados pelo compilador.

Escopo de variáveis

O escopo em Go segue as chaves {}. Uma variável declarada dentro de um bloco não existe fora dele:

func main() {
    x := 10

    if x > 5 {
        y := 20
        fmt.Println(x, y) // funciona
    }

    // fmt.Println(y) — erro: y não existe aqui
}

Variáveis declaradas no escopo de pacote (fora de funções) existem durante toda a execução do programa e são acessíveis em qualquer função do mesmo pacote.

Resumo do que foi coberto

Neste artigo foram apresentadas as formas de declarar variáveis em Go — var, := e const — junto com o conceito de valor zero, inferência de tipos, o operador iota e todos os tipos primitivos da linguagem. A conversão explícita de tipos e o identificador _ completam o conjunto de ferramentas essenciais para trabalhar com dados em Go.

Referências e leituras complementares

Próximo artigo: Artigo 04 — Operadores, expressões e conversão de tipos

you asked

Sim

claude response