Operatori in Rust

Gli operatori sono i simboli che usi per fare calcoli, confrontare valori e combinare condizioni. Se hai usato un qualsiasi linguaggio simile al C, la maggior parte ti sembrerà familiare.

Operatori aritmetici

fn main() {
    let a = 10;
    let b = 3;

    println!("{}", a + b); // 13
    println!("{}", a - b); // 7
    println!("{}", a * b); // 30
    println!("{}", a / b); // 3  (divisione intera, scarta il resto)
    println!("{}", a % b); // 1  (resto)
}

▶ Provalo tu

Attenzione

a / b con due interi ti dà una divisione intera: 10 / 3 fa 3, non 3.333.... Se vuoi un risultato decimale, almeno uno dei due lati deve essere un float: 10.0 / 3.0.

Operatori di confronto

Confrontano due valori e restituiscono un bool:

fn main() {
    let a = 5;
    let b = 8;

    println!("{}", a == b); // false
    println!("{}", a != b); // true
    println!("{}", a < b);  // true
    println!("{}", a > b);  // false
    println!("{}", a <= b); // true
    println!("{}", a >= b); // false
}

Li userai di continuo nelle condizioni degli if, di cui parliamo nella pagina If…else.

Operatori logici

Gli operatori logici combinano o invertono valori booleani:

fn main() {
    let is_logged_in = true;
    let is_admin = false;

    println!("{}", is_logged_in && is_admin); // false: devono essere vere entrambe
    println!("{}", is_logged_in || is_admin); // true: almeno una è vera
    println!("{}", !is_admin);                // true: trasforma false in true
}

▶ Provalo tu

• &&: e (and), vero solo se entrambi i lati sono veri.
• ||: o (or), vero se almeno un lato è vero.
• !: non (not), trasforma vero in falso e viceversa.

Operatori di assegnamento

Oltre al semplice =, Rust ha operatori abbreviati che aggiornano una variabile a partire dal suo valore attuale:

fn main() {
    let mut score = 10;

    score += 5; // come: score = score + 5
    score -= 2; // score = score - 2
    score *= 3; // score = score * 3
    score /= 2; // score = score / 2

    println!("{score}");
}

▶ Provalo tu

Ricorda che la variabile ha bisogno di mut perché uno qualsiasi di questi compili: stai cambiando il suo valore.

Nota

Rust non ha gli operatori ++ e --. Per aggiungere uno a un contatore, scrivi count += 1. È un carattere in più, e non lascia dubbi su cosa succede.

Ordine delle operazioni (precedenza)

Quando un’espressione contiene più operatori, Rust non va semplicemente da sinistra a destra. Come nella matematica di scuola, *, / e % vengono prima di + e -. Gli operatori dello stesso livello vengono eseguiti da sinistra a destra. Le parentesi vengono sempre per prime, quindi usale ogni volta che vuoi un ordine diverso.

fn main() {
    let a = 2 + 3 * 4;            // prima *: 2 + 12
    let b = (2 + 3) * 4;          // prima le parentesi: 5 * 4
    let c = 10 - 4 - 3;           // stesso livello, da sinistra a destra: (10 - 4) - 3
    let d = 17 % 5 * 2;           // stesso livello, da sinistra a destra: (17 % 5) * 2
    let ok = 1 + 1 == 2 && 3 > 2; // calcoli, poi confronti, poi &&

    println!("{a} {b} {c} {d} {ok}");
}

Output:

14 20 3 4 true

▶ Provalo tu

L’ordine completo, dal primo all’ultimo, è più o meno questo: aritmetica (* / %, poi + -), poi confronti (== != < > <= >=), poi &&, poi ||, e infine gli operatori di assegnamento (= += -= e compagnia). Ecco perché 1 + 1 == 2 && 3 > 2 funziona senza parentesi. Comunque, se devi fermarti a pensare all’ordine, aggiungi le parentesi. Non costano niente e rendono il codice più facile da leggere.

Attenzione

Non puoi concatenare i confronti come in matematica. 1 < x < 5 è un errore di compilazione («comparison operators cannot be chained», cioè gli operatori di confronto non si possono concatenare). Scrivilo come due confronti uniti da &&: 1 < x && x < 5.

Pratica

1. Minuti e secondi

Un video dura 125 secondi. Salvalo in una variabile, poi stampa quanti minuti interi e quanti secondi avanzano, come 2 minuti e 5 secondi. Suggerimento: la divisione intera / ti dà i minuti interi, e % ti dà quello che avanza.

Mostra la soluzione

fn main() {
    let total_seconds = 125;

    let minutes = total_seconds / 60; // 2 (il resto viene scartato)
    let seconds = total_seconds % 60; // 5 (il resto)

    println!("{minutes} minuti e {seconds} secondi");
}

Output:

2 minuti e 5 secondi

▶ Provalo tu

2. Tenere il punteggio

Fai partire il punteggio score di una partita da 10. Aggiungi 25, togli 5, poi raddoppialo, usando gli operatori di assegnamento abbreviati. Stampa il punteggio, se è almeno 50, e se è almeno 50 e pari. Suggerimento: un numero è pari quando score % 2 == 0.

Mostra la soluzione

fn main() {
    let mut score = 10;

    score += 25; // 35
    score -= 5;  // 30
    score *= 2;  // 60

    println!("punteggio: {score}");
    println!("livello superato? {}", score >= 50);
    println!("superato e pari? {}", score >= 50 && score % 2 == 0);
}

Output:

punteggio: 60
livello superato? true
superato e pari? true

▶ Provalo tu

Riepilogo

• Aritmetica: + - * / %. La divisione intera tronca: niente decimali.
• Confronto: == != < > <= >=, restituiscono tutti un bool.
• Logica: && (e), || (o), ! (non).
• Assegnamento abbreviato: += -= *= /= aggiornano sul posto una variabile mut. Non esiste ++.
• * / % vengono prima di + -, e i calcoli vengono prima dei confronti e di &&/||. Nel dubbio, usa le parentesi.

Verifica veloce

Verifica veloce

1. Quanto fa 10 / 3 quando entrambi i lati sono interi?

3.333... 3 4

2. Che tipo restituiscono sempre gli operatori di confronto come == e <?

i32 String bool

3. Cosa serve perché score += 5; compili?

score deve essere dichiarata con mut score deve essere un f64 Niente di speciale: compila sempre

Punteggio: 0 / 3

Per approfondire

• B - Operators and Symbols — The Rust Book (in inglese): una tabella di una pagina con tutti gli operatori di Rust e cosa fanno.
• Literals and operators — Rust by Example (in inglese): brevi esempi eseguibili di operatori aritmetici, logici e bit a bit.
• Expression precedence — The Rust Reference (in inglese): l’ordine esatto in cui Rust valuta gli operatori, dal primo all’ultimo.
• Operator expressions — The Rust Reference (in inglese): le regole precise di ogni operatore, compreso cosa succede in caso di overflow degli interi.