[Introdução ao fluxo de controle em Rust] Introdução ao fluxo de controle em Rust

---

Introdução ao fluxo de controle em Rust

O fluxo de controle é um conceito fundamental em programação. Ele determina a ordem em que o código é executado. Em Rust, como em muitas outras linguagens de programação, temos instruções condicionais e loops para gerenciar o fluxo de controle. Vamos mergulhar no primeiro capítulo e explorar as instruções condicionais em Rust.

1. Declarações Condicionais

1.1 ifDeclaração (se declaração)

A ifinstrução permite executar um bloco de código somente se uma determinada condição for verdadeira. Aqui está um exemplo básico:

let number = 5;

if number > 3 {
    
    
    println!("The number is greater than 3."); // The number is greater than 3. (数字大于3)
}

No código acima, como o número 5 é realmente maior que 3, a mensagem dentro da println!macro será impressa.

1.2 else ifDeclaração (declaração else if)

A else ifdeclaração vem depois da ifdeclaração e verifica outra condição se a ifcondição anterior for falsa.

let number = 2;

if number > 3 {
    
    
    println!("The number is greater than 3.");
} else if number < 3 {
    
    
    println!("The number is less than 3."); // The number is less than 3. (数字小于3)
}

Neste exemplo, como o número 2 não é maior que 3, o código dentro do else ifbloco será executado.

1.3 elseDeclaração (declaração else)

A elseinstrução é usada quando você deseja executar um bloco de código se nenhuma das condições anteriores for verdadeira.

let number = 3;

if number > 3 {
    
    
    println!("The number is greater than 3.");
} else if number < 3 {
    
    
    println!("The number is less than 3.");
} else {
    
    
    println!("The number is 3."); // The number is 3. (数字是3)
}

Aqui, como o número é exatamente 3, o código dentro do elsebloco será executado.

Concluindo, as instruções condicionais em Rust permitem que você tome decisões em seu código com base em certas condições. Eles são essenciais para a criação de programas dinâmicos e responsivos. No próximo capítulo, exploraremos loops em Rust.

2. Laços

Loops são usados ​​para executar um bloco de código repetidamente. Rust oferece várias maneiras de fazer loop, cada uma com seu próprio caso de uso. Vamos explorar os diferentes tipos de loops no Rust.

2.1 loop(loop loop)

A looppalavra-chave cria um loop infinito, o que significa que o código dentro do loop será executado indefinidamente até que seja explicitamente solicitado a parar. Isso pode ser útil quando você deseja que um trecho de código seja executado até que uma determinada condição seja atendida.

let mut counter = 0;

loop {
    
    
    counter += 1;
    println!("This is loop iteration number {}.", counter); // 这是循环的第{}次迭代

    if counter == 5 {
    
    
        break; // Exit the loop (退出循环)
    }
}

No código acima, o loop será executado cinco vezes e então a breakinstrução irá interrompê-lo.

2.2 whileLoop (loop while)

O whileloop é executado enquanto uma condição for verdadeira. Quando a condição se torna falsa, o loop é interrompido.

let mut number = 3;

while number != 0 {
    
    
    println!("{}!", number); // {}!
    number -= 1;
}

println!("Blast off!"); // 发射！

Aqui, o loop imprimirá os números 3, 2, 1 e depois “Decolar!” quando o número chegar a 0.

2.3 forLoop (para loop)

O forloop é usado para iterar sobre elementos de uma coleção, como um array ou um intervalo.

let fruits = ["apple", "banana", "cherry"];

for fruit in fruits.iter() {
    
    
    println!("I love {}!", fruit); // 我喜欢{}!
}

for number in (1..4).rev() {
    
    
    println!("{}!", number); // {}!
}

No primeiro loop, iteramos sobre um array de frutas e imprimimos cada fruta. No segundo loop, iteramos um intervalo de números na ordem inversa.

Em resumo, os loops no Rust permitem executar código várias vezes, indefinidamente ou com base em uma condição. Eles são uma ferramenta poderosa para criar tarefas eficientes e repetitivas em seus programas. Nos próximos capítulos, nos aprofundaremos em conceitos mais avançados de Rust.

Conclusão

Em nossa jornada de aprendizagem de programação, a compreensão é um passo importante para avançarmos para um nível superior. No entanto, dominar novas habilidades e ideias sempre requer tempo e persistência. Do ponto de vista psicológico, a aprendizagem é muitas vezes acompanhada por constantes tentativas, erros e ajustes, que é como se o nosso cérebro otimizasse gradualmente o seu “algoritmo” para resolver problemas.

É por isso que, quando encontramos erros, devemos vê-los como oportunidades de aprender e melhorar, e não apenas como aborrecimentos. Ao compreender e resolver esses problemas, podemos não apenas corrigir o código atual, mas também melhorar nossas habilidades de programação e evitar cometer os mesmos erros em projetos futuros.

Encorajo todos a participarem ativamente e melhorarem continuamente suas habilidades de programação. Quer você seja um desenvolvedor iniciante ou experiente, espero que meu blog seja útil em sua jornada de aprendizado. Se você achar este artigo útil, clique para marcá-lo ou deixe seus comentários para compartilhar suas idéias e experiências. Você também pode fazer sugestões e perguntas sobre o conteúdo do meu blog. Cada curtida, comentário, compartilhamento e atenção é o maior apoio para mim e a motivação para continuar compartilhando e criando.

---

Leia minha página inicial da CSDN e desbloqueie mais conteúdo interessante: Página inicial da CSDN do Bubble