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.

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

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

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

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

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:

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.

num := 65
letra := string(num)

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

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

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.

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.

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.

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.

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

Fiquem bem e até amanhã!