Belajar Pengaturcaraan Rust · Pelajaran

Peraturan Elisi

Apabila lifetime dibuat kesimpulan

Pelajaran 4 daripada 413 langkah

Peraturan Elisi ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. 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 4 pelajaran.

Jangka Hayat yang Tidak Perlu Anda Tulis

Banyak fungsi menerima dan memulangkan rujukan tanpa sebarang anotasi jangka hayat, namun tetap boleh dikompil. Hal ini disebabkan oleh pengguguran jangka hayat: pengompil membuat kesimpulan tentang jangka hayat yang jelas bagi anda.

Pengguguran Hanyalah Jalan Pintas

Pengguguran tidak menghapuskan jangka hayat; pengompil masih mengisinya secara tersirat menggunakan beberapa peraturan yang pasti. Apabila peraturan tersebut meliputi kes anda, anda boleh meninggalkan anotasi.

Fungsi dengan Pengguguran

Fungsi ini tidak mempunyai jangka hayat yang dinyatakan secara jelas, namun pengompil memahami bahawa rujukan yang dipulangkan meminjam daripada input. Peraturan tersebut menjadikannya tidak samar.

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

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

Peraturan 1: Setiap Input Mendapat Jangka Hayat Sendiri

Peraturan pertama: setiap jangka hayat yang digugurkan dalam parameter mendapat jangka hayat yang berbeza. Dua parameter rujukan mendapat dua jangka hayat yang berasingan.

Peraturan 2: Satu Input, Satu Output

Peraturan kedua: jika terdapat tepat satu jangka hayat input, jangka hayat itu diberikan kepada semua jangka hayat output. Ini meliputi fungsi seperti first_word yang menerima dan memulangkan satu rujukan.

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

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

Peraturan 3: Kaedah dan &self

Peraturan ketiga: jika kaedah mempunyai &self atau &mut self, jangka hayat self diberikan kepada semua jangka hayat output. Sebab itulah kaedah 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());
}

Apabila Pengguguran Gagal

Jika selepas menggunakan ketiga-tiga peraturan masih terdapat jangka hayat output yang tidak diketahui, pengompil meminta anda membuat anotasi secara jelas. Fungsi longest ialah kes klasik: dua input dengan output yang samar.

Fungsi longest Sekali Lagi

Dua input rujukan dan satu output rujukan: peraturan 2 tidak terpakai (lebih daripada satu input) dan tiada self. Jadi, anda mesti membuat 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"));
}

Berbilang Input, Output daripada self

Kaedah dengan beberapa parameter masih mendapat jangka hayat output daripada self mengikut peraturan 3, walaupun terdapat parameter rujukan lain.

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

Sebab Peraturan Ini Wujud

Ketiga-tiga peraturan ini meliputi sebahagian besar kod sebenar, jadi kebanyakan fungsi langsung tidak memerlukan sintaks jangka hayat. Anda hanya menulis anotasi apabila maksudnya benar-benar samar.

Senarai Semak Ringkas

Untuk menentukan sama ada pengguguran terpakai, tanyakan:

Adakah terdapat tepat satu rujukan input? Output meminjam daripadanya.
Adakah terdapat &self? Output meminjam daripada self.
Jika tidak, buat anotasi secara jelas.

Semakan Ringkas

Uji pemahaman anda tentang peraturan pengguguran.

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari masa jangka hayat dibuat kesimpulan:

Peraturan 1: setiap rujukan input mendapat jangka hayat sendiri
Peraturan 2: satu jangka hayat input dipetakan kepada semua output
Peraturan 3: &self menyediakan jangka hayat output dalam kaedah
Jika output masih samar, anda membuat anotasi secara jelas

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 “Peraturan Elisi” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Peraturan Elisi”, 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 4 pelajaran.

Apakah yang akan saya pelajari dalam “Peraturan Elisi”?

Apabila lifetime dibuat kesimpulan 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 4 daripada 4.

Berapa lamakah pelajaran “Peraturan Elisi” 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

← Kembali ke Belajar Pengaturcaraan Rust