Controle de Fluxo

Observação: Os arquivos utilizados neste conteúdo que falam sobre os diversos tipos de controle de fluxo, são os seguintes:

Neste conteúdo você vai aprender a usar a estrutura de controle If/else em conjunto com o When, For, Do...While e o While.

Fluxo de Controle (Control Flow)

Nos temos o famoso Control Flow, que traduzido para o bom português significa Fluxo de Controle. Que nada mais é do que a ordem na qual o computador executa as instruções que você escreve para ele.

Sendo assim, o código que informamos é executado deste a primeira linha, passando pela segunda, indo para a terceira até executar a última linha.

Veja só um exemplo de fluxo de controle por meio do comando println():

println('Eu serei executado PRIMEIRO!');

println('Olha, vejam só... eu sou o segundo da fila =)');

println('Terceiroooo!');

println('Pois bem... parece que eu fiquei por último rs');

Hoje existem estruturas que são capazes de "quebrar" esse fluxo de controle, de modo que o computador volte a executar aquela linha de código mais tarde, seja porque ela ainda não foi chamada, ou porque se tratam de estruturas condicionais ou iterações (loops).

Agora que já temos uma noção do que significa o Control Flow, podemos seguir mais a diante com nosso conteúdo.

Estrutura Condicional IF/ELSE

Como o próprio nome já nos diz, a estrutura condicional é uma estrutura do Kotlin, que verifica se uma determinada condição atende a algum padrão especificado.

Se está condição for verdadeiro, um bloco de código será executado, caso seja falso, o computador seguirá por um outro caminho.

Com isso temos a estrutura condicional If que permite que o Kotlin execute um trecho de código, somente se uma determinada condição for verdadeira.

Em conjunto com o If, podemos utilizar o Else. Nesse caso se o IF verifica se uma determinada condição é verdadeira para executar um bloco, o Else (se não) só pode executar outro bloco caso a condição não passar pelo IF.

val verdadeiro = true

if(verdadeiro){
println("Verdadeiro")
}else{
println("Falso")
}

println("Saí do IF/ELSE...")

println("Maior de Idade? ${maiorDeIdade(15)}")

É importante ressaltar que podemos aninhar diversos if/else dentro de outros:

if(10 < 5){
if(true){

}
}else if(5 == 10){

}else{

}

Além disso, podemos usar a estrutura sem o uso das chaves, mas somente quando temos uma única linha de comando:

//As chaves não são obrigatórias quando temos um único retorno

if(true)
println("uno")
else
println("dois")

Entretanto, caso preferir você pode utilizar a estrutura IF sozinha (sem o else), mas o contrário (else sem o if) não é possível:

if(10 < 5){
//Estrutura onde não usamos o ELSE
}

Controle de Fluxo (When)

No Kotlin nós temos o comando when que significa "quando", e ela funciona de forma muito similar ao switch de outras linguagens de programação.

//Control de Fluxo (When): QUE SIGNIFICA "QUANDO"

val numero = 1

when(numero){
1 -> {//Usamos chaves quando podemos ter mais de uma única instrução
println("Um")
}
2 -> {
println("Dois")
}
3 -> println("Três")//Quando temos uma única instrução, não precisamos das chaves
else -> {
println("Não achou")//O else só é executado quando nenhuma das opções foi encontrada
}
}

//No caso do comando "when" acima, ele executará a mensagem "Um"

//Outro exemplo do uso do When

val texto = "um"

when(texto){
"um" -> {
println("1")
}
"dois" -> println("2")
else -> println("Não achou")
}

Controle de Fluxo (For)

A estrutura de controle FOR (para), nos possibilita percorrer um laço (loop).

//Control de Fluxo (For)
for(i in 1..10){
println("$i")//Imprime uma linha de 1 a 10
}

val str = "Micilini Roll"
for(char in str){
println(char)//Para cada caracter na string nós mostramos separadamente
}

for(i in 1..10 step 2){//Percorre a lista a passo de 2 em 2
println("$i")//Imprime uma linha de 1, 3...
}

for(i in 20 downTo 0){//Vai do 20 até o 0
println("$i")//Imprime uma linha de 1 a 10
}

for(i in 20 downTo 0 step 3){//Vai do 20 até o 0, pulando de 3 em 3
println("$i")//Imprime uma linha de 1 a 10
}

Diferente de outras linguagens, o kotlin não tem suporte ao FOR padrão com os 3 statements como existe em outras linguagens:

for (int i = 0;i < 0;i++) {
System.out.println(i);
}

Controle de Fluxo (While)

Com o comando while (enquanto), estamos fazendo com que o Kotlin execute um bloco de código infinitamente (loop) até que uma determinada condição deixe de ser verdadeira.

while(true){//Enquanto for true ele executa eternamente
print("v")
}//Este é um exemplo de loop infinito

O código acima é um loop infinito porque true nunca deixará de ser true.

var numero = 0;

while(numero < 5){
print("$numero -")
numero++;
}//Ele sai do loop quando descobre que o numero ficou maior ou igual a 5

println("Saí do Loop!")

var i = 100
while(i > 0){
println(i)
i--
}//Exemplo de while que funciona de forma decrescente

Controle de Fluxo (Do...While)

Este comando funciona de forma parecida com o while, a diferença é que ele executa mais um loop antes de sair daquele loop.

Como o próprio nome já nos diz:

Do significa 'faça', while significa 'enquanto', portanto, podemos dizer que primeiro ele executa o bloco de código para depois verificar se pode continuar executando ou não.

O que funciona de forma diferente do while sozinho, que primeiro verifica se pode executar o bloco para em seguida entrar nele.

Vejamos o funcionamento deste comando:

do{//Faça enquanto, extremamente similar, a diferença é que ele executa primeiro antes de validar no while
print("Eterno!")
}while(true)

var t = 0
do{
print(t)
t++
}while(t == 1000)//Outro exemplo

Controle de Fluxo (Continue e Break)

Os comandos continue e break são muito utilizados dentro de estruturas de controle de fluxo.

O continue ignora todas as próximas sequências de modo a voltar ao início do loop:

while(true){
continue//Ignora tudo o que vem abaixo e volta pro while
println("Nunca vou ser chamado")
}

O break é o comando capaz de quebrar o laço do loop, e fazer com que o Kotlin pare de executar aquele loop:

while(true){
println("Vai sair por causa do 'break'")
break//Quebra o laço do loop e sai do while.
}

while(true){
while(true){
break//Aqui ele sai do escopo desse segundo while, mas o primeiro continua rodando
}
}

var loopy = 0
while(loopy < 100000){
if(loopy == 50){
break//Aqui ele sai do While mesmo estando no IF
}
print(loopy)
loopy++
}

Conclusão

Neste conteúdo você aprendeu um pouco mais sobre o significado de control flow, e os diversos usos de estruturas de controle que temos no Kotlin.

Até o próximo conteúdo 😁