Lær at programmere i Rust · Lektion

Organisering af kode med moduler

Lær at bruge Rusts modulsystem til logisk at gruppere kode, styre synlighed og gøre Deres projekter skalerbare.

Lektion 1 af 311 trin

Organisering af kode med moduler er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 1 af 3. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 3 lektioner i alt.

Organiser din kode med moduler

Efterhånden som dine Rust-projekter vokser, bliver det rodet at have al kode i én fil. Rusts modulsystem hjælper dig med at organisere koden i logiske enheder.

Moduler fungerer som mapper til din kode. De samler relaterede funktioner, structs, enums og konstanter og forbedrer dermed læsbarheden og vedligeholdelsen.

Erklæring af dit første modul

Du erklærer et modul ved hjælp af nøgleordet mod efterfulgt af modulets navn. Det svarer til at oprette et undermærkerum i dit program.

Lad os oprette et enkelt greetings-modul:

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

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

Forstå modulets synlighed

Som standard er alt i et modul privat. Det betyder, at du ikke kan få adgang til det uden for modulet, medmindre du udtrykkeligt gør det offentligt.

Hvis du forsøger at kalde en privat funktion, giver Rust dig en kompileringsfejl. Prøv at fjerne kommenteringen af linjen nedenfor og køre den:

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

Gør elementer offentlige med `pub`

Hvis du vil gøre et element (for eksempel en funktion, en struct eller en enum) synligt uden for modulet, bruger du nøgleordet pub.

pub fn gør en funktion offentlig.
pub struct gør en struct offentlig.
pub mod gør et undermodul offentligt, så der kan opnås adgang til dets indhold.

Privatliv er en central del af Rusts sikkerhed og organisering!

`pub` i praksis

Lad os nu gøre vores hello-funktion offentlig ved hjælp af pub. Det giver main-funktionen mulighed for at kalde den uden en fejl om privatliv.

Kør denne kode for at se hilsenen fra vores modul:

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

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

Forenkling af stier med `use`

Det kan blive gentagende at skrive fulde stier som greetings::hello(). Nøgleordet use lader dig bringe elementer ind i scope, så de bliver nemmere at referere til.

Det minder om import i Python eller using i C#. Du kan bringe et bestemt element eller et helt modul ind i scope.

`use` i praksis

Her kan du se, hvordan du bruger use til at forkorte stien til vores hello-funktion. Bemærk, at vi ikke længere har brug for præfikset greetings::.

Det gør din kode renere og nemmere at læse.

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
}

Indlejrede moduler og relative stier

Moduler kan indlejres! Du kan definere moduler i andre moduler for at organisere koden endnu mere detaljeret. Til navigation i disse moduler tilbyder Rust super og self.

super refererer til forældremodulet.
self refererer til det aktuelle modul.

De er nyttige til relative stier i komplekse modulhierarkier.

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

Moduler og filstruktur

I større moduler kan du placere koden i separate filer. Rust leder automatisk efter modulaire definitioner på bestemte placeringer:

For mod my_module; i src/main.rs leder Rust efter src/my_module.rs eller src/my_module/mod.rs.
Det hjælper med at holde din hovedfil overskuelig og overlade indholdet til de relevante filer.

Denne lektion bruger enkelte filer for enkelhedens skyld, men husk dette til større projekter!

Tjek af moduladgang

Se på følgende Rust-kode. Hvilke linjer kompilerer uden en fejl om privatliv?

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

Besvar den i den interaktive lektion

Moduler: Organiser og styr

Godt klaret! Du har lært, hvordan Rusts modulsystem hjælper dig med at strukturere din kode:

Brug mod til at erklære moduler og undermoduler.
Elementer er som standard private; brug pub til at gøre dem tilgængelige.
use forenkler lange stier til elementer.
Moduler kan fordeles på flere filer i store projekter.

Moduler er grundlæggende til håndtering af kompleksitet i Rust. Bliv ved med at øve dig!

Gratis at komme i gang

Lær Rust med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 39
Lektioner: 144

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Organisering af kode med moduler” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Organisering af kode med moduler”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 3 lektioner i alt.

Hvad lærer jeg i “Organisering af kode med moduler”?

Lær at bruge Rusts modulsystem til logisk at gruppere kode, styre synlighed og gøre Deres projekter skalerbare. Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lær at programmere i Rust?

Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 3.

Hvor lang tid tager lektionen “Organisering af kode med moduler”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?

Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Lær at programmere i Rust