Condizioni e Cicli in Rust: Controlla il Flusso del Tuo Programma

Impara a controllare il flusso del tuo programma in Rust con costrutti condizionali (if, else, else if), cicli (for, while, loop) e l’uso avanzato del pattern matching con match.

Dopo aver esplorato variabili, tipi di dati e operazioni di base, è arrivato il momento di gestire il flusso del programma in Rust. I costrutti come condizioni e cicli ti permettono di creare logica più complessa, mentre il potente match consente di implementare pattern matching in modo elegante. Vediamo insieme come utilizzarli!

Condizioni in Rust: if, else if, else

Le condizioni in Rust sono molto simili a quelle di altri linguaggi, ma con alcune caratteristiche uniche. La sintassi è semplice e diretta:

Esempio: Uso Base di if

fn main() {
    let numero = 10;

    if numero > 5 {
        println!("Il numero è maggiore di 5!");
    } else {
        println!("Il numero è minore o uguale a 5.");
    }
}

Esempio: Catene di Condizioni con else if

fn main() {
    let numero = 7;

    if numero % 2 == 0 {
        println!("Il numero è pari.");
    } else if numero % 3 == 0 {
        println!("Il numero è divisibile per 3.");
    } else {
        println!("Il numero non è divisibile né per 2 né per 3.");
    }
}

Rust e l’Espressività delle Condizioni

In Rust, puoi usare if anche come espressione per assegnare valori:

fn main() {
    let condizione = true;
    let numero = if condizione { 42 } else { 0 };
    println!("Il numero è: {}", numero);
}

Cicli in Rust: for, while, loop

Rust offre tre tipi principali di cicli per soddisfare ogni esigenza: for, while e loop.

Ciclo for

Il ciclo for è il più comune e iterativo. Funziona perfettamente con intervalli (ranges).

fn main() {
    for i in 1..5 {
        println!("Valore di i: {}", i);
    }
}

L'intervallo 1..5 genera i numeri da 1 a 4, escludendo il 5. Per includere il limite superiore, usa 1..=5.

Ciclo while

Il ciclo while continua finché la condizione è vera.

fn main() {
    let mut numero = 0;

    while numero < 5 {
        println!("Numero: {}", numero);
        numero += 1;
    }
}

Ciclo loop

Il ciclo loop è infinito per definizione e deve essere interrotto manualmente con la parola chiave break.

fn main() {
    let mut contatore = 0;

    loop {
        println!("Contatore: {}", contatore);
        contatore += 1;

        if contatore == 5 {
            break;
        }
    }
}

Uso Avanzato di match per Pattern Matching

Rust offre un costrutto potente chiamato match per effettuare controlli più complessi basati su pattern.

Esempio: Uso Base di match

fn main() {
    let numero = 3;

    match numero {
        1 => println!("Uno"),
        2 => println!("Due"),
        3 => println!("Tre"),
        _ => println!("Altro numero"),
    }
}

Il carattere _ è un wildcard che cattura tutti i casi non specificati.

Esempio: match con Ranges

Puoi usare intervalli per gestire casi specifici:

fn main() {
    let voto = 85;

    match voto {
        90..=100 => println!("Eccellente"),
        75..=89 => println!("Buono"),
        60..=74 => println!("Sufficiente"),
        _ => println!("Insufficiente"),
    }
}

Esempio: match con Enums

match è particolarmente utile con gli enums:

enum Colore {
    Rosso,
    Verde,
    Blu,
}

fn main() {
    let colore = Colore::Verde;

    match colore {
        Colore::Rosso => println!("Il colore è Rosso"),
        Colore::Verde => println!("Il colore è Verde"),
        Colore::Blu => println!("Il colore è Blu"),
    }
}

Esercizi Pratici

1. Esercizio 1: Scrivi un programma che verifica se un numero è positivo, negativo o zero usando if-else.
2. Esercizio 2: Usa un ciclo for per calcolare la somma dei numeri da 1 a 10.
3. Esercizio 3: Crea un programma che usa match per tradurre numeri (da 1 a 5) in parole (es. 1 → Uno).

Conclusione

Le strutture di controllo sono essenziali per ogni linguaggio di programmazione, e Rust le rende potenti e sicure. La combinazione di condizioni, cicli e pattern matching con match ti consente di costruire logica complessa in modo semplice e leggibile.

Preparati per la prossima lezione, dove approfondiremo funzioni, scope e modularità per creare programmi ancora più organizzati e scalabili. 

* Obbligatorio

Invia