Tipe Data & Koleksi

BAB 14: Slice (Basic)

Slice di Rust meminjam sebagian array tanpa menyalin, sehingga 1 fungsi bisa menerima array berbagai panjang dan batasnya diperiksa saat berjalan.

Fungsi rata-rata yang ditulis untuk array berisi 3 nilai tidak bisa dipakai pada array berisi 6 nilai, karena panjang array adalah bagian dari tipenya. Menyalin fungsi itu untuk setiap panjang berarti menulis kode yang sama berulang kali. Rust menyelesaikan masalah ini dengan slice: tipe [T] yang menunjuk sebagian elemen pada koleksi, tanpa memiliki data itu sendiri.

Bab ini membahas cara memotong array menjadi slice, menulis fungsi yang menerima slice, dan membaca isinya dengan aman lewat first dan last. Setelah bab ini selesai, kamu dapat menulis 1 fungsi untuk data berbagai panjang, mengubah sebagian isi array lewat slice, dan menjelaskan mengapa batas slice baru diperiksa saat program berjalan. Semua contoh dikompilasi dengan rustc 1.100.0 di mesin ini dan keluarannya disalin dari program yang dijalankan.

Memotong array dengan rentang

Slice dibuat dengan menulis rentang di dalam tanda kurung siku, lalu mengambil referensinya dengan &. Rentang 1..4 berarti mulai indeks 1 sampai sebelum indeks 4.

RSRUST
fn main() {
    let nilai = [70, 85, 90, 65, 100];
    let tengah = &nilai[1..4];

    println!("{:?}", tengah);
    println!("panjang {}", tengah.len());
    println!("elemen pertama {}", tengah[0]);
    println!("sumber tetap {:?}", nilai);
}
CodeTEXT
[85, 90, 65]
panjang 3
elemen pertama 85
sumber tetap [70, 85, 90, 65, 100]

Hasil potongan berisi 3 elemen, yaitu indeks 1, 2, dan 3 pada array asal. Indeks 4 tidak ikut, sama seperti batas kanan pada rentang for. Baris terakhir menunjukkan bahwa array asal tidak berubah, karena slice hanya menunjuk elemen yang sudah ada di sana.

Elemen slice juga dihitung mulai dari 0, dan penomoran itu dimulai ulang dari awal potongan. tengah[0] berisi 85, bukan 70, karena 85 adalah elemen pertama di dalam potongan.

Bentuk penulisan rentang

Rentang pada slice punya beberapa bentuk singkat. Batas yang dihilangkan diisi otomatis dengan awal atau akhir data.

RSRUST
fn main() {
    let nilai = [70, 85, 90, 65, 100];

    println!("awal {:?}", &nilai[..2]);
    println!("akhir {:?}", &nilai[3..]);
    println!("semua {:?}", &nilai[..]);
    println!("kosong {:?}", &nilai[2..2]);
    println!("panjang kosong {}", nilai[2..2].len());
}
CodeTEXT
awal [70, 85]
akhir [65, 100]
semua [70, 85, 90, 65, 100]
kosong []
panjang kosong 0

Bentuk ..2 mengambil dari awal sampai sebelum indeks 2, sedangkan 3.. mengambil dari indeks 3 sampai akhir. Bentuk .. mengambil seluruh isi array, dan bentuk 2..2 menghasilkan slice kosong dengan panjang 0 tanpa pesan error.

Slice kosong tetap sah karena batas kiri dan batas kanannya sama, sehingga tidak ada elemen yang diambil. Kesalahan baru muncul saat batasnya melewati panjang data, dan kasus itu dibahas pada bagian tentang panic di bawah.

1 fungsi untuk banyak panjang

Masalah utama array muncul saat fungsi harus menerima data dengan panjang berbeda. Program berikut mendefinisikan fungsi yang menerima &[i32; 3], lalu memanggilnya dengan array berisi 6 elemen.

RSRUST
fn rata_rata(data: &[i32; 3]) -> f64 {
    let mut total = 0;

    for isi in data {
        total += isi;
    }

    total as f64 / data.len() as f64
}

fn main() {
    let bulanan = [60, 75, 80, 95, 100, 65];
    println!("{:.2}", rata_rata(&bulanan));
}
CodeTEXT
error[E0308]: mismatched types
  --> salah_tipe_fungsi.rs:13:33
   |
13 |     println!("{:.2}", rata_rata(&bulanan));
   |                       --------- ^^^^^^^^ expected an array with a size of 3, found one with a size of 6
   |                       |
   |                       arguments to this function are incorrect
   |
note: function defined here
  --> salah_tipe_fungsi.rs:1:4
   |
 1 | fn rata_rata(data: &[i32; 3]) -> f64 {
   |    ^^^^^^^^^ ---------------

Pesan itu menyebut panjang 3 dan 6 sebagai bagian dari tipe, bukan sebagai nilai yang bisa disesuaikan. Solusinya adalah mengganti tipe parameter menjadi slice &[i32], yang tidak membawa panjang di dalam tipenya.

RSRUST
fn rata_rata(data: &[i32]) -> f64 {
    let mut total = 0;

    for isi in data {
        total += isi;
    }

    total as f64 / data.len() as f64
}

fn main() {
    let harian = [70, 85, 90];
    let bulanan = [60, 75, 80, 95, 100, 65];

    println!("harian {:.2}", rata_rata(&harian));
    println!("bulanan {:.2}", rata_rata(&bulanan));
    println!("3 hari pertama {:.2}", rata_rata(&bulanan[..3]));
}
CodeTEXT
harian 81.67
bulanan 79.17
3 hari pertama 71.67

Satu fungsi itu melayani 3 pemanggilan dengan panjang 3, 6, dan 3 dari potongan array. Referensi ke array bisa diberikan langsung ke parameter bertipe slice, karena Rust mengubahnya otomatis menjadi slice yang menunjuk seluruh isi array. Kemampuan itu yang membuat rata_rata(&harian) sah tanpa penulisan rentang.

Angka 71.67 berasal dari 3 elemen pertama array bulanan, yaitu 60, 75, dan 80. Pemanggilan ketiga menunjukkan bahwa slice tidak harus menunjuk dari awal data.

Slice adalah referensi, bukan salinan

The Rust Book menjelaskan slice dengan kalimat "A slice is a kind of reference, so it does not have ownership", dan Rust Reference menyebutnya "a dynamically sized type representing a 'view' into a sequence of elements". Kedua kalimat itu menjelaskan perilaku yang terlihat pada program pertama: array asal tetap utuh, karena tidak ada data yang disalin.

Akibat lain dari sifat itu ada pada ukuran. Dokumentasi tipe slice menyebut slice sebagai "a view into a block of memory represented as a pointer and a length", dan menyatakan bahwa slice berukuran 2 kali ukuran pointer. Pada bab array sudah diukur bahwa &[i32] berukuran 16 byte sementara &[i32; 3] berukuran 8 byte. Tambahan 8 byte itu adalah panjang slice, dan itulah sebabnya slice tahu di mana harus berhenti walau tidak membawa datanya sendiri.

Mengubah sebagian isi lewat slice

Slice bisa dipakai untuk mengubah data asal, asalkan sumbernya dideklarasikan mut dan slice-nya berupa referensi yang bisa diubah. Program berikut menaikkan 2 elemen di tengah array saja.

RSRUST
fn naikkan(data: &mut [i32], tambah: i32) {
    for isi in data.iter_mut() {
        *isi += tambah;
    }
}

fn main() {
    let mut nilai = [70, 85, 90, 65];

    naikkan(&mut nilai[1..3], 5);

    println!("{:?}", nilai);
}
CodeTEXT
[70, 90, 95, 65]

Hanya elemen indeks 1 dan 2 yang berubah, karena rentang 1..3 berhenti sebelum indeks 3. Fungsi naikkan menerima &mut [i32] sehingga bisa menulis ke elemen yang ditunjuk, dan perubahan itu terlihat pada array asal setelah fungsi selesai.

Bentuk ini berguna saat hanya sebagian data yang perlu diperbarui, misalnya menaikkan nilai 2 pelajaran tanpa menyentuh pelajaran lain. Kalau seluruh array perlu diubah, pemanggil cukup menulis &mut nilai tanpa rentang.

first dan last mengembalikan Option

Mengambil elemen pertama dengan data[0] berbahaya pada slice yang mungkin kosong, karena indeks 0 tidak selalu ada. Untuk kasus itu slice menyediakan first dan last, yang mengembalikan Option sehingga ketiadaan elemen bisa ditangani tanpa panic.

RSRUST
fn main() {
    let nilai = [70, 85, 90];

    println!("pertama {:?}", nilai.first());
    println!("terakhir {:?}", nilai.last());
    println!("get indeks 1: {:?}", nilai.get(1));
    println!("get indeks 9: {:?}", nilai.get(9));

    let kosong: &[i32] = &[];
    println!("kosong pertama {:?}", kosong.first());
    println!("nilai default {}", kosong.first().copied().unwrap_or(0));
}
CodeTEXT
pertama Some(70)
terakhir Some(90)
get indeks 1: Some(85)
get indeks 9: None
kosong pertama None
nilai default 0

Some(70) berarti elemennya ada, sedangkan None berarti posisi itu tidak ada. Baris get menunjukkan cara yang sama bekerja untuk indeks di tengah: indeks 1 menghasilkan Some(85), sedangkan indeks 9 menghasilkan None tanpa panic. Pemanggilan copied() mengubah Option<&i32> menjadi Option<i32>, lalu unwrap_or(0) memberi nilai pengganti saat hasilnya None. Rangkaian itu membuat program tetap berjalan pada data kosong, dan nilai 0 di sini adalah keputusan pemrogram, bukan nilai bawaan Rust.

Batas yang salah baru ketahuan saat berjalan

Berbeda dengan indeks array yang berupa angka tetap, potongan dengan batas tetap tidak ditolak kompilator. Program berikut lolos kompilasi, lalu berhenti saat dijalankan.

RSRUST
fn main() {
    let nilai = [70, 85, 90];

    let potong = &nilai[1..5];

    println!("{:?}", potong);
}
CodeTEXT
thread 'main' (825396) panicked at salah_potong.rs:4:24:
range end index 5 out of range for slice of length 3
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Kompilasi program itu selesai dengan kode keluar 0, dan panic baru terjadi saat biner dijalankan dengan kode keluar 101. Pesannya menyebut batas yang diminta dan panjang data yang tersedia, yaitu 5 dan 3.

Perbedaan ini perlu diingat karena tampak tidak konsisten: nilai[3] pada array ditolak saat kompilasi lewat lint unconditional_panic, sedangkan &nilai[1..5] tidak. Pemeriksaan batas slice dilakukan di dalam kode yang dihasilkan, dan lint itu hanya mencakup pengindeksan, bukan pembentukan rentang. Pada kedua kasus hasil akhirnya sama: program tidak boleh membaca data di luar batas.

Untuk data yang batasnya baru diketahui saat berjalan, satu-satunya cara aman adalah memeriksa lebih dulu. Bentuk yang dipakai adalah get, yang mengembalikan Option seperti first, sehingga batas yang salah menghasilkan None dan bukan panic.

Slice tidak bisa diubah saat masih dipinjam

Slice meminjam elemen dari array, dan aturan peminjaman tetap berlaku selama slice itu dipakai. Menulis ke array ketika slice masih hidup ditolak dengan E0506.

RSRUST
fn main() {
    let mut nilai = [70, 85, 90];

    let potong = &nilai[1..3];
    nilai[0] = 10;

    println!("{:?}", potong);
}
CodeTEXT
error[E0506]: cannot assign to `nilai[_]` because it is borrowed
 --> salah_pinjam.rs:5:5
  |
4 |     let potong = &nilai[1..3];
  |                   ----- `nilai[_]` is borrowed here
5 |     nilai[0] = 10;
  |     ^^^^^^^^^^^^^ `nilai[_]` is assigned to here but it was already borrowed
6 |
7 |     println!("{:?}", potong);
  |                      ------ borrow later used here

Kompilator menunjukkan 3 posisi sekaligus: tempat peminjaman, tempat penulisan, dan tempat pinjaman itu masih dipakai. Perbaikannya adalah menyelesaikan pemakaian slice lebih dulu, atau membatasi pinjaman pada rentang yang tidak ditulis. Pada contoh di atas, indeks 0 sebenarnya tidak termasuk dalam potongan, tetapi aturan Rust melarangnya karena pinjaman dianggap mencakup seluruh array.

Perhatikan juga peringatan yang menyertainya, yaitu value assigned to nilai is never read. Peringatan itu muncul karena penulisan ke indeks 0 tidak pernah terbaca sebelum program berhenti pada error. Peringatan seperti ini tidak menggagalkan kompilasi, tetapi menandakan ada baris yang maksudnya tidak tercapai.

Latihan

  1. Tulis fungsi yang menerima &[i32] dan mengembalikan jumlah semua elemen, lalu panggil dengan array berisi 3 nilai dan potongan berisi 2 nilai.
  2. Ubah contoh naikkan agar hanya menaikkan elemen pertama dan terakhir, lalu cetak hasilnya.
  3. Tulis program yang mengambil nama bulan ke-3 sampai ke-5 dari array 12 bulan memakai slice, lalu cetak isinya.

Ringkasan

Slice menunjuk sebagian elemen pada array tanpa memiliki datanya, sehingga array asal tetap utuh dan tidak ada penyalinan. Tipe &[i32] dipakai pada parameter fungsi supaya 1 fungsi bisa menerima data berbagai panjang, sementara &mut [i32] memungkinkan perubahan pada sebagian isi. Bentuk rentang ..2, 3.., dan .. mempersingkat penulisan batas, dan first serta last mengembalikan Option sehingga data kosong bisa ditangani tanpa panic. Batas slice yang salah tidak ditolak kompilator: program tetap dikompilasi dengan kode keluar 0, lalu berhenti dengan panic dan kode keluar 101 saat dijalankan, berbeda dari pengindeksan array dengan angka tetap yang ditolak lebih awal.

Referensi

  1. The Rust Programming Language. The Slice Type.
  2. The Rust Reference. Slice types.
  3. Rust Standard Library. Primitive Type slice.