BAB 13: Array
Array di Rust punya panjang yang menjadi bagian dari tipe, dicek batasnya saat diakses, dan bisa ditelusuri tanpa indeks manual.
Kompilator Rust menolak program yang menyalin [i32; 3] ke variabel bertipe [i32; 4], dan penolakan itu terjadi sebelum program dijalankan. Panjang array di Rust bukan keterangan tambahan yang disimpan di samping data, melainkan bagian dari tipe itu sendiri. Konsekuensinya terlihat di 3 tempat: deklarasi variabel, ukuran yang dipesan di memori, dan pemeriksaan batas saat elemen diakses.
Bab ini membahas array tetap: cara mendeklarasikannya, membaca panjangnya, mengubah isinya, dan menelusurinya. Setelah bab ini selesai, kamu dapat memilih array untuk data yang jumlahnya sudah pasti, membaca pesan kompilator saat panjangnya tidak cocok, dan menjelaskan mengapa indeks di luar batas menghentikan program. Semua contoh dikompilasi dengan rustc 1.100.0 di mesin ini dan keluarannya disalin dari program yang dijalankan.
Mendeklarasikan array dan membaca isinya
Array ditulis di dalam tanda kurung siku, dengan elemen dipisahkan koma. Panjangnya dihitung kompilator dari jumlah elemen yang ditulis.
fn main() {
let nilai = [70, 85, 90];
println!("isi {:?}", nilai);
println!("panjang {}", nilai.len());
println!("elemen pertama {}", nilai[0]);
println!("elemen terakhir {}", nilai[2]);
}
isi [70, 85, 90]
panjang 3
elemen pertama 70
elemen terakhir 90
Penanda :? dipakai karena array tidak punya bentuk cetak biasa seperti angka. Penanda itu memanggil trait Debug, yang mencetak isi array beserta tanda kurung sikunya. Tanpa :?, kompilator menolak dengan E0277:
fn main() {
let nilai = [70, 85, 90];
println!("isi {}", nilai);
}
error[E0277]: `[{integer}; 3]` doesn't implement `std::fmt::Display`
--> tanpa_debug.rs:3:24
|
3 | println!("isi {}", nilai);
| -- ^^^^^ `[{integer}; 3]` cannot be formatted with the default formatter
| |
| required by this formatting parameter
|
= help: the trait `std::fmt::Display` is not implemented for `[{integer}; 3]`
= note: in format strings you may be able to use `{:?}` (or `{:#?}` for pretty-print) instead
Perhatikan bahwa tipe yang disebut kompilator adalah [{integer}; 3], bukan [i32; 3]. Angka pada array itu belum dipaksa menjadi i32 karena tidak ada operasi yang menuntut tipe tertentu, dan kompilator hanya memberi tahu bahwa tipe apa pun yang dipilih tetap tidak punya bentuk Display.
Indeks dimulai dari 0, sehingga elemen terakhir pada array berisi 3 elemen berada di indeks 2. Hubungan itu yang membuat nilai[nilai.len() - 1] selalu menunjuk elemen terakhir, dan nilai[nilai.len()] selalu menunjuk satu posisi setelahnya.
Panjang array menjadi bagian dari tipe
Tipe lengkap array ditulis [T; N], dengan T tipe elemen dan N panjangnya. Rust Reference menuliskannya sebagai "An array is a fixed-size sequence of N elements of type T." Karena panjang ada di dalam tipe, 2 array dengan panjang berbeda adalah 2 tipe berbeda, dan kompilator menolak penyalinan di antara keduanya dengan E0308.
fn main() {
let a: [i32; 3] = [1, 2, 3];
let b: [i32; 4] = a;
println!("{:?}", b);
}
error[E0308]: mismatched types
--> salah_panjang.rs:3:23
|
3 | let b: [i32; 4] = a;
| -------- ^ expected an array with a size of 4, found one with a size of 3
| |
| expected due to this
|
help: consider specifying the actual array length
|
3 - let b: [i32; 4] = a;
3 + let b: [i32; 3] = a;
Pesan itu tidak menyebut nilai yang hilang atau elemen yang kurang, karena masalahnya bukan isi, melainkan tipe. Kalau data memang perlu berubah panjang, tipe yang dipakai adalah Vec, yang dibahas pada bab tersendiri. Array tetap dipakai saat jumlah elemen sudah diketahui dari awal, misalnya 7 nama hari atau 12 nilai bulanan.
Mengisi nilai awal dan mengubah elemen
Semua elemen bisa diisi nilai yang sama dengan bentuk [nilai; panjang]. Untuk mengubah satu elemen, array harus dideklarasikan mut dan elemennya ditunjuk lewat indeks.
fn main() {
let mut stok = [0; 4];
println!("awal {:?}", stok);
stok[1] = 12;
stok[3] = 5;
println!("akhir {:?}", stok);
println!("total {}", stok[0] + stok[1] + stok[2] + stok[3]);
}
awal [0, 0, 0, 0]
akhir [0, 12, 0, 5]
total 17
Bentuk [0; 4] disebut repeat expression di dokumentasi tipe array, dan hasilnya array berisi 4 angka 0. Tanpa mut, penulisan stok[1] = 12 ditolak dengan E0594:
fn main() {
let stok = [0; 4];
stok[1] = 12;
println!("{:?}", stok);
}
error[E0594]: cannot assign to `stok[_]`, as `stok` is not declared as mutable
--> tanpa_mut.rs:3:5
|
3 | stok[1] = 12;
| ^^^^^^^^^^^^ cannot assign
|
help: consider changing this to be mutable
|
2 | let mut stok = [0; 4];
| +++
Kompilator tidak hanya menolak, tetapi menunjukkan posisi penambahan mut. Perhatikan bedanya dengan E0384 pada bab variabel: E0384 muncul saat variabel ditimpa seluruhnya, sedangkan E0594 muncul saat yang diubah hanya sebagian, yaitu satu elemen di dalam array.
Rust Reference menambahkan satu jaminan yang penting untuk pemula: "All elements of arrays are always initialized". Tidak ada elemen yang berisi sampah memori seperti pada bahasa yang membiarkan variabel tanpa nilai awal. Elemen yang belum kamu isi tetap punya nilai, yaitu nilai dari deklarasi.
Ukuran array di memori
Karena panjangnya bagian dari tipe, kompilator tahu persis berapa byte yang dibutuhkan sebuah array. size_of menunjukkan angka itu, dan perbandingan dengan referensi memperlihatkan di mana datanya disimpan.
fn main() {
println!("[i32; 3] {}", std::mem::size_of::<[i32; 3]>());
println!("[u8; 3] {}", std::mem::size_of::<[u8; 3]>());
println!("&[i32; 3] {}", std::mem::size_of::<&[i32; 3]>());
println!("&[i32] {}", std::mem::size_of::<&[i32]>());
}
[i32; 3] 12
[u8; 3] 3
&[i32; 3] 8
&[i32] 16
Angka 12 berasal dari 3 elemen i32 yang masing-masing berukuran 4 byte, dan 3 berasal dari 3 elemen u8 yang masing-masing 1 byte. Array membawa datanya sendiri, sehingga ukurannya ikut membesar saat elemennya bertambah. Referensi ke array hanya menyimpan alamat, sehingga ukurannya tetap 8 byte pada mesin 64 bit. Referensi ke slice butuh 16 byte karena menyimpan alamat beserta panjangnya, dan bentuk itu dibahas di bab berikutnya.
The Rust Book menyebut array sebagai "a single chunk of memory of a known, fixed size that can be allocated on the stack". Kalimat itu menjelaskan akibat lain dari panjang yang tetap: ukuran yang sudah diketahui saat kompilasi memungkinkan seluruh isi array ditempatkan di satu blok memori.
Indeks di luar batas
Rust Reference menyatakan bahwa "access to an array is always bounds-checked in safe methods and operators". Pemeriksaan itu bekerja di 2 waktu yang berbeda, tergantung apakah indeksnya bisa diketahui kompilator.
Kalau indeksnya berupa angka tetap, kompilator menghitung sendiri bahwa posisi itu tidak ada, lalu menolak program dengan pesan this operation will panic at runtime.
fn main() {
let nilai = [70, 85, 90];
println!("elemen ke-4: {}", nilai[3]);
}
error: this operation will panic at runtime
--> salah_indeks_literal.rs:3:33
|
3 | println!("elemen ke-4: {}", nilai[3]);
| ^^^^^^^^ index out of bounds: the length is 3 but the index is 3
|
= note: `#[deny(unconditional_panic)]` on by default
Pesan itu bukan error tipe, melainkan penolakan atas operasi yang pasti gagal. Lint unconditional_panic aktif secara bawaan, sehingga program seperti ini tidak pernah sampai menjadi biner.
Kalau indeksnya baru diketahui saat program berjalan, kompilator tidak bisa menolak, dan pemeriksaan berpindah ke saat eksekusi. Kasus yang paling sering terjadi adalah perulangan yang berhenti satu langkah terlalu jauh.
fn main() {
let nilai = [70, 85, 90];
for posisi in 0..=nilai.len() {
println!("elemen {posisi}: {}", nilai[posisi]);
}
}
elemen 0: 70
elemen 1: 85
elemen 2: 90
thread 'main' (818806) panicked at salah_indeks_variabel.rs:5:41:
index out of bounds: the len is 3 but the index is 3
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Program mencetak 3 elemen dengan benar, lalu berhenti pada putaran keempat. Angka di dalam tanda kurung setelah main adalah identitas thread, dan nilainya berbeda di setiap penjalanan; pada penjalanan berikutnya di mesin ini angkanya menjadi 818940. Kode keluar program adalah 101, yang menandakan panic. Perbaikannya bukan menghapus pemeriksaan, melainkan mengubah rentangnya menjadi 0..nilai.len() tanpa tanda sama dengan, atau memakai for isi in nilai seperti pada bab sebelumnya.
Menelusuri array untuk total dan rata-rata
Pola yang paling sering dipakai pada array adalah menjumlahkan isinya. Perulangan for menyerahkan setiap elemen satu per satu, sehingga tidak ada indeks yang perlu dihitung.
fn main() {
let nilai = [70, 85, 90, 65];
let mut total = 0;
for isi in nilai {
total += isi;
}
let rata = total as f64 / nilai.len() as f64;
println!("total {total}");
println!("rata-rata {rata:.2}");
println!("a == b: {}", [1, 2, 3] == [1, 2, 3]);
println!("a == c: {}", [1, 2, 3] == [1, 2, 4]);
}
total 310
rata-rata 77.50
a == b: true
a == c: false
Rata-rata dihitung sebagai f64 karena pembagian bilangan bulat membuang pecahannya. Tanpa as f64, hasil 310 dibagi 4 akan menjadi 77, bukan 77.50. Penanda {rata:.2} mengatur 2 digit di belakang koma.
2 baris terakhir menunjukkan bahwa 2 array bisa dibandingkan langsung dengan ==. Perbandingan itu dilakukan elemen per elemen, dan hasilnya false begitu ada satu elemen yang berbeda. Kemampuan ini datang dari trait PartialEq yang sudah tersedia untuk array selama tipe elemennya juga mendukung perbandingan.
Array 2 dimensi
Array bisa berisi array lain, dan bentuk itu dipakai untuk data berbaris dan berkolom. Tipe [[i32; 3]; 2] berarti 2 baris, masing-masing berisi 3 angka.
fn main() {
let papan = [[1, 2, 3], [4, 5, 6]];
println!("baris {}", papan.len());
println!("kolom {}", papan[0].len());
println!("sel tengah {}", papan[1][1]);
for baris in papan {
println!("{:?}", baris);
}
}
baris 2
kolom 3
sel tengah 5
[1, 2, 3]
[4, 5, 6]
papan.len() menghasilkan 2 karena panjang array luar adalah jumlah baris. papan[0].len() menghasilkan 3 karena yang diambil adalah baris pertama, lalu panjang baris itu dibaca. Indeks ganda papan[1][1] membaca baris indeks 1 lalu kolom indeks 1, dan hasilnya 5 pada data di atas.
Bentuk 2 dimensi di Rust bukan matriks dengan baris yang bisa berbeda panjang. Setiap baris wajib bertipe sama, termasuk panjangnya, sehingga seluruh papan selalu berbentuk persegi panjang.
Elemen array harus bertipe sama
Satu array hanya boleh memuat satu tipe. Menulis angka dan teks dalam satu array ditolak dengan E0308, dan yang ditunjuk kompilator adalah elemen yang tipenya tidak sesuai dengan elemen pertama.
fn main() {
let data = [1, 2, "tiga"];
println!("{:?}", data);
}
error[E0308]: mismatched types
--> salah_tipe_elemen.rs:2:23
|
2 | let data = [1, 2, "tiga"];
| ^^^^^^ expected integer, found `&str`
error: aborting due to 1 previous error
Kompilator mengambil tipe dari elemen pertama, yaitu i32, lalu memeriksa elemen berikutnya terhadap tipe itu. Kalau data memang perlu memuat campuran, pilihannya adalah enum yang membungkus setiap kemungkinan tipe, dan enum dibahas pada bab tersendiri.
Latihan
- Tulis program yang menyimpan 5 suhu harian dalam array, lalu cetak suhu tertinggi dan terendah tanpa mengurutkan array.
- Ubah program rata-rata di bab ini agar mencetak jumlah nilai di atas 75 beserta indeksnya.
- Buat array 2 dimensi berukuran 3 baris dan 2 kolom, lalu cetak setiap barisnya dengan
{:?}.
Ringkasan
Array di Rust adalah deret elemen bertipe sama dengan panjang yang menjadi bagian dari tipe, sehingga [i32; 3] dan [i32; 4] tidak bisa saling ditukar. Panjang itu membuat ukurannya diketahui saat kompilasi: 12 byte untuk 3 elemen i32, sedangkan referensi ke array tetap 8 byte. Akses elemen selalu diperiksa batasnya, dan pemeriksaan itu bekerja dengan 2 cara: indeks tetap ditolak kompilator lewat lint unconditional_panic, sedangkan indeks yang baru diketahui saat berjalan menghentikan program dengan panic dan kode keluar 101. Array bisa dibandingkan langsung dengan ==, dan bentuk 2 dimensi dibuat dari array yang berisi array.
Referensi
- The Rust Programming Language. Data Types.
- The Rust Reference. Array types.
- Rust Standard Library. Primitive Type array.