Learn Rust Coding · Pelajaran

Mengatur Kode dengan Modul

Pelajari cara menggunakan sistem modul Rust untuk mengelompokkan kode secara logis, mengelola privasi, dan membuat proyek Anda mudah dikembangkan.

Pelajaran 1 dari 311 langkah

Mengatur Kode dengan Modul adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Atur Kode Anda dengan Modul

Seiring bertambah besarnya proyek Rust Anda, menyimpan semua kode dalam satu berkas menjadi berantakan. Sistem modul Rust membantu Anda mengatur kode ke dalam unit-unit yang logis.

Modul seperti folder untuk kode Anda. Modul mengelompokkan fungsi, struct, enum, dan konstanta yang berkaitan, sehingga meningkatkan keterbacaan dan kemudahan pemeliharaan.

Mendeklarasikan Modul Pertama Anda

Anda mendeklarasikan modul menggunakan kata kunci mod, diikuti nama modul. Ini seperti membuat ruang nama turunan di dalam program Anda.

Mari buat modul greetings sederhana:

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

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

Memahami Privasi Modul

Secara bawaan, semua yang berada di dalam modul bersifat privat. Artinya, Anda tidak dapat mengaksesnya dari luar modul tanpa menjadikannya publik secara eksplisit.

Jika Anda mencoba memanggil fungsi privat, Rust akan memberikan kesalahan kompilasi. Cobalah menghapus komentar pada baris di bawah ini lalu jalankan:

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 Publik dengan `pub`

Untuk membuat suatu item (seperti fungsi, struct, atau enum) terlihat dari luar modulnya, Anda menggunakan kata kunci pub.

pub fn menjadikan fungsi publik.
pub struct menjadikan struct publik.
pub mod menjadikan submodul publik, sehingga isinya dapat diakses.

Privasi adalah bagian inti dari keamanan dan pengorganisasian Rust!

`pub` dalam Praktik

Sekarang, mari jadikan fungsi hello kita publik menggunakan pub. Dengan demikian, fungsi main dapat memanggilnya tanpa kesalahan privasi.

Jalankan kode ini untuk melihat sapaan dari modul kita:

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

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

Menyederhanakan Jalur dengan `use`

Mengetik jalur lengkap seperti greetings::hello() dapat menjadi berulang. Kata kunci use memungkinkan Anda membawa item ke dalam lingkup, sehingga item tersebut lebih mudah dirujuk.

Ini mirip dengan import dalam Python atau using dalam C#. Anda dapat membawa item tertentu atau seluruh modul ke dalam lingkup.

`use` dalam Praktik

Berikut cara menggunakan use untuk mempersingkat jalur ke fungsi hello kita. Perhatikan bahwa kita tidak lagi memerlukan awalan greetings::.

Hal ini membuat kode Anda lebih rapi 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 & Jalur Relatif

Modul dapat dibuat bersarang! Anda dapat mendefinisikan modul di dalam modul lain untuk pengaturan yang lebih terperinci. Untuk menavigasinya, Rust menyediakan super dan self.

super merujuk ke modul induk.
self merujuk ke modul saat ini.

Keduanya berguna untuk jalur 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 Berkas

Untuk modul yang lebih besar, Anda dapat menempatkan kodenya dalam berkas terpisah. Rust secara otomatis mencari definisi modul di lokasi tertentu:

Untuk mod my_module; dalam src/main.rs: Rust mencari src/my_module.rs atau src/my_module/mod.rs.
Hal ini membantu menjaga berkas utama tetap rapi dan menyerahkan isinya kepada berkas yang sesuai.

Pelajaran ini menggunakan berkas tunggal demi kesederhanaan, tetapi ingatlah hal ini untuk proyek yang lebih besar!

Pemeriksaan Akses Modul

Perhatikan kode Rust berikut. Baris mana yang akan dikompilasi tanpa kesalahan 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 di pelajaran interaktif

Modul: Mengatur & Mengendalikan

Bagus sekali! Anda telah mempelajari bagaimana sistem modul Rust membantu menyusun kode Anda:

Gunakan mod untuk mendeklarasikan modul dan submodul.
Item bersifat privat secara bawaan; gunakan pub agar item dapat diakses.
use menyederhanakan jalur panjang menuju item.
Modul dapat disebarkan ke beberapa berkas untuk proyek besar.

Modul merupakan dasar penting untuk mengelola kompleksitas dalam Rust. Teruslah berlatih!

Gratis untuk memulai

Belajar Rust dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 39
Pelajaran: 144

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengatur Kode dengan Modul” gratis?

Ya — teks lengkap “Mengatur Kode dengan Modul” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Mengatur Kode dengan Modul”?

Pelajari cara menggunakan sistem modul Rust untuk mengelompokkan kode secara logis, mengelola privasi, dan membuat proyek Anda mudah dikembangkan. Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 3.

Berapa lama pelajaran “Mengatur Kode dengan Modul” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Mengatur Kode dengan Modul
Mengelola Dependensi dengan Crate
Penanganan Galat yang Tangguh dengan `Result`

← Kembali ke Learn Rust Coding