Learn Rust Coding · Lezione

Moduli e mod

Organizzazione del codice

Moduli e mod è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 di 4. 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 4 lezioni in totale.

Perché usare i moduli?

Quando i programmi crescono, inserire tutto in un unico file diventa caotico. I moduli consentono di raggruppare il codice correlato, controllare ciò che è pubblico ed evitare conflitti tra nomi.

La parola chiave mod dichiara un modulo.

Dichiarare un modulo inline

È possibile definire un modulo direttamente all'interno di un file con mod name { ... }. Tutto ciò che si trova tra le parentesi graffe appartiene al modulo.

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

fn main() {
    println!("module declared above");
}

Chiamare le funzioni di un modulo

Gli elementi all'interno di un modulo sono privati per impostazione predefinita. Per chiamarli dall'esterno, devono essere pub e occorre farvi riferimento usando il percorso del modulo e ::.

mod greetings {
    pub fn hello() {
        println!("hello!");
    }
}

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

Moduli annidati

I moduli possono contenere altri moduli, formando un albero. Il percorso elenca ogni livello separandolo con ::.

mod app {
    pub mod ui {
        pub fn draw() {
            println!("drawing ui");
        }
    }
}

fn main() {
    app::ui::draw();
}

I moduli raggruppano più delle sole funzioni

Un modulo può contenere funzioni, struct, enum, costanti e persino altri moduli. In questo modo tipi e comportamenti correlati rimangono insieme.

mod shapes {
    pub struct Circle {
        pub radius: f64,
    }
    pub const PI: f64 = 3.14159;
}

fn main() {
    let c = shapes::Circle { radius: 2.0 };
    println!("area = {}", shapes::PI * c.radius * c.radius);
}

L'albero dei moduli

Ogni crate ha un modulo radice. I moduli dichiarati formano un albero al di sotto di esso. I percorsi descrivono dove si trova un elemento, in modo simile alle cartelle di un file system.

super: il modulo genitore

All'interno di un modulo, super fa riferimento al modulo genitore. Consente a un modulo figlio di chiamare qualcosa definito un livello più in alto.

fn top_level() {
    println!("called via super");
}

mod inner {
    pub fn run() {
        super::top_level();
    }
}

fn main() {
    inner::run();
}

self: il modulo corrente

self fa riferimento al modulo corrente. Viene usato soprattutto per esplicitare dove si trova un elemento all'interno di un percorso.

mod tools {
    pub fn helper() {
        println!("helper running");
    }
    pub fn run() {
        self::helper();
    }
}

fn main() {
    tools::run();
}

Moduli in file separati

Oltre ai moduli inline, mod network; (con un punto e virgola e senza corpo) indica a Rust di caricare il contenuto da network.rs o network/mod.rs.

È così che i progetti reali suddividono il codice tra più file mantenendo un unico albero dei moduli.

Limiti di visibilità

I moduli definiscono limiti di visibilità. Un modulo figlio può vedere gli elementi privati dei propri antenati, ma i moduli genitori non possono accedere agli elementi privati di un figlio.

Questo incapsulamento mantiene nascosti i dettagli interni.

mod bank {
    fn secret() -> i32 { 42 }
    pub fn reveal() -> i32 { secret() }
}

fn main() {
    println!("{}", bank::reveal());
}

Organizzare progetti reali

Usi i moduli per rispecchiare il dominio: auth, db, handlers. Mantenga ciascun modulo focalizzato, esponga una superficie pubblica ridotta e nasconda il resto.

Limiti chiari tra i moduli rendono navigabili le basi di codice di grandi dimensioni.

Verifica rapida

Metta alla prova le Sue conoscenze sui moduli.

Riepilogo

Ha imparato a organizzare il codice con i moduli:

mod name { ... } dichiara un modulo inline
Gli elementi sono privati per impostazione predefinita; usi pub per esporli
I percorsi usano :: per attraversare l'albero dei moduli
super, self e mod name; consentono di spostarsi tra i moduli e suddividerli

Domande Frequenti

La lezione «Moduli e mod» è gratuita?

Sì — il testo completo di «Moduli e mod» è 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 4 lezioni in totale.

Cosa imparerò in «Moduli e mod»?

Organizzazione del codice 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 4.

Quanto tempo richiede la lezione «Moduli e mod»?

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