0Pricing
Learn Rust Coding · Pelajaran

Masa Hidup untuk Referensi yang Aman

Pelajari lebih mendalam masa hidup, mekanisme Rust yang memastikan referensi selalu valid dan mencegah penunjuk menggantung saat kompilasi.

Masa Hidup untuk Referensi yang Aman adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 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.

Mengapa Lifetime Penting

Aturan kepemilikan dan peminjaman Rust mencegah banyak error memori yang umum. Namun, masih ada satu lapisan keamanan lagi: lifetime.

Lifetime memastikan bahwa referensi dalam kode Anda selalu menunjuk ke data yang valid. Lifetime mengatasi masalah referensi yang menggantung, yaitu saat referensi mungkin menunjuk ke memori yang sudah dibebaskan.

Risiko Pointer yang Menggantung

Bayangkan sebuah skenario ketika fungsi membuat data, mengembalikan referensi ke data tersebut, lalu data itu dihancurkan saat fungsi berakhir. Referensi yang dikembalikan kemudian akan menunjuk ke memori yang tidak valid.

Rust menggunakan lifetime untuk mencegah hal ini saat kompilasi. Rust memeriksa bahwa setiap referensi yang Anda gunakan akan tetap valid selama Anda membutuhkannya, sehingga keamanan memori terjamin.

Rust Menyimpulkan Lifetime

Anda tidak selalu perlu menulis anotasi lifetime secara eksplisit. Rust memiliki serangkaian aturan penghilangan lifetime yang memungkinkan kompilator menyimpulkan lifetime dalam pola-pola umum.

Misalnya, dalam fungsi dengan satu referensi input, lifetime-nya sering kali secara otomatis ditetapkan ke referensi output. Dengan begitu, kode Anda menjadi lebih bersih!

Kapan Harus Memberi Anotasi

Saat Rust tidak dapat menyimpulkan lifetime, Anda harus memberi anotasi secara eksplisit. Hal ini memberi tahu kompilator bagaimana lifetime dari berbagai referensi saling berhubungan.

Sintaks untuk anotasi lifetime adalah tanda apostrof yang diikuti huruf kecil, seperti 'a. Ini adalah parameter generik untuk lifetime, bukan durasi tertentu.

Parameter Lifetime Fungsi

Saat sebuah fungsi menerima beberapa referensi dan mengembalikan salah satunya, Rust perlu mengetahui lifetime referensi input mana yang harus dimiliki referensi output. Hal ini memastikan referensi yang dikembalikan selalu valid.

Sintaks <'a> mendeklarasikan parameter lifetime generik. Mari kita lihat contohnya:

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

fn main() {
  let string1 = String::from("abcd");
  let string2 = "xyz";
  let result = longest(string1.as_str(), string2);
  println!("The longest string is: {}", result);
}

Lifetime 'static

Lifetime 'static adalah kasus khusus. Lifetime ini menunjukkan bahwa sebuah referensi dapat hidup selama seluruh durasi program.

Literal string (misalnya, "hello world") memiliki lifetime 'static karena disimpan langsung di biner program dan tersedia selama eksekusi.

fn main() {
  // 'static lifetime for a string literal
  let s: &'static str = "I live for the entire program!";
  println!("{}", s);

  // This is also implicitly 'static
  let another_s = "Hello from static land!";
  println!("{}", another_s);
}

Struct yang Menyimpan Referensi

Jika sebuah struct menyimpan referensi, Anda perlu menambahkan anotasi lifetime pada definisi struct tersebut. Hal ini memastikan bahwa setiap instance struct tidak memiliki lifetime yang melampaui data yang ditunjuk oleh referensinya.

Parameter lifetime pada struct memberi tahu Rust bahwa semua referensi di dalamnya harus memiliki setidaknya lifetime tersebut.

struct ImportantExcerpt<'a> {
  part: &'a str,
}

fn main() {
  let novel = String::from("Call me Ishmael. Some years ago...");
  let first_sentence = novel.split('.').next().expect("Could not find a '.'");
  let i = ImportantExcerpt {
    part: first_sentence,
  };
  println!("Excerpt part: {}", i.part);
}

Lifetime dengan Generik

Lifetime adalah salah satu bentuk generik! Anda dapat menggabungkannya dengan generik tipe untuk membuat struktur data atau fungsi yang fleksibel dan aman.

Misalnya, sebuah struct dapat menyimpan referensi ke tipe generik, yang semuanya dibatasi oleh satu parameter lifetime, sehingga hubungan data yang kompleks tetap valid.

Menguraikan Error Kompilator

Saat pertama kali menemukan error lifetime, error tersebut mungkin terasa menakutkan. Error yang paling umum adalah "peminjaman mungkin tidak hidup cukup lama".

Biasanya, ini berarti Anda mencoba menggunakan referensi setelah data yang ditunjuknya dihapus, atau Rust tidak dapat membuktikan validitasnya. Memahami pesan-pesan ini membantu Anda menyesuaikan anotasi lifetime.

Pemeriksaan Singkat: Lifetime

Manakah dari pernyataan berikut yang paling tepat menjelaskan masalah utama yang ingin diatasi oleh anotasi lifetime eksplisit Rust?

Lifetime: Keamanan Saat Kompilasi

Anda telah mempelajari bahwa lifetime merupakan bagian penting dari jaminan keamanan memori Rust. Lifetime mencegah referensi yang menggantung dengan memastikan semua referensi valid selama seluruh penggunaannya.

  • Rust sering menyimpulkan lifetime menggunakan aturan penghilangan.
  • Anda menggunakan anotasi eksplisit seperti 'a saat penyimpulan tidak memungkinkan.
  • Lifetime sangat penting untuk fungsi yang mengembalikan referensi dan untuk struct yang menyimpan referensi.
  • Lifetime khusus 'static berlangsung selama seluruh durasi program.

Menguasai lifetime adalah kunci untuk menulis kode Rust yang tangguh!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Masa Hidup untuk Referensi yang Aman” gratis?

Ya — teks lengkap “Masa Hidup untuk Referensi yang Aman” 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 “Masa Hidup untuk Referensi yang Aman”?

Pelajari lebih mendalam masa hidup, mekanisme Rust yang memastikan referensi selalu valid dan mencegah penunjuk menggantung saat kompilasi. 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 3.

Berapa lama pelajaran “Masa Hidup untuk Referensi yang Aman” 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

  1. Memahami Model Kepemilikan Rust
  2. Penjelasan tentang Referensi dan Peminjaman
  3. Masa Hidup untuk Referensi yang Aman
← Kembali ke Learn Rust Coding