Lär dig programmera i Rust · Lektion

Moduler och mod

Organisera kod

Lektion 1 av 413 steg

Moduler och mod är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Varför moduler?

När program växer blir det rörigt att lägga allt i en fil. Moduler låter Er gruppera relaterad kod, styra vad som är offentligt och undvika namnkonflikter.

Nyckelordet mod deklarerar en modul.

Deklarera en inline-modul

Ni kan definiera en modul direkt i en fil med mod name { ... }. Allt mellan klamrarna tillhör den modulen.

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

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

Anropa modulfunktioner

Element i en modul är privata som standard. För att anropa ett utifrån måste det vara pub, och Ni refererar till det med modulens sökväg och ::.

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

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

Kapslade moduler

Moduler kan innehålla andra moduler och bilda ett träd. Sökvägen listar varje nivå, separerad med ::.

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

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

Moduler grupperar mer än funktioner

En modul kan innehålla funktioner, structar, enum-typer, konstanter och även andra moduler. Det håller relaterade typer och beteenden tillsammans.

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);
}

Modulträdet

Varje crate har en rotmodul. Moduler Ni deklarerar bildar ett träd under den. Sökvägar beskriver var ett element finns, ungefär som mappar i ett filsystem.

super: Föräldramodulen

Inuti en modul hänvisar super till föräldramodulen. Det låter en undermodul anropa något som definierats en nivå upp.

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

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

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

self: Den aktuella modulen

self hänvisar till den aktuella modulen. Det används främst för att tydliggöra var ett element finns i en sökväg.

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

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

Moduler i separata filer

Utöver inline-moduler anger mod network; (med semikolon och utan block) att Rust ska läsa innehållet från network.rs eller network/mod.rs.

Så delar riktiga projekt upp kod över flera filer samtidigt som ett enda modulträd behålls.

Privata gränser

Moduler bildar privata gränser. En undermodul kan se sina förfäders privata element, men föräldrar kan inte komma åt en undermoduls privata element.

Denna inkapsling håller interna detaljer dolda.

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

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

Organisera riktiga projekt

Använd moduler för att spegla domänen: auth, db, handlers. Håll varje modul fokuserad, exponera en liten offentlig yta och dölj resten.

Tydliga modulgränser gör stora kodbaser lättare att navigera i.

Snabb kontroll

Testa Era kunskaper om moduler.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att organisera kod med moduler:

mod name { ... } deklarerar en inline-modul
Items är privata som standard; använd pub för att exponera dem
Sökvägar använder :: för att gå genom modulträdet
super, self och mod name; används för att navigera i och dela upp moduler

Gratis att börja

Lär dig Rust med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 144

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Moduler och mod” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Moduler och mod”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Vad lär jag mig i ”Moduler och mod”?

Organisera kod Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?

Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Moduler och mod”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?

Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lär dig programmera i Rust