Tipe Data
Setiap nilai di Rust memiliki suatu tipe data tertentu. Tipe itu memberi tahu Rust jenis data apa yang sedang kamu tentukan, sehingga Rust tahu cara bekerja dengan data tersebut. Kita akan melihat dua kelompok tipe data: skalar dan komposit.
Perlu diingat bahwa Rust adalah bahasa yang bertipe statis, artinya Rust
harus mengetahui tipe semua variabel pada waktu kompilasi. Biasanya compiler
bisa menyimpulkan tipe yang ingin kita pakai berdasarkan nilai dan cara kita
menggunakannya. Pada kasus di mana banyak tipe yang mungkin—seperti ketika kita
mengonversi String ke tipe numerik menggunakan parse di bagian
“Membandingkan Tebakannya dengan Angka
Rahasia” di Bab 2—kita
harus menambahkan anotasi tipe, seperti ini:
#![allow(unused)]
fn main() {
let guess: u32 = "42".parse().expect("Not a number!");
}
Jika kita tidak menambahkan anotasi tipe : u32 seperti pada kode sebelumnya,
Rust akan menampilkan error berikut, yang berarti compiler butuh informasi
lebih dari kita untuk mengetahui tipe mana yang ingin kita pakai:
$ cargo build
Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0284]: type annotations needed
--> src/main.rs:2:9
|
2 | let guess = "42".parse().expect("Not a number!");
| ^^^^^ ----- type must be known at this point
|
= note: cannot satisfy `<_ as FromStr>::Err == _`
= note: the type must also implement `FromStr`
note: required by a bound in `core::str::<impl str>::parse`
--> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/str/mod.rs:2782:4
help: consider giving `guess` an explicit type
|
2 | let guess: /* Type */ = "42".parse().expect("Not a number!");
| ++++++++++++
For more information about this error, try `rustc --explain E0284`.
error: could not compile `no_type_annotations` (bin "no_type_annotations") due to 1 previous error
Kamu akan melihat anotasi tipe yang berbeda untuk tipe data lainnya.
Tipe Skalar
Tipe skalar merepresentasikan satu nilai. Rust punya empat tipe skalar utama: bilangan bulat, bilangan floating-point, Boolean, dan karakter. Mungkin kamu mengenalnya dari bahasa pemrograman lain. Mari kita bahas cara kerjanya di Rust.
Tipe Bilangan Bulat
Bilangan bulat adalah angka tanpa komponen pecahan. Kita sudah memakai satu
tipe bilangan bulat di Bab 2, yaitu tipe u32. Deklarasi tipe ini menunjukkan
bahwa nilai yang terkait dengannya harus berupa bilangan bulat signed (tipe
bilangan bulat signed diawali i, bukan u) yang memakan ruang 32 bit.
Tabel 3-1 menunjukkan tipe bilangan bulat bawaan di Rust. Kita bisa memakai
varian mana pun untuk mendeklarasikan tipe sebuah nilai bilangan bulat.
Tabel 3-1: Tipe Bilangan Bulat di Rust
| Panjang | Bertanda | Tanpa Tanda |
|---|---|---|
| 8-bit | i8 | u8 |
| 16-bit | i16 | u16 |
| 32-bit | i32 | u32 |
| 64-bit | i64 | u64 |
| 128-bit | i128 | u128 |
| Bergantung arsitektur | isize | usize |
Setiap varian bisa berupa signed atau unsigned dan punya ukuran yang eksplisit. Signed dan unsigned menunjukkan apakah sebuah angka bisa bernegatif—dengan kata lain, apakah angka itu perlu membawa tanda (signed), atau apakah angka itu hanya akan selalu positif sehingga bisa direpresentasikan tanpa tanda (unsigned). Seperti menulis angka di kertas: ketika tandanya penting, sebuah angka ditampilkan dengan tanda plus atau minus; tetapi ketika aman mengasumsikan angka itu positif, angka itu ditampilkan tanpa tanda. Angka signed disimpan menggunakan representasi two’s complement.
Setiap varian signed bisa menyimpan angka dari −(2n − 1) sampai
2n − 1 − 1 inklusif, di mana n adalah jumlah bit yang dipakai
varian tersebut. Jadi, sebuah i8 bisa menyimpan angka dari −(27)
sampai 27 − 1, yang sama dengan −128 sampai 127. Varian unsigned
bisa menyimpan angka dari 0 sampai 2n − 1, sehingga sebuah u8
bisa menyimpan angka dari 0 sampai 28 − 1, yang sama dengan 0
sampai 255.
Selain itu, tipe isize dan usize bergantung pada arsitektur komputer tempat
program kamu berjalan: 64 bit jika kamu berada di arsitektur 64-bit dan 32 bit
jika kamu berada di arsitektur 32-bit.
Kamu bisa menulis literal bilangan bulat dalam bentuk apa pun yang ditampilkan
di Tabel 3-2. Perhatikan bahwa literal angka yang bisa berupa beberapa tipe
numerik mengizinkan sebuah akhiran tipe, seperti 57u8, untuk menentukan
tipenya. Literal angka juga bisa memakai _ sebagai pemisah visual agar
angkanya lebih mudah dibaca, seperti 1_000, yang punya nilai sama dengan
jika kamu menulis 1000.
Tabel 3-2: Literal Bilangan Bulat di Rust
| Literal angka | Contoh |
|---|---|
| Desimal | 98_222 |
| Heksadesimal | 0xff |
| Oktal | 0o77 |
| Biner | 0b1111_0000 |
Byte (hanya u8) | b'A' |
Lalu bagaimana kamu tahu harus memakai tipe bilangan bulat yang mana? Jika
kamu ragu, nilai default Rust biasanya tempat yang baik untuk memulai: tipe
bilangan bulat secara default adalah i32. Situasi utama di mana kamu akan
memakai isize atau usize adalah saat mengindeks semacam kumpulan.
Overflow Bilangan Bulat
Misalnya kamu punya variabel bertipe u8 yang bisa menampung nilai antara 0
dan 255. Jika kamu mencoba mengubah variabel itu ke nilai di luar rentang
tersebut, seperti 256, overflow bilangan bulat akan terjadi, yang bisa
menghasilkan salah satu dari dua perilaku. Saat kamu mengompilasi dalam mode
debug, Rust menyertakan pemeriksaan overflow bilangan bulat yang membuat
program kamu panic pada runtime jika perilaku ini terjadi. Rust memakai
istilah panicking ketika program keluar karena sebuah error; kita akan
membahas panic lebih dalam di bagian “Error yang Tidak Bisa Dipulihkan dengan
panic!” di Bab 9.
Saat kamu mengompilasi dalam mode release dengan flag --release, Rust
tidak menyertakan pemeriksaan overflow bilangan bulat yang memicu panic.
Sebaliknya, jika overflow terjadi, Rust melakukan two’s complement
wrapping. Singkatnya, nilai yang lebih besar dari nilai maksimum yang bisa
ditampung tipe tersebut akan “wrap around” ke nilai minimum yang bisa
ditampung tipe itu. Pada kasus u8, nilai 256 menjadi 0, nilai 257 menjadi
1, dan seterusnya. Program tidak akan panic, tetapi variabel itu akan punya
nilai yang mungkin bukan yang kamu harapkan. Mengandalkan perilaku wrapping
dari overflow bilangan bulat dianggap sebagai sebuah error.
Untuk menangani kemungkinan overflow secara eksplisit, kamu bisa memakai kelompok method berikut yang disediakan library standar untuk tipe numerik primitif:
- Membungkus (wrap) di semua mode kompilasi dengan method
wrapping_*, sepertiwrapping_add. - Mengembalikan nilai
Nonejika terjadi overflow, dengan methodchecked_*. - Mengembalikan nilai serta Boolean yang menunjukkan apakah terjadi overflow,
dengan method
overflowing_*. - Menjenuhkan ke nilai minimum atau maksimum dengan method
saturating_*.
Tipe Floating-Point
Rust juga punya dua tipe primitif untuk bilangan floating-point, yaitu angka
yang punya titik desimal. Tipe floating-point di Rust adalah f32 dan f64,
yang berukuran 32 bit dan 64 bit secara berturut-turut. Tipe defaultnya adalah
f64 karena di CPU modern, kecepatannya kira-kira sama dengan f32 tetapi
mampu memberikan presisi lebih tinggi. Semua tipe floating-point bersifat
signed.
Berikut contoh yang menunjukkan bilangan floating-point dalam aksi:
Filename: src/main.rs
fn main() {
let x = 2.0; // f64
let y: f32 = 3.0; // f32
}
Bilangan floating-point direpresentasikan sesuai standar IEEE-754.
Operasi Numerik
Rust mendukung operasi matematika dasar yang kamu harapkan untuk semua tipe
angka: penjumlahan, pengurangan, perkalian, pembagian, dan sisa bagi. Pembagian
bilangan bulat membuang bagian pecahannya menuju nol. Kode berikut menunjukkan
cara memakai setiap operasi numerik dalam sebuah statement let:
Filename: src/main.rs
fn main() {
// addition
let sum = 5 + 10;
// subtraction
let difference = 95.5 - 4.3;
// multiplication
let product = 4 * 30;
// division
let quotient = 56.7 / 32.2;
let truncated = -5 / 3; // Results in -1
// remainder
let remainder = 43 % 5;
}
Setiap ekspresi dalam statement ini memakai sebuah operator matematika dan dievaluasi menjadi satu nilai, yang kemudian diikat ke sebuah variabel. Lampiran B berisi daftar semua operator yang disediakan Rust.
Tipe Boolean
Seperti kebanyakan bahasa pemrograman lain, tipe Boolean di Rust punya dua
nilai yang mungkin: true dan false. Boolean berukuran satu byte. Tipe
Boolean di Rust didefinisikan dengan bool. Sebagai contoh:
Filename: src/main.rs
fn main() {
let t = true;
let f: bool = false; // with explicit type annotation
}
Cara utama memakai nilai Boolean adalah melalui kondisional, seperti ekspresi
if. Kita akan membahas cara kerja ekspresi if di Rust di bagian “Alur
Kontrol”.
Tipe Karakter
Tipe char di Rust adalah tipe alfabet paling primitif dalam bahasa ini.
Berikut beberapa contoh deklarasi nilai char:
Filename: src/main.rs
fn main() {
let c = 'z';
let z: char = 'ℤ'; // with explicit type annotation
let heart_eyed_cat = '😻';
}
Perhatikan bahwa kita menulis literal char dengan tanda kutip tunggal,
berbeda dengan literal string yang memakai tanda kutip ganda. Tipe char di
Rust berukuran 4 byte dan merepresentasikan sebuah nilai skalar Unicode,
artinya ia bisa mewakili jauh lebih banyak dari sekadar ASCII. Huruf beraksen;
karakter Tionghoa, Jepang, dan Korea; emoji; serta spasi lebar nol semuanya
merupakan nilai char yang valid di Rust. Nilai skalar Unicode berkisar dari
U+0000 sampai U+D7FF dan U+E000 sampai U+10FFFF inklusif. Namun,
“karakter” sebenarnya bukan konsep dalam Unicode, jadi intuisi manusiawi kamu
tentang apa itu “karakter” mungkin tidak cocok dengan pengertian char di
Rust. Kita akan membahas topik ini secara detail di “Menyimpan Teks Terenkripsi
UTF-8 dengan String” di Bab 8.
Tipe Komposit
Tipe komposit bisa mengelompokkan beberapa nilai ke dalam satu tipe. Rust punya dua tipe komposit primitif: tuple dan array.
Tipe Tuple
Tuple adalah cara umum untuk mengelompokkan sejumlah nilai dengan berbagai tipe ke dalam satu tipe komposit. Tuple punya panjang tetap: sekali dideklarasikan, ukurannya tidak bisa membesar atau mengecil.
Kita membuat tuple dengan menulis daftar nilai yang dipisahkan koma di dalam tanda kurung bulat. Setiap posisi dalam tuple punya sebuah tipe, dan tipe dari nilai-nilai berbeda dalam tuple tidak harus sama. Pada contoh ini kita menambahkan anotasi tipe yang opsional:
Filename: src/main.rs
fn main() {
let tup: (i32, f64, u8) = (500, 6.4, 1);
}
Variabel tup mengikat ke seluruh tuple karena tuple dianggap sebagai satu
elemen komposit. Untuk mengambil nilai-nilai individual dari sebuah tuple, kita
bisa memakai pencocokan pola untuk mendestruksi nilai tuple, seperti ini:
Filename: src/main.rs
fn main() {
let tup = (500, 6.4, 1);
let (x, y, z) = tup;
println!("The value of y is: {y}");
}
Program ini pertama-tama membuat sebuah tuple dan mengikatnya ke variabel
tup. Lalu ia memakai sebuah pola bersama let untuk mengambil tup dan
mengubahnya menjadi tiga variabel terpisah, yaitu x, y, dan z. Hal ini
disebut destructuring karena memecah tuple tunggal tersebut menjadi tiga
bagian. Terakhir, program mencetak nilai y, yaitu 6.4.
Kita juga bisa mengakses elemen tuple secara langsung dengan titik (.)
diikuti indeks nilai yang ingin diakses. Sebagai contoh:
Filename: src/main.rs
fn main() {
let x: (i32, f64, u8) = (500, 6.4, 1);
let five_hundred = x.0;
let six_point_four = x.1;
let one = x.2;
}
Program ini membuat tuple x lalu mengakses setiap elemennya menggunakan
indeks masing-masing. Seperti kebanyakan bahasa pemrograman, indeks pertama
dalam sebuah tuple adalah 0.
Tuple tanpa nilai apa pun punya nama khusus, yaitu unit. Nilai ini dan tipe
yang bersangkutan sama-sama ditulis () dan merepresentasikan nilai kosong
atau tipe kembalian kosong. Ekspresi secara implisit mengembalikan nilai unit
jika tidak mengembalikan nilai lain.
Tipe Array
Cara lain untuk punya kumpulan beberapa nilai adalah dengan sebuah array. Berbeda dengan tuple, setiap elemen array harus punya tipe yang sama. Berbeda dengan array di beberapa bahasa lain, array di Rust punya panjang tetap.
Kita menulis nilai dalam sebuah array sebagai daftar yang dipisahkan koma di dalam kurung siku:
Filename: src/main.rs
fn main() {
let a = [1, 2, 3, 4, 5];
}
Array berguna ketika kamu ingin data kamu dialokasikan di stack, sama seperti tipe-tipe lain yang sudah kita lihat sejauh ini, alih-alih di heap (kita akan membahas stack dan heap lebih lanjut di Bab 4), atau ketika kamu ingin memastikan selalu punya jumlah elemen yang tetap. Namun, array tidak sefleksibel tipe vector. Vector adalah tipe kumpulan serupa yang disediakan library standar dan boleh membesar atau mengecil ukurannya karena isinya hidup di heap. Jika kamu ragu harus memakai array atau vector, kemungkinan besar kamu sebaiknya memakai vector. Bab 8 membahas vector lebih lanjut.
Namun, array lebih berguna ketika kamu tahu jumlah elemennya tidak akan berubah. Sebagai contoh, jika kamu memakai nama bulan dalam sebuah program, kamu mungkin akan memakai array alih-alih vector karena kamu tahu isinya selalu 12 elemen:
#![allow(unused)]
fn main() {
let months = ["January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"];
}
Kamu menulis tipe sebuah array dengan kurung siku berisi tipe setiap elemen, lalu titik koma, dan terakhir jumlah elemen dalam array, seperti ini:
#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}
Di sini, i32 adalah tipe setiap elemen. Setelah titik koma, angka 5
menunjukkan array berisi lima elemen.
Kamu juga bisa menginisialisasi array agar setiap elemennya punya nilai yang sama dengan menentukan nilai awal, diikuti titik koma, lalu panjang array di dalam kurung siku, seperti ini:
#![allow(unused)]
fn main() {
let a = [3; 5];
}
Array bernama a akan berisi 5 elemen yang semuanya diatur ke nilai 3
pada awalnya. Ini sama dengan menulis let a = [3, 3, 3, 3, 3]; tetapi dengan
cara yang lebih ringkas.
Akses Elemen Array
Array adalah satu blok memori berukuran tetap yang sudah diketahui dan bisa dialokasikan di stack. Kamu bisa mengakses elemen array menggunakan indeks, seperti ini:
Filename: src/main.rs
fn main() {
let a = [1, 2, 3, 4, 5];
let first = a[0];
let second = a[1];
}
Pada contoh ini, variabel bernama first akan mendapat nilai 1 karena nilai
itu berada di indeks [0] dalam array. Variabel bernama second akan mendapat
nilai 2 dari indeks [1] dalam array.
Akses Elemen Array yang Tidak Valid
Mari kita lihat apa yang terjadi jika kamu mencoba mengakses elemen array yang berada melewati akhir array. Misalnya kamu menjalankan kode berikut, mirip dengan game tebak-tebakan di Bab 2, untuk mendapatkan indeks array dari pengguna:
Filename: src/main.rs
use std::io;
fn main() {
let a = [1, 2, 3, 4, 5];
println!("Please enter an array index.");
let mut index = String::new();
io::stdin()
.read_line(&mut index)
.expect("Failed to read line");
let index: usize = index
.trim()
.parse()
.expect("Index entered was not a number");
let element = a[index];
println!("The value of the element at index {index} is: {element}");
}
Kode ini berhasil dikompilasi. Jika kamu menjalankan kode ini dengan cargo run lalu memasukkan 0, 1, 2, 3, atau 4, program akan mencetak nilai
yang sesuai di indeks tersebut dalam array. Sebaliknya, jika kamu memasukkan
angka yang melewati akhir array, misalnya 10, kamu akan melihat keluaran
seperti ini:
thread 'main' panicked at src/main.rs:19:19:
index out of bounds: the len is 5 but the index is 10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Program menghasilkan error runtime pada saat nilai tidak valid dipakai dalam
operasi indeks. Program keluar dengan pesan error dan tidak mengeksekusi
statement println! terakhir. Saat kamu mencoba mengakses elemen menggunakan
indeks, Rust akan memeriksa bahwa indeks yang kamu tentukan lebih kecil dari
panjang array. Jika indeksnya lebih besar atau sama dengan panjangnya, Rust
akan panic. Pemeriksaan ini harus terjadi pada runtime, terutama dalam kasus
ini, karena compiler tidak mungkin tahu nilai apa yang akan dimasukkan
pengguna saat menjalankan kode tersebut nanti.
Ini adalah contoh prinsip keamanan memori Rust dalam aksi. Di banyak bahasa tingkat rendah, pemeriksaan semacam ini tidak dilakukan, dan ketika kamu memberikan indeks yang salah, memori yang tidak valid bisa diakses. Rust melindungi kamu dari error semacam ini dengan langsung keluar, alih-alih mengizinkan akses memori itu terjadi lalu melanjutkan program. Bab 9 membahas lebih lanjut tentang penanganan error di Rust dan bagaimana kamu bisa menulis kode yang mudah dibaca dan aman, yang tidak panic maupun mengizinkan akses memori yang tidak valid.