Belajar Pengaturcaraan Rust · Pelajaran

Menyusun Kod dengan Modul

Pelajari cara menggunakan sistem modul Rust untuk mengumpulkan kod secara logik, mengurus privasi dan menjadikan projek anda mudah diskalakan.

Pelajaran 1 daripada 311 langkah

Menyusun Kod dengan Modul ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 daripada 3. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Susun Kod Anda dengan Modul

Apabila projek Rust anda berkembang, menyimpan semua kod dalam satu fail akan menjadi berserabut. Sistem modul Rust membantu anda menyusun kod kepada unit yang logik.

Modul adalah seperti folder untuk kod anda. Modul mengumpulkan fungsi, struct, enum dan pemalar yang berkaitan, sekali gus meningkatkan kebolehbacaan dan kebolehselenggaraan.

Mengisytiharkan Modul Pertama Anda

Anda mengisytiharkan modul menggunakan kata kunci mod, diikuti nama modul. Ia seperti mencipta ruang nama kecil dalam program anda.

Mari cipta modul greetings yang ringkas:

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

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

Memahami Privasi Modul

Secara lalai, semua yang berada dalam modul adalah persendirian. Ini bermakna anda tidak boleh mencapainya dari luar modul tanpa menjadikannya awam secara jelas.

Jika anda cuba memanggil fungsi persendirian, Rust akan memberikan ralat kompilasi. Cuba nyahkomen baris di bawah dan jalankannya:

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

Menjadikan Item Awam dengan `pub`

Untuk menjadikan sesuatu item (seperti fungsi, struct atau enum) kelihatan dari luar modulnya, anda menggunakan kata kunci pub.

pub fn menjadikan fungsi awam.
pub struct menjadikan struct awam.
pub mod menjadikan submodul awam, lalu membolehkan kandungannya dicapai.

Privasi ialah bahagian teras keselamatan dan penyusunan Rust!

`pub` dalam Tindakan

Sekarang, mari jadikan fungsi hello kita awam menggunakan pub. Ini membolehkan fungsi main memanggilnya tanpa ralat privasi.

Jalankan kod ini untuk melihat ucapan daripada modul kita:

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

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

Memudahkan Laluan dengan `use`

Menulis laluan penuh seperti greetings::hello() berulang kali boleh menjadi leceh. Kata kunci use membolehkan anda membawa item ke dalam skop, supaya item tersebut lebih mudah dirujuk.

Ia serupa dengan import dalam Python atau using dalam C#. Anda boleh membawa item tertentu atau keseluruhan modul ke dalam skop.

`use` dalam Tindakan

Begini cara anda boleh menggunakan use untuk memendekkan laluan ke fungsi hello kita. Perhatikan bahawa kita tidak lagi memerlukan awalan greetings::.

Ini menjadikan kod anda lebih kemas dan mudah dibaca.

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
}

Modul Bersarang & Laluan Relatif

Modul boleh bersarang! Anda boleh mentakrifkan modul di dalam modul lain untuk penyusunan yang lebih terperinci. Untuk menavigasi modul ini, Rust menyediakan super dan self.

super merujuk kepada modul induk.
self merujuk kepada modul semasa.

Item ini berguna untuk laluan relatif dalam hierarki modul yang kompleks.

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

Modul dan Struktur Fail

Untuk modul yang lebih besar, anda boleh meletakkan kodnya dalam fail berasingan. Rust mencari definisi modul secara automatik di lokasi tertentu:

Untuk mod my_module; dalam src/main.rs: Rust mencari src/my_module.rs atau src/my_module/mod.rs.
Ini membantu memastikan fail utama kekal kemas dan menyerahkan kandungan kepada fail yang sesuai.

Pelajaran ini menggunakan fail tunggal demi kesederhanaan, tetapi ingat perkara ini untuk projek yang lebih besar!

Semakan Capaian Modul

Pertimbangkan kod Rust berikut. Baris yang manakah akan dikompil tanpa ralat privasi?

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

Jawab dalam pelajaran interaktif

Modul: Susun & Kawal

Tahniah! Anda telah mempelajari cara sistem modul Rust membantu anda menstrukturkan kod:

Gunakan mod untuk mengisytiharkan modul dan submodul.
Item adalah persendirian secara lalai; gunakan pub untuk menjadikannya boleh dicapai.
use memudahkan laluan panjang ke item.
Modul boleh diagihkan merentasi beberapa fail untuk projek besar.

Modul penting untuk mengurus kerumitan dalam Rust. Teruskan berlatih!

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 144

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Menyusun Kod dengan Modul” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Menyusun Kod dengan Modul”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Menyusun Kod dengan Modul”?

Pelajari cara menggunakan sistem modul Rust untuk mengumpulkan kod secara logik, mengurus privasi dan menjadikan projek anda mudah diskalakan. Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 3.

Berapa lamakah pelajaran “Menyusun Kod dengan Modul” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Menyusun Kod dengan Modul
Mengurus Kebergantungan dengan Crate
Pengendalian Ralat Kukuh dengan `Result`

← Kembali ke Belajar Pengaturcaraan Rust