Learn Rust Coding · Pelajaran

use dan Path

Mengimpor item

use dan Path adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. 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 4 pelajaran total.

Membawa Item ke Dalam Cakupan

Mengetik jalur lengkap seperti std::collections::HashMap di mana-mana cukup merepotkan. Kata kunci use membawa sebuah item ke dalam cakupan sehingga Anda dapat merujuknya dengan nama singkat.

use Dasar

Setelah menggunakan use, Anda merujuk item tersebut dengan nama akhirnya. Di sini kita mengimpor HashMap dan menggunakannya secara langsung.

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("ana", 10);
    println!("{:?}", scores.get("ana"));
}

Jalur Absolut dan Relatif

Jalur absolut dimulai dari crate (akar crate). Jalur relatif dimulai dari modul saat ini, dan dapat menggunakan self atau super.

mod a {
    pub mod b {
        pub fn hi() { println!("hi from b"); }
    }
    pub fn call_b() {
        crate::a::b::hi();
        self::b::hi();
    }
}

fn main() {
    a::call_b();
}

use di Dalam Modul

use hanya memengaruhi cakupan tempatnya berada. Letakkan di bagian atas modul untuk menyingkat nama yang digunakan di seluruh modul tersebut.

mod work {
    use std::collections::HashSet;
    pub fn run() {
        let mut s = HashSet::new();
        s.insert(1);
        s.insert(1);
        println!("size {}", s.len());
    }
}

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

Mengganti Nama dengan as

Jika dua item memiliki nama yang sama, atau sebuah nama terlalu panjang, ganti namanya saat mengimpor dengan as.

use std::collections::HashMap as Map;

fn main() {
    let mut m: Map<&str, i32> = Map::new();
    m.insert("x", 1);
    println!("{:?}", m.get("x"));
}

Mengelompokkan Impor

Impor beberapa item dari jalur yang sama dalam satu baris menggunakan kurung kurawal. Ini membuat blok impor tetap rapi.

use std::collections::{HashMap, HashSet};

fn main() {
    let map: HashMap<i32, i32> = HashMap::new();
    let set: HashSet<i32> = HashSet::new();
    println!("{} {}", map.len(), set.len());
}

Grup Bertingkat dan self

Di dalam grup, self mengimpor modul itu sendiri bersama item-itemnya. Dengan demikian, Anda dapat menggunakan nama modul sekaligus anggota tertentu.

use std::io::{self, Write};

fn main() {
    let _ = io::stdout().write_all(b"hello\n");
}

Impor Glob

Glob * membawa semua item publik dari suatu jalur. Gunakan secukupnya—glob dapat menyamarkan asal nama-nama tersebut—tetapi cara ini umum digunakan untuk pustaka pendahulu dan pengujian.

mod colors {
    pub fn red() -> &'static str { "red" }
    pub fn blue() -> &'static str { "blue" }
}

use colors::*;

fn main() {
    println!("{} {}", red(), blue());
}

Gaya Impor Idiomatis

Konvensinya: impor fungsi melalui modul induknya (use std::cmp; cmp::max(...)), tetapi impor tipe berdasarkan namanya (use std::collections::HashMap;). Ini membuat pemanggilan lebih jelas saat dibaca.

use std::cmp;

fn main() {
    println!("{}", cmp::max(3, 9));
}

Jalur ke Crate Eksternal

Untuk dependensi, jalur dimulai dengan nama crate, misalnya rand::thread_rng. Cantumkan crate tersebut di Cargo.toml, lalu impor item dengan cara yang sama seperti pada std.

Menjaga Impor Tetap Rapi

Kelompokkan impor yang berkaitan, ganti nama untuk menghindari benturan, dan pilih impor eksplisit daripada glob dalam kode aplikasi. Impor yang rapi membuat file mudah dipindai.

Pemeriksaan Singkat

Uji pengetahuan Anda tentang jalur.

Rangkuman

Anda telah mempelajari cara mengimpor item:

use membawa item ke dalam cakupan dengan nama singkat
Jalur absolut dimulai dari crate; jalur relatif menggunakan self/super
as mengganti nama, kurung kurawal mengelompokkan, dan * mengimpor secara glob
Impor tipe berdasarkan nama dan fungsi melalui modul induknya agar lebih jelas

Pertanyaan yang Sering Diajukan

Apakah pelajaran “use dan Path” gratis?

Ya — teks lengkap “use dan Path” 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 4 pelajaran total.

Apa yang akan aku pelajari di “use dan Path”?

Mengimpor item 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 3 dari 4.

Berapa lama pelajaran “use dan Path” 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

← Kembali ke Learn Rust Coding