Learn Rust Coding · Pelajaran

Aturan Elisi

Saat lifetime disimpulkan

Aturan Elisi adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 4 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.

Lifetime yang Tidak Perlu Anda Tulis

Banyak fungsi menerima dan mengembalikan referensi tanpa anotasi lifetime apa pun, tetapi tetap dapat dikompilasi. Hal ini terjadi karena elision lifetime: compiler menyimpulkan lifetime yang jelas untuk Anda.

Elision Hanyalah Jalan Pintas

Elision tidak menghapus lifetime; compiler tetap mengisinya secara internal menggunakan beberapa aturan deterministik. Jika aturan tersebut mencakup kasus Anda, anotasi dapat dihilangkan.

Fungsi dengan Elision

Fungsi ini tidak memiliki lifetime eksplisit, tetapi compiler memahami bahwa referensi yang dikembalikan dipinjam dari input. Aturan tersebut membuatnya tidak ambigu.

fn first_word(s: &str) -> &str {
    s.split(' ').next().unwrap_or("")
}

fn main() {
    let phrase = String::from("rust is fun");
    println!("{}", first_word(&phrase));
}

Aturan 1: Setiap Input Mendapatkan Lifetime Sendiri

Aturan pertama: setiap lifetime yang dihilangkan pada parameter mendapatkan lifetime yang berbeda. Dua parameter referensi mendapatkan dua lifetime terpisah.

Aturan 2: Satu Input, Satu Output

Aturan kedua: jika terdapat tepat satu lifetime input, lifetime tersebut diberikan kepada semua lifetime output. Ini mencakup fungsi seperti first_word yang menerima dan mengembalikan satu referensi.

fn trim_start(s: &str) -> &str {
    s.trim_start()
}

fn main() {
    println!("[{}]", trim_start("   hi"));
}

Aturan 3: Method dan &self

Aturan ketiga: jika sebuah method memiliki &self atau &mut self, lifetime self diberikan kepada semua lifetime output. Inilah sebabnya method jarang memerlukan anotasi.

struct Holder { value: String }

impl Holder {
    fn get(&self) -> &str {
        &self.value
    }
}

fn main() {
    let h = Holder { value: String::from("stored") };
    println!("{}", h.get());
}

Saat Elision Gagal

Jika setelah menerapkan ketiga aturan masih ada lifetime output yang belum diketahui, compiler meminta Anda memberikan anotasi secara eksplisit. Fungsi longest adalah kasus klasik: dua input dengan output yang ambigu.

Fungsi longest Sekali Lagi

Dua input referensi dan satu output referensi: aturan 2 tidak berlaku (karena inputnya lebih dari satu) dan tidak ada self. Jadi, Anda harus memberikan anotasi.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    println!("{}", longest("abcd", "ab"));
}

Beberapa Input, Output dari self

Method dengan beberapa parameter tetap mendapatkan lifetime output dari self berdasarkan aturan 3, meskipun ada parameter referensi lainnya.

struct Doc { body: String }

impl Doc {
    fn announce(&self, _note: &str) -> &str {
        &self.body
    }
}

fn main() {
    let d = Doc { body: String::from("content") };
    println!("{}", d.announce("ping"));
}

Mengapa Aturan Ini Ada

Ketiga aturan ini mencakup sebagian besar kode nyata, sehingga sebagian besar fungsi sama sekali tidak memerlukan sintaks lifetime. Anda hanya perlu menulis anotasi ketika maksudnya benar-benar ambigu.

Daftar Periksa Singkat

Untuk menentukan apakah elision berlaku, tanyakan:

Apakah tepat ada satu referensi input? Output meminjam dari referensi tersebut.
Apakah ada &self? Output meminjam dari self.
Jika tidak, berikan anotasi secara eksplisit.

Pemeriksaan Singkat

Uji pemahaman Anda tentang aturan elision.

Ringkasan

Anda telah mempelajari kapan lifetime disimpulkan:

Aturan 1: setiap referensi input mendapatkan lifetime sendiri
Aturan 2: satu lifetime input dipetakan ke semua output
Aturan 3: &self menyediakan lifetime output pada method
Jika output masih ambigu, berikan anotasi secara eksplisit

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Aturan Elisi” gratis?

Ya — teks lengkap “Aturan Elisi” 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 “Aturan Elisi”?

Saat lifetime disimpulkan 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 4 dari 4.

Berapa lama pelajaran “Aturan Elisi” 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