Variáveis em Go

Usando variáveis com Go

Olá leitor, seja muito bem vindo a mais uma lição da Jornada GoLang 😉

Nesta lição, você irá aprender um dos procedimentos básicos que todos os desenvolvedores usam para armazenar dados de forma temporária dentro da sua aplicação.

Estou me referindo as famosas variáveis, também conhecidas como pequenas caixinhas, que são usadas para armazenar algum tipo de valor, seja ele interno (já declarado pela própria aplicação), ou um valor informado pelo próprio usuário (externo).

Mas, antes de continuarmos é interessante você entender o que são variáveis e para que elas servem.

O que são variáveis?

No mundo da programação, nós temos um conceito conhecido como variáveis, pensem nelas como caixinhas (ou containers de navio) que servem para armazenar um certo dado (informação), como:

Elas são muito úteis para armazenar uma determinada informação, para que futuramente, o nosso próprio sistema possa usá-la, processá-la ou se ele quiser, mostrá-la para o usuário.

Imagina uma variável como uma caixinha, onde fora dessa caixinha exista um rótulo que nos dá uma ideia do conteúdo que é (ou será) armazenado ali:

Na ilustração acima, nós temos uma variável rotulada como "nome", que por sua vez armazena o texto (string) "Micilini Roll".

Beleza, tudo muito fácil até agora, não é mesmo?

Mas como será que eu represento isso no GoLang?

Bem, antes de responder essa pergunta, que tal criamos a pasta do nosso projeto de testes? 🙂

Criando seu projeto de testes

Dentro da pasta JornadaGoLang, nós iremos criar uma nova pasta chamada de 5-variaveis-em-go, onde dentro dela, vamos criar o nosso arquivo main.go:

package main

func main(){

}

Feito isso, vamos aprender um pouco mais sobre como criar variáveis em GoLang!

Criando sua primeira variável em Go

Uma das formas mais simples que temos hoje de se criar uma variável em Go, é por tipo de inferência, ou seja, declaramos o nome dessa variável, usamos o atribuidor := e em seguida informamos o dado que ela irá armazenar.

Vejamos alguns exemplos:

package main

func main(){
        //Tipo Inferência:
	nome := "Lucas Galdino"
	idade := 25
	altura := 1.87
}

Porque esse método é conhecido como tipo de inferência?

Simples, porque ele infere (identifica) o tipo de valor que aquela variável está armazenado. Isso significa dizer que o GoLang é inteligente o suficiente para identificar que aquela variável está armazenando um texto, ou um número decimal, ou um valor booleano, ou um número flutuante e etc...

Então se existe o tipo de inferência, na qual o sistema identifica o tipo armazenado de maneira automática, isso significa dizer que talvez seja possível declarar o tipo da variável, sem passar pela inferência, estou certo?

Sim, e o segundo método de criação de variáveis que veremos em GoLang é fazendo o uso da Declaração Explícita.

A declaração explicita, é a forma mais tradicional de declarar variáveis em GoLang (e também é a mais recomendada).

No caso dela, declaramos o comando var, seguido do nome da variável em conjunto com o tipo que ela armazena, onde por fim, usamos o sinal de atribuição (=) em conjunto com o valor que ela armazenará, observe:

package main

func main(){
	var sobrenome string = "Roll"
	var salario int = 700
	var pi float64 = 3.1415
}

Neste caso em específico, o tipo da variável é declarado explicitamente (string, int, float64, etc.), onde seus respectivos valores (Roll, 700 e 3.1415) são declarados depois do sinal de atribuição (=).

Além disso, você pode declarar variáveis usando o comando var, onde mais tarde, você pode decidir se vai atribuir valores para elas, ou não, observe um exemplo:

package main

func main(){
	var laptop string
	var preco int

	laptop = "Dell 5440"
	preco = 6850
}

Note que nós declaramos as variáveis com seus respectivos nomes e tipos, onde posteriormente, resolvemos atribuir valores para cada uma delas.

Declarando múltiplas variáveis simultaneamente

O GoLang também possui suporte a criação de diversas variáveis de forma simultânea, observe:

package main

func main(){
	//Declaração Simultânea:
	var nome2, sobrenome2 string = "Lucas", "Silva"
        var idade2, altura2 = 25, 1.75
}

Veja que nós declaramos os nomes das variáveis separadas por vírgulas, da mesma forma como o fizemos com seus respectivos valores.

Notou algo interessante ali em cima? Usamos o var sem precisar declarar o tipo de valor que a variável irá armazenar (var idade2, altura2 = 25, 1.75). Novamente vemos o tipo de inferência em atuação conjunta com o var 🥳

A mesma coisa pode ser feita sem o uso do comando var, observe:

package main

func main(){
	nome3, sobrenome3 := "Micilini", "Roll"
	idade3, altura3 := 22, 1.99
}

Agrupando variáveis por blocos

Quando temos muitas variáveis, nós podemos agrupá-las usando parênteses da seguinte forma:

package main

func main(){
	var (
          nome4   = "Lucas"
          idade4  = 25
          altura4 = 1.75
          ativo4  = true
        )
}

Isso faz com que se evite a necessidade de ficar digitando o comando var toda hora, deixando o código mais organizado.

Declarando variáveis globais

A medida em que você for avançando nas lições, você verá que é possível nós termos diversas funções fora da main().

E com essa nova necessidade, talvez surja a ideia de criar variáveis globais que possam ser usadas e acessadas fora da função main().

E para fazer isso, é bem simples, basta que você as declare fora da função principal, por exemplo:

package main

var nomeGlobal string
var idadeGlobal int = 12
var tokenGlobal = "234123"

func main(){

}

E sim, dentro da main(), você será capaz de acessar tais variáveis, portanto, fique tranquilo ☺️

Variáveis do tipo VAR

Até o momento, você aprendeu a criar variáveis com e sem o comando var. O que significa que tais variáveis podem ter seus valores alterados no decorrer da aplicação, vejamos um exemplo:

var notebook string = "Galaxy Book 2"

notebook = "Galaxy Book 4 Pro"
notebook = "Galaxy Book 5"

Quando declaramos uma variável declarando também o seu tipo de valor que ela recebe, nós estamos dizendo ao compilador, que tal variável só pode receber valores daquele tipo específico.

Sendo assim, caso tentássemos atribuir um valor inteiro (int) a uma variável que foi criada como uma string:

var notebook string = "Galaxy Book 2"

notebook = "Galaxy Book 4 Pro"
notebook = "Galaxy Book 5"
notebook = 99

Receberíamos um erro do console, alegando o seguinte:

cannot use 99 (untyped int constant) as string value in assignment

O código de erro acima, está dizendo que o tipo inteiro não pode ser atribuído ao tipo string.

Mas o que aconteceria caso não criássemos uma variável com tipo de inferência, e tentássemos fazer a atribuição depois?

var notebook = "Galaxy Book 2"

notebook = "Galaxy Book 4 Pro"
notebook = "Galaxy Book 5"
notebook = 99

Simples, também receberíamos o mesmo erro 😭

Diferente do que acontece em outras linguagens de programação, aqui aconteceria o mesmo erro, e isso significa que todas as variáveis em Go precisam ser explicitamente declaradas antes de serem usadas.

Isso ocorreu porque Go não permite a criação implícita de variáveis durante a atribuição, garantindo mais segurança e evitando erros comuns, como o uso acidental de variáveis não inicializadas.

E sim, o GoLang não permite mudar o tipo de uma variável após a sua declaração e inicialização mesmo que isso seja feito por tipo de inferência (como estamos tentando fazer no comando acima), uma vez que a linguagem é fortemente tipada e estaticamente tipada.

Isso significa dizer que se você declarou ou inicializou uma variável do tipo string, ela deverá ser sempre do tipo string, e nunca poderá receber outros tipos. A mesma coisa vale caso iniciássemos uma variável do tipo inteiro, booleano e entre outros.

package main

import "fmt"

func main() {
    var nome string = "Lucas"
    nome = "Maria" // ✅ Válido: continua sendo uma string

    nome = 25 // ❌ Erro: não é possível atribuir um int a uma variável string
}

Variáveis com valores imutáveis

Também no GoLang, e diferente das variáveis do tipo var, nós podemos declarar um tipo específico de variável, na qual é impossível alterar o seu valor.

Neste caso, estou me referindo às variáveis do tipo const, que representam constantes, e como toda constante, ela nunca tem seu o valor alterado, uma vez que se mantem constante naquilo que se propõe a fazer 🫡

Mas daí você deve estar se perguntando: Se uma variável não pode mudar, por que alguém a declararia? 🤔

A resposta é simples: imutabilidade traz segurança, clareza e otimização de desempenho. 

O fato de você declarar uma variável que nunca irá mudar, pode evitar diversos bugs no seu sistema.  Se um valor nunca deve ser alterado, usar const impede que mudanças acidentais aconteçam, reduzindo bugs difíceis de rastrear.  

Não só isso como o compilador pode otimizar constantes porque sabe que elas nunca mudarão, tornando o programa mais eficiente.

E por último e não menos importante, se um valor nunca deve ser alterado (como uma chave de API ou um identificador importante), usar const evita que ele seja modificado acidentalmente.

A declaração de uma constante (const) acontece da mesma forma que uma var, a única diferença é que se você tentar mudar seu valor posteriormente, o compilador gerará uma mensagem de erro.

Ah... constantes precisam receber valores no momento em que elas são declaradas, sendo assim, não há como definir uma constante e declarar o valor posteriormente, ok?

package main

import "fmt"

// Constantes globais (declaradas fora de qualquer função)
const (
    Pi       = 3.14159
    Language = "Go"
)

// Constantes dentro da função main (constantes locais)
func main() {
    // Constantes com valor numérico
    const number = 10

    // Constantes de tipo específico
    const (
        Year int = 2025
        Month     = 2
    )

    // Constantes de inferência de tipo
    const (
        Name     = "John Doe"
        IsActive = true
    )

    // Exemplo de bloco de constantes dentro do main
    const (
        ServerName   = "localhost"
        ServerPort   = 8080
        MaxClients   = 100
    )

}

No exemplo acima, você pode observar que nós criamos constantes globais, constantes declaradas em blocos, constantes com tipo explícito e constantes por inferência 🙂

Principais diferenças entre var e const

Existem algumas diferenças entre o criação de variáveis do tipo var, e const, veremos em detalhes cada um desses aspectos:

Mutabilidade:

Atribuição:

Tipos de Dados:

Escopo:

Reinicialização:

Uso de memória:

Definições de tipos:

Repositório da lição

Todos os arquivos relacionados com esta lição, podem ser encontrados nos seguintes repositórios abaixo:

Conclusão

Nesta lição, você aprendeu a criar variáveis e constantes com o GoLang.

Agora, partiremos para os tipos básicos que são aceitos pela linguagem, como strings, int, float64, booleans e entre outros.

Até!☺️