Strutture di controllo della ruggine e come usarle

Le strutture di controllo sono un costrutto di programmazione che consente di controllare il flusso di esecuzione nei programmi. Le strutture di controllo consentono di specificare le istruzioni da eseguire solo se vengono soddisfatte determinate condizioni.

Le strutture di controllo di Rust sono cruciali per la gestione del flusso del programma, consentendo un'esecuzione efficiente del codice e semplificando le attività complesse in componenti più piccoli e riutilizzabili.

Dichiarazioni condizionali di ruggine

Le istruzioni condizionali sono costrutti che consentono di eseguire codice in base alle condizioni. Le istruzioni condizionali sono utili per il processo decisionale poiché l'esecuzione del programma dipende dal fatto che la condizione valga o meno VERO O falso. La ruggine fornisce Se, altro, E incontro dichiarazioni per il processo decisionale.

Nei programmi Rust, il Se l'istruzione verifica se una determinata condizione restituisce true. In caso affermativo, il programma esegue il blocco di codice associato. Se la condizione restituisce false, il programma salta quel blocco di codice e passa all'istruzione successiva o esegue il

altro blocco di istruzioni se ce n'è uno.

IL incontro statement è un potente costrutto del flusso di controllo che consente a un programma di confrontare i valori con una serie di modelli ed eseguire il codice in base al modello di corrispondenza.

Dichiarazioni if ​​di Rust

Dichiarerai Se dichiarazioni nei tuoi programmi Rust con l'estensione Se parola chiave seguita da una condizione:

Se condizione {
// codice da eseguire se la condizione è vera
}

Ecco un esempio di come puoi usare un'istruzione if nei tuoi programmi Rust:

fnprincipale() {
permettere x = 15;
Se x > 10 {
stampa!("x è maggiore di 10");
 }
}

IL X variabile contiene un numero intero a 32 bit e l'istruzione if controlla se il valore di x è maggiore di dieci prima di eseguire il blocco di codice che lo stampa.

Dichiarazioni else di Rust

Userai il altro parola chiave per eseguire un blocco di codice quando si prevede che an Se affermazione verrebbe valutata come falsa.

Se condizione {
// codice da eseguire se la condizione è vera
} altro {
// codice da eseguire se la condizione è falsa
}

Ecco un esempio in cui X non è maggiore di 10, il Se dichiarazione valuta falso, e un altro l'istruzione viene eseguita.

fnprincipale(){
permettere x = 5;
Se x > 10 {
stampa!("x è maggiore di 10");
 } altro {
stampa!("x non è maggiore di 10");
 }
}

Da X è 5 e 5 non è maggiore di 10, il programma salta il Se blocca ed esegue il file altro bloccare.

Dichiarazioni sulla partita di Rust

Userai il incontro parola chiave per il processo decisionale complesso per controllare una serie di modelli ed eseguire il codice in base alle corrispondenze del modello. Le dichiarazioni di corrispondenza sono simili a istruzioni switch in C#, Vai e C++.

Ecco la struttura di un'istruzione match di Rust:

incontro valore {
 modello1 => {
// codice da eseguire se il valore corrisponde a pattern1
 },
 modello2 => {
// codice da eseguire se il valore corrisponde a pattern2
 },
// eccetera.
}

Ecco come puoi utilizzare le dichiarazioni di corrispondenza nei tuoi programmi:

permettere grado = 'B';
incontro voto {
'UN' => stampa!("Lavoro eccellente!"),
'B' => stampa!("Buon lavoro."),
'C' => stampa!("Potresti fare di meglio."),
 _ => stampa!("Non è un voto valido."),
}

IL grado la variabile è un carattere e il incontro l'istruzione controlla quale dei caratteri restituisce il valore della variabile grade prima di eseguire il codice dopo l'operatore =>. Puoi utilizzare il modello di sottolineatura (_) per trovare valori che non corrispondono ad altri modelli (il modello predefinito).

Loop in ruggine

I loop sono un costrutto fondamentale utilizzato per attività ripetitive come raschiamento del web e altre azioni automatizzate. Rust fornisce diversi tipi di loop, incluso Mentre anelli, per loop, e il ciclo continuo ciclo continuo.

Rust's while Loops

Mentre i cicli ripetono un blocco di codice fintanto che una condizione specificata restituisce true. Prima di specificare la condizione, dovrai specificare while loop in Rust con il Mentre parola chiave.

Mentre condizione {
// codice da eseguire
}

La condizione dovrebbe essere un'espressione booleana che determina la continuazione del ciclo. Quando la condizione restituisce false, il ciclo termina.

Ecco un esempio di ciclo while di Rust che stampa i numeri da uno a cinque.

fnprincipale() {
permetteremut io = 1;
Mentre io <= 5 {
stampa!("{}", io);
 io += 1;
 }
}

Il ciclo while in principale la funzione attraversa i numeri da uno a cinque mentre incrementa il io variabile di uno fino a io variabile è maggiore di cinque, dove termina il ciclo.

Il ciclo Ciclo

IL ciclo continuo la parola chiave crea un ciclo infinito fino a quando non dichiari un'uscita con il rottura parola chiave.

ciclo continuo {
// codice da eseguire
Se condizione {
rottura;
 }
}

Il codice nel ciclo continuo block continuerà a essere eseguito finché il ciclo non incontra a rottura parola chiave.

Ecco un esempio di utilizzo di ciclo continuo ciclo per stampare i numeri da uno a cinque prima di specificare il rottura parola chiave per l'uscita.

fnprincipale() {
permetteremut io = 1;
ciclo continuo {
stampa!("{}", io);
 io += 1;
Se io > 5 {
rottura;
 }
 }
}

IL principale la funzione esegue il ciclo e il Se dichiarazione incrementa il io variabile. IL Se L'istruzione specifica la fine del ciclo quando il file io variabile supera cinque.

Rust è per i loop

In Rust, i cicli for iterano attraverso un intervallo o una collezione di valori. Userai il per parola chiave per avviare un ciclo for, prima di specificare l'intervallo o la raccolta su cui agisce.

per variabile In allineare {
// codice da eseguire
}

IL allineare è un'espressione che restituisce una sequenza di valori e la variabile è una variabile che assume a sua volta ogni valore nella sequenza. Il blocco di codice verrà eseguito una volta per ogni valore nella sequenza.

Ecco un esempio di ciclo for che stampa valori compresi tra uno e dieci.

fnprincipale() {
per io In1..=10 {
stampa!("{}", io);
 }
}

Il ciclo scorre i valori da 1 a 10. Ad ogni iterazione, la variabile (i) contiene il valore successivo, che the stampa! macro quindi stampa.

Puoi usare il Continua parola chiave per saltare i valori nei cicli for. Ecco come puoi saltare i numeri pari quando operi su un intervallo:

fnprincipale() {
per num In1..=10 {
Se numero % 2 == 0 {
Continua; // salta i numeri pari
 }
stampa!("{}", numero); // stampa i numeri dispari
 }
}

IL Se dichiarazione utilizza il Continua parola chiave per specificare che il ciclo deve saltare i numeri divisibili per due.

Inoltre, puoi uscire da un ciclo for con il rottura parola chiave. Il ciclo termina incontrando il file rottura parola chiave.

fnprincipale() {
per num In1..=10 {
Se numero == 5 {
rottura; // esce dal ciclo quando il numero è uguale a 5
 }
stampa!("{}", numero); // stampa i numeri da 1 a 4
 }
}

IL Se specifica che il ciclo deve terminare quando il io variabile è uguale a cinque.

Usa le strutture di controllo di Rust con i tipi di dati per padroneggiare il linguaggio

Rust fornisce queste strutture di controllo flessibili per operazioni su tipi di dati incorporati e personalizzati. È possibile utilizzare queste strutture di controllo per operare su strutture di dati composte e composite come array, vettori, struct ed enum.

Rust fornisce anche strutture. Le strutture sono strutture di dati che raggruppano valori correlati in un singolo oggetto. Sono simili alle classi nei linguaggi orientati agli oggetti e puoi persino definire metodi su di esse.