If...else in Rust

if permette al tuo programma di prendere decisioni: eseguire un blocco di codice o un altro, a seconda di una condizione.

If di base

fn main() {
    let age = 20;

    if age >= 18 {
        println!("Puoi votare");
    }
}

▶ Provalo tu

Un paio di cose da notare, perché fanno inciampare chi arriva da altri linguaggi:

• Niente parentesi attorno alla condizione: if age >= 18, non if (age >= 18).
• La condizione deve essere un vero bool. if age (un numero) non compila: ti serve if age != 0 o qualcosa di simile.

if / else

fn main() {
    let age = 15;

    if age >= 18 {
        println!("Puoi votare");
    } else {
        println!("Non hai ancora l'età");
    }
}

▶ Provalo tu

else if per avere più rami

fn main() {
    let score = 72;

    if score >= 90 {
        println!("Voto: A");
    } else if score >= 75 {
        println!("Voto: B");
    } else if score >= 60 {
        println!("Voto: C");
    } else {
        println!("Voto: F");
    }
}

▶ Provalo tu

Rust controlla ogni condizione dall’alto verso il basso ed esegue la prima che corrisponde, proprio come ti aspetteresti.

Usare if come espressione

Ecco una cosa che Rust fa e molti linguaggi no: if può produrre un valore. Quindi puoi usarlo sul lato destro di un let:

fn main() {
    let age = 20;
    let status = if age >= 18 { "maggiorenne" } else { "minorenne" };

    println!("{status}");
}

▶ Provalo tu

Funziona come quando una funzione restituisce un valore: niente punto e virgola dopo il valore in ciascun ramo. L’unico requisito: entrambi i rami devono produrre lo stesso tipo (qui sono entrambi &str).

Attenzione

Se dimentichi il ramo else quando usi if come espressione, Rust non lo compila: non sa che valore usare quando la condizione è falsa. Un if usato solo per i suoi effetti (come stampare) non ha bisogno di un else; un if usato come espressione sì.

Combinare le condizioni invece di annidarle

Puoi mettere un if dentro un altro if. Funziona, ma a due o tre livelli di profondità diventa difficile da leggere. Spesso puoi invece unire le condizioni con gli operatori logici && (e) e || (o):

fn main() {
    let temperature = 22;
    let is_raining = false;

    // Annidato: funziona, ma scivola verso destra
    if temperature > 15 {
        if !is_raining {
            println!("Annidato: andiamo a fare una passeggiata");
        }
    }

    // Lo stesso controllo come un'unica condizione
    if temperature > 15 && !is_raining {
        println!("Combinato: andiamo a fare una passeggiata");
    }

    // || è vero se uno dei due lati è vero
    if temperature < 0 || temperature > 35 {
        println!("Resta in casa");
    } else {
        println!("Il tempo è bello");
    }
}

Output:

Annidato: andiamo a fare una passeggiata
Combinato: andiamo a fare una passeggiata
Il tempo è bello

▶ Provalo tu

Annidare ha ancora senso quando il blocco interno fa qualcosa in più, o quando ha un suo else. Ma quando l’unico scopo dell’if esterno è fare da guardia a quello interno, && dice la stessa cosa in modo più semplice. Per controllare che un numero sia dentro un intervallo, scrivi temperature >= 15 && temperature <= 25. Rust non permette 15 <= temperature <= 25.

Pratica

1. Pari o dispari

Salva un numero n = 7. Usa if come espressione per assegnare a una variabile kind il valore "pari" o "dispari", poi stampa 7 è dispari. Suggerimento: un numero è pari quando n % 2 == 0.

Mostra la soluzione

fn main() {
    let n = 7;
    let kind = if n % 2 == 0 { "pari" } else { "dispari" };
    println!("{n} è {kind}");
}

Output:

7 è dispari

▶ Provalo tu

2. Prezzi dei biglietti

Un cinema fa pagare 5 euro ai bambini sotto i 12 anni, 7 a chi ha 65 anni o più, e 12 a tutti gli altri. Salva un’età age di 70, calcola il prezzo price con un’unica espressione if / else if / else e stampa Biglietto: 7 euro. Suggerimento: ogni ramo deve restituire un numero, e l’intero if finisce con un punto e virgola dopo l’ultima }.

Mostra la soluzione

fn main() {
    let age = 70;

    let price = if age < 12 {
        5
    } else if age >= 65 {
        7
    } else {
        12
    };

    println!("Biglietto: {price} euro");
}

Output:

Biglietto: 7 euro

▶ Provalo tu

Riepilogo

• if condizione { ... }: non servono parentesi; la condizione deve essere un bool.
• Concatena altri controlli con else if, e ripiega su else.
• Unisci le condizioni con && e || invece di annidare un if dentro un altro.
• if si può usare come espressione per produrre un valore: entrambi i rami devono avere lo stesso tipo, e serve un else.

Verifica veloce

Verifica veloce

1. Quale di queste cose è obbligatoria per una condizione if in Rust?

Deve essere racchiusa tra parentesi Deve essere un vero bool Deve essere un intero

2. Quando usi if come espressione con let, cosa devono fare entrambi i rami?

Devono stampare entrambi qualcosa Devono essere lunghi entrambi una riga Devono produrre lo stesso tipo

Punteggio: 0 / 2

Per approfondire

• if Expressions — The Rust Book (in inglese): la spiegazione ufficiale di if, else if e dell’uso di if in un let.
• if/else — Rust by Example (in inglese): un esempio eseguibile che mostra rami che producono un valore.
• If expressions — The Rust Reference (in inglese): le regole esatte, per quando vuoi i dettagli precisi.
• Rust su Exercism (in inglese): esercizi gratuiti con mentoring; i primi usano molto if ed else.