Rust - Controle de Fluxo

Vamos entender o que é controle de fluxo.

Em ciência da computação, estrutura de controle (ou fluxo de controle) refere-se à ordem em que instruções, expressões e chamadas de função são executadas ou avaliadas em programas de computador sob programação imperativa ou funcional.

Toda linguagem tem seus controles de fluxo aquele if, else e loop. No Rust não seria diferente, vamos entender nesse post loop, while e for.

Loop

O loop no Rust executa varias vezes um bloco de instruções até que tenha uma condição que diga que pare.

fn main() {
    loop {
        println!("loop ")
    }
}

No caso acima teremos uma repetição infinita pois não informamos ao código qual a hora sair da repetição. Para sair da repetição usando a palavra chave break.

Expressões if e else if

O if permitir ramificar seu código dependente da condição foi proposta. Vamos utilizar-lo para definir a hora de parar o fluxo, aquele loop do exemplo anterior que estava infinito vamos dar uma break caso a variável x seja maior do que 3.

fn main() {
    let mut x = 1;
    loop {
        if x > 3 {
            break;
        }
        println!("x: {}", x);
        x += 1;
    }
}


/*
    x: 1
    x: 2
    x: 3
*/

Criamos uma variável chamada x que é mutável e comparamos o seu valor igual a 3, se sim usamos o break caso contrario incrementamos um valor até que a mesma chegue a comparação.

Nas condições temos “caso não” que é o else, no exemplo acima informamos só o caso positivo mas não o “negativo”.

Segue o exemplo.

fn main() {
    let mut x = 1;
    loop {
        if x > 3 {
            break;
        } else {
            println!("x: {}", x);
            x += 1;
        }
    }
}


/*
    x: 1
    x: 2
    x: 3
*/

Colocamos o else imprimindo a variável enquanto ela for menor do que 3. Se analisarmos os dois exemplos, podemos chegar a conclusão que o else as vezes não é necessário em alguns blocos de instruções.

Podemos gerar erros caso a instrução de código seja da seguinte forma.

fn main() {
    let mut x = 1;
    loop {
        if x {
            break;
        } else {
            println!("x: {}", x);
            x += 1;
        }
    }
}

/*
  --> main.rs:32:12
   |
32 |         if x {
   |            ^ expected bool, found integer
   |
   = note: expected type `bool`
              found type `{integer}`
*/

Em algumas linguagens essa instrução funcionaria por conta que estamos comparando se tem algo na variável mas no Rust esse tipo de comparação só pode ser feita quando o tipo for boolean como o próprio error informa “expected bool, found integer”.

Com o else if podemos combinar varias condições tipo, se o x for maior que 1 ou 2 ou 3 e assim vai.

Segue o código abaixo.

fn main() {
    let mut x = 1;
    loop {
        if x > 3 {
            break;
        } else if x == 1 {
            println!("x é igual 1: {}", x);
        } else if x == 2 {
            println!("x é igual 2: {}", x);
        } else {
            println!("x caiu no else: {}", x);
        }
        x += 1;
    }
}

/*
    x é igual 1: 1
    x é igual 2: 2
    x caiu no else: 3
*/

No caso acima colocamos uma comparação a cada número retiramos o x +=1 do else e colocamos fora para que não importe qual condição ele passe o mesmo vai seguir incrementando valor.

While

O while lembra o loop a diferença entre eles que um precisa de condição para executar o outro não. Nesse caso o while necessita de condição.

Segue o código abaixo.

fn main() {
    let mut valor = 4;

    while valor !=0 {
        println!("valor: {}", valor);
        valor -= 1;
    }

}

/*
    valor: 4
    valor: 3
    valor: 2
    valor: 1
*/

No caso acima estamos declarando um variável chamada valor com o número e comparamos o mesmo com uma condição, se for diferente de 0 imprimi o valor e decremento um até chegar igual a 0.

For

O for lembra o while a diferença entre eles que o for traz parâmetros que é o index e o valor de forma fácil.

Segue o código abaixo.

fn main() {
    for numero in (1..4).rev() {
        println!("o numero é: {}!", numero);
    }
}

/*
    o numero é: 3!
    o numero é: 2!
    o numero é: 1!
*/

No código acima faz uma contagem regressiva usando o loop for e usamos um método chamado .rev() que reverte a o intervalo dos números para uma ordem decrescente.

Então galera é isso, espero que tenham gostado até a próxima.