Seja bem vindo ao tutorial #7 da GoSchool!

Caso você tenha perdido o tutorial #6 sobre Estrutura de Dados e seus Métodos, segue o link:

#6 GoSchool: Estrutura de Dados e seus Métodos

Vamos abordar um dos recursos essenciais para todos os seus desenvolvimentos, as funções.

Por ser um assunto muito direto, vamos abordar sua estrutura por tópicos:

• Parâmetros;
• Retornos;
• Defer;
• Função como Parâmetro

Antes de abordarmos os tópicos, vamos entender um pouco sobre a declaração básica de uma função.

- “Show, vamos lá!”

Declaração

A declaração de uma função em Go é feita utilizando o operador func .

Possui uma estrutura obrigatória com alguns itens opcionais, apresentados a seguir:

func nomeDaFuncao (parametros) (retorno) {}

• nomeDaFuncao - Nome da função, pelo qual será chamada e identificada - [Obrigatório];
• parametros - Lista de parâmetros utilizados na função - [Obrigatório];
• retorno - Parâmetros de retorno da função - [Opcional]

- “Entendi como ela é declarada, mas não entendi como utilizá-la.”

Sem problemas! Vamos chamar os Gophers!

Criamos uma função que vai verificar, entre dois Gophers, qual deles é o maior, retornando o resultado para uma variável. Note que a estrutura ficou assim:

• maior - Nome da função;
• Gophers - Parâmetros da nossa função;
• Gopher - Tipo de retorno da função

Nesse caso, ele irá aplicar um série de conceitos que já vimos aqui na GoSchool, e vai identificar qual dos dois Gophers é o maior.

O resultado será:

- “Como devo executa-la?”

A execução de uma função é feita da seguinte forma:

• Função

func teste() { //LOGICA }

• Execução

func teste() { //LOGICA }

func main() {

  teste()

}

Note que declaramos nossa função teste fora da função main , isso porque nesse exemplo, vamos executar essa função logo que o código for executado.

Funções devem ser declaradas de forma individual e não compartilhada, podendo então, ser utilizadas por outras funções.

Vamos explicar as “partes” de um função para que tudo fique mais claro!

Começando por parâmetros.

1. Parâmetros

Os parâmetros são “valores” utilizados na lógica de uma função.

Uma conta de soma, por exemplo:

• 5 + 3 = 8

Os números 5 e 3, são os parâmetros utilizados para que a lógica operacional da soma possa ser executada.

Vamos entender melhor como utilizar parâmetros através dos tópicos:

• Indefinido;
• Definido Simples;
• Definido Composto;
• Definido Composto Variável

- Indefinido

Uma função com parâmetros indefinidos é responsável por executar algum tipo de ação sem a necessidade prévia de valores para sua lógica operacional.

Um exemplo de função com parâmetros implícitos:

• Função

func dizerOi() {

   fmt.Println("Oi")

}

• Execução

dizerOi()

//OUTPUT : Oi

- Definido Simples

Uma função definida simples possui apenas um parâmetro necessário para sua lógica operacional.

No momento que declaramos um parâmetro, precisamos definir seu tipo, já que nesses casos, a linguagem exige uma declaração explícita do mesmo.

Sua estrutura é:

func nomeDaFunc (nomeDoParametro tipo)

Um exemplo:

• Função

func dizNome(nome string){

   fmt.Printf("Olá %s", nome)

}

• Execução

dizNome("Guilherme")

/OUTPUT: Olá Guilherme

Note que para utilizarmos um parâmetro do tipo texto, foi necessário definir o tipo string após a declaração do nome.

Após criarmos a função, devemos obrigatoriamente preencher a variável solicitada pela função no momento de sua execução.

- Definido Composto

Diferente da função definida simples, a composta possui mais de um parâmetro de declaração.

Na definição de parâmetros também devemos especificar o tipo.

func nomeDaFuncao (param1 tipo, param2 tipo, param3 tipo)

• Parâmetros de tipos diferentes:

func nomeDaFuncao (param1 int, param2 string, param3 float32)

• Parâmetros de tipos iguais:

func nomeDaFuncao(param1, param2, param3 string)

Note quando o tipo é igual para todos, podemos defini-lo no final da declaração. Algo que simplifica e muito, a escrita de funções.

Um exemplo:

• Função

func declararIdade(nome string, anoNascimento int) {

    idade := 2018 - anoNascimento

    fmt.Printf("%s tem %d anos", nome, idade)

}

• Execução

declararIdade("Guilherme", 1997)

//OUTPUT: Guilherme tem 21 anos

Processo bem simples!

- Definido Composto Variável

Como apresentado anteriormente, parâmetros do mesmo tipo podem ser escritos de forma continua, tendo o seu tipo definido no término da declaração.

func nomeDaFuncao(param1, param2, param3 tipo)

Porém, nem sempre o número de parâmetros pode ser definido.

- “Como assim?”

Pense que você quer efetuar uma soma de diversos números. A quantidade de números é desconhecida, mas queremos executar essa operação da mesma forma.

A estrutura então, deve utilizar spread(... ),um operador lógico de distribuição :

func nomeDaFuncao(parametros... int)

Note que estamos declarando diversos parâmetros do tipo inteiro.

Voltando ao nosso exemplo, temos:

• Função

func soma(numeros... int) {

   var resultado int

   for _, num := range numeros {

      resultado += num      

   }

   fmt.Println(resultado)

}

- “Range, o que é isso?”

Como não havíamos falado de array e slice antes das estruturas de controle, não conseguimos explicar o range .

De forma rápida e direta, o range é utilizado para percorrer um array ou slice retornando seu índice e o seu valor em um for.

slice := []string{"a", "b", "c"}

for indice, valor := range slice {

   fmt.Printf("%d - %s\n", indice, valor)

}

//OUTPUT:
0 - a
1 - b
2 - c

Agora que entendemos range

• Execução

soma(1, 2, 3, 4, 5, 6)

//OUTPUT: 21

Note que passamos um número indeterminado de parâmetros, e mesmo assim, o sistema conseguiu executar a operação.

AGORA SIM!

Parâmetros entendidos, podemos falar sobre os retornos de uma função.

2. Retornos

O retorno de uma função é o que garante a vasta utilização de funções em todo e qualquer desenvolvimento.

Os retornos são opcionais, ou seja, podem ou não existir em uma função.

Sua declaração é feita da seguinte forma:

func nomeDaFuncao (parametros) (retorno)

Além disso, utilizamos dentro da função o operador return para informar o valor que será retornado.

Vamos entender um pouco melhor cada um dos tipos de retorno.

Eles podem ser:

• Indefinido;
• Definido Simples;
• Definido Composto;
• Definido Nomeado

- Indefinido

Funções que por padrão não retornam nenhum tipo de valor.

Todas as apresentadas até aqui, são funções de retorno indefinido.

Um exemplo simples é:

• Função

func dizerOi() {

   fmt.Println("Oi")

}

• Execução

dizerOi()

//OUTPUT : Oi

Note que ele executou uma ação, mas não retornou nenhum tipo de valor.

- Definido Simples

O retorno definido simples é composto por um único valor retornado.

Sua declaração é feita apresentando o tipo de retorno que será feito.

- “Não entendi nada.”

Vamos supor:

Preciso de uma função que capture dois números e me retorne o valor de sua divisão.

Sabemos que:

• 2 parâmetros int;
• 1 retorno int;

Dessa forma:

• Função

func divisao(num1, num2 int) int {

    divisao := num1 / num2
    
    return divisao 

}

• Execução

resultado := divisao(10, 2)

fmt.Println(resultado)

//OUTPUT: 5

Note que dessa vez, colocamos nossa função em uma variável chamada resultado , já que ela possui um parâmetro de retorno.

SIM! TODO PARÂMETRO DE RETORNO DEVE SER ARMAZENADO EM UMA VARIÁVEL OU CONSUMIDO COMO UM NOVO PARÂMETRO.

- Definido Composto

O retorno definido composto garante o retorno de múltiplos valores, de diversos tipos.

Diferente da declaração de parâmetros, independente se os tipos forem iguais, é necessário especificar o retorno de cada um deles.

- “Calma aí, explique melhor.”

Vamos utilizar o seguinte exemplo:

Preciso de uma função que receba o nome, sobrenome e ano de nascimento, que me retorne o nome completo e a idade.

Beleza, possuímos:

• 3 parâmetros ( 2 textos, 1 inteiro);
• 2 retornos (1 texto, 1 inteiro)

Nosso exemplo deve ficar assim:

• Função

func retornaDados(nome, sobrenome string, anoNascimento int)(string,int){

    nomeCompleto := nome + " " + sobrenome

    idade := 2018 - anoNascimento

    return nomeCompleto, idade

}

• Execução

nome, idade := retornaDados("Guilherme", "Caruso", 1997)

fmt.Printf("Nome Completo: %s\n Idade: %d", nome, idade

//OUTPUT: 
Nome Completo: Guilherme Caruso
Idade: 21 

Note que como possuímos dois retornos, precisamos armazená-los em diferentes variáveis.

O número de variáveis é exatamente o mesmo que o número de retornos.

- “Sou obrigado a utilizar todos os valores de retorno?”

Não!

Porém, para que a linguagem não apresente um erro, é necessário utilizar o operador _ no lugar da variável que não deseja utilizar.

Para que isso fique claro, vamos repetir o exemplo anterior, sem utilizar o retorno de idade

nome, _ := retornaDados("Guilherme", "Caruso", 1997)

fmt.Printf("Nome Completo: %s", nome)

//OUTPUT: Nome Completo: Guilherme Caruso

Utilizamos o _ para informar que nesse momento não queremos utilizar uma das variáveis de retorno .

Simples como falar!

Por fim, podemos falar de uma forma ainda mais simples de utilização dos retornos. Estou falando de retornos nomeados.

- Definido Nomeado

Esse método funciona da mesma forma que todos os retornos já apresentados, contudo, a variável de retorno é iniciada no momento da declaração da função.

- “Consegue melhorar essa explicação?”

CLARO!

Vamos utilizar o exemplo anterior, ok?

Preciso de uma função que receba o nome, sobrenome e ano de nascimento, que me retorne o nome completo e a idade.

• 3 parâmetros ( 2 textos, 1 inteiro);
• 2 retornos (1 texto, 1 inteiro)

A declaração fica:

• Função

func retornaDados(nome, sobrenome string, anoNascimento int)(nomeCompleto string, idade int) {

   nomeCompleto = nome + " " + sobrenome

   idade = 2018 - anoNascimento

   return

}

Sim, eu sei, ficou grandão ehhehe.

Note que na declaração de retorno, especificamos as variáveis e seus respectivos tipos.

Após a execução da lógica operacional, precisamos declarar com o operador de igualdade ( = ) o valor a ser atribuído para a nova variável, finalizando o processo com o return já que o sistema reconhece de forma automática quais são as variáveis de retorno.

• Execução

nome, idade := retornaDados("Guilherme", "Caruso", 1997)

fmt.Printf("Nome Completo: %s\n Idade: %d", nome, idade

//OUTPUT: 
Nome Completo: Guilherme Caruso
Idade: 21

A partir daqui, já estamos dominando tudo o que uma função é capaz de fazer. Agora, vamos abordar algumas funcionalidades que podem, e serão de extrema utilidade durante todos os seus desenvolvimentos.

3. Defer

Esse tópico será descrito de forma rápida, já que nos próximos tutoriais vamos abordar com muito mais detalhes sua utilização. Nesse momento, quero mostrar sua aplicação básica, para que seja possível começarmos a controlar o fluxo de ações dentro de um função.

ATENÇÂO: Aqui vamos fazer uma utilização básica do defer . Nos próximos tutorais entrei com mais detalhes.

- “Muito aviso e pouca ação!”

Bem, de forma direta, o operador defer garante que uma determinada função ou ação seja executada no “último” momento da função “pai”.

Não entendeu? Já sabe… Gophers!

Vamos imaginar que um Gopher esta percorrendo um mapa carregando uma caixa. O conteúdo dela foi definido no inicio do percurso, porém, apenas quando o nosso querido Gopher chegar no final do trajeto, o conteúdo dela será apresentado.

Viu? Fácil!

O defer funciona da mesma forma.

Você define uma ação no início da lógica operacional, porém, ela só será executada no último momento da função.

Vamos ao exemplo!

Quero uma função que faça uma saudação e me informe quando chegar ao fim.

• Função

func mostrarFim(nome string) {

    defer fmt.Println("Fim da função!")

    fmt.Printf("Olá %s, esse é um exemplo de função com defer\n", nome)

}

• Execução

mostrarFim("Guilherme")

//OUTPUT: 
Olá Guilherme, esse é um exemplo de função com defer 
Fim da função!

Note que, mesmo declarando a ação com defer no inicio do escopo lógico, a mesma só foi executada no término da função.

O uso de defer é bem comum em Go, portanto, se trombar com ele por ai, lembre-se da GoSchool 😄.

4. Função como Parâmetro

Para fecharmos esse capítulo com chave de ouro, mostrarei uma aplicação rápida de como podemos utilizar funções como parâmetros de outras funções.

SIM! ISSO É POSSÍVEL!

Aproveitando a onda do defer , vamos fazer com que uma função passada como parâmetro seja chamada no término da execução de outra, ok?

• Funções

func printaMsg() {

   fmt.Println("Fim da função!")

}

func mostrarFim(nome string, funcao func()) {

   defer funcao()

   fmt.Printf("Olá %s, esse é um exemplo de função com defer e função como parâmetro \n", nome)

}

Declaramos duas funções: printaMsg e mostraFim

Na função mostraFim, passamos o parâmetro funcao com o “tipo” func(), indicando que ali deve ser passada uma função.

• Execução

mostrarFim("Guilherme", printaMsg)

//OUTPUT:
Olá Guilherme,esse é um exemplo de função com defer e função como parâmetro
Fim da função!

FIM!

Conclusão

Chegamos ao fim de mais um tutorial da Gommunity.

Espero que, a partir de agora, a utilização das funções nunca seja um problema, mas sim, uma solução para qualquer tipo de desenvolvimento.

Nesse tutorial vimos:

• Parâmetros;
• Retornos;
• Defer;
• Função como Parâmetro

Espero que tenha aproveitado, e não se esqueça de ajudar a Gommunity divulgando nosso conteúdo 💙.

Nos vemos no próximo tutorial!

#7 GoSchool: Funções was originally published in Gommunity on Medium, where people are continuing the conversation by highlighting and responding to this story.

Seja bem vindo ao tutorial #6 da GoSchool!

Caso você tenha perdido o tutorial #5 sobre Estruturas de Controle, segue o link:

#5 GoSchool: Estruturas de Controle

Vamos falar sobre estrutura de dados abordando a sua vasta utilização em qualquer cenário de desenvolvimento.

Os tópicos abordados durante este tutorial são:

• Array
• Slice
• Map

- “Arra… o quê? ”

Calma lá, vamos por partes!

Primeiro, precisamos entender que as estrutura de dados faz referência a um grupo de informações, que por sua vez, podem ser manipuladas, consultadas, alteradas e eliminadas.

Não ficou claro?

Vamos pensar na seguinte hipótese:

8 Gophers estão de mãos dadas. Cada um deles possui uma posição especifica na fila (representado através dos números), e cada um possui um valor próprio, podendo ou não se repetir (representado através das cores).

Então ficamos assim:

• Tipo = Gopher;
• Valor = Cor;
• Posição = Número.

Por algum motivo, quero eliminar apenas os Gophers que estão em posições de números primos.

Note que o valor foi removido, tornando nossos Gophers “nulos”. Contudo, sua posição e tipo foram mantidas, dessa forma, capazes de serem “reutilizadas”.

AGORA SIM!

• Posições que quando criadas ocupam um espaço deixando “rastros”;
• Valores de mesmo tipo que podem ou não se repetir;
• Ordenação bem definida.

Esse é o princípio para que possamos entender o funcionamento das estruturas de dados.

Cada tipo possui suas peculiaridades, que serão abordadas a partir de agora.

1. Array

Aqui estamos, no “pai” das nossas estruturas de dados. O responsável por organizar e armazenar valores do mesmo tipo.

O array pode ser relacionado a uma lista de valores de mesmo tipo e tamanho pré-definido.

- “Como utilizo esse tal de array?”

Antes de tudo, se você nunca teve contato com programação, precisamos reestruturar o modo como você conta.

SIM, O MODO COMO VOCÊ CONTA!

Naturalmente, aprendemos a contar da seguinte forma:

1, 2, 3, 4, 5, 6 …

Por uma convenção definida a muitos anos (A long long time ago…), uma das práticas na programação é iniciar a contagem de índices a partir do 0.

0, 1, 2, 3, 4, 5, 6 …

Brincadeiras a parte, existe sim uma explicação para o motivo dessa convenção, contudo não vem ao caso neste tutorial devido ao nosso escopo. Caso queira aprender sobre, da uma olhadinha AQUI na resposta de uma pergunta do GUJ, para uma breve explicação.

Agora que entendemos como “contar”, podemos entrar de vez na utilização do array .

Dicionário

Vamos começar com o dicionário do array :

• Array - Estrutura de armazenamento de dados em índices;
• Índice - Posição de um valor no array ;
• Capacidade - Volume de índices suportados pelo array.

Sua declaração é feita com a seguinte estrutura:

var array [capacidade]tipo

Vamos pensar assim:

Preciso de uma lista de Gophers com capacidade 3.

Então, declaramos:

var array [3]Gopher

Atenção: Gopher é só um exemplo, logo vamos utilizar tipos reais.

Ficamos com o seguinte resultado:

Possuímos três índices do tipo Gopher, com valores nulos, ou seja, sabemos o tipo de cada índice, mas não sabemos o valor de cada tipo.

- “Mas como informo esses valores?

Cada valor será alocado em um índice, correto?

Dessa forma, podemos acessar o índice e atribuir um valor pra ele. O acesso fica assim:

var array [3]Gopher

array[0] = "Cinza"
array[1] = "Azul"
array[2] = "Rosa"

E nosso resultado final é:

CLARO COMO O DIA!

- “Ótimo, você utilizou um exemplo. No dia a dia, como devo aplicar um array?”

Declaração de Array

Vamos mudar o exemplo :

Gostaria de uma lista com o nome dos 5 maiores países do mundo.

Nossa declaração e atribuição deve ficar assim:

var paises [5]string

paises[0] = "Rússia"
paises[1] = "Canadá"
paises[2] = "China"
paises[3] = "Estados Unidos"
paises[4] = "Brasil"

fmt.Println(paises)

//OUTPUT: [Rússia Canadá China Estados Unidos Brasil]

Note que inicializamos a variável paises com capacidade igual a 5. Feito isso, preenchemos cada um de seus índices com valores do tipo string que representam os maiores países do mundo.

Quer melhor?

Também é possível inicializarmos a variável do nosso array com valores já definidos.

paises := [5]string{"Rússia", "Canadá", "China", "Estados Unidos", "Brasil"}

fmt.Println(paises)

//OUTPUT: [Rússia Canadá China Estados Unidos Brasil]

Entendemos a utilização básica de um array, portanto, podemos ver uma abordagem mais detalhada com o uso de matrizes.

Declaração de Matriz

Durante a utilização de nosso array , também é possível criar e utilizar o conceito de matriz.

Antes que me pergunte:

De forma direta, uma matriz é um conjunto de valores distribuídos em linhas e colunas, que constituem uma tabela de valores multidimensionais.

- “Continuo não entendendo…”

Vamos chamar nossos queridos Gophers!

Pense em um jogo de de Gophers:

Possuímos diversos gophers, além do especial que ainda não foi desbloqueado.

Assim funcionam nossas matrizes, pois repare que cada gopher esta distribuído em um ponto de interseção entre uma linha e uma coluna.

Nossas linhas e colunas são representadas dentro da linguagem, cada uma, por um array, ou seja, uma lista de valores diferentes, ou não, de tipos iguais.

- “Certo, mas como declaro isso?”

A declaração é bem simples:

var matriz [qtdLinhas][qtdColunas]tipo

Eu sei, ficou confuso. Vou explicar.

Usando a imagem anterior, repare que possuímos uma matriz 3x3, que possui 3 linhas e 3 colunas. Sabendo que cada linha e coluna é representado por um array , tudo fica mais fácil, portanto, temos:

var matriz [3][3]Gopher

Atenção: Tipo Gopher é só um exemplo, logo vamos utilizar tipos reais.

Dessa forma, tudo começa a fazer sentido.

O processo de declaração de valores pode ocorrer de duas formas, explícito e implícito.

Declaração Explicita

Vamos pensar dessa forma:

Uma matriz 2x2 de inteiros.

Sua declaração fica:

var matriz[2][2]int

E sua definição de valores:

var matriz [2][2]int

matriz[0][0] = 1

matriz[0][1] = 2

matriz[1][0] = 3

matriz[1][1] = 4

fmt.Println(matriz)

//OUTPUT: [ [1, 2] [3, 4] ]

Note que declaramos posição a posição.

Não ficou claro?

Nossa matriz é representada de acordo com o desenho acima

Agora sim!

Podemos deixar essa declaração ainda mais simples.

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

fmt.Println(matriz)

//OUTPUT: [ [1, 2] [3, 4] ]

- “Sempre vou ter que escrever o tipo?”

Uma das vantagens da linguagem esta na sua simplicidade, dessa forma, podemos falar das declarações implícitas.

Declaração Implícita

Utilizando o exemplo anterior, porém, com declarações implícitas, o resultado passa a ser:

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

fmt.Println(matriz)

//OUTPUT: [ [1, 2] [3, 4] ]

Simples, lindo e fácil!

- “Como posso consultar um valor?”

Lembra que cada valor está em uma posição específica de linha e coluna?

Através dessa informação encontramos e consultamos qualquer valor. Sua declaração fica:

matriz[linhaBusca][colunaBusca] //Valor posicional

Com valores, possuímos:

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

fmt.Println(matriz[0][1])

//OUTPUT: 2

Agora sim, entendemos todos os pontos relacionados a array e matriz.

Podemos falar de um parente próximo do array , com uma pequena diferença, já que o mesmo é um pouco mais “liberal”. Estou falando do slice .

2. Slice

O slice pode ser, de forma indireta, chamado de “array flexível” já que diferente do array convencional, não possui uma capacidade limite.

- “Liberdade total?”

Calma lá, não sejamos tão radicais.

COM GRANDES PODERES, VEM GRANDES RESPONSABILIDADES.

Primeiro vamos entender bem como funciona um slice para que seja possível tirar o máximo de proveito dessa estrutura de dados.

Declaração

• A declaração de um slice é semelhante a de um array , a única diferença é que não definimos uma capacidade.

var slice []tipo{}

Note que quando inicializamos um slice nulo precisamos adicionar um par de chaves {} a fim de informar que ainda não existem item associados a ele. Tanto que, ao “printarmos” o valor do nosso slice , o resultado apresentado é o de uma lista vazia.

slice := []tipo{}

fmt.Println(slice)

//OUTPUT: []

Até aqui, tudo lindo e maravilhoso!

O modo anterior de declaração, por sua vez não permite a declaração literal de um slice , ou seja, caso você precise reservar um espaço inicial na memória para um número maior de elementos, precisamos utilizar a função make .

Make

O make permite a inicialização de um slice com tamanho definido de pré elementos e capacidade.

• Sua declaração é bem simples:

slice := make([]tipo, inicialização, capacidade)

Ao utilizarmos o make , informamos que estamos inicializando um novo slice, com uma capacidade inicial já preenchida, podendo ou não ter uma capacidade final. Dessa forma, nosso sistema já reserva uma certa quantidade de memória na máquina.

- “Complicado…”

Vamos utilizar os Gophers para explicar.

Atenção: Tipo Gopher é só um exemplo, logo vamos utilizar tipos reais.

Repare que a declaração simples do slice não deixa nenhum tipo de pré-registro na memória, ao contrário do slice que foi inicializado com make que definiu um espaço inicial de nove valores vazios do tipo Gopher.

• Dessa forma, ao “printarmos” nosso slice com make , ficamos com:

slice := make([]int, 9)

fmt.Println(slice)

//OUTPUT: [0 0 0 0 0 0 0 0 0]

Agora nosso sistema já inicializou nove itens de valor “vazio” para o tipo int .

- “Legal, agora entendi tudo. Só queria saber como faço para obter elementos especificos de um slice”

Assim como no array , podemos obter um elementos utilizando o seu índice:

slice := []int{1, 2, 3}

fmt.Println(slice[2])

//OUTPUT: 3

Porém, também podemos obter uma faixa especifica de elementos, utilizando a seguinte sintaxe:

slice[de:até]

• de - Índice inicial da busca;
• até - Índice final, mas não incluso da busca.

Para não enrolarmos mais:

slice := []int{1, 2, 3, 4, 5, 6, 7}

fmt.Println(slice[1:4])

//OUTPUT: [2 3 4]

Note que indicamos o índice 4 como final, mas o mesmo não foi incluído no resultado final, já que a linguagem exclui o índice de conclusão.

Agora que a base do slice foi entendida, podemos falar de suas funções!

Então vamos falar das funções que podem ser utilizadas com slice , seguindo essa ordem:

• len - Apresenta o tamanho do slice ;
• cap - Apresenta a capacidade do slice ;
• append - Permite adicionar novos itens ao slice ;
• copy - Permite copiar elementos entre slice ;

Len

De forma direta, retorna o tamanho do nosso slice .

• Slice

slice := []int{}

fmt.Println(len(slice))

//OUTPUT: 0

• Slice com make

slice := make([]int, 9, 15)

fmt.Println(len(slice))

//OUTPUT: 9

Cap

Retorna a capacidade momentânea do slice .

• Slice

slice := []int{}

fmt.Println(cap(slice))

//OUTPUT: 0

• Slice com make

slice := make([]int, 9, 15)

fmt.Println(cap(slice))

//OUTPUT: 15

Append

Permite agrupar valores ou até mesmo um slice dentro de um slice .

- “Que confusão!”

GOPHERS!

A declaração de um append é feita da seguinte forma:

append(sliceInicial, valorVinculado)

Nota: Quando utilizamos um append , ele nos retorna um novo slice!

Sua utilização mais básica fica:

slice := []int{1,2,3}

sliceNovo := []int{4,5,6}

slice = append(slice, sliceNovo...)

fmt.Println(slice)

//OUTPUT: [1 2 3 4 5 6]

- “Por que utilizou reticências (…) ?”

O operador ... , chamado de spread é uma forma de declararmos todos os elementos de um slice de forma individual.

Pense no seguinte slice :

sliceNovo := []int{1,2,3}

Agora, sabendo que um “print” dele ficaria assim:

//OUTPUT: [1 2 3]

Utilizamos o operador spread para utilizar todos os itens como variáveis individuais, já que nosso append não aceita um slice como uma variável a ser acrescentada no nosso slice inicial.

Sendo assim:

append(slice, sliceNovo...)

É exatamento o mesmo que:

append(slice, 1, 2, 3)

Copy

Assim como o append, copy faz a “transferência” de elementos de um slice para outro.

A diferença é que o copy faz o processo de sobrescrita de valores entre posições de um slice pai e um filho.

Sua declaração é feita da seguinte forma:

copy(sliceBase[de:ate], sliceDeCopia[de:ate])

Também algo bem simples!

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

sliceNovo := []int{8, 9, 10}

copy(slice[0:2], sliceNovo[0:1])

fmt.Println(slice)

//OUTPUT: [8, 2, 3, 4, 5]

Note que informamos que o primeiro elemento do slice deveria ser substituído pelo primeiro elemento do sliceNovo .

Antes que me pergunte, vou abordar algumas diferenças entre o append e copy

Append X Copy

Antes de apresentar detalhes em código, vamos descrever de forma simples, a lógica aplicada em cada um.

• Append

Caso o capacidade de um slice seja atingida, o mesmo se encarrega de amplia-la.

slice := make([]int, 3, 5)

novoSlice := []int{1, 2, 3, 4, 6, 7}

slice = append(slice, novoSlice...)

fmt.Println(slice)

fmt.Println(cap(slice))

fmt.Println(len(slice))

//OUTPUT:
[0 0 0 1 2 3 4 6 7]
10
9

Sim, você não viu errado!

Mesmo declarando que a capacidade do nosso slice é 5, após preenchermos todos os “espaços” pré estabelecidos, a própria linguagem se responsabilizou de liberar mais espaço de forma exponencial.

Vendo que a capacidade de 5 foi atingida, automaticamente a mesma foi ampliada para 10, comportando-se assim sempre que for necessário.

• Copy

De forma alguma o copy altera a capacidade de um slice .

slice := make([]int, 3, 3)

novoSlice := []int{1, 2, 3, 4, 6, 7}

copy(slice, novoSlice)

fmt.Println(slice)

fmt.Println(cap(slice))

fmt.Println(len(slice))

//OUTPUT:
[1 2 3]
3
3

Note que, mesmo passando um slice de capacidade maior, o copy sobrescreveu apenas a capacidade limite da variável slicepor elementos da variável novoSlice.

Enfim chegamos ao fim do slice e podemos abordar a nossa última estrutura de dados, o map .

3. Map

O nosso “dicionário” das estruturas de dados. O map diferente do array e do slice não se comporta por índices, mas sim pelo conceito chave/valor.

- “Já li muito até aqui, deixe isso mais claro!”

Pense que possuímos uma lista de produtos, e nela temos o nome do produto relacionado ao seu valor. Sendo assim, quando consultar um produto, logo, o retorno será o seu valor.

Considere a lista:

• Arroz (5.50)
• Feijão (4.40)
• Carne (15.30)
• Refrigerante (7.80)

Declaração

A declaração de um map é feita da seguinte forma:

var lista map[tipo]tipo

ou utilizando make

lista := make(map[tipo]tipo)

Note que declaramos duas vezes o tipo, já que um deles representa nossa chave, e o outro, nosso valor

Voltando a lista anterior, nossa map inicializado fica assim:

listaProdutos := make(map[string]float32)

Seu preenchimento, segue o modelo:

lista[chave] = valor

Dessa forma, nossa lista de compras fica:

listaProdutos := make(map[string]float32)

listaProdutos["Arroz"] = 5.50
listaProdutos["Feijao"] = 4.40
listaProdutos["Carne"] = 15.30
listaProdutos["Refrigerante"] = 7.80

Como estamos falando de Go, sua declaração pode ficar ainda mais simples!

listaProdutos := map[string]float32{"Arroz":5.50, "Feijao":4.40, "Carne": 15.30, "Refrigerante": 7.80}

- “E a consulta desses valores, como é feita?”

Como estamos utilizando o conceito chave/valor, podemos busca-los através da chave pré-definida.

listaProdutos := make(map[string]float32)

listaProdutos["Arroz"] = 5.50
listaProdutos["Feijao"] = 4.40
listaProdutos["Carne"] = 15.30
listaProdutos["Refrigerante"] = 7.80

fmt.Println(listaProdutos["Arroz"])

//OUTPUT: 5.5

Além da declaração simples de um map , podemos também trabalhar com conceitos de aninhamento, que trata-se de um map dentro de outro.

Map Aninhado

Pense agora que queremos separar produtos por categorias:

• Casa : [ Sofá (100.00), Colchão (80.00), Mesa (100.00)]
• Cozinha: [ Faca (30.00), Colher(10.00), Garfo(10.00) ]

A declaração de um map aninhado fica:

var aninhado map[tipo]map[tipo]tipo

Apenas adicionamos um map como valor de resposta para outro map .

Aplicando na lista anterior, ficamos com:

var itensCasa map[string]map[string]float32

Seu preenchimento, é semelhante ao map comum, com a única diferença de possuir um nível a mais de declaração:

itensCasa := map[string]map[string]float32{

     "Casa": {

          "Sofa": 100.00,
          "Colchao": 80.00,
          "Mesa": 100.00,      
     },
     "Cozinha": {

          "Faca": 30.00,
          "Colher": 10.00,
          "Gargo": 10.00,      
     },

}

Por fim, sua consultado ocorre por níveis:

itensCasa := map[string]map[string]float32{

"Casa": {

"Sofa": 100.00,
          "Colchao": 80.00,
          "Mesa": 100.00,      
     },
     "Cozinha": {

"Faca": 30.00,
          "Colher": 10.00,
          "Gargo": 10.00,      
     },

}

fmt.Println(itensCasa["Casa"]["Sofa"])

//OUTPUT: 100

Para finalizarmos o assunto de map , precisamos falar de sua capacidade de exclusão de chaves.

Exclusão

Para que seja possível excluir uma chave de um map , utilizamos a seguinte estrutura:

delete(map, chave)

Logo:

listaProdutos := make(map[string]float32)

listaProdutos["Arroz"] = 5.50
listaProdutos["Feijao"] = 4.40

delete(listaProdutos, "Feijao")

fmt.Println(listaProdutos)

//OUTPUT: map[Arroz:5.5]

Note que o item “Feijao” foi deletado do map final.

Conclusão

Chegamos ao fim de mais um tutorial da Gommunity.

ESSE FOI MUITO LONGO!

Espero que a utilização das estruturas de dados tenha ficado bem claro, para que você possa tirar o máximo de proveito dessa prática no seu dia a dia, pessoal e profissional.

Nesse tutorial vimos:

• array ;
• slice;
• map

Esse tutorial gigantesco merece um um aplausozinho? hahahaha

Nos vemos no próximo tutorial sobre Funções!

#7 GoSchool: Funções

#6 GoSchool: Estrutura de Dados e seus Métodos was originally published in Gommunity on Medium, where people are continuing the conversation by highlighting and responding to this story.

O Visual Studio Code é um dos melhores editores que existem, quiçá o melhor. Num mercado que era dominado pelo Sublime e via o Atom ganhar força, o VSCode atropelou todo mundo e se tornou o queridinho dos desenvolvedores.

Assim como o Atom, o Visual Studio Code é um excelente editor com um ecossistema de plugins para a maioria das linguagens e ferramentas.

Caso ainda não tenha o Visual Studio Code, você pode baixá-lo nesse link:

Visual Studio Code - The open source AI code editor | Your home for multi-agent development

Hoje vamos ver como configurá-lo para trabalhar com Go.

Configurando Go no VSCode

Primeiro passo é ir na aba de extensões e pesquisar por "Go", o primeiro pacote é o fornecido pela própria Microsoft, basta clicar em install.

Agora vamos ver se está tudo nos conformes. Vamos printar no terminal uma frase e ver se a sintaxe do Go está funcionando no VSCode.

Vamos escrever um código simples:

Agora basta ir na aba Terminal e clicar em New Terminal (ou usar o atalho Ctrl+`) que o seu terminal aparecerá no próprio VSCode como a imagem abaixo. Agora basta salvar seu arquivo como main.go, garantir que o terminal está na mesma pasta do arquivo e rodar:

go run main.go

E temos a frase Welcome to Visual Studio Code printada no terminal.

(☞⌐▀͡ ͜ʖ͡▀ )☞

Atenção: se você está perdido ou quer melhorar seus conhecimentos, a Gommunity tem um monte de tutoriais de Go pra te ajudar, é só clicar e ser feliz:

Gommunity

Debugando Go no VSCode

Ter a sintaxe colorida é muito bom, mas que tal poder debugar em Go? Afinal, é bem melhor saber o que está ocorrendo a cada passo ao invés de simplesmente ficar na tentativa e erro, ou colocar um fmt.Println a cada três linhas de código.

Para começar a debugar, precisaremos de um debugger, o Delve.

macOS

Garanta que você consegue compilar corretamente:

xcode-select --install

E instale o Delve usando go get:

go get -u github.com/derekparker/delve/cmd/dlv

Com esse método, você não poderá usar o backend nativo do Delve, mas não precisará dele de qualquer maneira: o backend nativo no macOS tem problemas conhecidos em versões recentes do SO e não é mantido atualmente.

Linux

Existem 2 maneiras de instalar no Linux:

A primeira é a mais simples, usando go get:

go get -u github.com/derekparker/delve/cmd/dlv

Alternativamente, você precisa garantir que o $GOPATH está setado (por exemplo:~/.go) e então:

git clone https://github.com/derekparker/delve.git $GOPATH/src/github.com/derekparker/delve

cd $GOPATH/src/github.com/derekparker/delve

make install

Muitos amantes de Linux precisam ver esse make rolando, né? :P

Windows

Nota: Eu me pergunto o porquê de estar usando Windows, mas sem julgamentos. Se quiser instalar Ubuntu, pode dar uma olhada aqui. Ele é rápido, seguro e simples de usar, mesmo para quem não está familiarizado com a linha de comando. Vai na fé.

Use o go get para buildar e instalar no Windows:

go get -u github.com/derekparker/delve/cmd/dlv

Importante para todos os SOs: Se você estiver usando o Go 1.5, deverá definir GO15VENDOREXPERIMENT=1 antes de continuar. Essa variável de ambiente simplesmente opta pelo Go 1.5 Vendor Experiment.

No momento que você tiver instalado, basta clicar no espaço próximo aos números de linhas no VSCode, clicar no ícone de debug na barra lateral e dar play:

Vejam que a execução parou na linha 7. Abaixo, eu cliquei em DEBUG CONSOLE para poder ver o que está acontecendo.

Estes são os comandos que você pode fazer ao parar em uma linha (mostrados na imagem acima):

• Continuar a execução
• Passar a linha
• Entrar na função
• Sair da função
• Reiniciar a execução
• Parar a execução

E assim temos um ambiente de desenvolvimento em Go.

Bônus

Para facilitar não só o desenvolvimento em Go, mas em outras linguagens também, recomendo a extensão Paste JSON as Code, que reconhece o arquivo e formata o JSON que você colar para ela.

Hey, não vá embora tão rápido

Debugar é uma parte crucial do desenvolvimento de software, e com ferramentas como o Visual Studio Code, nossas vidas podem ser muito mais fáceis.

Usamos um exemplo simples aqui para explicar os conceitos, mas fique à vontade para adicionar o debugger a qualquer um dos seus projetos existentes. Você vai acabar reduzindo seus fmt.Printlnusados para logar e ver o valor/estado do código em um dado ponto durante sua execução.

Se você gostou desse artigo e ele te ajudou de alguma forma, deixe suas palmas ali embaixo. Isso ajuda para que outras pessoas possam encontrá-lo.

Se você tem outras configurações de VSCode ou desenvolve de um outro jeito/com outro editor/IDE, conte para nós nos comentários.

Um abraço e até breve.

Configurando o Visual Studio Code para trabalhar com Go was originally published in Gommunity on Medium, where people are continuing the conversation by highlighting and responding to this story.

Seja bem vindo ao tutorial #5 da GoSchool!

Caso você tenha perdido o tutorial #4 sobre Operadores, segue o link:

#4 GoSchool: Operadores

Vamos falar sobre estrutura de controle e sua utilização nos mais diversos problemas do nosso dia a dia.

Estruturas de controle são responsáveis por definir determinadas ações, baseadas em critério lógicos. Essas ações por sua vez, podem definir um caminho correto para sua aplicação seguir, ou simplesmente, gerar um processo de repetição.

- “Entendi, mas qual estrutura vamos controlar?”

Para que o processo de estrutura de controle fique claro, vamos separar a lógica do nosso código em quatro etapas.

• Início
• Decisão
• Ação
• Conclusão

Agora, vamos transformar nossa lógica em um texto:

“ Guilherme só consegue abrir a porta se estiver com a chave em mãos. Caso não a tenha, precisa busca-la no porta chaves.”

Ótimo!

Com a nossa lógica definida, vamos abordar cada uma das etapas.

Início

• A primeira ação que nosso sujeito deve fazer é tentar abrir a porta.

Decisão ( 1 )

• Ao girar a maçaneta, ele percebe que não esta com as chaves.

Ação ( 1 )

• O sujeito então, busca a chave no porta chaves

Início

• Ele volta até a etapa inicial e tenta abrir a porta.

Decisão ( 2 )

• Agora com a chave em mãos, ele pode abrir a porta.

Ação ( 2 )

• A porta é aberta.

Conclusão

• O processo de abrir a porta é finalizado.

Vamos facilitar ainda mais?

Aqui esta um fluxograma de todo o processo:

Dessa forma, conseguimos perceber que uma estrutura de controle nada mais é, do que um processo de tomada de decisão, que tem como objetivo garantir que determinados critérios sejam cumpridos antes de uma ação ser tomada.

Eu sei, eu sei, comecei a falar muito e explicar pouco. Pode deixar que agora a brincadeira vai começar.

Os tópicos desse tutorial serão divididos da seguinte forma:

1. If
2. Switch

3. For

Cada um dos tópicos que serão abordados são fundamentais para que sua aplicação obedeça regras de negócio, garantindo como dito anteriormente, que cada ação seja tomada de maneira correta.

1. IF

O controle de fluxo mais utilizado em todas as linguagens de programação. Responsável por executar blocos de código, baseando-se inteiramente em operações lógicas.

Ao utilizarmos este controlador de fluxo, utilizamos três palavras chave:

• if - Critério “se” ;
• else - Critério “senão” ;
• else if - Critério “senão se”

A estrutura de código para sua utilização é:

<Palavra chave>  [Critério]  { //AÇÃO }

- “Blocos de código, se, senão, senão se ?”

Vamos voltar ao exemplo apresentado no começo do tutorial:

“ Guilherme só consegue abrir a porta se estiver com a chave em mãos. Caso não a tenha, precisa busca-la no porta chaves.”

Analisando a frase e utilizando nossas palavras chave:

SE ele estiver com a chave, a porta pode ser aberta, SENÃO, ele deve buscar a chave no porta chaves.

Agora tudo começa a clarear!

• Vamos verificar a ação, caso o nosso sujeito não tenha a chave.

Aqui iniciamos uma variável como false , dando a entender que nosso sujeito não tinha a chave quando tentou abrir a porta.

temChave := false

if temChave == true {

    fmt.Println("Porta aberta!")

} else {

   fmt.Println("Vá buscar a chave!")

}

//OUTPUT: Vá buscar a chave! 

Note que, verificamos se ele tinha a chave utilizando o critério if . Como passamos para o sistema que ele não a possuía, o critério else foi executado já que nosso controle principal temChave == true retornou false .

Podemos interpretar este código da seguinte forma:

SE temChave for igual a true , me informe que a porta pode ser aberta, SENÃO, me informe que preciso buscar as chaves.

• Vamos checar o que aconteceria, se dessa vez, o usuário possuísse a chave.

temChave := true

if temChave == true {

   fmt.Println("Porta aberta!")

} else {

   fmt.Println("Vá buscar a chave!")

}

//OUTPUT: Porta aberta!

Note que agora, o sistema não executou o bloco else , mas sim o bloco if ,

pois o critério de aceitação foi cumprido.

- “Você comentou sobre if e else, mas onde esta o else if?”

Vamos adicionar um grau maior de complexidade em nossa frase inicial, para que seja possível entendermos a utilização do else if .

“ Guilherme só consegue abrir a porta se estiver com a chave em mãos. Caso não a tenha, pode tentar bater na porta para ver se existe alguém dentro do quatro. Se ninguém atender, ele deve buscar a chave no porta chaves.”

Agora ganhamos um critério a mais no nosso processo de verificação, onde precisamos verificar mais de uma possibilidade para que a porta possa ser aberta.

Após a adição, nossa interpretação fica assim:

SE ele estiver com a chave, a porta pode ser aberta, SENÃO, SE ele bater na porta a mesma pode ser aberta, SENÃO, ele deve buscar a chave no porta chaves.

Portanto, ficamos com o nosso código da seguinte forme:

temChave := false
bateuNaPorta := true

if temChave == true {

   fmt.Println("Porta aberta com a chave!")

} else if bateuNaPorta == true {

  fmt.Println("Porta aberta ao bater nela!")

} else {

  fmt.Println("Vá buscar a chave!")

}

//OUTPUT: Porta aberta ao bater nela!

Como colocamos a variável bateuNaPorta como true , ao verificar o critério else if o sistema rodou o bloco de código pertencente a ele.

Vamos simplificar um pouquinho?

Em GO, é possível iniciar variáveis ou executar funções de retorno (assunto que será abordado no tutorial #7) no momento da inicialização de um operador if.

A estrutura fica assim:

<Palavra chave> [Inicialização]; [Critério]  { //AÇÃO }

Vamos usar o primeiro exemplo abordado no tópico IF para detalharmos sua aplicação.

if temChave:=true; temChave == true {

   fmt.Println("Porta aberta!")

} else {

   fmt.Println("Vá buscar a chave!")

}

//OUTPUT: Porta aberta!

Note que de maneira direta, declaramos a variável e já aplicamos uma operação lógica de controle. Reduzindo o número de linhas, resumindo o escopo do código.

Entendido o nosso controlador if , vamos falar de um outro controlador muito utilizado. Estou falando do switch .

2. Switch

Diferente do controlador if , o switch tem como objetivo executar um bloco de código baseando-se na comparação de critérios do mesmo tipo.

Ao utilizarmos este controlador de fluxo, utilizamos três palavras chave:

• switch - Definição de critério ;
• case - Critério a ser analisado;
• default - Ação padrão caso nenhum critério seja aceito.

A estrutura de código para sua utilização é:

switch <variavel a ser análisada>{

case <critério a ser análisado>:

      //Código caso ele seja aceito.

default:

     //Código caso todos os 'cases' sejam recusados.
}

- “Critérios do mesmo tipo?”

Pense da seguinte forma:

“Os produtos que custam R$10, são classificados como “Caros”. Os que custam R$5, classificados como “Populares”. Por fim, os que possuem valores diferentes, devem ser classificados como “Sem classificação”.

Utilizando if nosso código ficaria assim:

valorProduto := 5.00

if valorProduto == 10 {

   fmt.Println("Caros")

} else if valorProduto == 5 {

   fmt.Println("Populares")

} else {

   fmt.Println("Sem classificação")

}

//OUTPUT: Populares

Nesse caso, precisamos verificar caso a caso, declarando um bloco de código com um validador lógico.

Com switch , deixamos nosso código assim:

valorProduto := 5

switch valorProduto {

case 10:

   fmt.Println("Caros")

case 5:

   fmt.Println("Populares")

default:

   fmt.Println("Sem classificação")

}

//OUTPUT: Populares

Agora sim, tudo ficou claro!

Ao declararmos o switch, definimos que o valor a ser analisado era do tipo int armazenado na variável valorProduto . A partir dessa definição, criamos todos os cases responsáveis por validar nossas afirmações. Com isso, nosso sistema comparou todos os casos e verificou que nosso valor se enquadrava no case, apresentando a mensagem “Populares” quando foi executado.

Agora que nossos controladores switch e if estão totalmente alinhados, podemos falar do último controlador, utilizado para a criação de processos de repetição. O controlador for .

3. For

Enfim, chegamos ao controlador de repetição!

O for tem como objetivo, executar uma sequência de repetição limitada ou não, de um bloco de código.

A estrutura de código para sua utilização é:

for <inicializador>; <controlador>; <incremento> {}

- “Ainda não ficou claro…”

Para facilitar o entendimento do for , vou separar a explicação em três aplicações práticas.

• Repetição;
• Repetição com inicializador e incremento desassociado;
• Repetição infinita.

Repetição

Vamos utilizar o seguinte caso:

Preciso fazer a contagem de 0 a 10, apresentando-a no console.

Até agora, com o que aprendemos, nosso código ficaria assim:

fmt.Println(1)
fmt.Println(2)
fmt.Println(3)
fmt.Println(4)
fmt.Println(5)
fmt.Println(6)
fmt.Println(7)
fmt.Println(8)
fmt.Println(9)
fmt.Println(10)

//OUTPUT: 
1
2
3
4
5
6
7
8
9
10

Mas estamos falando de um controlador de repetição, onde o mundo se torna maravilhoso!

Portanto, utilizando nosso controlador de repetição. O código anterior passa a ser:

for contador := 1; contador <= 10; contador ++ {

   fmt.Println(contador)

}

//OUTPUT: 
1
2
3
4
5
6
7
8
9
10

- “Legal, mas o que aconteceu ai?”

Vamos por partes:

• Logo após a declaração do for , a variável contador foi iniciada com o valor 1 .

for contador:=1

• Após a inicialização da variável de controle, criamos o controlador, responsável por determinar quantas repetições serão feitas em nosso bloco de código. Nesse caso, informamos que ele deve ser executado até o momento em que a variável contador seja <=10 .

for contador := 1; contador <= 10

• Por fim, adicionamos um “incrementador” para nossa variável contador . Ele é o responsável por adicionar +1 ao contador no final de cada repetição.

for contador := 1; contador <= 10; contador++ 

Após essas etapas, estamos com nosso controlador de repetição for prontinho para ser utilizado.

Repetição com inicializador e incremento desassociado

Sua aplicação é semelhante a utilizada no for comum, a única diferença é que precisamos inicializar a variável de controle antes do bloco de repetição, e o incremento depois.

Dessa forma:

contador := 1

for contador <= 10 {

   fmt.Println(contador)
   contador ++

}

//OUTPUT: 
1
2
3
4
5
6
7
8
9
10

Simples, rápido e indolor!

Vamos para a última e menos recomendada prática dos laços de repetição.

Repetição infinita

ATENÇÃO! MUITO ATENÇÃO! ATENÇÃO!

Como o próprio nome diz, essa repetição não possui um ponto de parada, ou seja, seu código vai rodar, rodar, rodar e rodar.

Apenas para fins didáticos, a declaração desse controlador ocorre da seguinte forme:

contador := 1

for {

  fmt.Println(contador)
  contador++

}

//OUTPUT:
1
2
3
.
.
.
Infinito

De forma alguma estou dizendo que este processo não possa ser utilizado, contudo, sua aplicação deve ser muito bem pensada e planejada.

EVITE REPETIÇÕES INFINITAS SEM PLANEJAMENTO!

#FICADICA

Conclusão

Chegamos ao fim de mais um tutorial da Gommunity.

Espero que a utilização das estruturas de controle tenha ficado bem claro, para que você possa tirar o máximo de proveito dessa prática no seu dia a dia, pessoal e profissional.

Nesse tutorial vimos:

• if - Critério “se” ;
• else - Critério “senão” ;
• else if - Critério “senão se”

Nos vemos no próximo tutorial sobre Estruturas de Dados e seus métodos.

#6 GoSchool: Estrutura de Dados e seus Métodos

#5 GoSchool: Estruturas de Controle was originally published in Gommunity on Medium, where people are continuing the conversation by highlighting and responding to this story.

Seja bem vindo ao tutorial #4 da GoSchool!

Caso você tenha perdido o tutorial #3 sobre Declarações e Tipos Primitivos, segue o link:

#3 GoSchool: Declarações e Tipos

Hoje, vamos falar de um assunto muito importante, que será utilizado em todos os desenvolvimentos em GO. Sim, estou falando dos Operadores.

Toda e qualquer tarefa dentro de um algoritmo é feita utilizando operadores, que por sua vez, irá executar alguma ação baseada em seu tipo.

- “Como assim, uma ação baseada em tipo?”

Os principais tipos de operadores são:

• Aritméticos
• Relacionais
• Lógicos
• Atribuição

Cada tipo de operador é responsável por uma determinada operação. Alguns são popularmente conhecidos, dentro e fora da programação, como é o caso dos operadores aritméticos.

Chega de enrolação e vamos colocar a mão na massa para entendermos os diferentes tipos de operadores.

Vamos seguir a ordem da lista apresentada anteriormente, ok?

1. Aritméticos

Como citei anteriormente, operadores aritméticos são responsáveis pela realização de operações básicas de processamento, muitas vezes utilizadas em nosso cotidiano.

Em GO possuímos sete operadores aritméticos, que são:

• Soma +
• Subtração -
• Multiplicação *
• Divisão /
• Módulo (Resto da Divisão) %
• Incremento ++
• Decremento --

Soma ( + )

Operação de “combinação” entre dois números.

num1 := 4
num2 := 8
resultado := num1 + num2

fmt.Println(resultado)

OUTPUT: 12

Subtração ( - )

Operação de subtração entre dois números.

num1 := 10
num2 := 5
resultado := num1 - num2

fmt.Println(resultado)

OUTPUT: 5

Multiplicação ( * )

Operação entre dois número que visa obter um resultado que representa a soma de uma quantidade finita de um mesmo número.

num1 := 8
num2 := 3
resultado := num1 * num2

fmt.Println(resultado)

OUTPUT: 24

Divisão ( / )

Operação que visa obter um quociente a partir da divisão de dois números.

num1 := 100
num2 := 10
resultado := num1 / num2

fmt.Prinln(resultado)

OUTPUT: 10

Módulo — Resto da Divisão ( % )

Operação que visa obter um resto a partir da divisão de dois números.

num1 := 17
num2 := 2
resultado := num1 % num2

fmt.Prinln(resultado)

OUTPUT: 1

Incremento ( ++ )

Operador responsável por adicionar 1 à uma variável.

num1 := 10
num1++

fmt.Println(num1)

OUTPUT: 11

++ é o mesmo que +1 .

Decremento ( -- )

Operador responsável por remover 1 à uma variável.

num1 := 20
num1--

fmt.Println(num1)

OUTPUT: 19

-- é o mesmo que -1 .

Operadores aritméticos são simples, já que fazem parte de tudo aquilo que praticamos dentro e fora do mundo da programação.

2. Relacionais

Operadores relacionais verificam uma expressão e retornam um valor boolean de aceitação true ou negação false .

São utilizados por todos os processos dentro de um algoritmo, já que ditam retornos de critérios lógicos.

Em GO possuímos seis principais operadores relacionais, que são:

• Comparação ==
• Diferença !=
• Maior >
• Menor <
• Maior ou igual >=
• Menor ou igual >=

Comparação ( == )

Verifica igualdade entre variáveis, retornando o status relacional de ambas.

num1 := 5
num2 := 5
resultado := num1 == num2

fmt.Println(resultado)

OUTPUT: true

O processo de comparação é feito utilizando variáveis do mesmo tipo.

Diferença ( != )

Verifica diferença entre variáveis, retornando o status relacional de ambas.

num1 := 8
num2 := 15
resultado := num1 != num2

fmt.Println(resultado)

OUTPUT: true

O processo de diferença é feito utilizando variáveis do mesmo tipo.

Maior ( > )

Operador responsável por verificar, entre duas variáveis, se o primeiro argumento é maior que o segundo argumento.

num1 := 30
num2 := 20
resultado := num1 > num2
fmt.Println(resultado)

OUTPUT: true

Antes de continuar!

Nos exemplos, estou utilizando apenas variáveis numéricas. Contudo, o processo de verificação pode ser feito utilizando qualquer tipo primitivo da linguagem, como strings, números e booleans.

Nas operações lógicas utilizando string, por exemplo, o comparativo é feito utilizando os valores decimais de cada caractere presente na tabela ASCII.

Vale lembrar, que uma operação envolvendo soma de strings é válida e chamada de concatenação. Assunto abordado no tutorial sobre funções.

Menor ( < )

Operador responsável por verificar, entre duas variáveis, se o primeiro argumento é menor que o segundo argumento.

num1 := 10
num2 := 40
resultado := num1 < num2
fmt.Println(resultado)

OUTPUT: true

Maior ou igual ( >= )

Operador responsável por verificar, entre duas variáveis, se o primeiro argumento é maior ou igual ao segundo argumento.

num1 := 20
num2 := 20
resultado := num1 >= num2
fmt.Println(resultado)

OUTPUT: true

Menor ou igual ( <= )

Operador responsável por verificar, entre duas variáveis, se o primeiro argumento é maior ou igual ao segundo argumento.

num1 := 5
num2 := 20
resultado := num1 <= num2
fmt.Println(resultado)

OUTPUT: true

Operadores relacionais não possuem grandes segredos, já que realizam processos lógicos comparativos de forma rápida dentro de seu algoritmo.

Entendido o assunto de operadores relacionais, podemos utiliza-los em conjunto com um novo tipo de operador. Os operadores lógicos.

3. Lógicos

Como o nome já diz, são responsáveis por definir uma lógica baseada em critérios e valores relacionais.

- “Legal, me fale mais sobre isso…”

Operações lógicas tem como objetivo, o retorno de valores booleanos trueou false , que poderão ser utilizados em estruturas de controle (Assunto que será abordado no próximo tutorial).

Em GO possuímos três principais operadores lógicos, que são:

• Conjunção (E) &&
• Disjunção (Ou) ||
• Negação !=

Conjunção ( && )

Conjunção é a operação que possui o objetivo de “agregar” valores relacionais e verificar se os mesmos são condizentes à uma condição.

Calma lá! Vamos melhorar essa explicação.

Vamos utilizar a seguinte frase:

Caruso e Esteves escrevem artigos sobre GO.

Agora, vamos trata-los como variáveis:

autor1 := "Caruso"
autor2 := "Esteves"

Vamos adicionar um critério. Apenas uma ideia:

“Só existem artigos sobre GO, se Caruso e Esteves forem os autores.”

Beleza!

Agora que possuímos valores e um critério, conseguimos utilizar nosso operador lógico de conjunção junto com um operador relacional para obter um resultado lógico booleano.

//Seguindo nosso critério

autor1 := "Caruso"
autor2 := "Esteves"
criterio := autor1 == "Caruso" && autor2 == "Esteves"

fmt.Println(criterio)

OUTPUT: true

Repare que autor1 e autor2 satisfazem o critério que: Somente quando Caruso e Esteves estiverem juntos, o resultado será positivo

Note que, caso uma das variáveis não seja válida, o algoritmo retorna false .

//Seguindo nosso critério

autor1 := "Guilherme"
autor2 := "Esteves"
criterio := autor1 == "Caruso" && autor2 == "Esteves"

fmt.Println(criterio)

OUTPUT: false

Em um operador lógico de conjunção, todos os critérios relacionais devem ser true .

Disjunção ( || )

Disjunção tem como objetivo verificar se um dos critérios relacionais é válido, gerando um resultado baseado na ordem de chamada.

- “Ordem de chamada?”

Um algoritmo é lido da esquerda para a direita, dessa forma, variáveis declaradas mais a esquerda são lidas e interpretadas antes das variáveis declaradas mais a direita.

Ainda não ficou claro?

Pense da seguinte forma:

Você precisa encontrar uma porta que esteja destrancada. Em um total de 4 portas, a primeira que você conseguir abrir, finaliza o seu processo de busca.

Dessa forma temos:

Porta 1 || Porta 2 || Porta 3 || Porta 4

• Você tenta acessar a porta 1 e percebe que ela esta trancada;
• Verifica a porta de número 2 que também esta trancada;
• Verificando a porta de número 3 ela se abre.

Nesse momento, você não precisa verificar a porta 4, pois o critério lógico dizia que, ao encontrar a primeira porta aberta o processo seria finalizado.

Sendo assim, ao utilizarmos o operador lógico de disjunção || , estamos buscando em diversas variáveis relacionais, um único valor positivo para que nosso processo seja válido.

Veja o exemplo:

relacional1 := 10 > 30 //false
relacional2 := 20 == 18 //false
relacional3 := 18 < 50 //true
relacional4 := 50 == 50 //true

resultado := relacional1 || relacional2 || relacional3 || relacional4

fmt.Println(resultado)

OUTPUT: true

Note que as duas primeiras variáveis relacionais retornam false, e as duas últimas, true. Por mais que a quarta variável seja verdadeira, o sistema constatou que o resultado era true logo que verificou a terceira variável.

Negação ( != )

Negação pode também ser caracterizado como uma operador relacional, dessa forma, sua explicação é plausível para ambos os casos.

Note que o operador lógico de negação possui as mesmas características que o operador relacional de diferença.

O operador lógico de negação visa comparar variáveis, sejam elas tipos primitivos ou resultados relacionais, a fim de obter uma verdade quando se existe uma diferença.

De forma clara:

nome1 := "Guilherme"
nome2 := "Caruso"
resultado := nome1 != nome2

fmt.Println(resultado)

OUTPUT: true

ou

relacional1 := 10 == 10 // true
relacional2 := 20 < 10 // false
resultado := relacional1 != relacional2

fmt.Println(resultado)

OUTPUT: true

Conseguimos comprovar que o operador lógico de negação se comporta da mesma forma para tipos primitivos e resultados relacionais.

4. Atribuição

Operadores de atribuição possibilitam que valores de variáveis sejam alterados de diversas formas.

Em GO possuímos seis principais operadores de atribuição, que são:

• Atribuição =
• Soma e atribuição +=
• Subtração e atribuição -=
• Multiplicação e atribuição *=
• Divisão e atribuição /=
• Módulo e atribuição %=

Atribuição ( = )

Utilizado para atribuir valor inicial ou sobrescrever um valor já existente de uma variável.

var nome string = "Guilherme"

ou

nome := "Guilherme"
nome = "Caruso"

fmt.Println(nome)

OUTPUT: Caruso

Soma e atribuição ( += )

Utilizado para efetuar somas e, no caso de strings, concatenações. Atribuindo à variável inicial um novo valor já processado.

• Numérico

numero := 20
numero += 10

fmt.Printf("%d", numero)

OUTPUT: 30

• Texto (Concatenação)

nome := "Guilherme"
nome += " Caruso"

fmt.Println(nome)

OUTPUT: Guilherme Caruso

Subtração e atribuição ( -= )

Utilizado para efetuar subtrações. Atribuindo à variável inicial um novo valor já processado.

numero := 50
numero -= 10

fmt.Printf("%d", numero)

OUTPUT: 40

Multiplicação e atribuição ( *= )

Utilizado para efetuar multiplicações . Atribuindo à variável inicial um novo valor já processado.

numero := 20
numero *= 2

fmt.Printf("%d", numero)

OUTPUT: 40

Divisão e atribuição ( /= )

Utilizado para efetuar divisões . Atribuindo à variável inicial o valor do quociente da divisão.

numero := 30
numero /= 2

fmt.Printf("%d", numero)

OUTPUT: 15

Resto e atribuição ( %= )

Utilizado para efetuar divisões . Atribuindo à variável inicial o valor do resto da divisão.

numero := 17
numero %= 2

fmt.Printf("%d", numero)

OUTPUT: 1

Conclusão

Entendendo todos os nossos principais operadores, começamos a ter uma visão cada vez melhor da linguagem. Podemos enxergar possibilidades e aplicações de GO em operações muitas vezes repetitivas do nosso cotidiano.

Nesse tutorial vimos:

• Operadores aritméticos;
• Operadores relacionais;
• Operadores lógicos;
• Operadores de atribuição.

Nos vemos no próximo post sobre estruturas de controle!

#5 GoSchool: Estruturas de Controle

#4 GoSchool: Operadores was originally published in Gommunity on Medium, where people are continuing the conversation by highlighting and responding to this story.

Seja bem vindo ao tutorial de número #3, onde iremos falar sobre declarações e tipos da linguagem.

Caso você tenha perdido o #2 sobre Estrutura Básica, segue o link:

#2 GoSchool : Estrutura Básica

O material do tutorial será dividido da seguinte forma:

1. Declarações

• Variável
• Constante

2. Tipos Primitivos

Tenha em vista que após esse tutorial, você estará preparado para começar a desbravar pequenos projetos na linguagem.

VAMOS LÁ!

1. Declarações

Variáveis

Variáveis são nossas companheiras durante todo e qualquer desenvolvimento, já que são responsáveis por iniciar, armazenar e disponibilizar qualquer tipo de informação.

Há diversas formas possíveis para se declarar uma variável, algumas delas são:

• Declaração explícita

var nomeDaVariavel tipo

Dessa forma declaramos de forma explicita o nome da variável e o seu “tipo” sem um valor definido. O valor por sua vez, é definido baseado no tipo da variável, mais adiante abordaremos este assunto.

• Declaração explicita com valor definido

var nomeDaVariavel tipo = valorDaVariavel

Dessa forma, iniciamos uma variável e já atribuimos um valor ao mesmo tempo. Vale lembrar que a partir do momento que um tipo é definido para uma variável, ele não irá aceitar valores de tipagem diferente.

Para os preguiçosos de plantão, a linguagem também permite iniciarmos mais de uma variável ao mesmo tempo, atribuindo ou não valores à ela.

• Declaração explícita — Declaração múltipla

var nomeVar1, nomeVar2 tipo

O único detalhe é que esse tipo de declaração define o mesmo “tipo”para as diferentes variáveis, sendo proibido definir mais de um “tipo”.

• Declaração explícita com valor definido — Declaração múltipla

var nomeVar1, nomeVar2 tipo = valor1, valor2

Um detalhe bem bacana, é que a linguagem permite que você inicie uma nova variável sem a necessidade de declarar de forma explicita o seu “tipo”, dessa forma, ela se torna a responsável por identificar a definir essa informação. O único detalhe é que esse suporte só ocorre para declarações com valores já definidos.

• Declaração implícita com valor definido;

var nomeVar = valor1

• Declaração implícita com valor definido — Declaração múltipla

var nomeVar, nomeVar2 = valor, valor2

- “Você falou que a linguagem era fácil… tenho que escrever muito!”

Muita calma nessa hora padawan, deixei a cereja do bolo de variáveis para o final!

Como GO possui sintaxe semelhante a linguagem de programação C, algumas de suas características foram “herdadas”. A mais utilizada, na minha opinião, a mais “bonita”, é a declaração reduzida de variáveis que é feita utilizando := , sim, apenas isso.

• Declaração implícita reduzida

nomeVar := valor

• Declaração implícita reduzida — Declaração múltipla

nomeVar, nomeVar2 := valor, valor2

Esse tipo de declaração, diferente do tipo explícito, permite que você declare ao mesmo tempo diferentes tipos de variáveis.

Esse tipo de declaração só pode ser utilizado em um escopo de função, causando erro de compilação caso seja declarada de outra forma.

package main

i := valor

func main() {

}

O modelo acima irá gerar um erro de compilação

package main

func main() {

i := valor

}

o modelo acima apresenta uma declaração correta

Por fim, ao utilizarmos a declaração reduzida, qualquer alteração no valor da variável deve ser feito utilizando símbolo de igualdade =, já que := representa a inicialização de uma nova variável.

variavel := valor  // valor

variavel = novoValor // novoValor

Muita calma nessa hora, pois existe mais uma forma de declararmos múltiplas variáveis!

Anteriormente comentei sobre a declaração múltipla em linha, ou seja:

variavel, variavel2 := 1, 2

Esse tipo de declaração facilita o processo de criação, contudo, possuímos uma forma ainda mais agradável de declararmos múltiplas variáveis de forma implícita ou explícita.

• Declaração explícita aninhada — Declaração múltipla

var (

variavel tipo = valor
   variavel2 tipo = valor
   variavel3 tipo = valor

)

• Declaração implícita aninhada — Declaração múltipla

var (

variavel = valor
   variavel2 = valor
   variavel3 = valor

)

Chegamos ao fim da explicação sobre variáveis!

Aos poucos vamos nos adaptando com sua utilização fazendo com que a sua escrita seja feita de forma quase automática.

Constantes

Saindo do maravilhoso mundo das variáveis, chegamos no não tão belo mundo das constantes.

- “Mas qual o motivo de não ser tão belo?”

O único motivo para essa frase é que como o próprio nome já diz, as constantes devem nascer com um valor já definido e em momento algum possuem seus valores alterados.

A sua declaração é semelhante a utilizada nas variáveis, ficando da seguinte forma:

• Declaração explícita

const nomeConstante tipo = valorConstante

Ao ser inicializado, deve possuir seu valor final definido.

• Declaração implícita

const nomeConstante = valorconstante

Semelhante a variável, o tipo da constante não precisa ser explícito.

Por fim, podemos declarar constantes de forma aninhada.

• Declaração explícita aninhada — Declaração múltipla

const (

constante tipo = valor
   constante2 tipo = valor
   constante3 tipo = valor

)

• Declaração implícita aninhada — Declaração múltipla

constante (

constante = valor
   constante2 = valor
   constante3 = valor

)

Essa etapa foi bem rápida, já que as constantes não possuem declarações reduzidas ou “firulas” bonitinhas 😃.

Chegamos ao fim das declarações!

Podemos iniciar o assunto relacionado aos tipos primitivos da linguagem que tanto comentamos anteriormente.

2. Tipos primitivos

A partir de agora vamos abordar os tipos primitivos utilizados na linguagem GO.

Um tipo primitivo representa o nível mais baixo de declaração de um valor, podendo atuar como um texto, número ou booleano.

String

O tipo String é o responsável por representar valores de texto. Sim, simples e direto.

Uma curiosidade a respeito da utilização de textos na linguagem GO, é que a mesma utiliza codificação binária UTF-8 Para saber mais sobre UTF-8 acesse AQUI!

- “Tá, mas como posso declarar uma String?”

A declaração de uma String pode ser feita de duas formas:

• Aspas duplas "..."

novaString := "Essa é uma nova String"

• Backticks `...`

novaString := `Essa é uma nova String`

Um detalhe a respeito da utilização do backtick, é que ele permite uma quebra de linha durante a sua declaração.

novaString := `Essa é 
                 uma nova String`

Caso queira declarar uma String de forma explícita, é possível utilizar a seguinte sintaxe:

var novaString string

novaString = "Oi"

Agora que você já possui conhecimento sobre a utilização de String, podemos falar de um outro tipo muito utilizado, o Boolean.

Boolean

O tipo boolean é responsável por definir o valor de uma variável como true (verdadeiro) ou false (falso). Diferente de outras linguagens de programação, em GO, um boolean não pode ser representado por números ,0 e 1, por exemplo.

A declaração de um boolean é feita seguindo o padrão:

var novoBooleano bool

novoBooleano = true

Vale ressaltar que também que é possível declarar um boolean de forma reduzida.

novoBoolean := false

Por padrão, quando declaramos um boolean e não definimos um valor inicial para ele, o mesmo passa a ter false como seu valor.

Ok, a utilização do boolean pode ser um pouco abstrata nesse momento, mas nas próximas aulas veremos o seu verdadeiro potencial em prática!

Tipos numéricos

Enfim, chegamos aos tipos numéricos que, assim como o nome diz, representam todo e qualquer tipo de variável contendo números.

A lista é um pouco extensa, mas logo tudo ficará bem claro.

╔═════════╦══════════════════════════════════════════════════════╗
║   Tipo  ║                        Faixa                         ║
╠═════════╬══════════════════════════════════════════════════════╣                        
║ rune    ║-2,147,483,648 ~ 2,147,483,647                        ║                       
║ int8    ║-128 ~ 127                                            ║                       
║ int16   ║-32,768 ~ 32,767                                      ║
║ int32   ║-2,147,483,648 ~ 2,147,483,647                        ║
║ int64   ║-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807║       
║ byte    ║ 0 ~ 255                                              ║
║ uint8   ║ 0 ~ 255                                              ║
║ uint16  ║ 0 ~ 65,535                                           ║
║ uint32  ║ 0 ~ 4,294,967,295                                    ║
║ uint64  ║ 0 ~ 18,446,744,073,709,551,615                       ║
║ float32 ║ -3.4^38 ~ +3.4^38                                    ║
║ float64 ║ -1.7^308 to +1.7^308                                 ║
╚═════════╩══════════════════════════════════════════════════════╝

Podemos notar que rune possui as mesmas características de um int32 , assim como um byte esta para uint8 .

Além dos tipos apresentados na tabela, existem outros dois que apresentarei de forma breve devido ao seu nível de complexidade.

Estou falando do complex64 e complex128

- “Tudo bem. Uma dúzia de tipos e valores, mas como realmente podemos utiliza-los? ”

Vou separar a explicação em três etapas para que seja possível iniciarmos de forma descomplicada.

1. Inteiros
2. Fracionários
3. Complexos

Inteiros

“Os números inteiros são constituídos dos números naturais e seus simétricos negativos, incluindo o zero.”

Dentro dos inteiros simétricos possuímos os seguintes tipos:

╔═════════╦══════════════════════════════════════════════════════╗
║   Tipo  ║                        Faixa                         ║
╠═════════╬══════════════════════════════════════════════════════╣                        
║ rune    ║-2,147,483,648 ~ 2,147,483,647                        ║                       
║ int8    ║-128 ~ 127                                            ║                       
║ int16   ║-32,768 ~ 32,767                                      ║
║ int32   ║-2,147,483,648 ~ 2,147,483,647                        ║
║ int64   ║-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807║       
╚═════════╩══════════════════════════════════════════════════════╝

A única grande diferença entre eles está na capacidade de bytes que cada tipo suporta.

- “Já falou muita coisa. Como posso utiliza-los?”

A declaração explícita de inteiros simétricos é bem simples.

var runeVar rune = 255
var intVar int8 = 100
var intVar2 int16 = -300
var intVar3 int32 = 1000
var intVar4 int64 = -10000

A declaração de qualquer tipo de número, diferente dos textos, não necessita da utilização de "" ou `` .

Ainda sobre inteiros, existem os que possuem capacidade apenas, para valores positivos.

╔═════════╦══════════════════════════════════════════════════════╗
║   Tipo  ║                        Faixa                         ║
╠═════════╬══════════════════════════════════════════════════════╣                        
║ byte    ║ 0 ~ 255                                              ║
║ uint8   ║ 0 ~ 255                                              ║
║ uint16  ║ 0 ~ 65,535                                           ║
║ uint32  ║ 0 ~ 4,294,967,295                                    ║
║ uint64  ║ 0 ~ 18,446,744,073,709,551,615                       ║
╚═════════╩══════════════════════════════════════════════════════╝

O processo de declaração explícita continua idêntico ao descrito anteriormente.

var byteVar byte = 20
var uintVar uint8 = 20
var uintVar2 uint16 = 100
var uintVar3 uint32 = 1233
var uintVar4 uint64 = 12313

- “Você falou que GO era fácil!”

Claro que GO é uma linguagem fácil!

Caso a declaração não seja explícita, nosso querido e amado GO se encarrega de solucionar este problema.

Atenção: O código abaixo irá demonstrar apenas o processo de identificação automático da linguagem. Não se preocupe em entendê-lo agora.

package main

import (

"fmt"

"reflect"

)

func main() {

variavelInteira := -2000

fmt.Println(reflect.TypeOf(variavelInteira))

}

// OUTPUT: int

A variável foi interpretada e automaticamente definida como int, algo que pode ocorrer com qualquer outro tipo numérico.

Agora que conhecemos todos os tipos de inteiros, vamos falar dos fracionários, que garantem um pouco mais de liberdade durante sua utilização.

Fracionários

“ Fração é um modo de expressar uma quantidade a partir de um valor que é dividido por um determinado número de partes iguais entre si. Número fracionário expressa esta condição. ”

Todo e qualquer número representado por uma fração de um valor. Os tipos utilizados em GO, são:

╔═════════╦══════════════════════════════════════════════════════╗
║   Tipo  ║                        Faixa                         ║
╠═════════╬══════════════════════════════════════════════════════╣                        
║ float32 ║ -3.4^38 ~ +3.4^38                                    ║
║ float64 ║ -1.7^308 to +1.7^308                                 ║
╚═════════╩══════════════════════════════════════════════════════╝

Sua declaração explícita é semelhante a utilizada anteriormente, contudo, a fração de seu valor deve ser representada através de um . .

var variavelFloat float32 = 15.50
var variavelFloat2 float64 = 35.588

Podemos deixar mais uma vez a responsabilidade de definição de tipos com o GO.

Atenção: O código abaixo irá demonstrar apenas o processo de identificação automático da linguagem. Não se preocupe em entendê-lo agora.

package main

import (

"fmt"

"reflect"

)

func main() {

num1 := 5.5

fmt.Println(reflect.TypeOf(num1))

}

// OUTPUT: float64

ENFIM CHEGAMOS AO ÚLTIMO TÓPICO DESTE TUTORIAL!

Complexos

Comentei anteriormente que este seria um tópico rápido e sem muitos detalhes, já que seu nome representa a dificuldade de utiliza-lo.

De forma direta, um número complexo é representado através da fórmula complexa a + bi onde a,b são números reais e i é o resultado da equação i² = -1 , já que o seu valor final não pode ser representada por um número real.

Por convenção:

• i é denominado de número imaginário
• a é denominado de parte real
• bi é denominado de parte imaginária

Os números complexos deram origem ao teorema fundamental da álgebra

- “ ????? ”

Para prender sua atenção nesse momento final, veja como os fractais criados e estudados através de números complexos são lindos!

complex64 e complex128 são os tipos complexos existentes em GO.

Sua declaração é idêntica a utilizada nos inteiros e fracionários.

var complexo complex64 = 1+2i
var complexo2 complex128 = 10+4i

Como a utilização de complexos é restrita a cálculos avançados e “diferenciados”, GO disponibiliza de forma nativa um pacote contendo funções já prontas para sua utilização. Caso queira saber mais sobre esse pacote, ACESSE!

Preciso ressaltar que números complexos possuem utilização muito específica. Com isso, caso você não entenda sobre sua utilização, fique tranquilo que isso não terá impacto algum na sua performance daqui pra frente! #VocêÉoMelhor

CHEGAMOS AO FIM !!!!!

Após essa longa jornada, finalmente chegamos ao fim.

Espero que de alguma forma, você tenha absorvido e compreendido esse dois tópicos que serão a base para todo e qualquer desenvolvimento a partir de agora.

Nesse tutorial vimos:

• Declarações de variáveis e constantes;
• Definição de todos os tipos primitivos da linguagem.

Nos vemos no próximo post sobre operadores!

#4 GoSchool: Operadores

#3 GoSchool: Declarações e Tipos Primitivos was originally published in Gommunity on Medium, where people are continuing the conversation by highlighting and responding to this story.

Bem vindo ao tutorial de número #2 do GoSchool!

Caso você tenha perdido, aqui está o primeiro tutorial:

#1 GoSchool : Instalação

Vamos entender como funciona a estrutura básica de código da linguagem GO.

Obs: Os exemplos aqui apresentados podem ser escritos e executados em qualquer sistema operacional e editor de texto.

Criando o projeto

Por padrão, a criação de projetos deve ocorrer dentro da pasta src definida em nosso GOPATH. Mais pra frente entrarei em detalhes sobre a estrutura de importação e utilização de bibliotecas.

Nesse primeiro momento, utilize a seguinte sequência de códigos:

$ cd $GOPATH 
$ cd src/
$ mkdir github.com 
$ cd github.com/
$ mkdir <Seu usuario GIT>
$ cd <Seu usuario GIT>
$ mkdir <Nome do seu Projeto>

Criada a pasta do seu projeto, agora podemos abri-la com um editor de texto para que possamos iniciar nosso tutorial.

• Estrutura do projeto

Vamos utilizar a seguinte estrutura de pastas para esse tutorial.

<Nome do seu Projeto>
|
└── main.go

Crie ou utilize o comando abaixo dentro da pasta do seu projeto.

$ touch main.go

• Entendendo o arquivo main.go

Dentro de seus requisitos, GO solicita que qualquer programa tenha sua função principal declarada. Em outras palavras, tudo que acontece deve e irá partir de uma função “main” de seu código.

Como o foco desse segundo tutorial não são declarações e tipos da linguagem, irei abordar o assunto de forma direta, porém, nos próximos tutoriais trarei mais detalhes a respeito disso.

• Uma função em GO é declarada da seguinte forma

func <nomeDaFuncao>() {
        //<TODO>
}

Sendo assim, para que possamos declarar uma função main dentro de nosso arquivo main.go devemos escreve-la da seguinte forma:

func main() {
        //<TODO>
}

Agora, toda e qualquer ação do nosso sistema irá ser chamado a partir dessa função.

- “Só isso?”

- “Posso rodar meu código?”

Estamos quase lá, mas ainda é necessário preparar um pouco mais o nosso terreno para que GO possa rodar sem nenhum problema, mostrando todo o seu potêncial.

Assim como nossa função principal, precisamos declarar também nosso pacote principal pois sem ele a mágica não acontece.

Para declararmos o pacote principal, dentro do arquivo main.go definimos na parte inicial do arquivo o seguinte código:

package main

Dessa forma, nosso código até o momento está assim:

package main

func main() {
    //<TODO>
}

Bem, até aqui já verificamos os dois principais requisitos para qualquer desenvolvimento GO.

• Criação da função “main”;
• Definição do pacote principal.

O detalhe final para qualquer programa GO rodar sem nenhum problema são as suas importações. Elas definem e disponibilizam funções para utilizarmos dentro do nosso sitema.

• Entendendo Imports

GO conta com uma série de funções já estabelecidas em seu core, podendo ser acessado e estudado a qualquer momento em sua documentação oficial AQUI!

Por se tratarem de pacotes nativos da linguagem, qualquer utilização de suas funções será de forma automática reconhecida pelo compilador da linguagem.

Vamos parar de enrolar!

Um dos primeiros passos de qualquer linguagem é o famoso “Hello World”, sendo assim, para que seja possível printar uma mensagem no console quando o programa for executado, devemos utilizar o seguinte pacote:

• fmt

O pacote responsável por formatar qualquer entrada ou saida de informação deve ser importado dentro do nosso arquivo main.go, para que suas funções sejam disponibilizadas.

Para importarmos uma biblioteca nativa da linguagem, devemos declará-la da seguinte forma:

import "fmt"

Vale lembrar que ela deve ser escrita abaixo da declaração do pacote e acima da função, deixando o código da seguinte forma:

package main

import "fmt"

func main() {
    //<TODO>
}

- “Mas onde está o meu Hello World?”

• Ao utilizarmos o pacote fmt, uma das funções disponibilizadas é o Println (abreviação de Print line), que permite a “impressão” de um texto no console. Com isso:

package main 

import "fmt"

func main() {

    fmt.Println("Hello World")

}

• Agora se acessarmos o local de nosso arquivo main.go e rodarmos o comando abaixo, teremos como resposta o nosso querido e amado “Hello World”:

$ go run main.go
//Hello World

Conclusão

Enfim, com nosso Hello World em mãos podemos estudar tipos e conceitos da linguagem.

Nesse tutorial vimos:

• Criação da função “main”;
• Definição do pacote principal;
• Importação de pacotes nativos

Nos vemos no próximo tutorial!

#3 GoSchool: Declarações e Tipos

#2 GoSchool : Estrutura Básica was originally published in Gommunity on Medium, where people are continuing the conversation by highlighting and responding to this story.

Bem vindo ao tutorial de número #1 do GoSchool, uma iniciativa da Gommunity.

Nesse primeiro momento vamos preparar o ambiente para que você possa utilizar GO em sua máquina. O processo de instalação será feito para Windows, Linux e macOS.

Obs: Existem formas e formas de se instalar GO, caso encontre alguma diferente da apresentada neste tutorial, compartilhe com a gente

Para ter acesso ao material oficial de instalação do GO entre AQUI!

Chega de enrolação!

Vamos seguir essa ordem, Ok?

1. Windows
2. Linux
3. macOS

Windows

1. Para iniciar o processo de instalação no Windows você deve acessar o link: Download GO — Microsoft Windows
2. Clique no botão para download e aguarde o processo ser finalizado.

3. Por estarmos dentro do Windows, não existem muitos segredos. Basta pressionar o botão “Next” até que o botão “Install” apareça. Com isto, o processo de instalação do Go estará finalizado no Windows.

Vamos realizar um teste simples para ver se a instalação foi feita com sucesso! Explicarei em um próximo post um trecho de código mais elaborado para executarmos e realizarmos o teste de instalação, tudo bem?

4. Agora precisamos definir o folder que apontado durante a instalação. Para isso, rode o seguinte comando:

cd $HOME && mkdir go && cd go && mkdir bin && mkdir src && mkdir pkg && echo 'Gopath Definido'

5. Para testar se o GO realmente foi instalado em sua máquina, abra seu terminal e digite:

go

• A saída deve ser algo parecido com:

Go is a tool for managing Go source code.

Usage:

go <command> [arguments]

The commands are:

bug         start a bug report
build       compile packages and dependencies
clean       remove object files and cached files
doc         show documentation for package or symbol
env         print Go environment information
fix         update packages to use new APIs
fmt         gofmt (reformat) package sources
generate    generate Go files by processing source
get         download and install packages and dependencies
install     compile and install packages and dependencies
list        list packages or modules
mod         module maintenance
run         compile and run Go program
test        test packages
tool        run specified go tool
version     print Go version
vet         report likely mistakes in packages

Use "go help <command>" for more information about a command.

Additional help topics:

buildmode   build modes
c           calling between Go and C
cache       build and test caching
environment environment variables
filetype    file types
go.mod      the go.mod file
gopath      GOPATH environment variable
gopath-get  legacy GOPATH go get
goproxy     module proxy protocol
importpath  import path syntax
modules     modules, module versions, and more
module-get  module-aware go get
packages    package lists and patterns
testflag    testing flags
testfunc    testing functions

Use "go help <topic>" for more information about that topic.

6.Tudo certo? Então estamos com tudo funcionando perfeitamente.

Linux

1. Para iniciar o processo de instalação no Linux você deve acessar o link: Download GO — Linux
2. Clique no botão para download e aguarde o processo ser finalizado.

3. Feito o Download, abra seu terminal e acesse o local no qual o arquivo foi baixado. Execute o comando para que ele seja descompactado:

tar -C /usr/local -xzf go1.11.2.linux-amd64.tar.gz

Obs: é possível que em alguns casos seja necessário a utilização do “sudo” para a execução como root user.

4. Após descompactar o arquivo, é necessário adicionar o caminho da pasta onde o GO foi instalado no PATH raíz de sua máquina. Para isso, vou utilizar o editor VIM.

Atenção! Muito cuidado nessa hora!

• Primeiro vamos abrir o arquivo de configuração do bash.

vim ~/.bashrc

Caso não utilize bash, a edição pode ser feito no arquivo de configuração zsh ~/.zshrc.

• Com ele aberto, vá para o final do arquivo e adicione o seguinte código.

export PATH=$PATH:/usr/local/go/bin

Ele irá garantir que comandos e binários GO sejam reconhecidos pelo sistema.

• Salve o arquivo.

5. Por fim, é necessário adicionar o GOPATH para que toda instalação e leitura de arquivo possa ser feita. Nesse caso, vamos definir o próprio “/urs/local/go” como GOPATH.

• Abra novamente o arquivo de configuração do bash.

vim ~/.bashrc

Caso não utilize bash, a edição pode ser feito no arquivo de configuração zsh ~/.zshrc.

• Adicione o seguinte código.

export GOPATH=/urs/local/go

• Salve o arquivo.

6. Para testar se o GO realmente foi instalado em sua máquina, abra seu terminal e digite:

go

Para que o comando descrito acima funcione perfeitamente, é necessário abrir um novo terminal para que as novas configurações do bash sejam carregadas.

• A saída deve ser algo parecido com:

Go is a tool for managing Go source code.

Usage:

go <command> [arguments]

The commands are:

bug         start a bug report
build       compile packages and dependencies
clean       remove object files and cached files
doc         show documentation for package or symbol
env         print Go environment information
fix         update packages to use new APIs
fmt         gofmt (reformat) package sources
generate    generate Go files by processing source
get         download and install packages and dependencies
install     compile and install packages and dependencies
list        list packages or modules
mod         module maintenance
run         compile and run Go program
test        test packages
tool        run specified go tool
version     print Go version
vet         report likely mistakes in packages

Use "go help <command>" for more information about a command.

Additional help topics:

buildmode   build modes
c           calling between Go and C
cache       build and test caching
environment environment variables
filetype    file types
go.mod      the go.mod file
gopath      GOPATH environment variable
gopath-get  legacy GOPATH go get
goproxy     module proxy protocol
importpath  import path syntax
modules     modules, module versions, and more
module-get  module-aware go get
packages    package lists and patterns
testflag    testing flags
testfunc    testing functions

Use "go help <topic>" for more information about that topic.

7. Tudo certo? Então estamos com tudo funcionando perfeitamente.

macOS

1. Vamos instalar a linguagem GO utilizando o gerenciador de pacotes do macOS, o Homebrew. Para isso, utilize:

brew install go --cross-compile-common

2. Com a instalação concluída, precisamos definir algumas variáveis de ambiente nos arquivos de configuração bash ou zsh. Nesse caso vamos utilizar o editor VIM, porem, sinta-se a vontade para utilizar o editor de sua preferência.

vim ~/.bashrc

ou

vim ~/.zshrc

• Adicione os seguintes exports:

export PATH=$PATH:/usr/local/go/bin
export GOPATH=/urs/local/go

Os exports são responsáveis por fazer com que o macOS reconheça e possa executar os binários GO.

• Salve o arquivo.

3. Para testar se o GO realmente foi instalado em sua máquina, abra seu terminal e digite:

go

Para que o comando descrito acima funcione perfeitamente, é necessário abrir um novo terminal para que as novas configurações do bash sejam carregadas.

• A saída deve ser algo parecido com:

Go is a tool for managing Go source code.

Usage:

go <command> [arguments]

The commands are:

bug         start a bug report
build       compile packages and dependencies
clean       remove object files and cached files
doc         show documentation for package or symbol
env         print Go environment information
fix         update packages to use new APIs
fmt         gofmt (reformat) package sources
generate    generate Go files by processing source
get         download and install packages and dependencies
install     compile and install packages and dependencies
list        list packages or modules
mod         module maintenance
run         compile and run Go program
test        test packages
tool        run specified go tool
version     print Go version
vet         report likely mistakes in packages

Use "go help <command>" for more information about a command.

Additional help topics:

buildmode   build modes
c           calling between Go and C
cache       build and test caching
environment environment variables
filetype    file types
go.mod      the go.mod file
gopath      GOPATH environment variable
gopath-get  legacy GOPATH go get
goproxy     module proxy protocol
importpath  import path syntax
modules     modules, module versions, and more
module-get  module-aware go get
packages    package lists and patterns
testflag    testing flags
testfunc    testing functions

Use "go help <topic>" for more information about that topic.

4. Tudo certo? Então estamos com tudo funcionando perfeitamente.

Conclusão

Enfim, tudo funcionando!

Agora podemos iniciar nossos tutoriais com o que realmente importa: CÓDIGO!.

Nos vemos no próximo post!

#2 GoSchool : Estrutura Básica

#1 GoSchool : Instalação was originally published in Gommunity on Medium, where people are continuing the conversation by highlighting and responding to this story.