Forem: Linive

Slice multi-dimensional

Linive — Thu, 04 Jun 2020 21:12:13 +0000

Vocês lembram dos slices? Ele se parece com uma linha.

Agora imagine uma pilha com vários slices, um em cima do outro.

Esse exemplo é de um slice com duas dimensões, e é dele que vamos falar hoje.

Olhando para foto é possível perceber que um slice 2d é semelhante a uma tabela, com linhas e colunas, assim como no Excel. Não podemos esquecer disso.

Declarando um slice multi-dimensional

var tabela = [][]int{
    []int{1, 2, 3, 4},
    []int{5, 6, 7, 8},
    []int{9, 10, 11, 12},
}

var sl = []int{40, 41, 42, 43} //Slice comum

A declaração não é tão diferente. Temos o nome da nossa variável, os colchetes e o tipo dos valores que serão armazenados.

A primeira diferença é que temos dois pares de colchetes [][]int. Isso irá indicar que nosso slice tem duas dimensões, podemos colocar várias outras.

Um slice 2d é composto por vários slices comuns empilhados, semelhante a uma tabela. E é exatamente isso que foi feito, colocamos vários slices dentro do nosso slice bidimensional.

É assim que devemos enxergar a tabela que criamos:

Essa tabela possui linhas e colunas. Através delas conseguiremos pegar um elemento de forma individual.

var tabela = [][]int{

     colunas:  0  1  2  3
linha: 0 []int{1, 2, 3, 4},
linha: 1 []int{5, 6, 7, 8},
linha: 2 []int{9, 10, 11, 12},
}

Para identificar um único valor, vamos utilizar o padrão:
[linha][coluna].

var tabela = [][]int{

    []int{1, 2, 3, 4},
    []int{5, 6, 7, 8},
    []int{9, 10, 11, 12},
} 

fmt.Println(tabela[0][2], tabela[2][3])

//Resultado: 3 12

Loops

Vamos testar o for range na nossa tabela.

var tabela = [][]int{

    []int{1, 2, 3, 4},
    []int{5, 6, 7, 8},
    []int{9, 10, 11, 12},
} 

for indice, valor := range tabela{
    fmt.Println(indice, valor)
}

/*Resultado: 
0 [1 2 3 4]
1 [5 6 7 8]
2 [9 10 11 12]
*/

O índice retorna o índice das linhas, já o valor retorna todo o slice que corresponde aquele índice.

E se quisermos demonstrar cada valor de cada slice de forma individual?

Vamos ter que fazer outro loop, desta vez percorrendo elemento por elemento de cada slice.

Sabe quem retorna todos os elemento unidos da slice? O valor. Só que ele retorna todos os valores juntos, por isso vamos fazer um loop for nele.

var tabela = [][]int{

    []int{1, 2, 3, 4},
    []int{5, 6, 7, 8},
    []int{9, 10, 11, 12},
} 

for indice, valor := range tabela{
    fmt.Println("Linha:",indice)

    for i, numero := range valor{
        fmt.Println("\tcoluna:", i, "Numero:", numero)
    }
}

/*Resultado: 
Linha: 0
        coluna: 0 Numero: 1
        coluna: 1 Numero: 2
        coluna: 2 Numero: 3
        coluna: 3 Numero: 4
Linha: 1
        coluna: 0 Numero: 5
        coluna: 1 Numero: 6
        coluna: 2 Numero: 7
        coluna: 3 Numero: 8
Linha: 2
        coluna: 0 Numero: 9
        coluna: 1 Numero: 10
        coluna: 2 Numero: 11
        coluna: 3 Numero: 12
*/

Também conseguimos fazer com o for normal.

var tabela = [][]int{

    []int{1, 2, 3, 4},
    []int{5, 6, 7, 8},
    []int{9, 10, 11, 12},
} 

for indice := 0; indice < len(tabela); indice++ {
    fmt.Println(indice, tabela[indice]) 
}

/*Resultado: 
0 [1 2 3 4]
1 [5 6 7 8]
2 [9 10 11 12]
*/

O len(tabela) vai percorrer os índices das linhas, por isso que tabela[indice] retorna o slice completo. Se quisermos percorrer elemento por elemento, vamos ter que fazer outro loop.

var tabela = [][]int{

    []int{1, 2, 3, 4},
    []int{5, 6, 7, 8},
    []int{9, 10, 11, 12},
} 

for indice := 0; indice < len(tabela); indice++ {
    fmt.Println("Linha:", indice)

    for c := 0; c < len(tabela[indice]); c++ {
        fmt.Println("\tcoluna:", i, "Numero:", tabela[indice][i])
    }
}

/*Resultado: 
Linha: 0
        coluna: 0 Numero: 1
        coluna: 1 Numero: 2
        coluna: 2 Numero: 3
        coluna: 3 Numero: 4
Linha: 1
        coluna: 0 Numero: 5
        coluna: 1 Numero: 6
        coluna: 2 Numero: 7
        coluna: 3 Numero: 8
Linha: 2
        coluna: 0 Numero: 9
        coluna: 1 Numero: 10
        coluna: 2 Numero: 11
        coluna: 3 Numero: 12
*/

A tabela[indice] contém todo o nosso slice, então fizemos um loop com o seu length, len(tabela[indice]).

Para selecionar um elemento do loop devemos ter a informação da linha e da coluna tabela[linha][coluna]. A linha esta contida no indice, tabela[indice], a coluna irá ser "c", tabela[indice][c].

Caso fiquem confusos com tanto loop 👇🏼

Loop for range em go

Linive ・ May 24 ・ 5 min read

#go #beginners #tutorial

Make

Caso não tenha lido o post sobre slices, basicamente o make nos permite criar slices com uma capacidade máxima.

var tabela = make([][]int, 3, 10)

fmt.Println(tabela, len(tabela), cap(tabela))

//Resultado: [[] [] []] 3 10

make([][]int, 3, 10). Esse 3 será o length das linhas, ele já criou espaço para 3 slices no meu slice 2d. Mas como ainda não atribuímos nenhum valor, eles estão vazios.

Existem algumas formas de atribuir valor:

var tabela = make([][]int, 3, 10)

//Primeira
sl:= []int{1, 2, 3, 4}
tabela[0] = sl

//Segunda
tabela[1] = []int{5, 6, 7, 8}

fmt.Println(tabela, len(tabela), cap(tabela))

//Resultado: [[1 2 3 4] [5 6 7 8] []] 3 10

Vamos supor que já preenchemos nossos espaços disponível, agora vamos ter que adicionar novos elementos com o append.

Lembrando que uma slice 2d é formado por outras slices, então não podemos dar um append em números isolados int. Nossa tabela só receberá elementos do tipo []int, slice of int.

var tabela = make([][]int, 3, 10)

tabela[0] = []int{1, 2, 3, 4}
tabela[1] = []int{1, 2, 3, 4}
tabela[2] = []int{5, 6, 7, 8}
fmt.Println(tabela, len(tabela), cap(tabela))

sl := []int{9, 10, 11, 12}
tabela = append(tabela, sl)
fmt.Println(tabela, len(tabela), cap(tabela))

tabela = append(tabela,[]int{13, 14, 15, 16})
fmt.Println(tabela, len(tabela), cap(tabela))

/*Resultado: 
[[1 2 3 4] [1 2 3 4] [5 6 7 8]] 3 10
[[1 2 3 4] [1 2 3 4] [5 6 7 8] [9 10 11 12]] 4 10
[[1 2 3 4] [1 2 3 4] [5 6 7 8] [9 10 11 12][13 14 15 16]] 5 10
*/

Por hoje é isso, espero que tenham entendido e testem bastante.

Caso queiram se aprofundar em go 👉🏼 vamo nessa

✊🏼 Slice em Golang

Linive — Wed, 03 Jun 2020 22:30:12 +0000

⚠️ Aviso: Antes de mais nada, você deve saber que os arrays são a base para os slices. Então se você nunca viu arrays:

Arrays em Golang

Linive ・ Jun 2 '20

#go #beginners #tutorial

Agora vamos entrar no maravilhoso mundo dos slices.


sliceDeNumeros := []int{1, 2, 3, 4, 5}

fmt.Println(sliceDeNumeros)

Se você leu o post sobre arrays, deve ter notado a semelhança entre os dois. A única diferença na declaração é que não estamos definindo o length do slice.


sliceDeNumeros := []int{1, 2, 3, 4, 5}
arrayDeNumeros := [5]int{1, 2, 3, 4, 5}

Já sabemos que em arrays não podemos adicionar novos elementos, pois o length dele não pode aumentar. Em slice não teremos esse problema, pois não declaramos qual será seu tamanho.

Você deve pensar no slice como um array sem tamanho definido, onde podemos adicionar novos elemento. Um slice é um array mais flexível.

Adicionando elementos a um slice


sliceDeNumeros := []int{1, 2, 3, 4, 5}

sliceDeNumeros = append(sliceDeNumeros, 6)
fmt.Println(sliceDeNumeros)

//Resultado: 1, 2, 3, 4, 5, 6

append significa adicionar, e é exatamente isso que queremos fazer, adicionar um elemento a nossa slice. Então chamamos a funcionalidade append e depois indicamos onde será adicionado: sliceDeNumeros e quem será adicionado: 6.

Quem será adicionado é um detalhe importante.

O nosso slice é do tipo slice of int, ou seja, é um slice formado por elementos int. Então só podemos adicionar números inteiros a ele.


sliceDeNumeros := []int{1, 2, 3, 4, 5}

sliceDeNumeros = append(sliceDeNumeros, 6.5)
sliceDeNumeros = append(sliceDeNumeros, "a")

//Nenhum dos dois casos pode ser realizado

Outro exemplo:


bairros := []string{"Pajuçara", "Ponta Verde", "Jacintinho", "Benedito Bentes"}

bairros = append(bairros, "Farol")

fmt.Println("São bairros de Maceó: " )
for indice, bairro := range bairros{
    fmt.Printf("%v - %v\n", indice + 1, bairro)
}

/*
Resultado:
São bairros de Maceó:
1 - Pajuçara
2 - Ponta Verde
3 - Jacintinho
4 - Benedito Bentes
5 - Farol
*/

Se quisermos pegar apenas um dos elemento:


bairros := []string{"Pajuçara", "Ponta Verde", "Jacintinho", "Benedito Bentes"}

fmt.Println("É um bairro de Maceó: ", bairros[0] )

//Resultado: É um bairros de Maceó: Pajuçara

Tem uma coisa que precisamos entender sobre os slices. Por baixo dos panos um slice nada mais é quem um array, quando adicionamos um novo elemento a um slice, seu array escondido é jogado fora e um novo é criado. Todas as vezes que adicionarmos elementos a um slice, um array será descartado e um novo será criado.

O array será descartado porque seu tamanho é imutável.

Agora imagine um slice com centenas de elementos e precisamos adicionar novos dados a cada 60 segundos. A cada minuto um array gigantesco será descartado e outro será criado, essa ação irá demandar muito custo computacional, deixando nosso programa pesado.

Não se preocupe, pois temos a solução para seu problema.

Make

Podemos utilizar o make. Com o ele conseguimos definir a capacidade do array subjacente a nossa slice. Podemos criar um slice onde seu array subjacente terá length 5 e capacidade 10.

Mas qual é a diferença entre length e capacidade? Vamos ver na prática.


var numeros = make([]int, 5, 10)

Estou declarando um slice of int, com length 5 e capacidade 10. O tamanho desse slice é 5, eu tenho espaço garantido para 5 elemento.


var numeros = make([]int, 5, 10)

numeros[0], numeros[1], numeros[2], numeros[3], numeros[4] = 1, 2, 3, 4, 5
fmt.Println(numeros,"-", len(numeros))

//Resultado: [1 2 3 4 5]- 5

Se eu deixar de declarar um dos elemento, ele será zero, assim como nos arrays.

A novidade vem agora. Já utilizamos todos os elementos disponíveis, tínhamos 5. Agora se quisermos adicionar novos elementos, vamos ter que utilizar o append.

Acabamos de aprender que quando inserimos um novo elemento a um slice, seu array é jogado fora. Mas não nesse caso, pois definimos sua capacidade. Capacidade é a quantidade de novos elementos que podem ser adicionados ao slice sem seu array ser jogado fora.


var numeros = make([]int, 5, 10)

numeros[0], numeros[1], numeros[2], numeros[3], numeros[4] = 1, 2, 3, 4, 5
numeros = append(numeros, 6)

fmt.Println(numeros,"-", len(numeros), "-", cap(numeros))
//Resultado: [1 2 3 4 5 6] - 6 - 10

Podemos adicionar até 10 elementos ao slice antes do seu array ser jogado fora.


var numeros = make([]int, 5, 10)

numeros[0], numeros[1], numeros[2], numeros[3], numeros[4] = 1, 2, 3, 4, 5
numeros = append(numeros, 6, 7, 8, 9, 10)

fmt.Println(numeros,"-", len(numeros), "-", cap(numeros))
//Resultado: [1 2 3 4 5 6] - 10 - 10

Chegamos a capacidade máxima. Quando o próximo elemento for adicionado, o array será descartado e um novo será criado, a diferença é que sua capacidade irá dobrar.


var numeros = make([]int, 5, 10)

numeros[0], numeros[1], numeros[2], numeros[3], numeros[4] = 1, 2, 3, 4, 5
numeros = append(numeros, 6, 7, 8, 9, 10, 11)

fmt.Println(numeros,"-", len(numeros), "-", cap(numeros))
//Resultado: [1 2 3 4 5 6] - 11 - 20

Tipos

Agora vamos supor que eu quero unir duas slices.


numeros1 := []int{1, 2, 3, 4}
numeros2 := []int{5, 6, 7, 8}

numeros1 = append(numero1, numero2)

Essa ação não pode ser realizada. Estou tentando adicionar a slice numeros2 na slice numeros1, mas existe uma incompatibilidade de tipos.

Lembra que em go não podemos realizar operações com tipos diferentes?

As slices são tipo []int e são compostas por elementos int, ou seja, só podemos adicionar números inteiros. O tipo slice of int ([]int) é diferente do tipo int, isso quer dizer que não podemos simplesmente adicionar uma slice na outra. Não é possivel adicionar um []int onde deveria ser int.

Então precisamos pegar apenas os números que pertencem a slice numeros2, pois eles sim são inteiros.


numeros1 := []int{1, 2, 3, 4}
numeros2 := []int{5, 6, 7, 8}

numeros1 := append(numero1, numero2...)

fmt.Println(numeros1)

//Resultado: [1 2 3 4 5 6 7 8]

Basta colocar 3 pontos logo depois do nome da slice. Assim estamos acessando apenas os valores da slice e não ela em si.

Também podemos fazer assim:


numeros1 := []int{1, 2, 3, 4}

numeros1 := append(numero1, []int{5, 6, 7, 8}...)

fmt.Println(numeros1)

//Resultado: [1 2 3 4 5 6 7 8]

Slice of Slice

Sabemos como pegar um elemento de forma individual, mas e se quisermos pegar um grupo de elementos da slice?

Vamos utilizar a slice of slice, fatiando a slice.


numeros1 := []int{1, 2, 3, 4}

fmt.Println(numeros1[0:3])

//Resultado: [1 2 3]

numeros1[0:3] é assim que fatiamos a nossa slice, vamos indicar onde nossa fatia vai iniciar e onde ela irá terminar.

Um detalhe, indicamos que ela termina no índice 3 (número 4), mas apenas mostramos até o índice 2 (número 3). Isso é padrão, temos que ir um índice a mais do que queremos mostrar.

Pode ser um pouco confuso mesmo.


numeros1 := []int{1, 2, 3, 4}

fmt.Println(numeros1[0:2])
fmt.Println(numeros1[1:4])
fmt.Println(numeros1[0: ])

/*
Resultado: 
[1 2]
[2 3 4]
[1 2 3 4]
*/

O nosso slice vai do índice 0 ao 3, mas no fmt.Println(numeros1[1:4]) indicamos o índice 4. Queremos mostrar o último elemento da slice (índice 3), mas por padrão devemos adicionar mais um, então temos que indicar o índice 4.

O fmt.Println(numeros1[0: ]) também mostra o último elemento, mas não indicamos nenhum índice. Essa é outra opção, deixamos o campo vazio.

Deletando elementos

Para deletar elementos vamos utilizar a slice of slice e o append.

Vamos criar duas fatias da slice, deixando os números que queremos deletar de fora e depois vamos juntar as duas fatias. Fica mais fácil na prática.

numeros1 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

numeros1 = append(numeros1[0:4], numeros1[7:]...)
fmt.Println(numeros1)

//Resultado: [1 2 3 4 8 9 10]

A primeira fatia selecionou do número 1 ao 4 (índice 0 ao 3/ 4), já a segunda foi do número 8 ao 10 (índice 7 ao 9/ 10). Os números 5 ao 7 fora deixados de fora.

Para finalizar, damos um append nas duas fatias. Lembrando que queremos os elementos da fatia 2, pois eles são int.

Outro exemplo:

numeros1 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

numeros1 = append(numeros1[1:5], numeros1[6:9]...)
fmt.Println(numeros1)

//Resultado: [2 3 4 5 7 8 9]

Já falamos muito por hoje, espero que tenham entendido tudo. Amanhã vamos conhecer os slices multidimensionais.

Se quiserem me acompanhar nos estudos 👉🏽 curso

Arrays em Golang

Linive — Tue, 02 Jun 2020 21:13:42 +0000

Se você já teve contato com outras linguagens, então deve conhecer o array. Em Go eles não são tão diferentes, mas você precisa saber que ele não é o mais utilizado.

Você deve está pensando: "Nossa, o que vamos utilizar no lugar do array?
A resposta é fácil: Vamos utilizar slices.

Antes de estudarmos slice, é preciso conhecer um pouco sobre o array, pois ele será a nossa base. Então vamos lá...

Primeiro pense na sua rua. Existem várias casas, incluindo a sua. Cada casa ocupa o espaço e tem um número para ser identificada. Essa mesma lógica se aplica aos arrays.

Só que ao invés de casas, vamos ter dados. Ao invés de espaço na rua, ele ocupará um espaço na memoria do computador. E o número da casa se chamará índex ou índice.

O array é um tipo de dado composto, ele será formado por vários elementos do mesmo tipo. Posso ter um array com varias variáveis do tipo int, outro só com tipos strings e por ai vai.

Outro detalhe que vale ser lembrado é que o índice do array sempre começa do 0. Então se um array for composto por 6 elementos, o índice irá do 0 a 5.

Já falamos demais, vamos para a parte boa.



arrayDeNumeros := [5]int{1, 2, 3, 4, 5}

fmt.Println(arrayDeNumeros)

[5]int{1, 2, 3, 4, 5} essa é a forma de declaração mais utilizada, mas não é a única. Antes de conhecermos as outras, vamos entender os detalhes.

Percebam que estamos indicando o número de elementos que nosso array vai suportar, o length. Esse número é fixo, uma vez declarado, não pode aumentar, ou seja, não podemos adicionar novos elementos ao nosso array.

Podemos alterar os 5 elementos já existentes, mas não adicionar um sexto.

Adicionar novos elemento a um array é uma ação comum em outras linguagem, mas aqui não pode ser realizada. Não surte ainda, isso pode ser feito com slices



var arrayDeNumeros [5]int 

arrayDeNumeros[0], arrayDeNumeros[1], arrayDeNumeros[2] = 1, 2, 3
arrayDeNumeros[4] = 4

fmt.Println(arrayDeNumeros)

/*
Resultado: [1, 2, 3, 4, 0]
*/

Agora estamos declarando o array e atribuindo valor para seus elementos de forma separada. Um dos elementos não teve seu valor definido, então ele será zero.

For e arrays



arrayDeNumeros := [5]int{1, 2, 3, 4, 5}

for i:=0; i < len(arrayDeNumeros); i++{
    fmt.Printf("Indice: %v - Valor: %v\n", i, arrayDeNumeros)
}

fmt.Println(" ")

for i, valor := range arrayDeNumeros{
   fmt.Printf("Indice: %v - Valor: %v\n", i, valor)
} 

/*
Resultado:
Indice: 0 - Valor: 1
Indice: 1 - Valor: 2
Indice: 2 - Valor: 3
Indice: 3 - Valor: 4
Indice: 4 - Valor: 5
*/

O resultado será exatamente o mesmo.

Caso você não tenha entendido o for 👇🏽

Loop for range em go

Linive ・ May 24 '20

#go #beginners #tutorial

Agora vamos atribuir novos valores aos elementos.



arrayDeNumeros := [5]int{1, 2, 3, 4, 5}


for i, valor := range arrayDeNumeros{
    arrayDeNumeros[i] = valor + 10
} 

fmt.Println(arrayDeNumeros)

/*
Resultado: {11, 12, 13, 14, 15}
*/

Para mudar o valor de um elemento do array, é so chama-lo junto com o índice que queremos alterar: arrayDeNumeros[2]. Depois é só passar o novo valor: arrayDeNumeros[2] = 33. Nessa caso, o elemento 3 (índice 2) terá seu valor igual a 33.

Bem, de array é o que temos. Só precisamos saber que seu número de elementos é fixo, como declarar, iniciar um array e como fazer um loop com ele, pois são coisas que iremos utilizar nos slices.

Espero que tenham entendido.

Fiquem bem e para não perder o costume...
👉🏽 curso 👈🏽

Switch em Golang

Linive — Wed, 27 May 2020 20:03:35 +0000

Já ouviram falar do switch?

Não é esse tipo de switch...

Essa aí é a Taylor Swift 🤔

O switch, assim como o if, é um comando que pertence ao controle de fluxo condicional. Com ele conseguimos diminuir a quantidade de if/else encadeados.

Switch vem do verbo mudar. Vamos mudar algo, caso a condição seja verdadeira. Ele é muito utilizado em menus.

"Sr, digite um caso queira falar com a atendente. Digite dois, caso queira falar com o RH. Digite três, caso queira informações diversas."


op := 2

switch {
case op == 1:
    fmt.Println("Falar com a atendente")

case op == 2:
    fmt.Println("Falar com o RH")//Essa mensagem será exibida

case op == 3:
    fmt.Println("Informações diversas")

default:
    fmt.Println("Repetir opções")
}

Ele vai mudando de acordo com os casos. Caso a opção seja um, ele faz algo, caso a opção seja dois, ele irá fazer outra coisa, e assim por diante.

Iremos para o default se nenhum dos casos for utilizado.


op := 10

switch {
case op == 1:
    fmt.Println("Falar com a atendente")

case op == 2:
    fmt.Println("Falar com o RH")

case op == 3:
    fmt.Println("Informações diversas")

default:
    fmt.Println("Repetir opções")//Essa mensagem será exibida
}

Podemos utilizar a variável como statement. Facilitando ainda mais.


op := 10

switch op {//Estou colocando a variavel como statement
case 1:
    fmt.Println("Falar com a atendente")

case 2:
    fmt.Println("Falar com o RH")

case 3:
    fmt.Println("Informações diversas")

default:
    fmt.Println("Repetir opções")//Essa mensagem será exibida
}

Quando escolhemos fazer dessa maneira, não podemos utilizar condições que retornem true ou false.

Também podemos colocar mais de uma condição em cada case, utilizando os operadores lógicos.


num := 50

switch {
case (num >= 0) && (num <= 10):
    fmt.Println("num está entre 0 e 10  ")

case (num >= 10) && (num <= 30):
    fmt.Println("num está entre 11 e 30")

case(num >= 31) && (num == 50):
    fmt.Println("num está entre 31 e 50")//Essa mensagem será exibida

default:
    fmt.Println("num é maior que 50")
}

Se colocarmos a variável como statement, não poderemos fazer essas condições do exemplo.

fallthrough significar cair através. Quando colocamos ele em um dos casos, se ele for executado, o próximo caso também será. Ele cairá para o caso de baixo.


op := 1

switch op {
case 1:
    fmt.Println("Falar com a atendente")//Essa mensagem será exibida
    fallthrough

case 2:
    fmt.Println("Falar com o RH")//Essa também, pois utilizamos o fallthrough 

case 3:
    fmt.Println("Informações diversas")

default:
    fmt.Println("Repetir opções")
}

Também podemos fazer um switch de acordou com o tipo da variável.


var op interface{}//Declarando a variável como interface vazia

op := 10//Go vai deduzir que o tipo é int pelo valor atribuído

switch op.(type) {
case float64:
    fmt.Println("op é do tipo float64")

case bool:
    fmt.Println("op é do tipo bool")

case int:
    fmt.Println("op é do tipo int")//Essa mensagem será exibida

default:
    fmt.Println("nenhum dos casos")
}

var op interface{}. Quando declaramos uma variável com interface vazia quer dizer que ela poderá receber qualquer tipo (int, float, bool...). Normalmente já declaramos com um tipo certo: var op int, aqui ela so aceitaria tipos int.

Sabe porque a função de print aceita todos os tipos de valores? Ela tem a interface vazia, func Print(a ...interface{}) (n int, err error).

O post de hoje foi mais curto, mas cobrimos muito bem o switch.

Como sempre, se liga no curso.

Até amanhã.

Lógica booleana e operadores lógicos

Linive — Tue, 26 May 2020 23:27:18 +0000

O assunto de hoje é bem básico, mas é muito importante na programação.

Vamos começar falando da lógica booleana.

Curiosidade: O nome é em homenagem ao George Boole. Um matemático e criador da lógica booleana.

A lógica booleana trabalha com true e false, 0 e 1, ligado e desligado. São apenas dois valores opostos. Nenhuma novidade para nós, já trabalhamos com variáveis booleanas antes.

Bem, agora vamos entrar na parte da lógica...

Se eu falar: Hoje eu vou a praia E ao cinema
Necessariamente eu tenho que ir aos dois lugares. Se eu não for a praia, terei contado uma mentira. Se eu não for ao cinema, a frase também será falsa. Para a frase ser verdade, eu tenho que ir aos dois lugares.

Mas se eu falar: Hoje vou a praia OU ao cinema
Eu só precisarei ir a um dos dois lugares para a frase ser verdade. Não importa qual dos dois, basta ir a praia ou ao cinema.

O "E" e o "OU" são operadores lógicos. Eles são utilizados tanto no dia a dia, quanto na programação, a diferença é que não são representados da mesma forma.

&& = "E"
|| = "OU"
! = "NOT"

Hoje eu vou a praia E ao cinema


fuiPraia := true
fuiCinema := true

frase := fuiPraia && fuiCinema

fmt.Println("A frase é", frase)

//Resultaso: "A frase é true"

A frase é verdadeira, pois o operador lógico é o && e as variaveis são true. Um "E" só retornará verdade quando todos os elementos forem verdadeiros, ou seja, basta um false para a frase ser falsa.


fuiPraia := false
fuiCinema := true

frase := fuiPraia && fuiCinema

fmt.Println("A frase é", frase)

//Resultaso: "A frase é false"

O not é a negação de algo. Se uma variavel é true, com o not ela passa a ser false. Ele converte tudo para o oposto.


fuiPraia := false
fuiCinema := true

frase := !fuiPraia && fuiCinema //estou negando a variável praia

fmt.Println("A frase é", frase)

//Resultaso: "A frase é true"

A praia tem seu valor false, mas quando negamos, ela deixa se ser false e passa a ser true. E como já vimos true && true = true


fuiPraia := false
fuiCinema := true

frase := !fuiPraia && fuiCinema //estou negando a variável praia

fmt.Println("A frase é", !frase)//Estou negando a frase

//Resultaso: "A frase é false"

O valor da frase era true, mas estamos negando, então passa a ser false.

Agora vamos testar o && e o ! junto com um if. Lembra do exemplo do post passado?

if e operadores relacionais em Golang

Linive ・ May 25 ・ 4 min read

#go #beginners #tutorial

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 


if fizerSol { 
    fmt.Println("Vou a praia") 

}  else if tenhoDinheiro { 

    if diaDaSemana { 
        fmt.Println("Vou ao cinema")
    } else { 
        fmt.Println("Vou a festa")
    }
} else  { 
    fmt.Println("Ficarei em casa")
}

Ele pode ficar bem mais legível utilizando um operador lógico.

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 


if fizerSol && tenhoDinheiro && !diaDaSemana { 
    fmt.Println("Vou a praia") 

} else if tenhoDinheiro && diaDaSemana  { 
   fmt.Println("Vou ao cinema")

} else if tenhoDinheiro && !diaDaSemana{ 
        fmt.Println("Vou a festa")

}else { 
    fmt.Println("Ficarei em casa")
}

/*
Resultado : Vou a festa
*/

Vamos analisar por partes...

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 

/*Se fizer sol, e se eu tiver dinheiro e não for dia de semana, eu vou a praia*/
if fizerSol && tenhoDinheiro && !diaDaSemana { 
    fmt.Println("Vou a praia") 

}

Infelizmente, não está fazendo sol, fizerSol := false. Já sabemos que um false já basta para o && ser falso. Então toda a condição do primeiro if será falsa.

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 

/*Se tiver dinheiro e for dia da semana, vou ao cinema*/
...else if tenhoDinheiro && diaDaSemana  { 
   fmt.Println("Vou ao cinema")

}

Eu tenho dinheiro 🙌🏽, tenhoDinheiro := true, mas não é dia da semana diaDaSemana := false. Basta um falso para a condição ser falsa, então não vou ao cinema.

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 

/*Se tiver dinheiro e NÃO for dia da semana, vou a festa*/
...else if tenhoDinheiro && !diaDaSemana{ 
        fmt.Println("Vou a festa")

}

As duas variáveis são verdadeiras. Eu tenho dinheiro e não é dia da semana, então a condição é verdadeira e eu vou a festa 💁🏽‍♂️.

Para finalizar, vamos conhecer o "OU".

Hoje vou a praia OU ao cinema


fuiPraia := false
fuiCinema := true

frase := fuiPraia || fuiCinema 

fmt.Println("A frase é", frase)

//Resultaso: "A frase é true"

Diferente do "E" que precisa de duas verdades, no "OU" uma verdade basta. Só preciso ir a um dos dois ligares e a frase será verdadeira.


fuiPraia := false
fuiCinema := false

frase := !fuiPraia || fuiCinema //estou negando a variável praia

fmt.Println("A frase é", frase)

//Resultaso: "A frase é true"

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 


if fizerSol || tenhoDinheiro || !diaDaSemana { 
    fmt.Println("Vou a praia") 

}

if tenhoDinheiro || diaDaSemana  { 
   fmt.Println("Vou ao cinema")

}

if tenhoDinheiro || !diaDaSemana{ 
        fmt.Println("Vou a festa")

}

/*
Resultado : 
Vou a praia
Vou ao cinema
Vou a festa
*/

Todos os casos foram verdadeiros utilizando o ||, pois em cada condição tinha pelo menos uma verdade e uma verdade já basta.

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 

/* Se fizer sol OU eu tiver dinheiro OU não for dia da semana, vou a praia.
Não fez sol, mas eu tenho dinheiro e não é dia da semana*/ 
//   false         true             true          
if fizerSol || tenhoDinheiro || !diaDaSemana { 
    fmt.Println("Vou a praia") 
}

/*Se tiver dinheiro OU for dia da semana, vou a cinema.
Eu tenho dinheiro, mas não é dia da semana*/
//     true             false
if tenhoDinheiro || diaDaSemana  { 
   fmt.Println("Vou ao cinema")
}

/*Se eu tiver dinheiro ou não for dia da semana, vou a festa.
Tenho dinheiro e não é dia da semana*/
//   true               true
if tenhoDinheiro || !diaDaSemana{ 
        fmt.Println("Vou a festa")
}

Também podemos utilizar todos os operadores em uma condição:

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 
noite := true


if (fizerSol && tenhoDinheiro) || !diaDaSemana {
    fmt.Println("Vou a praia")
}  

if (tenhoDinheiro || diaDaSemana) && (!fizerSol && !noite) {
    fmt.Println("Vou ao cinema")
}

if (tenhoDinheiro && !diaDaSemana) && noite {
    fmt.Println("Vou a festa")
}

Aqui misturamos todos os operadores, vocês conseguem descobrir qual será a resposta?

A resposta será: Vou a praia / Vou a festa.

Vamos analisar o código...

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 
noite := true

/*Se fizer sol E eu tiver dinheiro, OU for dia da semana, vou a praia*/         
if (fizerSol && tenhoDinheiro) || !diaDaSemana {
    fmt.Println("Vou a praia")
}  

/*Se tiver dinheiro OU for dia da semana, E não fizer sol E não for noite, vou ao cinema*/    
if (tenhoDinheiro || diaDaSemana) && (!fizerSol && !noite) {
    fmt.Println("Vou ao cinema")
}

/*Se tiver dinheiro E não for dia da semana E for noite, vou a festa*/ 
if (tenhoDinheiro && !diaDaSemana) && noite {
    fmt.Println("Vou a festa")
}

Como toda operação matemática, devemos começar pelos parênteses.

fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false 
noite := true


//   (false  &&     true)     
//         false               ||     true  = true
if (fizerSol && tenhoDinheiro) || !diaDaSemana {
    fmt.Println("Vou a praia")
} 

//     (true      ||   false)         (true     &&   false)   
//               true             &&            false         = false   
if (tenhoDinheiro || diaDaSemana) && (!fizerSol && !noite) {
    fmt.Println("Vou ao cinema")
}

//     (true      ||   true)          
//               true             &&   true =  true
if (tenhoDinheiro && !diaDaSemana) && noite {
    fmt.Println("Vou a festa")
}

Espero que tenham entendido a lógica booleana, é um assunto que eu acho muito divertido.

Se quiserem me acompanhar nos estudos, chema mais ✌🏽

Espero que estejam bem e se puder, fiquem em casa 🏡
Até amanhã.

if e operadores relacionais em Golang

Linive — Mon, 25 May 2020 22:36:43 +0000

Então prontos para mais um post?

Hoje vamos falar sobre o fluxo de controle condicional e operadores relacionais.

Primeiros temos que entender o que é uma condição. Segundo o google: "Condição é o que determina, ou não, a realização de alguma coisa". Exemplos:

Se fizer sol, vou a praia, se não fizer, ficarei em casa

Aqui a condição é fazer sol. Se fizer sol, a pessoa vai sair, mas se não fizer, ou seja, se chover, ela ficará em casa.

Se ganhar na loteria, vou viajar o mundo, se não ganhar, vou ao cinema

Desta vez a condição é ganhar na loteria.

É uma lógica fácil e que todos utilizam no dia a dia, mesmo sem perceber. Agora vamos aplica-la na linguagem de programação.


var fizerSol bool

if fizerSol == true {
    fmt.Println("Vou a praia")

} else {
   fmt.Println("Ficarei em casa")

}

Vamos analisar o código parte por parte.

fizerSol é uma variável booleana, ou seja, só aceita true ou false.

if literalmente significa "se". Então ele deve sempre estar acompanhado de uma condição, "se isso acontecer... se não...".

fizerSol == true, essa é a condição que acompanha o if. Se ela for verdadeira (true), então o código que está no code block do if será executado.


fizerSol := true //Está fazendo sol

if fizerSol == true { //A condição é verdadeira
    fmt.Println("Vou a praia") //Esse código será executado 
}

else é o nosso "se não". Ele só será executado se a condição do if for falsa, ou seja, não esteja fazendo sol.


fizerSol := false //Está chovendo

if fizerSol == true { //A condição é false
    fmt.Println("Vou a praia") //Esse código não será executado

}  else { 
    fmt.Println("Ficarei em casa")//Esse código será executado
}

Nós também podemos criar várias condições em sequência com o else if.


fizerSol := false 
tenhoDinheiro := true


if fizerSol == true { 
    fmt.Println("Vou a praia") 

}  else if tenhoDiheiro == true { //Condição verdadeira
    fmt.Println("Vou ao cinema")//Esse código será executado

} else  { 
    fmt.Println("Ficarei em casa")
}

Agora além da condição do sol, temos a condição do dinheiro.
"Se fizer sol, vou a praia, se não fizer, ok 🤷🏽‍♀️... Eu ainda posso ir ao cinema, contanto que tenha dinheiro. Se eu não tiver dinheiro, ai não tem jeito, vou ficar em casa"

Ainda podemos colocar mais condições:


fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false //Não é dia da semana


if fizerSol == true { 
    fmt.Println("Vou a praia") 

}  else if tenhoDiheiro == true { //Condição verdadeira

    if diaDaSemana == true { //Condição falsa
        fmt.Println("Vou ao cinema")
    } else { 
        fmt.Println("Vou a festa")//Esse código será executado 
    }
} else  { 
    fmt.Println("Ficarei em casa")
}

A lógica é a seguinte:

"Se fizer sol, vou a praia, se não fizer, ok 🤷🏽‍♀️... Se eu tiver dinheiro e for dia da semana, vou ao cinema. Se eu tiver dinheiro e não for dia da semana, vou a festa. Se eu não tiver dinheiro, fico em casa"

Agora que entendemos a lógica, vamos falar desse carinha aqui: ==. Já percebemos que ele tem o sentido de igual, mas estamos utilizando dois iguais ao invés de um. Isso acontece porque ele esta em uma condição.

Quando falamos: tenhoDinheiro = true, estou atribuindo um valor a variável. Quando estamos em uma condição, não queremos atribuir valor, queremos comparar duas coisas, relacionar elas. Então para não confundir, utilizamos dois iguais ==. Ele é chamado de operador relacional.

Um detalhe é que podemos tirar ele da condição, pois por padrão só iremos entrar no if se a variável for verdadeira, true. O efeito é o mesmo e ainda deixamos menos poluído.


fizerSol := false 
tenhoDinheiro := true
diaDaSemana := false //Não é dia da semana


if fizerSol { 
    fmt.Println("Vou a praia") 

}  else if tenhoDiheiro { //Condição verdadeira

    if diaDaSemana { //Condição falsa
        fmt.Println("Vou ao cinema")
    } else { 
        fmt.Println("Vou a festa")//Esse código será executado 
    }
} else  { 
    fmt.Println("Ficarei em casa")
}

Existem outros operadores relacionais, são eles:

< - Menor
> - Maior
== - Comparação
<= - Menor ou igual
>= - Maior ou igual
!= - Diferente

Menor e Maior

Esses são mais utilizados no cotidiano.


num1 := 10
num2 := 100

if num1 > num2{//false, 10 não é maior que 100
    fmt.Println(num1,"é maior que", num2) //Esse código não será executado

} 

if num1 < num2  { // true, 10 é menor que 100 
    fmt.Println(num1,"é maior que", num2) //Esse código será executado
}

Menor ou igual e Maior ou igual


num1 := 10
num2 := 100
num3 := 10

if num1 >= num2{//false, 10 não é maior, nem igual a 100
    fmt.Println(num1,"é maior ou igual a", num2) //Esse código não será executado
} 

if num1 <= num2  { // true, 10 é MENOR ou igual a 100 
    fmt.Println(num1,"é maior ou igual a", num2) //Esse código será executado
}

if num1 <= num3  { // true, 10 é menor ou IGUAL a 10
    fmt.Println(num1,"é menor ou igual a", num3) //Esse código também será executado
}

Diferente


num1 := 10
num2 := 100
num3 := 10

if num1 != num2{//true, 10 é diferente de 100
    fmt.Println(num1,"é diferente", num2) //Esse código será executado
}

if num1 != num3  { // false, 10 não é diferente de 10
    fmt.Println(num1,"diferente de", num3) //Esse código não será executado
}

Além dos operadores relacionais, temos os Operadores lógicos. Mas vamos conhece-los amanhã, junto a com a nossa querida lógica booleana.

Para não perder o costume...
Vai dar uma olhada nesse curso. Material de qualidade e gratuito para a comunidade 🤙🏽

Fiquem bem, assistam muitas séries e até amanhã.

Loop for range em go

Linive — Sun, 24 May 2020 21:23:26 +0000

Hoje vamos falar um pouco mais sobre loops.

Vocês já ouviram valar sobre o for range?

Calma que não é esse tipo de ranger...

Ele é outra versão do loop for, muito utilizado com slices, arrays, maps e strings. O que esses tipos têm em comum? São compostos por um grupo de outros elementos.

Ainda não vimos slices, arrays e maps, apenas sabemos que são tipos compostos, ou seja, formado por tipos primitivos. Mas já conhecemos bem o tipo string.

Sabemos que a string é uma cadeia de caracteres, ou runes, e que uma rune é do tipo int32, podendo ter até 4 bytes. Já aprendemos a transformar caracteres em slice of bytes, sabemos que existe a tabela ASCII, o UTF-8 e o unicode, entre outras coisas. Por isso vamos aprender o for range com strings.

Esse é o for range:


serie := "modern family" 

for indice, valor := range serie {

    fmt.Printf("índice: %v - valor: %v\n", indice, valor)
}
/*
resultado:
índice: 0 - valor: 109 
índice: 1 - valor: 111 
índice: 2 - valor: 100
índice: 3 - valor: 101
índice: 4 - valor: 114
índice: 5 - valor: 110
índice: 6 - valor: 32
índice: 7 - valor: 102
índice: 8 - valor: 97
índice: 9 - valor: 109
índice: 10 - valor: 105
índice: 11 - valor: 108
índice: 12 - valor: 121
*/

O resultado foi numérico, se você leu o post de conversão 👇🏽:

Conversão de tipos em Golang

Linive ・ May 22 ・ 4 min read

#go #beginners #tutorial

Já deve saber exatamente o que aconteceu, o tipo deixou de ser string e passou a ser int32, que é o tipo de um caractere. Esses números que saíram no resultado podem ser encontrados na tabela ASCII, o número 32, por exemplo, é referente ao espaço que existe na string.

Vamos conhecer parte por parte do for range.


serie := "modern family" 

for indice, valor := range serie {...}

O range vai percorrer toda a extensão da string, ele vai pulando de letra em letra a cada volta do loop. Toda vez que ele mudar de letra irá retornar dois valores, o índice e o valor daquele caractere.

O indice indicará a localização do caractere na string. Começando do zero até finalizar toda a extensão da variável. O espaço está na localização 6, lembrando que começamos a contar sempre do zero.
Muitas pessoas chamam o índice de i.

Já o valor, value, irá receber a informação do valor daquele caractere.
Podemos chama-lo apenas de v.

Juntando as duas informações i e v, conseguimos indicar a localização e o valor das letras: fmt.Printf("indice: %v, valor: %v", i, v).

Se não precisarmos de um desses valores, podemos apenas ignora-lo utilizando o underline _.


serie := "modern family" 

for _, valor := range serie {...}
//Estou ignorando o índice

Para exibir as letras como caracteres, podemos converter novamente para strings.


serie := "modern family" 

for i, v := range serie {

    fmt.Printf("índice: %v - valor: %v -  letra: %s\n", i, v, string(v))

}
/*
resultado:
índice: 0 - valor: 109 - letra: m
índice: 1 - valor: 111 - letra: o 
índice: 2 - valor: 100 - letra: d
índice: 3 - valor: 101 - letra: e
índice: 4 - valor: 114 - letra: r
índice: 5 - valor: 110 - letra: n
índice: 6 - valor: 32 - letra:
índice: 7 - valor: 102 - letra: f
índice: 8 - valor: 97 - letra: a
índice: 9 - valor: 109 - letra: m
índice: 10 - valor: 105 - letra: i
índice: 11 - valor: 108 - letra: l
índice: 12 - valor: 121 - letra: y
*/

Muitas das coisas que fazemos com o for range também podem ser feitas com o for normal, esse exemplo é uma delas.

Apenas precisamos conhecer a funcionalidade do len. Length que dizer comprimento, extensão. Ele pegará o comprimento da minha string e assim poderemos fazer o for normal de acordo com a extensão, assim como o for range.

serie := "modern family" 

for i := 0; i < len(serie); i++ {//enquanto i for menor que a extensão da string

    fmt.Printf("índice: %v - valor: %v -  letra: %s\n", i, serie[i], string(serie[i]))

}

Outra diferença é esse tal de serie[i]. O for normal não irá pular de letra em letra automaticamente igual ao range. Então temos que indicar de alguma forma que a cada loop iremos mudar de letra. Por isso utilizamos o serie[i].

Essa estrutura é muito utilizada em arrays e slices. Colocamos o nome da variável e o índice que queremos fica dentro dos colchetes. Como o i começa do zero e será incrementado a cada volta do loop, ele será nosso índice.

O resultado dos dois for será exatamente o mesmo, mas nem sempre será assim. Vamos ver o que acontece se um caractere ocupar mais de um byte.


sdds := "São João" 

for i, v := range sdds{

    fmt.Printf("índice: %v - valor: %v -  letra: %s\n", i, v, string(v))

}
/*
resultado:
índice: 0 - valor: 83 - letra: S
índice: 1* - valor: 227 - letra: ã
índice: 3* - valor: 111 - letra: o
índice: 4 - valor: 32 - letra:
índice: 5 - valor: 74 - letra: J
índice: 6 - valor: 111 - letra: o
índice: 7* - valor: 227 - letra: ã
índice: 9* - valor: 111 - letra: o
*/

No for range não aconteceu nenhuma mudança. Mas percebam que os índices estão pulando alguns números, ele foi de 1 para 3 e de 7 para 9.

Vamos ver no for:

sdds:= "São João" 

for i := 0; i < len(sdds); i++ {

    fmt.Printf("índice: %v - valor: %v -  letra: %s\n", i, sdds[i], string(sdds[i]))

}

/*
Resultado:
índice: 0 - valor: 83 - letra: S
índice: 1 - valor: 195 - letra: Ã*
índice: 2 - valor: 163 - letra: £*
índice: 3 - valor: 111 - letra: o
índice: 4 - valor: 32 - letra:
índice: 5 - valor: 74 - letra: J
índice: 6 - valor: 111 - letra: o
índice: 7 - valor: 195 - letra: Ã*
índice: 8 - valor: 163 - letra: £*
índice: 9 - valor: 111 - letra: o
*/

Os índices não pularam nenhum número, mas em compensação alguns caracteres estranhos apareceram.

Isso aconteceu pois existem letras acentuadas, elas ocupam 2 bytes, diferente das outras. O for range percorrer caractere por caractere (int32), não importando quantos bytes eles ocupam. Já o for irá de byte por byte (uint8), então se uma letra ocupar mais de um byte, o for irá mostrar.

Essa é uma diferença sutil, mas as vezes o resultado não sai como o esperado e não sabemos o motivo.

Hoje conhecemos o for range e trabalhamos um pouco mais com o for, espero que tenham entendido e procurem exercitar e experimentar mais os dois.

Se quiserem me acompanhar nos estudos: É só clicar aqui e ser feliz.

A missão de hoje foi realizada com sucesso, até amanhã.

Loop for em Golang

Linive — Fri, 22 May 2020 21:32:31 +0000

Já vamos começar com uma notícia impactante, estão prontos?

Em Go não tem loop while.

Também achei estranho, mas no final das contas ele não faz falta 🤷🏾‍♀️.

Vamos rebobinar e começar por onde deveríamos ter começado, pelo começo.

Existem 3 tipos de fluxo de controle:

Sequencial: É o fluxo padrão do código. Ele é lido de cima para baixo, de forma sequencial, sem interrupções.
Repetição: É o fluxo que estudaremos hoje. Também é conhecido como iterativo ou loop. Ele irá repetir o mesmo código diversas vezes.
Condicional: O fluxo condicional depende das condições que iremos criar. Ele só irá executar o código se a condição for verdadeira.

for contador := 0; contador < valorMaximoDeVoltas; contador++{
    //Tudo que estiver aqui dentro será executado a cada volta do loop 
}

Fluxo de controle de repetição

Como já mencionamos, o fluxo de controle de repetição irá quebrar o fluxo sequencial, que é o padrão. Ele será interrompido e um loop irá iniciar.

Em Go, temos apenas o loop for. Pode parecer insuficiente, mas não se engane, ele irá resolver bem os nossos problemas.

contador:

Ele irá contar as voltas do nosso loop. Podemos chamar ele de qualquer coisa, muitas pessoas chamam de "i".

Estamos declarando e inicializando o contador com o valor zero.

valor máximo de voltas:

Normalmente quando fazemos um for, já sabemos a quantidade de loops que iremos precisar (5, 10, 20 voltas);

Esse número de voltas necessárias é o nosso valor máximo.

contador < valorMaximoDeVoltas:

Isso aqui é uma condição, ela deve ser verdadeira para o loop acontecer.

A lógica é a seguinte: Se o contador for menor que o valor máximo de voltas, então repita o loop mais uma vez.

contador++:

Estamos realizando um pós incremento. O incremento só será realizado depois que a volta do loop for feita.

contador ++ é a mesma coisa que contador = contador + 1.

O incremento é importante, pois sem ele irá acontecer um loop infinito. Não teremos mais controle sob quantas voltas o loop deu, o contador nunca irá ficar maior que o valor máximo de voltar, então o loop nunca parará de rodar.
Em alguns casos essa pode ser a funcionalidade que queremos, mas na maioria das vezes não é.

for i := 0; i <= 10; i++{
   fmt.Printf("%v -", i)
}

//Resultado: 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10

Esse é um exemplo básico.

Também podemos ter loops dentro de loops, são loops aninhados.

for horas := 1; horas <= 2; horas++{
   fmt.Printf("***Hora: %v", horas)

   for minutos := 1; minutos <= 60; minutos{
       fmt.Printf("\t%v\t", minutos)
   }

   fmt.Println(" ")
}

/*Resultado: Vamos mostrar cada minutos que existe em duas horas
*** Hora: 1
        1       2       3       4       5       6       7       8       9       10      11      12      13      14      15      16      17      18      19      20      21      22    
23      24      25      26      27      28      29      30      31      32      33      34      35      36      37      38      39      40      41      42      43      44      45    
46      47      48      49      50      51      52      53      54      55      56      57      58      59      60
*** Hora: 2
        1       2       3       4       5       6       7       8       9       10      11      12      13      14      15      16      17      18      19      20      21      22    
23      24      25      26      27      28      29      30      31      32      33      34      35      36      37      38      39      40      41      42      43      44      45    
46      47      48      49      50      51      52      53      54      55      56      57      58      59      60
*/

horas e minutos são nossos contadores, iniciamos eles do 1 pois não existe minuto 0 e não queremos começar com a hora 0.

O loop de horas é o maior, ele engloba o loop de minutos. Já o loop de minutos está contido no loop de horas, ele é menor. O que isso quer dizer? Quer dizer que o loop de minutos irá rodar mais vezes que o loop de horas.

Essa sempre será a lógica, quando mais interno um loop é, mais ele irá rodar.

Para um loop de horas (1 hora), o loop de minutos irá girar 60 vezes, pois temos 60 minutos em uma hora.

Podemos aninhar quantos loops quisermos. Podemos até colocar um loop de segundo dentro do loop de minutos. O loop de segundos irá girar 60 vezes para cada loop do minuto, e girará 3600 vezes para um loop da hora.

Tentem fazer um loop que mostre todos os dias de 3 meses, vamos considerar que cada mês tem exatamente 30 dias.


for mes := 1; mes <= 3; mes++{
    fmt.Println("*** mês:", mes)

    for dia := 1; dia <= 30; dia++{
        fmt.Printf("%v   ", dia)
    }

    fmt.Println(" ")
}

/*Resultado:
*** mês: 1
1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  
27  28  29  30
*** mês: 2
1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  
27  28  29  30
*** mês: 3
1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  
27  28  29  30
*/

Podemos fazer isso para todos os meses do ano

Se você quiser simular um while, também é possível.

i := 0

for i < 10 {
    fmt.Println(i)
    i++
}

Agora conheçam um loop infinito:

for  {
    fmt.Println("loop infinito")
}

Esse loop é infinito de propósito, não colocamos uma condição para ele parar de girar. Quando fazemos um loop assim, sua funcionalidade demanda algo que esteja rodando constantemente. Mas as vezes podemos esquecer de algum incremento ou outro elemento, então criaremos um loop infinito por falha.

Temos outro tipo de for, o for range, mas vamos falar dele amanhã. Podemos fazer a maioria das coisas com o for normal, mas as vezes o for range pode ser a melhor escolha. Ele é muito utilizado com slices e strings.

Continue e break

São funcionalidades muito utilizadas no loop. O break é para interromper um loop antes dele completar suas voltas necessárias. Já o continue interrompe apenas uma volta, ele pula aquela volta, mas não interrompe o loop completo.

Exemplo:

for i := 0; i < 20; i++{
    if(i == 5){ //Se i for igual a 5, interrompa a volta dele
        continue
    }

    if (i == 16){ //Se i for igual a 16, quebre o loop
        break
    }

    fmt.Println(i)
}

//Resultado: 1 2 3 4 6 7 8 9 10 11 12 13 14 15

O número 5 não será exibido, pois a volta dele foi interrompida pelo continue, já o 16 não será mostrado pois o loop foi interrompido pelo break.

Se você não entendeu esse tal de if(i == 5) e if (i == 16), não se preocupe. O if faz parte do fluxo de controle condicional, é assunto para outro dia.

Lembrando, estou aqui para documentar meus estudos. Se quiserem estudar também, assistam esse curso que é sucesso 🤙🏾.

Por hoje é só, fiquem bem e se cuidem. Até amanhã.

Conversão de tipos em Golang

Linive — Fri, 22 May 2020 02:16:22 +0000

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ã!

Uint vs Int. Qual a diferença em Go?

Linive — Wed, 20 May 2020 23:03:47 +0000

⚠️ Alerta: Antes de entrar nesse assunto, é necessário um conhecimento básico de tipos primitivos e medidas de armazenamento.

Tipos primitivos e tipos compostos em golang

Linive ・ May 18 '20

#go #beginners

Bases numéricas e Medidas de armazenamento

Linive ・ May 19 '20

#go #beginners #tutorial

Já deu uma lida? Então vamos lá!

◾ Uint - unsigned int

Unsigned significa sem sinal, não assinalado. Então é exatamente isso que ele é, um int que desconsidera o sinal.

Moleza demais

Agora vamos para as suas variações:

uint8
uint16
uint32
uint64

Já mencionamos algumas delas em outros posts, mas hoje vamos entrar em detalhes.

Uint8

Sabemos que esse 8 faz referência a quantidade de bits, que é uma medida de armazenamento. Esses bits irão definir a capacidade desse tipo.

Mas como descobrimos a capacidade de armazenamento de um tipo, tendo apenas sua quantidade de bits? É fácil, tem uma fórmula para isso.

Esse n é a quantidade de bits.

No caso do uint8, a formula fica assim:

O Resultado dessa conta é 256. Então uma variável do tipo uint8 tem capacidade de armazenamento de 0 a 255. Nunca esqueçam do zero, ele também conta!.

Vocês devem esta se perguntando: "ok. Mas qual a importância disso?"

Problemas podem ocorrer se passarmos dessa capacidade máxima, esse problema se chama overflow e a NASA o conhece muito bem...

370 milhões de dólares por um erro de integer overflow. Se quiser conhecer mais a história: aqui

Como ocorre um overflow?

1°: Podemos tentar atribuir um valor maior que a capacidade



var x uint8 = 1000

fmt.Println(x) 
//Um erro será apresentado: 1000 overflows uint8
//Esse código não será executado

Esse aqui é o melhor caso, ou menos pior, pois o erro será apresentado e o código não será executado. A mensagem indicará qual é o erro e assim podemos corrigi-lo.

2°: Vamos causar o ovewflow durante o código



var x uint8 = 255

fmt.Println(x) 
/*Esse código irá executar sem nenhum erro, pois não ultrapassamos 
o limite de armazenamento da variável*/

Nenhum erro aconteceu, mas sabemos que o número atribuído a variável está no limite de sua capacidade. Isso é bem perigoso, pois no meio do código pode ocorrer um incremento e o overflow irá acontecer.



var x uint8 = 255

x++ //Um incremento. O overflow aconteceu, x agora vale 256

fmt.Println(x)

O que vocês acham que vai acontecer? O código não irá executar ou irá apresentar um erro?

Nenhum das opções. O código continuará funcionando normalmente. Ai que está o perigo, nenhuma mensagem irá aparecer.

Sabe o que irá acontecer com a variável? Ela volta a ser zero. x = 0 .

Agora imagine isso em um código gigante e com inúmeras variáveis. Imagine o trabalho para achar qual delas sofreu overflow, e a pior parte vai ser deduzir que o problema é de overflow, já que nenhum erro é apresentado.

Falta só um detalhe para finalizar o int8.

Vocês lembram quem um byte é igual a 8 bits? Sabe quem tem 8 bits? Exatamente, o uint8. Um byte é igual a uint8 e podemos declarar uma variável como byte, o resultado será o mesmo.



var x byte = 255 // byte = uint8

fmt.Println(x)

Essa lógica do uint8 se aplica a todas suas variações.

uint16
uint32
uint64

O que irá mudar é a capacidade de armazenamento, já que os bits são diferentes.

◾ Int - signed int

Signed significa assinalado, com sinal. Então o int irá considerar o sinal dos números.

Essas são suas variações:

int8
int16
int32
int64

As variações são as mesmas, a única diferença é a questão do sinal. O que isso irá mudar na prática?

Bem, o armazenamento do uint começava do zero, pois ele não considera os números negativos. Então se sua capacidade é de 256, vai de 0 a 255.

Os ints consideram o sinal, então eles utilizam tanto o lado positivo quanto o negativo.

Então se teoricamente a capacidade de armazenamento for de 256, ele deve ir de 0 a 255, mas também deve ir para o lado negativo, de -1 a -256.

Espero que tenham entendido, mas se não ficou claro, vocês vão entender mais para frente.

Int8

Se vocês estão achando que o int8 irá armazenar 256 assim como o uint8, vocês estão... errados.

Eles não serão iguais porque um dos bits do int8 será destinado ao sinal, então apenas 7 entrarão no cálculo.

O resultado será 128. Então vai de 0 a 127 e de -1 a -128.

Overflow funciona exatamente da mesma forma, mas levando em consideração os números negativos.



var x int8 = 128 // Overflow, pois vai até 127
var y int8 = -129// Overflow, pois vai até -128

Essa mesma lógica se aplica as outras variações.

int16
int32
int64

Uma informação importante. Vocês lembras das runes? rune é um caractere de string. Uma rune é igual a um int32, e assim como no caso byte/uint8, podemos declarar uma variável com rune.



var x rune = 127 //rune = int32

Outro ponto que não devemos esquecer é que nenhum tipo é igual a outro. Um int não é igual a um int8, uint32 não é igual a int32 e assim por diante. As únicas coisas que são iguais são: rune = int32 e byte = uint8, pense neles como apelidos.

Essas são as diferenças entre uint e int, espero que tenham entendido.

Este é o curso que estou seguindo, recomendo!

Já falamos muito por hoje, vejo vocês amanhã!

Bases numéricas e Medidas de armazenamento

Linive — Tue, 19 May 2020 21:27:13 +0000

AVISO⚠️
Esse é um post mais teórico, mas o conteúdo é importante para entender os tipos numéricos. Assunto de amanhã.

O post passado foi sobre os tipos primitivos. Se você não viu, dá um pulinho lá! Vai facilitar o entendimento sobre o assunto de hoje 👇

Tipos primitivos e tipos compostos em golang

Linive ・ May 18 ・ 3 min read

#go #beginners

Eu disse que existiam detalhes por trás de cada tipo primitivo. Bem, hoje vamos fazer uma introdução, criar uma base para em seguida entender esses detalhes mencionados.

Antes de mais nada, precisamos conhecer as bases numéricas. Calma que não é nenhum bicho de sete cabeças!

Decimal

O decimal já conhecemos bem, é nosso companheiro desde o jardim de infância.

A base decimal vai de 0 a 9. Sim, de 0 a 9, não é de 0 a 10.
0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Se chama decimal porque possui 10 números, o zero conta, e não porque vai até 10.

Octal

O nome parece estranho, mas ele não é muito diferente do decimal. A base octal vai de 0 a 7.
0, 1, 2, 3, 4, 5, 6, 7

E o nome octal segue a mesma lógica do decimal, são 8 números contando com o zero.

Hexadecimal

Esse aqui é mais utilizado no mundo da programação. Ele possui 10 números, igual ao decimal, e 6 letras. Juntando as duas informações, fica hexadecimal.
0, 1, 2, 3, 4, 5, 6, 7, 9 e a, b, c, d, e, f

Ele é utilizado pois permite representar números muito grandes de forma mais suscita. Exemplo


num := 198056 //decimal

fmt.Printf("num em octal: %#o", numero) // resultado: num em octal: 0602650
fmt.Printf("num em hexadecimal: %#X", numero) // resultado: num em hexadecimal: 0X305A8

Outro detalhe importante. Utilizamos um 0X antes do número para indicar que ele é hexadecimal e um 0 para indicar que é octal, assim não confundimos eles.

O resutado foi 0X305A8, mas o número real é apenas 305A8.

Vocês lembram dos formt verbs? %#o é o format verb para octal e %#X é para hexadecimal.

Binário

Possivelmente é a base mais importante para nós.

Binário trabalha apenas com dois números 0 e 1. E o computador trabalha apenas com números binários, ou seja, um computador entende apenas 0 e 1.

Tudo que fazemos em nossos computadores é traduzido para número binário.

Um digito binário (0 ou 1), ou binary digit, é mais conhecido como bit. E o bit é a menor unidade de informação que pode ser armazenada ou transmitida, usada na computação. Ou seja, não existe nada menor que um bit.


num := 198056 //decimal

fmt.Printf("num em binario: %b", numero) // resultado: num em binario: 110000010110101000

Existe muito assunto a ser estudado sobre bases numéricas. É possível converter uma base em outra com cálculos feitos a mão, com código é fácil demais, para nossa alegria. Também é possível fazer operações matemática com cada uma das bases. É importante salientar que todo conhecimento é válido, mas esses detalhes não serão tão utilizados no dia a dia.

Já conhecemos as bases, sabemos o que é um bit e descobrimos que um computador trabalha apenas com eles.

O que falta para entrarmos nos detalhes dos tipos primitivos?

Temos que conhecer as medidas de armazenamento.


bit < byte < kilobyte < megabyte < gigabyte < terabyte

Bit

Já conhecemos esse carinha. É a menor unidade de armazenamento.

Byte

Ele é composto por 8 bits.

8 bits é igual a 1 byte. Eles são a mesma coisa

Kilobyte

Composto por 1024 bytes

Megabytes

Composto por 1024 kilobytes

Gigabytes

Esse aqui muita gente já conhece, é o mais utilizado para se referir a armazenamento de memória.

Composto por 1024 megabytes

Tera

Composto por 1024 gigabytes.

Pesquisas indicam que pessoas que possuem armazenamento em terabytes são mais felizes e menos estressadas. Fonte: Linive

Finalizamos as bases numéricas e as medidas de armazenamento. Agora vocês devem está se perguntando: Qual a ligação disso com os tipos numéricos?

Lembram das variações de int? int8, int32, in64, uint8 ...

Esses números depois do int são bits, olha só que surpresa. Eles vão ser fundamentais na hora do armazenamento de uma variável. Agora que sabemos a base, será muito mais fácil entender os tipos numéricos e suas diferenças.

Espero que vocês estejam se sentindo bem durante a quarentena.

Se quiser ocupar a cabeça e ainda aprender uma coisa incrível, vem pro lado programador da força.

Até amanhã!

Tipos primitivos e tipos compostos em golang

Linive — Mon, 18 May 2020 19:14:37 +0000

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.

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.

nome string := "Avatar"
idade int := 112
altura float64 := 1.45
careca bool := true

Os tipos primitivos são:

nome string := "Avatar"

string trabalha com cadeia de caracteres, basicamente são textos. Um caractere da string é chamado de rune, runa em português.

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.

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.

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.

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.

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

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.

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. Ele é muito bom para quem esta iniciando, assim como eu.

Até o próximo post!