Estruturas de controle de ferrugem e como usá-las

As estruturas de controle são uma construção de programação que permite controlar o fluxo de execução em seus programas. As estruturas de controle permitem que você especifique instruções para serem executadas apenas se certas condições forem atendidas.

As estruturas de controle do Rust são cruciais para gerenciar o fluxo do programa, permitindo a execução eficiente do código enquanto simplifica tarefas complexas em componentes menores e reutilizáveis.

Declarações Condicionais Rust

Instruções condicionais são construções que permitem executar código com base em condições. As instruções condicionais são úteis para a tomada de decisões, pois a execução do programa depende se a condição é avaliada como verdadeiro ou falso. A ferrugem fornece se, outro, e corresponder declarações para a tomada de decisão.

Em programas Rust, o se A instrução testa se uma determinada condição é avaliada como verdadeira. Em caso afirmativo, o programa executa o bloco de código associado. Se a condição for falsa, o programa pula esse bloco de código e passa para a próxima instrução ou executa o

outro bloco de declaração, se houver.

O corresponder A instrução é uma poderosa construção de fluxo de controle que permite que um programa corresponda valores a uma série de padrões e execute o código com base no padrão correspondente.

Declarações if de Rust

você vai declarar se declarações em seus programas Rust com o se palavra-chave seguida por uma condição:

se doença {
// código a ser executado se a condição for verdadeira
}

Aqui está um exemplo de como você pode usar uma instrução if em seus programas Rust:

fnprincipal() {
deixar x = 15;
se x > 10 {
println!("x é maior que 10");
 }
}

O x A variável contém um inteiro de 32 bits e a instrução if verifica se o valor de x é maior que dez antes de executar o bloco de código que o imprime.

Declarações else de Rust

Você usará o outro palavra-chave para executar um bloco de código quando você antecipa que um se declaração seria avaliada como falsa.

se doença {
// código a ser executado se a condição for verdadeira
} outro {
// código a ser executado se a condição for falsa
}

Aqui está um exemplo onde x não for maior que 10, o se declaração avalia falso, e um outro instrução é executada.

fnprincipal(){
deixar x = 5;
se x > 10 {
println!("x é maior que 10");
 } outro {
println!("x não é maior que 10");
 }
}

Desde x é 5 e 5 não é maior que 10, o programa pula o se bloqueia e executa o outro bloquear.

Declarações de correspondência de Rust

Você usará o corresponder palavra-chave para tomada de decisão complexa para verificar uma série de padrões e executar código com base em correspondências de padrão. As instruções de correspondência são semelhantes a instruções switch em C#, Ir e C++.

Aqui está a estrutura de uma declaração de correspondência do Rust:

corresponder valor {
 padrão1 => {
// código a ser executado se o valor corresponder a pattern1
 },
 padrão2 => {
// código a ser executado se o valor corresponder ao padrão2
 },
// etc.
}

Veja como você pode usar declarações de correspondência em seus programas:

deixar nota = 'B';
corresponder nota {
'A' => println!("Excelente trabalho!"),
'B' => println!("Bom trabalho."),
'C' => println!("Você poderia fazer melhor."),
 _ => println!("Essa não é uma nota válida."),
}

O nota variável é um caractere, e o corresponder A instrução verifica qual dos caracteres é avaliado como o valor da variável de nota antes de executar o código após o operador =>. Você pode usar o padrão de sublinhado (_) para corresponder a valores que não correspondem a outros padrões (o padrão padrão).

Loops em Rust

Loops são uma construção fundamental usada para tarefas repetitivas como Raspagem da web e outras ações automatizadas. Rust fornece diferentes tipos de loops, incluindo enquanto rotações, para laços e o laço laço.

Rust’s while Loops

Enquanto os loops repetem um bloco de código, desde que uma condição especificada seja avaliada como verdadeira. Antes de especificar a condição, você especificará loops while em Rust com o enquanto palavra-chave.

enquanto doença {
// código para executar
}

A condição deve ser uma expressão booleana que determina a continuação do loop. Quando a condição é avaliada como falsa, o loop é encerrado.

Aqui está um exemplo de loop while do Rust que imprime números de um a cinco.

fnprincipal() {
deixarmudo eu = 1;
enquanto eu <= 5 {
println!("{}", eu);
 eu += 1;
 }
}

O loop while no principal função percorre os números de um a cinco enquanto incrementa o eu variável por um até eu variável é maior que cinco, onde o loop termina.

o laço o laço

O laço A palavra-chave cria um loop infinito até que você declare uma saída com o quebrar palavra-chave.

laço {
// código para executar
se doença {
quebrar;
 }
}

O código no laço O bloco continuará executando até que o loop encontre um quebrar palavra-chave.

Aqui está um exemplo de uso do laço loop para imprimir números de um a cinco antes de especificar o quebrar palavra-chave para a saída.

fnprincipal() {
deixarmudo eu = 1;
laço {
println!("{}", eu);
 eu += 1;
se eu > 5 {
quebrar;
 }
 }
}

O principal função executa o loop, e o se declaração incrementa o eu variável. O se A instrução especifica a terminação do loop quando o eu variável excede cinco.

Rust's for Loops

No Rust, os loops for percorrem um intervalo ou uma coleção de valores. Você usará o para palavra-chave para iniciar um loop for, antes de especificar o intervalo ou coleção em que ele atua.

para variável em faixa {
// código para executar
}

O faixa é uma expressão que resulta em uma sequência de valores, e a variável é uma variável que assume cada valor na sequência por vez. O bloco de código será executado uma vez para cada valor na sequência.

Aqui está um exemplo de um loop for que imprime valores variando de um a dez.

fnprincipal() {
para eu em1..=10 {
println!("{}", eu);
 }
}

O loop itera pelos valores de 1 a 10. A cada iteração, a variável (i) contém o próximo valor, que o println! macro, em seguida, imprime.

Você pode usar o continuar palavra-chave para pular valores em loops for. Veja como você pode pular os números pares ao operar em um intervalo:

fnprincipal() {
para num em1..=10 {
se num % 2 == 0 {
continuar; // pula números pares
 }
println!("{}", num); // imprime números ímpares
 }
}

O se declaração usa o continuar palavra-chave para especificar que o loop deve pular números divisíveis por dois.

Além disso, você pode sair de um loop for com o quebrar palavra-chave. O loop termina ao encontrar o quebrar palavra-chave.

fnprincipal() {
para num em1..=10 {
se num == 5 {
quebrar; // sai do loop quando o número é igual a 5
 }
println!("{}", num); // imprime números de 1 a 4
 }
}

O se A instrução especifica que o loop deve terminar quando o eu variável é igual a cinco.

Use as estruturas de controle do Rust com tipos de dados para dominar o idioma

O Rust fornece essas estruturas de controle flexíveis para operações em tipos de dados integrados e personalizados. Você pode usar essas estruturas de controle para operar em estruturas de dados compostas e compostas, como arrays, vetores, struct e enums.

Rust também fornece structs. Estruturas são estruturas de dados que agrupam valores relacionados em um único objeto. Eles são semelhantes às classes em linguagens orientadas a objetos e você pode até definir métodos neles.