Borrowing & References di Rust

Daripada memindahkan ownership, kita bisa meminjam (borrow) value menggunakan references. Ini adalah cara paling umum untuk melewatkan data tanpa kehilangan ownership.

Immutable Reference (&)

fn hitung_panjang(s: &String) -> usize {
    s.len()
}  // s keluar scope, tapi karena tidak punya ownership, tidak terjadi drop

fn main() {
    let nama = String::from("Budi");
    let panjang = hitung_panjang(&nama);  // pinjam dengan &
    println!("{} panjangnya {}", nama, panjang);  // nama masih valid!
}

Mutable Reference (&mut)

fn tambah_sapaan(s: &mut String) {
    s.push_str(", selamat datang!");
}

fn main() {
    let mut pesan = String::from("Halo");
    tambah_sapaan(&mut pesan);
    println!("{}", pesan);  // "Halo, selamat datang!"
}

Aturan Borrowing

Pada satu waktu, kamu hanya boleh punya salah satu dari:

1. Satu mutable reference (&mut T), ATAU
2. Banyak immutable references (&T)

let mut s = String::from("hello");

let r1 = &s;     // OK
let r2 = &s;     // OK — multiple immutable refs
// let r3 = &mut s; // ERROR! tidak boleh mutable ref saat ada immutable ref

println!("{} {}", r1, r2);  // r1 dan r2 selesai digunakan di sini

let r3 = &mut s;  // OK — karena r1 dan r2 sudah tidak dipakai
r3.push_str(" world");
println!("{}", r3);

Dangling References — Dicegah oleh Compiler

// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s  // ERROR! s akan di-drop, reference menjadi dangling
// }

// Solusi: kembalikan owned value
fn no_dangle() -> String {
    let s = String::from("hello");
    s  // ownership berpindah ke caller
}

Slice — Borrowed View

let s = String::from("hello world");
let hello: &str = &s[0..5];   // "hello"
let world: &str = &s[6..11];  // "world"

let angka = [1, 2, 3, 4, 5];
let slice: &[i32] = &angka[1..3];  // [2, 3]