Short variable declarations?
Tags: go, beginners, programming
Published: 2020-05-16 21:12:31

Vocês conhecem esse carinha aqui **``:=``**? Então, ele é o tal do **short variable declarations**, também pode ser chamado de **operador curto de atribuição**, e os brasileiros mais íntimos podem chama-lo de marmota.


![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/vjerw1fv49k8a8d2mkl3.jpg)

Antes de falarmos sobre o operador curto, precisamos discutir algumas coisas.

Vocês sabem a diferença entre:
###**Declaração x Inicialização x Atribuição?**###

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/1gp2x7dks49nen6su7yj.jpg)

```golang
var nome string 
var idade int
var gostaDeChocolate bool
```
**Declaração é quando criamos a variável**, perceba que não passamos valor para nenhuma das variaveis criadas.

*Curiosidade: Quando não passamos nenhum valor para uma variável, ela tem o chamado valor zero. Cada tipo tem o seu valor zero. Se déssemos um ``fmt.Println(nome, idade, gostaDeChocolate)``, o resultado seria: ``" " 0 false``* 

Bem, essa é a inicialização, basicamente a criação de uma variável sem atribuir nenhum valor.

```golang
var nome = "Linive" 
var idade = 23
var gostaDeChocolate = true
```
É parecido com o de antes, mas não e igual... 

Percebam que agora estamos criando a variável, **declarando**, e **passando um valor**. O ato de passar o primeiro valor para uma variável se chama **inicialização**. Estou declarando e inicializando a variável. 

Outro detalhe é que quando inicializamos a variável junto da declaração, podemos tirar o tipo da variável. Percebam que não tem mais ``string, int e bool``. Isso é possível porque o go irá deduzir qual é o tipo da variável pelo valor que estamos inserindo nela. Incrível, né?  

Já criamos variáveis e demos valores para elas, agora vamos supor que eu completei ano. Minha idade vai passar a ser 24, teremos que modificar a variável.

```golang
idade = 24
```

Já tínhamos declarado e inicializado a variável idade, agora estamos apenas modificando-a. O ato de passa um valor para uma variável é chamado de **atribuição**. Percebam que **toda inicialização é uma atribuição**, pois na inicialização estamos passando valores para variáveis, mas **nem toda atribuição é uma inicialização**. 

*Ok, mas onde entra esse tal de operador curto de atribuição, vulgo marmota?*

vamos falar dele agora!

```golang
nome := "Linive" 
idade := 23
gostaDeChocolate := true
```
**O operador curto consegue declarar e inicializar a variável de uma vez só**, não precisamos nem colocar o ``var`` na frente! 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/jntotiyaor0nzgafvr3f.gif)

Como nem tudo é perfeito, a marmota tem suas limitações 😟

**1°**: Ela só pode ser utilizada dentro de code blocks, blocos de códigos, como a ``func main``. Sempre que quisermos declarar uma variável fora de um bloco de código, devemos utilizar o ``var`` 


**Correto:**
```golang
package main

import "fmt"

var nome = "Linive"

func main(){
    idade := 23
    gostaDeChocolate := true
}
```
O operador curto esta sendo utilizado dentro de um bloco de código, a func main 👍.

**Errado:** 
```golang
package main

import "fmt"

idade := 23
gostaDeChocolate := true

func main(){
    
}
```
O operador curto não está dentro de nenhum bloco 👎.

**2°**: A segunda limitação é que ele **não pode apenas atribuir valor a variáveis já inicializadas**. Lembram daquela história de inicialização e atribuição? Vamos utilizar aqui.

**Isso aqui não pode ser feito.**
 
```golang
package main

import "fmt"

var idade = 23

func main(){
    idade := 24
}
```
Eu já declarei e inicializei a variável idade, então não posso utilizar o operador curto para modificar seu valor, atribuir um novo valor. Para modificar valores, utilizamos o igual, ``=``.

**Correto:**
```golang
package main

import "fmt"

var idade = 23

func main(){
    idade = 24
}
```

Tem um detalhe, nós podemos utilizar **uma marmota para duas variáveis**. 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/txub9e75gbitf2etehkp.jpeg)

**Vamos com calma...**

```golang
package main

import "fmt"

var idade = 23

func main(){
    
}
```
Percebam que estamos declarando e inicializando a variável idade fora do code block, então **teoricamente** não podemos mais usar o operador curto nela. **Agora vem o pulo do gato.**

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/1omkwjpn1e3kkbayvokg.jpg)

**Podemos utilizar a marmota na variável idade novamente, contanto que outra variável esteja sendo declarada e inicializada**.
```golang
package main

import "fmt"

var idade = 23

func main(){
    idade, nome := 24, "Linive"
}
```

**Esse código aqui não vai apresentar nenhum erro**. A idade vai passar a ser 24 e o nome, que não tinha sido declarando ainda, vai ser declarado e inicializado. 

É importante **prestar atenção na ordem das coisas**, se colocamos a variável idade primeiro, o valor dela deve vir primeiro, caso contrário vai virar uma bagunça.

Por hoje é isto. Vale lembrar que estou estudando e registando meu avanço. Se você também tem interesse por go, tem esse [curso](https://youtu.be/WiGU_ZB-u0w) maravilhoso, vem sem medo de ser feliz.

 **E vamos continuar os estudos!**

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/znzlj4ygbjc450c58s1e.jpg)