PricingLoginStart free
Learn Rust Coding · Lezione

Organizzare il codice con i moduli

Impari a utilizzare il sistema dei moduli di Rust per raggruppare logicamente il codice, gestire la privacy e rendere i progetti scalabili.

Lezione 1 di 311 passaggi

Organizzare il codice con i moduli è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 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.

Organizzare il codice con i moduli

Man mano che i progetti Rust crescono, mantenere tutto il codice in un unico file diventa disordinato. Il sistema dei moduli di Rust aiuta a organizzare il codice in unità logiche.

I moduli sono come cartelle per il codice. Raggruppano funzioni, struct, enum e costanti correlate, migliorando leggibilità e manutenibilità.

Dichiarare il primo modulo

Si dichiara un modulo usando la parola chiave mod, seguita dal nome del modulo. È come creare un sotto-namespace all'interno del programma.

Creiamo un semplice modulo greetings:

mod greetings {
    // This is where greeting functions would go
}

fn main() {
    println!("Hello from main!");
}

Capire la privacy dei moduli

Per impostazione predefinita, tutto ciò che si trova all'interno di un modulo è privato. Ciò significa che non è possibile accedervi dall'esterno del modulo senza renderlo esplicitamente pubblico.

Se prova a chiamare una funzione privata, Rust restituirà un errore di compilazione. Provi a rimuovere il commento dalla riga seguente ed eseguirla:

mod greetings {
    fn hello() {
        println!("Hello from the greetings module!");
    }
}

fn main() {
    // Uncomment the line below and try to run!
    // greetings::hello();
    println!("Main function running.");
}

Rendere pubblici gli elementi con `pub`

Per rendere un elemento (come una funzione, una struct o un enum) visibile dall'esterno del modulo, si usa la parola chiave pub.

  • pub fn rende pubblica una funzione.
  • pub struct rende pubblica una struct.
  • pub mod rende pubblico un sottomodulo, consentendo di accedere al suo contenuto.

La privacy è una parte fondamentale della sicurezza e dell'organizzazione di Rust!

`pub` in azione

Ora rendiamo pubblica la nostra funzione hello usando pub. In questo modo la funzione main può chiamarla senza generare un errore di privacy.

Esegua questo codice per vedere il saluto proveniente dal nostro modulo:

mod greetings {
    pub fn hello() {
        println!("Hello from the greetings module!");
    }
}

fn main() {
    greetings::hello();
}

Semplificare i percorsi con `use`

Scrivere percorsi completi come greetings::hello() può diventare ripetitivo. La parola chiave use consente di portare gli elementi nell'ambito corrente, rendendoli più semplici da usare.

È simile a import in Python o a using in C#. È possibile portare nell'ambito corrente un elemento specifico o un intero modulo.

`use` in azione

Ecco come usare use per abbreviare il percorso della funzione hello. Noti che non è più necessario il prefisso greetings::.

Questo rende il codice più pulito e facile da leggere.

mod greetings {
    pub fn hello() {
        println!("Hello, module user!");
    }
}

use greetings::hello; // Bring `hello` into scope

fn main() {
    hello(); // Now we can call it directly
}

Moduli annidati e percorsi relativi

I moduli possono essere annidati! È possibile definire moduli all'interno di altri moduli per un'organizzazione ancora più dettagliata. Per spostarsi tra questi moduli, Rust mette a disposizione super e self.

  • super fa riferimento al modulo genitore.
  • self fa riferimento al modulo corrente.

Sono utili per i percorsi relativi all'interno di gerarchie di moduli complesse.

mod outer {
    pub mod inner {
        pub fn call_me() {
            println!("Called from inner module!");
        }
    }

    pub fn call_inner() {
        // Accessing inner module from parent
        inner::call_me();
    }
}

fn main() {
    outer::call_inner();
    outer::inner::call_me();
}

Moduli e struttura dei file

Per i moduli più grandi, è possibile inserire il codice in file separati. Rust cerca automaticamente le definizioni dei moduli in posizioni specifiche:

  • Per mod my_module; in src/main.rs: Rust cerca src/my_module.rs o src/my_module/mod.rs.
  • Questo aiuta a mantenere pulito il file principale e a delegare il contenuto ai file appropriati.

Questa lezione usa file singoli per semplicità, ma lo tenga a mente per i progetti più grandi!

Verifica dell'accesso ai moduli

Consideri il seguente codice Rust. Quali righe verranno compilate senza un errore di privacy?

mod calculator {
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }

    pub fn subtract(a: i32, b: i32) -> i32 {
        a - b
    }

    mod advanced {
        pub fn multiply(a: i32, b: i32) -> i32 {
            a * b
        }
    }
}

fn main() {
    // Line A
    // calculator::add(5, 3);

    // Line B
    // calculator::subtract(10, 4);

    // Line C
    // calculator::advanced::multiply(2, 6);

    // Line D
    // calculator::advanced::add(1, 1);
}
Rispondi nella lezione interattiva

Moduli: organizzare e controllare

Ottimo lavoro! Ha imparato come il sistema dei moduli di Rust aiuta a strutturare il codice:

  • Usi mod per dichiarare moduli e sottomoduli.
  • Gli elementi sono privati per impostazione predefinita; usi pub per renderli accessibili.
  • use semplifica i percorsi lunghi degli elementi.
  • I moduli possono essere distribuiti su più file nei progetti grandi.

I moduli sono fondamentali per gestire la complessità in Rust. Continui a esercitarsi!

Gratis per iniziare

Impara Rust con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
39
Lezioni
144
Inizia a imparare gratisVisualizza il corso completo

Domande Frequenti

La lezione «Organizzare il codice con i moduli» è gratuita?

Sì — il testo completo di «Organizzare il codice con i moduli» è 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 «Organizzare il codice con i moduli»?

Impari a utilizzare il sistema dei moduli di Rust per raggruppare logicamente il codice, gestire la privacy e rendere i progetti scalabili. 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 1 di 3.

Quanto tempo richiede la lezione «Organizzare il codice con i moduli»?

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

  1. Organizzare il codice con i moduli
  2. Gestire le dipendenze con i crate
  3. Gestione robusta degli errori con `Result`
← Torna a Learn Rust Coding