#1 - Learning Go - Tipos primitivos e declarações de variáveis
Tags: go, beginners, learning, career
Published: 2023-12-25 22:09:29

Estou de volta **╰( ^o^)╮╰( ^o^)╮.**

No começo do ano acabei sofrendo um layoff e com isso alguns pensamentos surgiram.

1 - Procurar emprego não foi uma tarefa tão fácil quanto em anos anteriores, fiz diversas entrevistas e acabei demorando cerca de 2 meses até de fato estar empregado novamente, claro que o momento atual do cenário tech influencia, mas alguns outros fatores me abriram os olhos também.

2 - Um desses fatores acabou sendo a linguagem principal que trabalho, em comparação com outras vagas, vejo que Ruby acaba não tendo tanta demanda assim, claro nunca foi equiparável com Java, C# e, recentemente, JavaScript, porém, em tempos de vacas magras, as linguagens menos populares tendem a sofrer mais rapidamente com escassez de vagas.

3 - Percebi também uma total mudança na forma como as entrevistas técnicas estão sendo conduzidas. É quase que unanime, pelo menos em vagas gringas, o processo FAANG like, com algoritmos e estruturas de dados na primeira fase e system design na seguinte.

Para me preparar para o ponto 2, acabei escolhendo Go como a linguagem que quero aprender, muito baseado em vagas que vim observando e sobre como o mercado vem utilizando Go recentemente.

A linguagem em si possui diversas características interessantes, além de ser bem performática, porém o foco principal é na minha aposta em que Go vai ser a próxima linguagem do momento das startups.

Dada as devidas introduções, estou lendo esse livro aqui [Learning Go](https://www.amazon.com.br/Learning-Go-Idiomatic-Real-World-Programming/dp/1492077216), estou já no capítulo 10, porém ao programar de fato, me pego tento que revisitar com frequência os capítulos anteriores até absorver por completo os conceitos abordados, portanto resolvi fazer resumos dos capítulos com os pontos chaves para facilitar esse processo e ajudar a internalizar ainda mais os conceitos.

Irei compartilhar as anotações aqui conforme for concluindo.

O primeiro capítulo é sobre setup de ambiente de desenvolvimento e ferramental, acabei pulando esse capitulo pois é algo muito especifico de cada projeto e basicamente é só seguir os tutoriais.

As anotações a seguir são do capítulo 2 - Tipos primitivos e Declarações (de variáveis).

## Zero Value

Um conceito muito importante de ser entendido, qualquer variável em Go possui um `zero value` ou seja, existe um valor padrão para cada tipo, que é associado a variáveis em casos em que estás não sejam inicializadas com algum valor.

## Literals

Um `literal` é uma representação textual de algum valor no código fonte, ou seja, números para `integer` e `float` , texto em “aspas” para representar `string`, true e false pra `boolean` , etc.

Em Go, `literals` podem ser de 4 tipos comuns: integer, floating point, rune (characters) e strings.

`Literals` em Go não possuem tipo, o que torna interações entre um `literal` e qualquer variável compatível possíveis.

### String (and Rune) Literals

Em Go, aspas duplas `“”` e aspas simples `‘’` não são sinônimos para strings, ou seja, apresentam comportamentos diferentes.

Aspas duplas criaram strings interpretadas, ou seja, “\n” irá interpretar um new line e irá pra próxima linha.

```
"interpreted string \n"
```

Aspas simples criam Runes (ou caracteres) que podem ser representados por diversas notações diferentes, como Unicode (’a’), 8-bit octal number ('\141’), hexadecimal (’\x61’), entre outras.

Backtick cria raw strings, ou seja, não interpreta \n, \t, etc.
```
`raw string`
```

## Tipos integer especiais

Em Go existem alguns tipos especiais de `integer` , sendo os mais notáveis `byte` , `int` , `rune` e `uint` .

Um `byte` é um alias para `uint8` , um integer de 8 bits sem sinal (unsigned).

O `int` depende da CPU (32 bits ou 64 bits), mesmo vale para `uint` , e é o tipo padrão para literals de integer.

O tipo `rune` é um alias para `int32` e representa um único code point no Unicode (ou seja, um único caractere).

### Dica: Qual tipo de integer usar?

Se estiver trabalhando com um formato de arquivo binário ou um protocolo de rede que tem um tipo especifico ou tamanho de int, use este tipo, caso contrário use apenas `int` .

Até que se prove necessário ser explicito sobre o sinal ou tamanho de um int, para questões de performance ou integração, use sempre o `int` . Considere qualquer outro tipo de int como otimização prematura até que se prove o contrário.

## Conversão de tipos

Em Go não existe uma conversão de tipos de forma automática e antes de fazer operações é preciso fazer uma conversão explícita entre tipos compatíveis (por exemplo, operações entre integer e float).

Esse modo estrito de tratamento de tipos possui outras implicações, por exemplo, não existe o conceito de “truthy”, ou seja, não é possível utilizar outros tipos como boolean, valores diferente de zero ou strings com conteúdo não são tratadas como um valor `true` .

## var Versus :=

Com `var` é possível declarar variáveis sem um valor de inicialização, que são imediatamente criadas com o seu valor zero (que varia de tipo para tipo), e também com um valor de inicialização, além de ser possível utilizar a inferência de tipo.

`:=` sempre depende de um valor para ser inicializado e utiliza a inferência de tipo pra saber qual tipo a variável terá, se limita a ser utilizado somente dentro de funções.

`:=` permite sobrescrever uma variável ja previamente inicializada, desde que seja declarada junto de uma nova variável inexistente.

{% gist https://gist.github.com/erick-tmr/fcbbe3bdc943b73d52a5b8f9179eff90 %}

### Quando usar var vs :=

Como via de regra, usar := dentro de funções e nas raras ocasiões em que faz sentido utilizar variáveis de pacote, utilizar var.

Existem algumas situações especiais em que usar var pode ser mais recomendado:

- ao inicializar uma variável no seu valor zero, isso deixa claro que o valor zero é proposital
- ao atribuir uma constante sem tipo ou um literal a uma variável em que o tipo padrão não é o desejado, utilizar a declaração de variável completa com tipo é mais idiomático
- em situações onde se está criando novas variáveis e atribuindo valores a antigas ao mesmo tempo, é mais idiomático declarar explicitamente as novas variáveis usando var, para deixar claro quais são elas

## Constantes (valores imutáveis)

A keyword `const` é usada pra declarar constantes e somente pode guardar valores literais e operações sobre eles, ou seja, que conseguem ser calculados em tempo de compilação.

### Constantes tipadas e não tipadas

Constantes podem ter tipo ou não, uma constante sem tipo é mais flexível, por exemplo, ser associada a diferentes tipos numéricos. Nos casos em que queremos forçar um tipo especifico, utilizamos a tipagem em constantes.

## Variáveis não utilizadas

O compilador irá retornar um erro caso uma variável seja declarada e não seja lida pelo menos uma vez, ou seja, é obrigatório que toda variável declarada seja lida pelo menos umas vez.

Esse check não é tão “esperto” assim, portanto, caso uma variável tenha seu valor modificado, o compilador não vai forçar que ela seja lida uma segunda vez.

Essa regra não é aplicada para variáveis a nível de pacote e para constantes.

## Outros capítulos
Esta é uma série onde pretendo fazer anotações de todos os capítulos relevantes do livro Learning Go, seguem os links para os capítulos anteriores e futuros:
[#4 - Learning Go - Funções](https://dev.to/erick_tmr/4-learning-go-funcoes-2n30)
[#3 - Learning Go - Blocos, Shadowing e Estruturas de controle](https://dev.to/erick_tmr/learning-go-blocos-shadowing-e-estruturas-de-controle-5a2o)
[#2 - Learning Go - Tipos compostos](https://dev.to/erick_tmr/learning-go-tipos-compostos-3f4b)