#5 GoSchool: Estruturas de Controle

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