Learn Rust Coding · Lezione

Funzioni e flusso di controllo

Impari a definire funzioni e a utilizzare le espressioni `if`/`else`, `loop`, `while` e `for` per controllare il flusso di esecuzione del programma.

Funzioni e flusso di controllo è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 3 lezioni in totale.

Cosa sono le funzioni?

Le funzioni sono blocchi di codice con un nome che eseguono un'attività specifica. Sono fondamentali per organizzare il codice e renderlo riutilizzabile.

Riutilizzabilità del codice: scrivere una parte della logica una sola volta e utilizzarla più volte.
Modularità: suddividere i problemi complessi in parti più piccole e gestibili.
Leggibilità: assegnare nomi significativi ai blocchi di codice per facilitarne la comprensione.

La prima funzione in Rust

In Rust, si definisce una funzione usando la parola chiave fn. La funzione main è il punto di ingresso di ogni programma Rust.

Ecco come dichiarare e chiamare una funzione semplice:

fn say_hello() {
    println!("Hello from a function!");
}

fn main() {
    say_hello(); // Call the function
    println!("Back in main.");
}

Funzioni con parametri

Le funzioni possono accettare valori in ingresso chiamati parametri. In questo modo, la funzione può operare su dati diversi ogni volta che viene chiamata.

I parametri sono definiti con un nome e un tipo, separati da due punti.

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
    greet("Bob");
}

Funzioni con valori restituiti

Le funzioni possono anche restituire un valore al chiamante. Il tipo restituito viene specificato dopo una freccia (->).

L'ultima espressione nel corpo della funzione viene restituita implicitamente. Non serve il punto e virgola per l'espressione restituita!

fn add_numbers(x: i32, y: i32) -> i32 {
    x + y // No semicolon: this expression is returned
}

fn main() {
    let sum = add_numbers(5, 7);
    println!("The sum is: {}", sum);
}

Prendere decisioni: `if`/`else`

L'espressione if consente al programma di eseguire blocchi di codice diversi in base a una condizione. Le condizioni devono essere sempre di tipo bool (true/false).

Usi if per la prima condizione.
Usi else if per le condizioni aggiuntive.
Usi else come alternativa se non viene soddisfatta nessun'altra condizione.

In Rust, if è un'espressione, quindi può restituire un valore!

Le espressioni if-else in azione

Ecco come usare if e else per assegnare un valore in base a una condizione. Noti che si comportano come l'operatore ternario di altri linguaggi.

fn main() {
    let number = 7;

    let message = if number < 10 {
        "Small number"
    } else {
        "Large number"
    };

    println!("The number is: {}", message);

    let other_num = 15;
    if other_num % 2 == 0 {
        println!("{} is even", other_num);
    } else {
        println!("{} is odd", other_num);
    }
}

Ripetere il codice: `loop`

La parola chiave loop crea un ciclo infinito. È utile quando è necessario ripetere un'azione finché non si decide esplicitamente di interromperla.

Usi break per uscire dal ciclo. È anche possibile restituire un valore da un'espressione loop usando break.

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // Break and return a value
        }
    };

    println!("The result is {}", result);
}

Ripetizione condizionale: `while`

Il ciclo while esegue un blocco di codice finché una determinata condizione rimane vera. È perfetto quando non si sa esattamente quante volte sia necessario ripetere il ciclo.

fn main() {
    let mut count = 3;

    while count != 0 {
        println!("{}!", count);
        count -= 1;
    }

    println!("LIFTOFF!!!");
}

Iterare con i cicli `for`

Il ciclo for serve per iterare sugli elementi di una raccolta o su un intervallo di numeri. È il costrutto per i cicli più usato in Rust e consente di scrivere codice sicuro e conciso.

Viene spesso usato con gli intervalli (ad esempio, 1..4 per 1, 2, 3 oppure 1..=4 per 1, 2, 3, 4).
Funziona con qualsiasi tipo che implementi il trait Iterator.

fn main() {
    // Loop through a range
    for number in 1..4 { // 1, 2, 3
        println!("Number: {}", number);
    }

    // Loop through an array
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("The value is: {}", element);
    }
}

Sfida sul flusso di controllo

Consideri il seguente codice Rust. Quale sarà il valore finale di result?

fn calculate_value(input: i32) -> i32 {
    if input > 10 {
        input * 2
    } else if input == 5 {
        input + 5
    } else {
        input
    }
}

fn main() {
    let result = calculate_value(5);
    // What is result?
}

Riepilogo: funzioni e flusso di controllo

Ha imparato a padroneggiare gli elementi fondamentali per creare programmi dinamici!

Funzioni: organizzare e riutilizzare il codice usando fn, parametri e valori restituiti.
if/else: prendere decisioni ed eseguire il codice in modo condizionale. Ricordi che è un'espressione!
loop: creare cicli infiniti, uscire con break e restituire valori.
while: ripetere il ciclo finché una condizione è vera.
for: iterare in modo sicuro su raccolte e intervalli.

Questi strumenti sono essenziali per scrivere programmi Rust strutturati ed efficienti!

Domande Frequenti

La lezione «Funzioni e flusso di controllo» è gratuita?

Sì — il testo completo di «Funzioni e flusso di controllo» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 3 lezioni in totale.

Cosa imparerò in «Funzioni e flusso di controllo»?

Impari a definire funzioni e a utilizzare le espressioni `if`/`else`, `loop`, `while` e `for` per controllare il flusso di esecuzione del programma. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.

Quanto tempo richiede la lezione «Funzioni e flusso di controllo»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Learn Rust Coding