Cicli Rust

Oltre alle espressioni condizionali flessibili, Rust ha anche una progettazione di strutture di ciclo molto matura. Questo punto dovrebbe essere percepito da un sviluppatore esperto.

Ciclo while

Il ciclo while è il tipo di ciclo condizionale più tipico:

fn main() {
　　　　let mut number = 1;　
　　　　while number != 4 {　
　　　　　　　　println!("{}", number);　
　　　　　　　　number += 1;　
　　　　}　
　　　　println!("EXIT");　
}

Risultato dell'esecuzione:

1
2
3
EXIT

Il linguaggio Rust non utilizza l'espressione do-while fino alla data di redazione di questa guida, ma do è specificato come riservato, forse verrà utilizzato nelle versioni future.

Nel linguaggio C, il ciclo for utilizza espressioni ternarie per controllare il ciclo, ma in Rust non c'è questa utilità, è necessario sostituirlo con un ciclo while:

int i;　
for (i = 0; i < 10; i++) {　
　　　　// Corpo del ciclo
}

let mut i = 0;　
while i < 10 {　
　　　　// Corpo del ciclo　
　　　　i += 1;　
}

Ciclo for

Il ciclo for è la struttura di ciclo più utilizzata, solitamente usata per esplorare una struttura dati lineare (ad esempio un array). Il ciclo for esplora l'array:

fn main() {　
　　　　let a = [10, 20, 30, 40, 50];　
　　　　for i in a.iter() {　
　　　　　　　　println!("Il valore è: {}", i);　
　　　　}　
}

Risultato dell'esecuzione:

Il valore è: 10
Il valore è: 20
Il valore è: 30
Il valore è: 40
Il valore è: 50

Il ciclo for di questo programma esegue l'iterazione dell'array a. a.iter() rappresenta l'iteratore (iterator) di a, che non sarà spiegato prima di studiare la sezione sugli oggetti.

Naturalmente, il ciclo for può accedere agli array tramite gli indici:

fn main() {　
let a = [10, 20, 30, 40, 50];　
　　　　for i in 0..5 {　
　　　　　　　　println!("a[{}] = {}", i, a[i]);　
　　　　}　
}

Risultato dell'esecuzione:

a[0] = 10
a[1] = 20
a[2] = 30
a[3] = 40
a[4] = 50

Ciclo loop

Gli sviluppatori esperti hanno sicuramente incontrato diverse situazioni in cui un ciclo non può determinare se continuare o meno all'inizio e alla fine, ma deve controllare il ciclo all'interno del corpo del ciclo. In questo caso, spesso implementiamo l'operazione di uscita dal ciclo all'interno di un ciclo while (true).

Il linguaggio Rust ha una struttura di ciclo infinito nativa chiamata loop:

fn main() {　
　　　　let s = ['R', 'U', 'N', 'O', 'O', 'B'];　
　　　　let mut i = 0;　
　　　　loop {　
　　　　　　　　let ch = s[i];　
　　　　　　　　if ch == 'O' {　
　　　　　　　　　　　　break;　
　　　　　　　　}　
　　　　　　　　println!("'{}'", ch);
　　　　　　　　i += 1;　
　　　　}　
}

Risultato dell'esecuzione:

'R'　
'U'　
'N'

Il ciclo loop può essere usato con la parola chiave break per uscire dal ciclo intero e fornire un valore di ritorno esterno. Questo è un design molto ingegnoso, poiché il ciclo loop viene spesso utilizzato come strumento di ricerca; se si trova qualcosa, naturalmente si deve consegnare il risultato:

fn main() {　
　　　　let s = ['R', 'U', 'N', 'O', 'O', 'B'];　
　　　　let mut i = 0;　
　　　　let location = loop {　
　　　　　　　　let ch = s[i];
　　　　　　　　if ch == 'O' {　
　　　　　　　　　　　　break i;　
　　　　　　　　}　
　　　　　　　　i += 1;　
　　　　};　
　　　　println!("L'indice di 'O' è {}", location);　
}

Risultato dell'esecuzione:

　L'indice di 'O' è 3