Tipos primitivos e tipos compostos em golang
Tags: go, beginners
Published: 2020-05-18 19:14:37

**Vocês já assistiram "Avatar: a lenda de Aanng"?** *Espero que sim...*

Em avatar existem os dobradores de ar, fogo, terra e água. Cada dobrador pode controlar um elemento, apenas um. O único que consegue controlar todos os elemento é o avatar. 

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

*Calma que essa loucura vai fazer sentido* 

Os tipos primitivos são os dobradores, tem apenas um tipo de poder, só conseguem controlar um elemento. Já os tipos compostos se parecem com o avatar, é o mais forte dos dobradores. 

```golang
nome string := "Avatar"
idade int := 112
altura float64 := 1.45
careca bool := true
``` 
Os tipos primitivos são: 

```golang
nome string := "Avatar"
```
- **string** trabalha com cadeia de caracteres, basicamente são textos. 
Um caractere da string é chamado de rune, runa em português.

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

Segundo o Wikipedia: *"As runas são letras características, usadas para escrever nas línguas germânicas da Europa do Norte"*. Faz sentido chamar os caracteres da string de rune. Não esqueçam disso, vamos precisas depois. 
 
```golang
idade int := 112
``` 
- **Int** vem de integer, ele trabalha com números inteiro, ou seja, sem vírgulas. 

O int tem muitas variações. Temos o ``uint``, unsigned int, que desconsidera o sinal do número e o ``int`` normal, signed int, que leva em consideração o sinal. Cada um dos dois tem suas próprias variações: uint8, uint16, uint32, uint64, e a mesma coisa para o int. 

*Vamos ver esses detalhes em outro post.*   

```golang
altura float64 := 1.45
``` 
- **float** significa floating-point numbers, ou seja, ele trabalha com números decimais.  

Existe o ``float32`` e o ``float64``, quando declaramos uma variável com valor decimal, que possui virgula, e não especificamos seu tipo, por padrão ela será o ``float64``. Então virou convenção usarmos apenas o ``float64``. 

```golang
careca bool := true
``` 
 
- **bool** trabalha unicamente com verdadeiros e falsos, zeros e uns, ligado e desligado. É a tal da lógica booleana.

**Basicamente esses são os quatro elementos.** 

*Basicamente mesmo, existem alguns detalhes por trás de cada um deles. Mais detalhes sobre string, sobre runes, bytes, slice of bytes e entre outros. Mas vamos ver tudo isso outro dia.*

**Entendi os tipos primitivos, mas e os tipos compostos?**
Os tipos compostos são formados por tipos primitivos, eles são o avatar. Temos os arrays, slaces, maps, structs... Vamos falar deles mais para frente. 

*Não se engane, apesar da comparação com o avatar, o tipo composto não consegue "dobrar" todos os tipos primitivos ao mesmo tempo. Devemos escolher um e assim trabalharemos com ele. Não se preocupe em entender tudo agora, entenda que um tipo composto é formado por tipos primitivos e vamos entrar em detalhes um outro dia.*

Também podemos criar nossos próprios tipos.

```golang
package main

import "fmt"

type pastel int
var x pastel = 10

func main(){
    fmt.Printf("Tipo da variavel x: %T", x)
}
``` 

O resultado seria **``Tipo da variavel x: pastel``**. Pastel é o novo tipo que criamos. 

- **Criando o Tipo**

```golang
type pastel int
```
Criar um tipo é fácil. Basta utilizar a key-word ``type``, depois colocamos o nome do tipo que estamos criado, aqui o tipo se chamará pastel. Por fim, colocamos o tipo Subjacente. O tipo subjacente será a base para o que estamos criando.

Como int é a base do tipo pastel, ele não aceitará valores com virgulas, ou seja, valores float. Mas não se engane, eles não são iguais. Tanto é que não podemos relacionar os dois. 

```golang
type pastel int

var x patel = 4
var y int = 2

soma := x + y
```

 X é uma variável do tipo pastel, já o y é uma variável do tipo int. Eles são tipos diferentes, apesar do int ser o tipo subjacente do pastel. A prova disso é que a **soma dos dois não pode ser realizada**, pois em go não podemos fazer operações com variáveis de tipos diferentes.

Bem, entendi que pastel é um tipo novo, ele é diferente do int, mas se comporta como um. Ele só aceita números inteiros, então qual a diferença entre criar um tipo novo e utilizar um tipo primitivo? 

Quando criamos nossos próprios tipos, ganhamos um leque de possibilidades, mas calma que isso é assunto para outro dia. 

**Hoje entendemos a diferença entre tipos primitivos e compostos, conhecemos os tipos primitivos e aprendemos a criar nosso próprio tipo**. Ainda temos muito a aprender, mas vamos com calma.

Estou acompanhando esse curso aqui: [curso](https://youtu.be/WiGU_ZB-u0w). Ele é muito bom para quem esta iniciando, assim como eu. 

**Até o próximo post!**

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