Forem: Renato O da Silva

Zero Values em Go: o que toda variável traz de fábrica

Renato O da Silva — Sat, 09 May 2026 16:33:02 +0000

Em outras linguagens é muito comum variáveis serem inicializadas com undefined ou null.
Em Go toda variável já nasce com um valor. No qual é chamado de Zero Value.

Conceito

Em Go, declarar uma variável sem atribuir nada não é deixar ela "vazia". A linguagem coloca um valor padrão lá. Esse valor depende do tipo.

var x int
var s string
var b bool

fmt.Println(x, s, b) // 0  false

Nesse caso não temos lixo de memória, nem undefined ou null, temos um valor pré-definido.

Tabela rápida

Para consultar quando bater dúvida:

Tipo	Zero value
`bool`	`false`
inteiros (`int`, `int64`, `uint`...)	`0`
floats (`float32`, `float64`)	`0.0`
`string`	`""`
ponteiros (`*T`)	`nil`
slices (`[]T`)	`nil`
maps (`map[K]V`)	`nil`
channels (`chan T`)	`nil`
funções	`nil`
interfaces	`nil`
arrays (`[N]T`)	array com cada posição no zero value
structs	struct com cada campo no zero value

Por que isso é bom

Segurança de memória

Em C, ler uma variável não inicializada devolve qualquer coisa que estava em memória naquele momento. Em Go isso não acontece. O compilador garante o valor inicial.

O famoso "useful zero value"

A biblioteca padrão é desenhada para que muitos tipos funcionem direto, sem precisar inicializar nada:

var b bytes.Buffer
b.WriteString("oi")        // funciona

var mu sync.Mutex
mu.Lock()                  // funciona

var wg sync.WaitGroup
wg.Add(1)                  // funciona

Isso elimina uma porção de construtores que outras linguagens exigem.

Cuidados com tipos nil

Nem todo zero value é inofensivo. Slices, maps e channels têm nil como zero value, e cada um se comporta de um jeito quando usado nesse estado.

Slice nil

Slice nil aceita len, aceita range e aceita append. Por isso quase sempre dá para tratar igual a slice vazio:

var s []int
fmt.Println(len(s))   // 0
s = append(s, 1)      // funciona, vira []int{1}

A diferença aparece se você comparar com nil:

var a []int
b := []int{}

fmt.Println(a == nil)   // true
fmt.Println(b == nil)   // false

Map nil

Aqui já muda de figura. Você pode ler de um map nil (volta o zero value do tipo do valor), mas escrever quebra o programa:

var m map[string]int
v := m["chave"]    // ok, v == 0
m["chave"] = 1     // panic: assignment to entry in nil map

Antes de escrever em um map, sempre make:

m := make(map[string]int)

Channel nil

Channel nil bloqueia para sempre, tanto envio quanto recebimento. Parece bug, mas é útil dentro de select para desligar um case sob demanda.

Structs

Um struct também tem zero value. Cada campo recebe o zero value respectivo ao seu tipo.

type User struct {
    Name string
    Age  int
    Tags []string
}

var u User
// u.Name vale ""
// u.Age vale 0
// u.Tags vale nil

Se todos os campos forem comparáveis, dá para checar contra o zero value do tipo:

if u == (User{}) {
    fmt.Println("usuário ainda não preenchido")
}

Composite literal: `{}` não é igual a `nil`

Isso é um pequeno detalhe que confunde no início:

var a []int       // nil
b := []int{}      // não é nil, é vazio

var m map[string]int        // nil
n := map[string]int{}       // não é nil, está pronto pra escrever

Os dois têm len igual a zero, mas o segundo já está alocado.

A confusão clássica em JSON

Aqui é onde zero values mais confunde quem está integrando APIs.

type T struct {
    Name string
    Age  int
}

b, _ := json.Marshal(T{})
fmt.Println(string(b))
// {"Name":"","Age":0}

Atenção: json.Marshal retorna dois valores, []byte e error. Se você imprimir direto sem converter, vai aparecer um monte de número:

[123 34 78 97 109 101 ...] <nil>

Sempre string(b) ou fmt.Printf("%s\n", b).

A tag omitempty resolve em parte:

type T struct {
    Name string `json:"name,omitempty"`
    Age  int    `json:"age,omitempty"`
}

Mas aqui temos um problema. omitempty esconde qualquer zero value. Se Age for legitimamente 0, ou Active for legitimamente false, eles somem do JSON. Quem está do outro lado não sabe se o campo veio vazio ou se nunca foi enviado.

Como saber se o valor é zero de propósito

Esse é um problema comum em Go. Abaixo temos algumas alternativas.

1. Usar ponteiros

A solução mais comum em APIs REST é utilizar ponteiros, pois quando não inicializado, Go inicializa o campo com valor nil. Ponteiro com valor significa explícito, mesmo que o valor apontado seja zero.

type T struct {
    Name   *string `json:"name,omitempty"`
    Age    *int    `json:"age,omitempty"`
    Active *bool   `json:"active,omitempty"`
}

2. `omitzero` (Go 1.24+)

Tag nova com semântica mais clara. Resolve dois pontos cegos do omitempty:

Struct zero some. time.Time{} finalmente é tratado como vazio.
Respeita IsZero() em tipos próprios.

type T struct {
    Name string    `json:"name,omitzero"`
    Age  int       `json:"age,omitzero"`
    When time.Time `json:"when,omitzero"`
}

Para tipos próprios, basta implementar IsZero() bool:

type Money struct{ Cents int64 }

func (m Money) IsZero() bool { return m.Cents == 0 }

O que `omitzero` ainda NÃO resolve

omitzero continua sem distinguir zero explícito de zero por default em primitivos. Os dois são iguais em memória.

type T struct {
    Age    int  `json:"age,omitzero"`
    Active bool `json:"active,omitzero"`
}

// setando explicitamente:
t := T{Age: 0, Active: false}
b, _ := json.Marshal(t)
fmt.Println(string(b))   // {}

Mesmo escrevendo Age: 0 e Active: false na mão, o JSON sai vazio.

Podemos ter casos onde as propriedades podem ter valor false ou 0de forma proposital, podendo gerar um bug silencioso.

A saída é combinar com ponteiro:

type T struct {
    Age    *int  `json:"age,omitzero"`
    Active *bool `json:"active,omitzero"`
}

t := T{Age: ptr(0)}
// {"age":0}     ← preserva zero explícito

t2 := T{}
// {}            ← ausente de verdade

Se a diferença entre "ausente" e "zero explícito" importa pro consumidor da API, ponteiro é obrigatório, mesmo com omitzero.

Concluindo

Zero values são uma escolha de design que cabe bem com o estilo de Go: onde temos um comportamento previsível e com menos código de inicialização.
Devemos ter uma atenção redobrada quando estamos trabalhando com JSON onde campos podem ser omitidos, mesmo quando temos valores validos.

Referências

Go do zero: var vs :=

Renato O da Silva — Sat, 02 May 2026 20:02:45 +0000

Go tem duas formas de declarar variáveis: var e :=. Elas existem por motivos diferentes e têm regras diferentes. Saber quando cada uma se aplica evitamos erros bobos e código que não compila.

Sintaxe

`var` (forma longa)

var x int           // tipo explícito, recebe o zero value
var x int = 5       // tipo e valor
var x = 5           // valor com tipo inferido
var x, y = 1, 2     // múltiplas variáveis de uma vez

var (
    a int
    b string = "hi"
    c = 3.14
)

O bloco var (...) é útil quando você quer agrupar declarações relacionadas, especialmente em nível de pacote.

`:=` (short variable declaration)

x := 5
a, b := 1, "hello"
ch := make(chan int)
v, ok := m[key]

Pense no := como um atalho para var x = expr. Ele sempre infere o tipo a partir do valor à direita, e por isso o valor é obrigatório.

Regras principais

Aspecto	`var`	`:=`
Onde usar	Pacote ou função	Só dentro de função
Tipo explícito	Opcional	Não tem, sempre infere
Inicializador	Opcional (usa o zero value)	Obrigatório
Redeclaração	Não	Sim, com condições

A diferença mais importante na prática: := não funciona fora de uma função. Se você tentar usar no escopo de pacote, o compilador reclama.

Redeclaração com `:=`

Esse é um dos pontos que mais confunde quem está começando. O := permite reusar nomes já existentes, mas só se algumas condições forem atendidas:

As variáveis já existentes precisam ter sido declaradas no mesmo bloco.
O tipo precisa ser o mesmo.
Pelo menos uma variável do lado esquerdo precisa ser nova.
Nomes não-blank precisam ser únicos no lado esquerdo.

Um padrão comum com tratamento de erro:

field, offset := nextField(s, 0)
field, offset = nextField(s, offset)   // = atribui (ambas já existem)
field2, offset := nextField(s, offset) // := redeclara offset (field2 é nova)

Note que na segunda linha usamos =, porque tudo já existe. Na terceira voltamos para := porque field2 é nova, e isso "carrega" a redeclaração de offset junto.

Já o exemplo abaixo não compila:

x, y, x := 1, 2, 3   // ilegal: x aparece duas vezes

Quando usar cada um

Não existe uma regra absoluta, mas existem situações em que a escolha é praticamente automática.

Use var quando:

Está em nível de pacote (não tem escolha):

package main

var version = "1.0"   // := não funciona aqui

Quer o zero value explicitamente:

var users []string   // nil slice, sem alocar nada

Quer um tipo diferente do que seria inferido:

var port int32 = 8080   // com := seria int

Está declarando várias variáveis de tipos diferentes em bloco:

var (
    name   string
    age    int
    active bool
)

Use := quando:

Está dentro de uma função e tem um valor para inicializar.

Recebendo o retorno de uma função (esse é o uso mais idiomático):

data, err := os.ReadFile("config.yaml")

Em if, for ou switch com escopo local:

if v, ok := m["k"]; ok {
    // Faça algo
}

Aqui v e ok só existem dentro do if. Esse padrão é muito comum em Go e vale a pena memorizar.

Múltipla atribuição

Go permite atribuir várias variáveis de uma vez, onde temos algumas coisas úteis:

a, b := 1, 2
a, b = b, a            // swap sem variável temporária
x, _ := getXY()        // descarta o segundo retorno com _

O _ é o blank identifier. Use ele quando precisa receber um valor que a função retorna mas não vai ser usado, isso evita que o compilador reclame de variável não usada.

Pegadinhas

nil sozinho não tem tipo

var n = nil      // erro: cannot infer type
var n *int = nil // ok
var n []int      // ok, zero value de slice já é nil

O compilador não consegue adivinhar o tipo a partir de nil, porque nil é válido para vários tipos diferentes (ponteiros, slices, maps, channels, interfaces, funções). Você precisa indicar o tipo.

:= em escopo aninhado faz shadow

err := outer()
if true {
    err := inner()   // nova variável no bloco interno
    _ = err
}
// err aqui ainda é o da função outer

A variável de fora continua intocada. Shadowing costume causar efeitos indesejáveis na execução. Então é necessário muito cuidado, ou evitar.

Variável declarada e não usada = erro de compilação

func f() {
    x := 10   // declared and not used
}

Sempre que você declara um variável, Go obriga o uso. Variáveis não usadas costumam ser sinal de bug ou código morto.

Próximo post irei falar sobre Zero Values, até lá.

Tipos Básicos em Kotlin - String Literals

Renato O da Silva — Sat, 14 Sep 2024 03:02:48 +0000

Na última postagem eu comecei falar sobre strings e vamos dar continuidade falando de string literals.
Kotlin possui dois tipos de strings literals, Multiline Strings e Scaped Strings.

Multiline Strings

Diferente das strings convencionais, a multiline permite a adição de mais linhas dentro do texto. Se você tentar criar uma string com várias linhas, utilizando aspas duplas, isso irá gerar um erro.

fun main() {
    val texto = "
    Hoje é domingo
    Pede cachimbo
    O cachimbo é de barro
    Bate no jarro
    "

    println(texto)
}

O código acima irá gerar vários erros conforme abaixo:

Syntax error: Expecting '"'.
Syntax error: Incorrect template entry: .
Unresolved reference 'Hoje'.
Unresolved reference 'domingo'.
Unresolved reference 'Pede'.
Unresolved reference 'O'.
Unresolved reference 'é'.
Unresolved reference 'barro'.
Unresolved reference 'Bate'.
Unresolved reference 'jarro'.
Syntax error: Expecting '"'.
Syntax error: Incorrect template entry: .

Então o que fazemos quando precisamos imprimir um texto com múltiplas linhas? Utilizamos multiline strings:

fun main() {
    val texto = """
    Hoje é domingo
    Pede cachimbo
    O cachimbo é de barro
    Bate no jarro
    """

    println(texto)
    // Hoje é domingo
    //     Pede cachimbo
    //     O cachimbo é de barro
    //     Bate no jarro
}

Repare que o texto mesmo estando formatado, gerou uma saída toda bagunçada. Uma maneira de resolver isso é utilizando o método ** trimMargin()** que pode ser utilizado para remover espaços em brancos quando estamos utilizando multiline strings:

fun main() {
    val texto = """
    |Hoje é domingo
    |Pede cachimbo
    |O cachimbo é de barro
    |Bate no jarro
    """.trimMargin()

    println(texto)
    // Hoje é domingo
    // Pede cachimbo
    // O cachimbo é de barro
    // Bate no jarro
}

O Kotlin por padrão usa o símbolo "|" como prefixo para margem, mas podemos utilizar outro símbolo, apenas devemos indicar isso no método trimMargin():

fun main() {
    val texto = """
    ?Hoje é domingo
    ?Pede cachimbo
    ?O cachimbo é de barro
    ?Bate no jarro
    """.trimMargin("?")

    println(texto)
    // Aqui utilizamos a ? como prefixo, podendo ser outro caractere
    // Hoje é domingo
    // Pede cachimbo
    // O cachimbo é de barro
    // Bate no jarro
}

Escaped Strings

Escaped strings podem conter caracteres escapados. Abaixo temos um exemplo:

fun main() {
    val saudacao = "Ola\nJosé"

    println(saudacao)
    // Ola
    // José
}

Para utilizar escape, usamos o caractere *. Repare que a string está em uma linha só, mas na hora de imprimir na tela, foi impresso em duas linhas. O caractere *\n serve para pular uma linha e o mesmo não é impresso visualmente.
Temos uma lista de caracteres que podem ser escapados, conforme abaixo:

\t – tabulação
\b – backspace (não gostei dessa tradução, por isso deixei sem tradução)
\n – nova linha
\r – enter
\' – aspas simples
\" – aspas duplas
\ – barra inversa
\$ – Sinal de Dólar

fun main() {
    println("\tAqui temos uma tab")
    //  Aqui temos uma tab
    println("\bAqui temos um backspace")
    //Aqui temos um backspace 
    println("Aqui imprime uma nova linha\n")
    // Aqui imprime uma nova linha
    // 
    println("Aqui imprime um enter\r")
    // Aqui imprime um enter 
    println('\'')
    // '
    println("\"")
    // "
    println("Aqui imprime a barra inversa \\")
    // Aqui imprime a barra inversa \
    println("Aqui imprime o sinal de dólar \$")
    // Aqui imprime o sinal de dólar $
}

Vou ficando por aqui, em breve continuaremos com as strings.

Tipos Básicos em Kotlin - Strings

Renato O da Silva — Thu, 12 Sep 2024 16:36:13 +0000

Hoje irei abordar um tipo de dados que é muito utilizado na computação em geral, que são as Strings. Em algumas linguagens de programação antigas é um tanto complicado trabalhar com Strings, mas em linguagens mais recentes como Kotlin é bem fácil de criar e manipular Strings.

Strings são sequências de caracteres, comumente usadas para representar palavras, frases ou textos em um programa. Em Kotlin, strings são representadas pelo tipo String.

Podem ser atribuídas a uma variável da seguinte maneira:

val palavra = "abacate" 
// Uma string sempre irá começar com aspas duplas 
// e terminar com aspas duplas.

É possível acessar caracteres de uma string por meio de indexação, ou seja, através da posição da string no qual você deseja acessar. Podemos iterar sobre os caracteres através de for:

fun main() {
    val item = "um texto qualquer"
    for (i in item) {
        println(i)
    }
    // Ou podemos acessar o item pelo índice
    println(item[0])
    println(item.get(3))
}

Quando vamos acessar uma parte da string pelo índice, temos que tomar cuidado para não tentarmos acessar um índice que não existe.
Caso tente acessar um índice inexistente, será lançada uma exceção do tipo StringIndexOutOfBoundsException. Execute o código abaixo e verá o erro acontecendo:

fun main() {
    val item = "um texto qualquer"
    println(item[20])
}

Strings são imutáveis. Uma vez inicializada, seu valor não pode ser alterado. Qualquer operação que a modifique cria um novo objeto String, preservando o original:

fun main() {
    val item = "Ola mundo"

    // o método abaixa cria e imprime uma nova string escrita ao contrário
    println(item.reversed())
    // odnum alO

    // o valor original continua o mesmo
    println(item) 
    // Ola mundo
}

Existe a possibilidade de se concatenar strings, onde você junta duas strings conforme abaixo:

fun main() {
    val saudacao = "Ola "
    val pessoa = "Renato"    

    println(saudacao + pessoa)
    // Ola Renato

    var novaSaudacao = "Ola "
    novaSaudacao = novaSaudacao + pessoa

    println(novaSaudacao)
    // Ola Renato
}

Vou ficando por aqui, em breve volto com a continuação de strings.

Tipos Básicos em Kotlin - Inteiros sem sinais

Renato O da Silva — Tue, 11 Jun 2024 00:03:11 +0000

No último post eu falei sobre os tipos de dados numéricos mais utilizados.
Hoje vamos falar de outros tipos de dados numéricos,
que não são tão utilizados pela maioria dos desenvolvedores.

Hoje vou dos números inteiros sem sinal, mas o que isso quer dizer? São tipos de dados que só aceitam números positivos, onde o valor inicial começa em 0 e vai até a capacidade máxima permitida para o tipo em questão.

O Kotlin fornece os seguintes tipos de dados para valores inteiros sem sinal:

Tipo	Tamanho (bits)	Valor Máximo
UByte	8	255
UShort	16	65535
UInt	32	4,294,967,295 (232 - 1)
ULong	64	18,446,744,073,709,551,615 (264 - 1)

Números inteiros sem sinal devem ser declarados de forma específica como abaixo:

val b: UByte = 1u
val s: UShort = 1u
val l: ULong = 1u
val x: UInt = 55u

Repare que todos os números são finalizados com a letra u, pode a ser tanto maiúscula ou minúscula. Você pode inicializar uma variável sem especificar o tipo dela, mas nesse caso o Kotlin vai inferir o tipo UInt ou ULong à depender do tamanho do valor.

val b = 1U // Nesse caso será inferido o UInt como tipo
val k = 4294967298U // Como ultrapassa o tamanho reservado ao UInt é inferido o ULong como tipo.

Caso você queira verificar o tipo da variável você pode rodar o código abaixo:

No Exemplo acima você pode ser perguntar o motivo de estar usando Java juntamente com Kotlin, isso é possível por Kotlin tem uma interoperabilidade com Java, onde é possível utilizar código Java com Kotlin e vice-versa.

Com Kotlin é possível você definir o tipo da variável através da inferência de tipos, especificando que a mesma será do tipo Long, adicionando um L ao final:

Um cuidado muito importante ao se trabalhar com números inteiros sem sinal é que não podemos adicionar um valor negativo, pois isso gerará um erro.

Então se você não tiver certeza de que irá trabalhar apenas com números positivos, escolha outro tipo de dados, assim não acontecerá um erro na sua aplicação. Por hoje vou ficando por aqui, até a próxima.

Tipos Básicos em Kotlin - Tipos numéricos

Renato O da Silva — Sat, 08 Jun 2024 01:23:11 +0000

Introdução

Recentemente mudei de equipe na empresa onde estou trabalhando atualmente. Nessa equipe trabalhamos com Android Nativo com Java e Flutter. Como eu não tinha muito conhecimento em desenvolvimento nativo, comecei a estudar e comecei a utilizar Kotlin para ter acesso ao mundo do desenvolvimento de aplicativos Android.

Apesar de eu gostar de desenvolvimento backend, volta e meia estou inserido no desenvolvimento de aplicativos, comecei com React Native, e após algumas escolhas próprias decidi mudar para Flutter e fui seguindo.

Agora com o estudo de Kotlin, pensei e registrar o meu desenvolvimento conforme eu vou estudando. Então hoje vou começar falando sobre tipos de variáveis.

Apesar de ter desenvolvido bastante em JavaScript, pessoalmente eu prefiro linguagens fortemente tipadas e por esse motivo eu migrei para TypeScript e venho desenvolvendo em NestJS com TypeScript desde então.

Para quem está começando no mundo da programação, variável é um nome exclusivo que a identifica dentro do programa. O valor salvo que pode mudar durante a execução do programa. Ebac

No Kotlin variáveis são estaticamente tipadas, o que significa que uma vez que você declarou o seu tipo, isso não pode ser mais alterado. E dentre os tipos básicos podemos ter os seguintes:

Numbers (Números)
Booleans (Booleanos)
Characters (Caracteres)
Strings (Sequência de Caracteres)

Hoje eu falarei apenas do tipo Number, onde podemos ter valores inteiros e de ponto flutuante.

Números Inteiros

De acordo com Rafael C. Asth professor de matemática, os números inteiros são os números positivos e negativos, que não apresentam parte decimal e, o zero. Toda Matéria

Entre os números inteiros, temos os seguintes tipos:

Tipo	Tamanho (bits)	Valor Mínimo	Valor Máximo
Byte	8	-128	127
Short	16	-32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231 - 1)
Long	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263 - 1)

Em Kotlin quando você inicializa uma variável sem especificar o tipo, o compilador automaticamente infere o tipo com a menor tamanho à partir do tipo inteiro. Dependendo do tamanho do número o compilador pode inferir como Long.

As variáveis podem começar com as palavras chaves val e var, sendo val para variáveis que não irão mudar seus valores durante a execução do programa e var para aquelas que poderão ter seus valores alterados.

Segue um exemplo de tipagens com números inteiros:

val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneLong = 1L // Long

No exemplo acima, todos os tipos foram inferidos pelo compilador. Agora segue um exemplo onde você pode definir o tipo:

val one: Byte = 1
val valueShort: Short = -25000
val valueInt: Int = 600000
val valueLong: Long = 3000000000

Temos que ter um certo cuidado quando vamos definir o tipo da variável, pois o seu valor pode ultrapassar o seu limite máximo gerando um erro de tipagem.

Números de Ponto Flutuante

De acordo com Rafael C. Asth professor de matemática, os números reais podem ser representados de diversas formas, como: inteiros positivos e negativos, frações, decimais, notação científica, raízes, etc. Toda Matéria

Na computação definimos como números reais números que possuem casas decimais. Ex: 2.50 ou 3.14 ou 300000.85. Note que ao contrário do que estamos acostumados usamos ponto ao invés de vírgula.

Kotlin provê dois tipos de ponto flutuantes, utilizando o padrão IEEE 754:

Tipo	Tamanho (bits)	Bits Significativos	Bits Expoentes	Digitos Decimais
Float	32	24	8	6-7
Double	64	53	11	15-16

Como ocorre com os números inteiros, quando você não específica um tipo para variável, o compilador por padrão infere o tipo Double. Sempre que você quiser definir o tipo Float, você deve colocar um f ao final número. Caso você defina um tipo como Float e não adicione o f ao final do número isso irá gerar um erro de tipagem.

val pi = 3.14 // Double
val oneDouble = 1.0 // Double
val floatValue = 328.25f // Float

Você também pode decidir qual o tipo você quer utilizar:

val e: Double = 2.7182818284 // Double
val eFloat: Float = 2.7182818284f

O tipo Double é o mais utilizado quando se trata de números com pontos flutuantes.

Vou ficando por aqui e espero que tenha dado uma noção sobre os tipos numéricos em Kotlin.