Learn Rust Coding · Lekcja

Organizowanie kodu za pomocą modułów

Nauczą się Państwo korzystać z systemu modułów Rust do logicznego grupowania kodu, zarządzania prywatnością i tworzenia skalowalnych projektów.

Organizowanie kodu za pomocą modułów to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 3 lekcji w sumie.

Organizowanie kodu za pomocą modułów

W miarę rozrastania się projektów Rust trzymanie całego kodu w jednym pliku staje się nieporęczne. System modułów Rust pomaga organizować kod w logiczne jednostki.

Moduły przypominają foldery na kod. Grupują powiązane funkcje, struktury, enumy i stałe, poprawiając czytelność oraz łatwość utrzymania.

Deklarowanie pierwszego modułu

Moduł deklaruje się za pomocą słowa kluczowego mod, po którym podaje się nazwę modułu. Przypomina to tworzenie podprzestrzeni nazw w programie.

Utwórzmy prosty moduł greetings:

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

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

Zrozumienie prywatności modułów

Domyślnie wszystko wewnątrz modułu jest prywatne. Oznacza to, że nie można uzyskać do tego dostępu spoza modułu bez jawnego oznaczenia elementu jako publiczny.

Jeśli spróbuje Pan wywołać prywatną funkcję, Rust zgłosi błąd kompilacji. Proszę odkomentować poniższy wiersz i uruchomić kod:

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

Udostępnianie elementów za pomocą `pub`

Aby element (na przykład funkcja, struktura lub enum) był widoczny spoza swojego modułu, należy użyć słowa kluczowego pub.

pub fn udostępnia funkcję publicznie.
pub struct udostępnia strukturę publicznie.
pub mod udostępnia podmoduł, umożliwiając dostęp do jego zawartości.

Prywatność jest kluczowym elementem bezpieczeństwa i organizacji kodu w Rust!

`pub` w praktyce

Teraz udostępnijmy publicznie naszą funkcję hello za pomocą pub. Dzięki temu funkcja main może ją wywołać bez błędu związanego z prywatnością.

Uruchom ten kod, aby zobaczyć powitanie z naszego modułu:

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

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

Upraszczanie ścieżek za pomocą `use`

Wpisywanie pełnych ścieżek, takich jak greetings::hello(), może stać się powtarzalne. Słowo kluczowe use pozwala wprowadzać elementy do zakresu, dzięki czemu można łatwiej się do nich odwoływać.

Przypomina to import w Pythonie lub using w C#. Do zakresu można wprowadzić konkretny element albo cały moduł.

`use` w praktyce

Oto jak za pomocą use skrócić ścieżkę do naszej funkcji hello. Proszę zauważyć, że nie potrzebujemy już prefiksu greetings::.

Dzięki temu kod jest czytelniejszy i łatwiejszy do zrozumienia.

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
}

Moduły zagnieżdżone i ścieżki względne

Moduły można zagnieżdżać! Można definiować moduły wewnątrz innych modułów, aby jeszcze dokładniej organizować kod. Do poruszania się między nimi Rust udostępnia super i self.

super odwołuje się do modułu nadrzędnego.
self odwołuje się do bieżącego modułu.

Są one przydatne do tworzenia ścieżek względnych w złożonych hierarchiach modułów.

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

Moduły i struktura plików

W przypadku większych modułów ich kod można umieścić w osobnych plikach. Rust automatycznie szuka definicji modułów w określonych lokalizacjach:

Dla mod my_module; w src/main.rs Rust szuka pliku src/my_module.rs lub src/my_module/mod.rs.
Pomaga to zachować porządek w głównym pliku i przenieść zawartość do odpowiednich plików.

Ta lekcja używa pojedynczych plików dla uproszczenia, ale warto pamiętać o tym w przypadku większych projektów!

Sprawdzanie dostępu do modułów

Proszę przeanalizować poniższy kod Rust. Które wiersze skompilują się bez błędu związanego z prywatnością?

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

Moduły: organizowanie i kontrolowanie

Świetna praca! Dowiedział się Pan, jak system modułów Rust pomaga strukturyzować kod:

Używaj mod do deklarowania modułów i podmodułów.
Elementy są domyślnie prywatne; używaj pub, aby je udostępnić.
use upraszcza długie ścieżki do elementów.
W dużych projektach moduły można rozdzielać na wiele plików.

Moduły mają podstawowe znaczenie dla zarządzania złożonością w Rust. Proszę dalej ćwiczyć!

Często zadawane pytania

Czy lekcja „Organizowanie kodu za pomocą modułów” jest bezpłatna?

Tak — pełny tekst „Organizowanie kodu za pomocą modułów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 3 lekcji w sumie.

Co nauczysz się w „Organizowanie kodu za pomocą modułów”?

Nauczą się Państwo korzystać z systemu modułów Rust do logicznego grupowania kodu, zarządzania prywatnością i tworzenia skalowalnych projektów. Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.

Ile czasu zajmuje lekcja „Organizowanie kodu za pomocą modułów”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Organizowanie kodu za pomocą modułów
Zarządzanie zależnościami za pomocą crates
Solidna obsługa błędów za pomocą `Result`

← Powrót do Learn Rust Coding