Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Tipe Slice

Slices memungkinkan kamu mereferensikan urutan elemen yang berurutan di dalam sebuah collection. Slice adalah sejenis reference, sehingga tidak memiliki ownership.

Berikut sebuah masalah pemrograman kecil: tulis sebuah fungsi yang menerima string berisi kata-kata yang dipisahkan spasi dan mengembalikan kata pertama yang ditemukannya dalam string itu. Jika fungsi tidak menemukan spasi dalam string, berarti seluruh string itu adalah satu kata, jadi seluruh string harus dikembalikan.

Catatan: Untuk keperluan pengenalan slice, kita berasumsi hanya ASCII di bagian ini; pembahasan lebih menyeluruh tentang penanganan UTF-8 ada di bagian “Menyimpan Teks Berkode UTF-8 dengan String” di Bab 8.

Mari kita telusuri bagaimana menulis tanda tangan fungsi ini tanpa menggunakan slice, agar kamu memahami masalah yang akan diselesaikan oleh slice:

fn first_word(s: &String) -> ?

Fungsi first_word memiliki parameter bertipe &String. Kita tidak memerlukan ownership, jadi itu tidak masalah. (Dalam Rust yang idiomatic, fungsi tidak mengambil ownership dari argumennya kecuali memang perlu, dan alasannya akan jelas seiring kita melanjutkan.) Tapi apa yang harus kita kembalikan? Kita sebenarnya tidak punya cara untuk membahas sebagian dari sebuah string. Namun, kita bisa mengembalikan indeks akhir kata yang ditandai sebuah spasi. Mari kita coba cara itu, seperti yang ditunjukkan Listing 4-7.

Filename: src/main.rs
fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}
Listing 4-7: Fungsi first_word yang mengembalikan nilai indeks byte ke dalam parameter String

Karena kita perlu menelusuri String elemen per elemen dan memeriksa apakah sebuah nilai adalah spasi, kita akan mengubah String menjadi array byte dengan metode as_bytes.

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Selanjutnya, kita membuat iterator di atas array byte dengan metode iter:

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Kita akan membahas iterator lebih detail di Bab 13. Untuk sekarang, ketahuilah bahwa iter adalah metode yang mengembalikan setiap elemen dalam sebuah collection, dan enumerate membungkus hasil dari iter sehingga mengembalikan setiap elemen sebagai bagian dari sebuah tuple. Elemen pertama tuple yang dikembalikan enumerate adalah indeks, dan elemen kedua adalah reference ke elemen tersebut. Ini sedikit lebih nyaman daripada menghitung indeksnya sendiri.

Karena metode enumerate mengembalikan tuple, kita bisa menggunakan pattern untuk mendestrukturisasi tuple itu. Kita akan membahas pattern lebih lanjut di Bab 6. Di dalam loop for, kita menentukan pattern yang memiliki i untuk indeks dalam tuple dan &item untuk byte tunggal dalam tuple. Karena kita mendapatkan reference ke elemen dari .iter().enumerate(), kita menggunakan & dalam pattern tersebut.

Di dalam loop for, kita mencari byte yang mewakili spasi dengan menggunakan sintaks literal byte. Jika kita menemukan sebuah spasi, kita mengembalikan posisinya. Kalau tidak, kita mengembalikan panjang string dengan menggunakan s.len().

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Sekarang kita punya cara untuk mengetahui indeks akhir kata pertama dalam string, tapi ada masalah. Kita mengembalikan sebuah usize yang berdiri sendiri, dan angka itu hanya bermakna dalam konteks &String. Dengan kata lain, karena merupakan nilai terpisah dari String, tidak ada jaminan angka itu masih valid di kemudian hari. Perhatikan program di Listing 4-8 yang menggunakan fungsi first_word dari Listing 4-7.

Filename: src/main.rs
fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s); // word will get the value 5

    s.clear(); // this empties the String, making it equal to ""

    // word still has the value 5 here, but s no longer has any content that we
    // could meaningfully use with the value 5, so word is now totally invalid!
}
Listing 4-8: Menyimpan hasil pemanggilan fungsi first_word lalu mengubah isi String

Program ini terkomilasi tanpa error apa pun, dan tetap begitu juga jika kita menggunakan word setelah memanggil s.clear(). Karena word sama sekali tidak terhubung dengan keadaan s, word masih berisi nilai 5. Kita bisa menggunakan nilai 5 itu bersama variabel s untuk mencoba mengekstrak kata pertama, tapi itu akan menjadi bug karena isi s sudah berubah sejak kita menyimpan 5 di word.

Khawatir indeks di word keluar sinkron dengan data di s itu melelahkan dan rawan error! Mengelola indeks-indeks ini jadi semakin rapuh jika kita menulis fungsi second_word. Tanda tangannya akan terlihat seperti ini:

fn second_word(s: &String) -> (usize, usize) {

Sekarang kita melacak indeks awal dan indeks akhir, dan kita punya semakin banyak nilai yang dihitung dari data pada keadaan tertentu tapi sama sekali tidak terikat dengan keadaan itu. Kita punya tiga variabel yang tidak saling terkait melayang-layang dan harus dijaga kesinkronannya.

Untungnya, Rust punya solusi untuk masalah ini: string slice.

String Slice

Sebuah string slice adalah reference ke urutan elemen yang berurutan dari sebuah String, dan tampilannya seperti ini:

fn main() {
    let s = String::from("hello world");

    let hello = &s[0..5];
    let world = &s[6..11];
}

Alih-alih sebuah reference ke seluruh String, hello adalah reference ke sebagian String, yang ditentukan oleh bagian tambahan [0..5]. Kita membuat slice dengan cara menentukan rentang di dalam kurung siku berupa [starting_index..ending_index], di mana starting_index adalah posisi pertama dalam slice dan ending_index adalah satu lebih dari posisi terakhir dalam slice. Secara internal, struktur data slice menyimpan posisi awal dan panjang slice, yang sesuai dengan ending_index dikurangi starting_index. Jadi, pada kasus let world = &s[6..11];, world akan menjadi slice yang berisi pointer ke byte pada indeks 6 dari s dengan nilai panjang 5.

Gambar 4-7 menunjukkan ini dalam sebuah diagram.

Tiga tabel: sebuah tabel yang mewakili data stack dari s, yang
menunjuk ke byte pada indeks 0 dalam tabel data string "hello world"
di heap. Tabel ketiga mewakili data stack dari slice world, yang memiliki nilai
panjang 5 dan menunjuk ke byte 6 dari tabel data heap.

Gambar 4-7: Sebuah string slice yang merujuk ke sebagian String

Dengan sintaks rentang .. milik Rust, jika kamu ingin mulai dari indeks 0, kamu bisa menghilangkan nilai sebelum dua titik. Dengan kata lain, ini setara:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let slice = &s[0..2];
let slice = &s[..2];
}

Dengan cara yang sama, jika slice kamu menyertakan byte terakhir dari String, kamu bisa menghilangkan angka di bagian akhir. Artinya ini setara:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[3..len];
let slice = &s[3..];
}

Kamu juga bisa menghilangkan kedua nilai untuk mengambil slice dari seluruh string. Jadi, ini setara:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[0..len];
let slice = &s[..];
}

Catatan: Indeks rentang string slice harus berada pada batas karakter UTF-8 yang valid. Jika kamu mencoba membuat string slice di tengah sebuah karakter multibyte, program kamu akan berhenti dengan error.

Dengan semua informasi ini, mari kita tulis ulang first_word agar mengembalikan sebuah slice. Tipe yang menandai “string slice” ditulis sebagai &str:

Filename: src/main.rs
fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {}

Kita mendapatkan indeks akhir kata dengan cara yang sama seperti di Listing 4-7, yaitu dengan mencari kemunculan pertama sebuah spasi. Ketika kita menemukan sebuah spasi, kita mengembalikan sebuah string slice dengan menggunakan awal string dan indeks spasi tersebut sebagai indeks awal dan indeks akhir.

Sekarang saat kita memanggil first_word, kita mendapatkan kembali satu nilai yang terikat pada data di bawahnya. Nilai itu tersusun dari sebuah reference ke titik awal slice dan jumlah elemen dalam slice.

Mengembalikan sebuah slice juga akan berfungsi untuk fungsi second_word:

fn second_word(s: &String) -> &str {

Sekarang kita punya sebuah API yang lugas dan jauh lebih sulit disalahgunakan, karena compiler akan memastikan reference ke dalam String tetap valid. Ingat bug pada program di Listing 4-8, saat kita mendapatkan indeks akhir kata pertama lalu mengosongkan string sehingga indeks kita jadi tidak valid? Kode itu secara logika salah, tapi tidak menunjukkan error apa pun secara langsung. Masalahnya baru muncul nanti jika kita terus mencoba menggunakan indeks kata pertama pada string yang sudah dikosongkan. Slice membuat bug semacam itu mustahil terjadi dan memberi tahu kita jauh lebih cepat bahwa ada masalah pada kode kita. Menggunakan versi slice dari first_word akan memunculkan error waktu kompilasi:

Filename: src/main.rs
fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // error!

    println!("the first word is: {word}");
}

Inilah error dari compiler:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
  --> src/main.rs:18:5
   |
16 |     let word = first_word(&s);
   |                           -- immutable borrow occurs here
17 |
18 |     s.clear(); // error!
   |     ^^^^^^^^^ mutable borrow occurs here
19 |
20 |     println!("the first word is: {word}");
   |                                   ---- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Ingat aturan borrowing: jika kita punya sebuah reference immutable ke sesuatu, kita tidak bisa sekaligus mengambil reference mutable. Karena clear perlu memotong String, ia perlu mendapatkan reference mutable. println! setelah pemanggilan clear menggunakan reference di word, jadi reference immutable itu harus masih aktif pada titik tersebut. Rust melarang reference mutable di clear dan reference immutable di word eksis pada saat yang sama, sehingga kompilasi gagal. Tidak hanya Rust membuat API kita lebih mudah digunakan, tapi juga menghilangkan seluruh kelas error pada waktu kompilasi!

Literal String sebagai Slice

Ingat bahwa kita pernah membahas literal string yang disimpan di dalam binary. Sekarang setelah kamu mengenal slice, kita bisa memahami literal string dengan benar:

#![allow(unused)]
fn main() {
let s = "Hello, world!";
}

Tipe s di sini adalah &str: sebuah slice yang menunjuk ke titik spesifik dalam binary tersebut. Inilah juga alasan literal string itu immutable; &str adalah sebuah reference immutable.

String Slice sebagai Parameter

Mengetahui bahwa kamu bisa mengambil slice dari literal dan nilai String membawa kita ke satu penyempurnaan lagi untuk first_word, yaitu tanda tangannya:

fn first_word(s: &String) -> &str {

Rustacean yang lebih berpengalaman akan menulis tanda tangan di Listing 4-9 sebagai gantinya, karena tanda tangan itu memungkinkan kita menggunakan fungsi yang sama baik pada nilai &String maupun &str.

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` works on slices of `String`s, whether partial or whole.
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` also works on references to `String`s, which are equivalent
    // to whole slices of `String`s.
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` works on slices of string literals, whether partial or
    // whole.
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}
Listing 4-9: Menyempurnakan fungsi first_word dengan menggunakan string slice sebagai tipe parameter s

Jika kita punya sebuah string slice, kita bisa meneruskannya langsung. Jika kita punya sebuah String, kita bisa meneruskan sebuah slice dari String atau sebuah reference ke String. Fleksibilitas ini memanfaatkan deref coercions, sebuah fitur yang akan kita bahas di bagian “Menggunakan Deref Coercions dalam Fungsi dan Metode” di Bab 15.

Mendefinisikan sebuah fungsi yang menerima string slice alih-alih sebuah reference ke String membuat API kita lebih umum dan berguna tanpa kehilangan fungsi apa pun:

Filename: src/main.rs
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` works on slices of `String`s, whether partial or whole.
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` also works on references to `String`s, which are equivalent
    // to whole slices of `String`s.
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` works on slices of string literals, whether partial or
    // whole.
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // Because string literals *are* string slices already,
    // this works too, without the slice syntax!
    let word = first_word(my_string_literal);
}

Slice Lainnya

String slice, seperti yang bisa kamu bayangkan, spesifik untuk string. Tapi ada tipe slice yang lebih umum. Perhatikan array ini:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];
}

Sama seperti kita mungkin ingin merujuk ke sebagian sebuah string, kita juga mungkin ingin merujuk ke sebagian sebuah array. Caranya seperti ini:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];

assert_eq!(slice, &[2, 3]);
}

Slice ini bertipe &[i32]. Cara kerjanya sama dengan string slice, yaitu menyimpan sebuah reference ke elemen pertama beserta sebuah panjang. Kamu akan menggunakan slice semacam ini untuk berbagai collection lain. Kita akan membahas collection ini secara detail saat membahas vector di Bab 8.

Ringkasan

Konsep ownership, borrowing, dan slice menjamin keamanan memori dalam program Rust pada waktu kompilasi. Bahasa Rust memberi kamu kendali atas penggunaan memori dengan cara yang sama seperti bahasa pemrograman sistem lainnya. Tapi dengan adanya pemilik data yang secara otomatis membersihkan data tersebut saat pemilik keluar dari scope, kamu tidak perlu menulis dan men-debug kode ekstra untuk mendapatkan kendali itu.

Ownership memengaruhi banyak bagian lain dari cara kerja Rust, jadi kita akan membahas konsep-konsep ini sepanjang sisa buku ini. Mari kita lanjut ke Bab 5 dan melihat cara mengelompokkan potongan data di dalam sebuah struct.