Conversão de tipos em Golang
Tags: go, beginners, tutorial
Published: 2020-05-22 02:16:22

Vocês sabiam que quando uma variável é inicializada em um tipo, esse tipo é imutável? É isso aí, uma variável não pode mudar de tipo em go, se ela iniciou como int, irá terminar como int. 

**Go é uma linguagem de tipagem estática**.

*Tendo isso em mente, vamos colocar a mão na massa*.

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

Na maioria das vezes a forma de conversão será esta:

```golang

num := 10.3 //Declarei uma variável do tipo float64
num2 := int(num)//Estou convertendo ela para int e atribuindo o valor para uma nova variável

fmt.Printf("%T - %v", num2, num2)// O resultado: int - 10
//A parte decimal do número será descartada
```

Primeiro percebam que estamos armazenando o valor da conversão em outra variável (``num2``), isso é necessário pois a variável original (``num``) tem seu tipo float e isso é imutável. Ela esta sendo convertida para int apenas naquele momento, depois ela voltará ao normal. Então se quisermos utilizar o valor convertido durante o código, vamos ter que armazena-lo em outra variável 

```golang

num := 10.3//Variável do tipo float64

fmt.Printf("%T", int(num))//Aqui o tipo será int, pois estamos efetuando a conversão
fmt.Printf("%T", num)//Aqui o tipo volta a ser float64, pois a conversão feita não é permanente
```

Já vimos a conversão de ``float`` para ``int``, agora vamos conhecer as outras.
*A lógica se repete para os outros tipos*

- **int para float**

```golang

num := 23
num2 := float64(num)

fmt.Printf("num: %T - %v", num, num) //Resultado: num: int - 23
fmt.Printf("num2: %T - %v", num2, num2) //Resultado: num2: float64 - 23
```
O valor do número não é alterado, pois 23 não tem casas decimais. Mas agora ele deixou de ser int e passou a ser um tipo float64.

- **int para string**

```golang
num := 65
letra := string(num)
```

Estamos tentando converter o número 65 para string. Essa conversão é estranha para quem nunca viu, parece que não é possível de ser realiza-da, mas na verdade é possível sim. 

*Vocês já ouviram falar sobre a tabela ASCII e sobre o UTF-8?*

Tabela ASCII: 
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/7l53oopgt7d1kl7ypb6k.png)

Notem que cada número na tabela corresponde a um caractere. O numero 65 é equivalente ao caractere "A", e é exatamente esse o valor da conversão.

```golang
num := 65
letra := string(num)

fmt.Printf("letra: %s", letra) //Resultado: letra: A
```

O UTF-8 é um velho conhecido daqueles hackers de HTML. 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/vq0k1os2jkx1u58hx3xy.jpg)
*Eu estou nesse balaio também, tentando sair agora* 

UTF-8 é como se fosse a atualização da tabela ASCII. Contem mais caracteres, como acentos, e atualmente é a mais utilizada na web. 

*Fato interessante: Os criadores do UTF-8 também são criadores da linguagem go. E go é baseada em UTF-8*

Temos também o unicode, que contem vários outros símbolos, inclusive os emojis que eu uso. 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/3w9wz2zqxv1by3yzi9zw.PNG)

*Já convertemos de float para int, de int para float e de int para string. Falta converter de string para algum outro tipo*. 

**A conversão com strings é um pouco diferente**. O método que usamos até agora não irá funcionar. 

```golang
letra := "A"
num := []byte(letra)//Transformando em slice of bytes

fmt.Printf("num: %v - %T - %#U", num, num, num) 
//Resultado: num: 65 - []uint8 - U+0041 'A'
```

Strings são cadeia de caracteres, estamos pegando esses caracteres e criando uma **slice de bytes**, *coisa que vamos estudar mais para frente*. O importante é saber que cada caractere virou byte (uint8). Agora o valor é numérico, podendo ser mostrado como decimal, binário e unicode. 

```golang
palavra := "pipa"
num := []byte(letra)//Transformando em slice of bytes

fmt.Printf("num: %v - %T - %#U", num, num, num) 
/*Resultado: 
    num:  [112 105 112 97] - 
          []uint8 - 
          [U+0070 'p' U+0069 'i' U+0070 'p' U+0061 'a']*/
```

A palavra "pipa" virou um conjunto (slice) de 4 bytes, cada byte é de uma letra. Se formos na tabela ASCII e olharmos o número 112, ele é equivalente ao "p", o mesmo serve para os outros.  

*Então quer dizer que sempre uma letra irá virar um byte?* Não, pois existem caracteres especiais, como letras com acentos, que ocupam mais de um byte. Um caractere, rune, é do tipo int32, 32 bits = 4 bytes. Então uma rune pode ocupar até 4 bytes.   

```golang
palavra := "pipâ"//Coloquei um acento no ultimo a
num := []byte(letra)//Transformando em slice of bytes

fmt.Printf("num: %v - %T - %#U", num, num, num) 
/*Resultado: 
    num:  [112 105 112 195 162] - 
          []uint8 -  
          [U+0070 'p' U+0069 'i' U+0070 'p' U+00C3 'Ã' U+00A2 '¢']*/
```

Percebam que deixamos de ter 4 números e passamos a ter 5, mas nenhuma letra foi adicionada. A diferença é que o ultimo "a" passou a ocupar dois bytes, ele pode ocupar até 4. A quantidade de unicode também mudou. 

O importante é saber que a quantidade de caracteres e de bytes no slice pode ser diferente.

Depois vamos estudar mais sobre slice, strings e loop. 
[curso](https://youtu.be/WiGU_ZB-u0w)

**Fiquem bem e até amanhã!**

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