Rust Ownership

Ownership adalah strategi yang dilakukan Rust dalam manage data di memory. Berikut hal penting mengenai ownership

• Setiap data memiliki satu owner,
• Owner tersebut bertanggung jawab untuk melakukan clean up data pada memory.
• Cleanup terjadi ketika owner out of scope.
• Owner akan menentukan mutability suatu data.

Moving ownership dalam konteks variable

Misalnya, kita definisikan variable s berisi string Hello.

let s = String::from("Hello");

Ownership saat ini ada di s.

Jika kita assign nilai s ke variable t, maka ownership akan berpindah ke t.

let t = s;

Moving Ownership dalam konteks function.

Misalnya ada function say seperti dibawah.

fn say(s: String){
  println!("Say, {}", s);
}

fn main(){
  let a = String::from("hello");
  say(a);
}

Saat fungsi say(a) dipanggil dari main(), ownership a, akan berpindah ke function say.

Anda dapat lakukan test, dengan mencoba mengakses lagi variable a. Akan terjadi error.

fn say(s: String){
  println!("Say, {}", s);
}

fn main(){
  let a = String::from("hello");
  say(a);
  //akan terjadi error, karena ownership sudah berpindah ke fungsi say.
  println!("Using a again {}", a);
}

Cloning Data

Jika program membutuhkan, kita dapat melakukan deep copy dengan method clone.

fn say(s: String){
  println!("Say, {}", s);
}

fn main(){
  let a = String::from("hello");
  say(a.clone());
  println!("Using a again {}", a);
}

Dengan melakukan cloning, ownership akan ditransfer ke function say. Cleanup akan dilakukan setelah function say selesai dijalankan.

Sementara variable a original, bisa digunakan karena, yang ownership yang ditransfer adalah hasil clone. Cleanup akan dilakukan setelah a out of scope, yaitu akhir dari main() function.

Data Cleanup pada Bahasa Pemograman lain

Perbandingan dengan C, digunakan perintah malloc dan free untuk melakukan alokasi dan cleanup. Kelemahan dari pendekatan diatas, dapat terjadi error: use after free, memory leaks, double free.

Perbandingan dengan Ruby, menggunakan garbage collector. Keuntungannya adalah sebagai programmer, tidak perlu melakukan memory management. Kekurangannya adalah kurangnya control dan penurunan performa program, karena garbage collector akan live dalam memory untuk melakukan fungsinya.

Latihan Soal Ownership

fn main(){

    let s = String::from("book");

    //tambahkan code disini agar program berjalan
    //menampilkan tulisan I have one book, you have two books, dengan menggunakan function pluralize.


    println!(
        "I have one {}, you have two {}", 
        s,
        //tambahkan code disini,
    );
}

fn pluralize(singular: String)-> String{
     singular + "s"
}

Solusi Clone Ownership

fn main(){

    let s = String::from("book");

    let pluralbook = pluralize(s.clone());

    println!(
        "I have one {}, you have two {}", 
        s,
        pluralbook,
    );
}

fn pluralize(singular: String)-> String{
     singular + "s"
}

Borrowing Ownership

Solusi kedua adalah dengan cara borrowing ownership. Pendekatan ini mirip pointer pada bahasa pemograman lain.

Borrowing dapat diumpamakan dengan meminjamkan value dari suatu variable. Tidak ada ownership transfer yang terjadi.

Solusi Borrowing Ownership

Perhatikan, saat function pluralize dipanggil data yang dipassing menggunakan tanda &.

Function pluralize juga perlu kita modifikasi agar menerima parameter string slice.

fn main(){

    let s = String::from("book");

    //pendekatan borrowing ownership
    let pluralbook = pluralize(&s);

    println!(
        "I have one {}, you have two {}", 
        s,
        pluralbook,
    );
}

fn pluralize(singular: &str)-> String{
     singular.to_owned() + "s"
}

Kesimpulan

Pendekatan borrowing lebih disarankan karena mengurangi alokasi memory, dimana akan mempengaruhi performa aplikasi yang kita buat.