Learn Rust Coding · Pelajaran

Lifetime dalam Struct

Field yang dipinjam

Lifetime dalam Struct 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.

Struct Dapat Meminjam

Sebagian besar struct memiliki datanya sendiri. Namun, struct juga dapat menyimpan referensi ke data yang bukan miliknya. Jika demikian, struct memerlukan parameter lifetime.

Hal ini menjamin bahwa struct tidak pernah hidup lebih lama daripada data yang dipinjamnya.

Mendeklarasikan Lifetime pada Struct

Tambahkan lifetime di dalam tanda kurung sudut setelah nama struct, lalu gunakan lifetime tersebut pada field referensi. Ini menyatakan bahwa struct tidak dapat hidup lebih lama daripada referensi itu.

struct Excerpt<'a> {
    text: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first = novel.split('.').next().unwrap();
    let e = Excerpt { text: first };
    println!("{}", e.text);
}

Batasan yang Ditambahkannya

Anotasi tersebut berarti sebuah instance dari Excerpt hanya valid selama string yang dipinjamnya masih hidup. Compiler memberlakukan hal ini di setiap tempat struct digunakan.

Method pada Struct yang Meminjam

Method pada struct semacam itu juga memuat lifetime pada header impl. Sering kali Anda dapat menghilangkan lifetime di dalam isi method berkat elision (yang dibahas pada pelajaran berikutnya).

struct Excerpt<'a> { text: &'a str }

impl<'a> Excerpt<'a> {
    fn announce(&self) -> &str {
        println!("Attention!");
        self.text
    }
}

fn main() {
    let s = String::from("hello world");
    let e = Excerpt { text: &s };
    println!("{}", e.announce());
}

Mengapa Tidak Memiliki Datanya Saja?

Memiliki data sendiri (menggunakan String) lebih sederhana dan biasanya lebih disarankan. Peminjaman menghindari penyalinan data berukuran besar dan berguna untuk parser serta tampilan yang membaca buffer yang sudah ada.

Gunakan lifetime pada struct hanya jika peminjaman benar-benar memberikan manfaat.

Contoh Tampilan Parser

Struct yang menyimpan slice ke dalam string sumber adalah penggunaan klasik. Struct tersebut membaca buffer asli tanpa menyalinnya.

struct Token<'a> {
    word: &'a str,
}

fn main() {
    let line = String::from("let x = 5");
    let tokens: Vec<Token> = line.split_whitespace().map(|w| Token { word: w }).collect();
    for t in &tokens {
        println!("token: {}", t.word);
    }
}

Beberapa Field Referensi

Sebuah struct dapat menyimpan beberapa referensi. Referensi tersebut dapat menggunakan satu lifetime bersama atau lifetime yang berbeda, bergantung pada hubungan validitasnya.

struct Pair<'a> {
    left: &'a str,
    right: &'a str,
}

fn main() {
    let a = String::from("foo");
    let b = String::from("bar");
    let p = Pair { left: &a, right: &b };
    println!("{} {}", p.left, p.right);
}

Error Struct yang Menggantung

Jika data yang dipinjam dihapus saat struct masih ada, compiler akan menolaknya. Parameter lifetime memungkinkan pemeriksaan ini dilakukan.

Mengembalikan Struct yang Meminjam

Fungsi yang membangun struct semacam itu mengaitkan lifetime struct dengan inputnya. Struct tersebut tidak dapat hidup lebih lama daripada data yang diberikan.

struct Wrap<'a> { inner: &'a str }

fn wrap<'a>(s: &'a str) -> Wrap<'a> {
    Wrap { inner: s }
}

fn main() {
    let text = String::from("wrapped");
    let w = wrap(&text);
    println!("{}", w.inner);
}

Perbandingan Memiliki dan Meminjam

Panduan singkat:

Perlu menyimpan data secara mandiri? Miliki datanya (String, Vec).
Perlu tampilan singkat ke data yang sudah ada? Pinjam data tersebut dengan lifetime.

Model Mental

Struct dengan 'a seperti catatan tempel yang ditempelkan pada buku catatan milik orang lain: catatan itu hanya bermakna selama buku catatan tersebut masih ada. Rust memastikan Anda tidak pernah membaca catatan pada buku catatan yang sudah tidak ada.

Pemeriksaan Singkat

Uji pemahaman Anda tentang lifetime pada struct.

Ringkasan

Anda telah mempelajari lifetime pada struct:

Struct yang menyimpan referensi memerlukan parameter lifetime
Lifetime mengaitkan validitas struct dengan data yang dipinjam
Method memuat lifetime pada header impl
Lebih baik memiliki data sendiri, kecuali peminjaman menghindari penyalinan yang berarti

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Lifetime dalam Struct” gratis?

Ya — teks lengkap “Lifetime dalam Struct” 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 “Lifetime dalam Struct”?

Field yang dipinjam 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 “Lifetime dalam Struct” 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