BAB 5: Tipe Data: Primitive Scalar
Tipe scalar di Rust: integer dengan rentang tiap ukuran, float dan keterbatasan presisinya, bool, char, serta ukuran byte masing-masing tipe.
Rust tidak menebak tipe data secara longgar. Setiap nilai punya tipe yang pasti, dan tipe itu menentukan rentang nilai, ukuran di memori, serta perilaku saat batasnya terlampaui. Perbedaan perilaku di dalam dan di luar batas ini yang membuat program Rust bisa berhenti dengan panic di satu build dan berputar nilainya di build lain.
Bab ini membahas 4 kelompok tipe scalar: integer, float, boolean, dan karakter. Semua angka di bawah diukur dengan std::mem::size_of pada rustc 1.100.0 untuk target 64 bit, dan keluarannya diambil dari program yang dijalankan.
Integer dan rentangnya
Integer di Rust punya ukuran yang ditulis di namanya: i8, i16, i32, i64, i128 untuk bilangan bertanda, dan u8, u16, u32, u64, u128 untuk bilangan tanpa tanda. Huruf i dan u diikuti jumlah bit.
fn main() {
println!("i8 min {} max {}", i8::MIN, i8::MAX);
println!("u8 min {} max {}", u8::MIN, u8::MAX);
println!("i32 min {} max {}", i32::MIN, i32::MAX);
}
i8 min -128 max 127
u8 min 0 max 255
i32 min -2147483648 max 2147483647
Selain itu ada isize dan usize, yang lebarnya mengikuti arsitektur mesin. Pada target 64 bit, keduanya 8 byte. Tipe usize dipakai untuk indeks dan panjang koleksi, karena ukurannya sesuai kemampuan mesin mengalamatkan memori.
| Tipe | Ukuran terukur | Rentang |
|---|---|---|
i8 | 1 byte | -128 sampai 127 |
u8 | 1 byte | 0 sampai 255 |
i32 | 4 byte | -2.147.483.648 sampai 2.147.483.647 |
i64 | 8 byte | sekitar -9,2 triliun sampai 9,2 triliun |
i128 | 16 byte | sekitar -1,7 kali 10 pangkat 38 |
usize | 8 byte | 0 sampai batas alamat mesin |
Tanpa anotasi, angka bulat dianggap i32. Untuk memilih tipe lain, tulis akhiran pada angka atau anotasi pada variabel:
fn main() {
let kecil = 5u8;
let besar = 5_i64;
println!("{} {}", kecil, besar);
}
5 5
Integer melewati batas
Penambahan yang melewati batas tipe berperilaku berbeda tergantung mode build. Pada build debug, program berhenti dengan panic. Pada build release, nilainya berputar.
fn main() {
let mut n: u8 = 255;
n += 1;
println!("{n}");
}
Pada build debug, program berhenti dan mencetak:
thread 'main' panicked at berkas.rs:3:5:
attempt to add with overflow
Nama berkas dan nomor baris mengikuti tempat kode ditulis, sedangkan isi pesannya selalu menyebut operasi yang melewati batas.
Pada build release, keluarannya 0, karena 255 ditambah 1 kembali ke awal rentang. Saya memverifikasi keduanya dari berkas yang sama: build debug berhenti dengan panic, build release mencetak 0. Perilaku berputar ini bisa dicegah dengan cara eksplisit, misalnya n.wrapping_add(1) yang memang menghasilkan 0, atau n.checked_add(1) yang mengembalikan None saat batas terlampaui. Pilihan itu membuat niat kode terlihat jelas, bukan bergantung pada mode build.
Float dan presisinya
Ada 2 tipe float: f32 sebesar 4 byte dan f64 sebesar 8 byte. Tanpa anotasi, angka desimal dianggap f64.
fn main() {
let a = 0.1_f64;
let b = 0.2_f64;
println!("0.1 + 0.2 = {}", a + b);
println!("sama dengan 0.3? {}", (a + b) == 0.3);
}
0.1 + 0.2 = 0.30000000000000004
sama dengan 0.3? false
Hasil itu bukan kesalahan Rust, melainkan cara bilangan pecahan disimpan dalam biner. Karena itu perbandingan float tidak dilakukan dengan ==, tetapi dengan selisih yang ditoleransi:
fn main() {
let a = 0.1_f64 + 0.2_f64;
let selisih = (a - 0.3_f64).abs();
println!("selisih = {selisih}");
println!("dianggap sama? {}", selisih < 1e-9);
}
selisih = 0.00000000000000005551115123125783
dianggap sama? true
Untuk uang dan nilai yang menuntut ketepatan, float bukan pilihan yang tepat. Nilai disimpan sebagai integer dalam satuan terkecil, misalnya rupiah tanpa desimal, lalu pembagian dilakukan saat menampilkan.
Boolean
bool berisi true atau false, dan ukurannya 1 byte. Tipe ini hanya dipakai untuk logika, dan tidak bisa ditukar dengan angka:
fn main() {
let sudah_bayar = true;
let jumlah = 3;
println!("{} {}", sudah_bayar, jumlah > 2);
}
true true
Ekspresi perbandingan seperti jumlah > 2 menghasilkan bool, dan nilai itulah yang dipakai di if pada bab 9. Menulis if jumlah tidak sah, karena jumlah bertipe integer.
Karakter
char menyimpan 1 karakter Unicode dan berukuran 4 byte, bukan 1 byte seperti di bahasa yang memakai ASCII. Artinya char bisa memuat huruf Latin, aksara Jawa, atau emoji:
fn main() {
let huruf = 'A';
let aksara = 'ꦄ';
let emoji = '🦀';
println!("{huruf} {aksara} {emoji}");
println!("{:?}", std::char::from_u32('ꦄ' as u32));
}
A ꦄ 🦀
Some('ꦄ')
Tanda kutip untuk char adalah kutip tunggal, sedangkan string memakai kutip ganda. Perbedaan ini penting: 'A' adalah char, sedangkan "A" adalah string yang dibahas di bab 6.
Menulis angka dalam basis lain
Angka bulat bisa ditulis dalam basis desimal, heksadesimal, oktal, dan biner. Semuanya bernilai sama, dan yang berbeda hanya cara penulisannya:
fn main() {
println!("{} {} {} {}", 255, 0xff, 0o377, 0b1111_1111);
println!("{}", b'A');
}
255 255 255 255
65
Awalan 0x untuk heksadesimal, 0o untuk oktal, dan 0b untuk biner. Garis bawah boleh disisipkan di mana saja untuk memisahkan kelompok digit. Bentuk b'A' adalah literal byte, yang bernilai 65 karena kode ASCII huruf A.
Penulisan basis ini dipakai saat nilainya memang berhubungan dengan bit, misalnya masker izin akses atau warna. Untuk angka biasa, desimal lebih mudah dibaca.
Memilih tipe yang tepat
| Kebutuhan | Tipe yang dipakai |
|---|---|
| penghitung dan indeks koleksi | usize |
| angka umum tanpa alasan khusus | i32 |
| nilai yang nilainya besar | i64 atau i128 |
| nilai yang tidak boleh negatif | u32 atau u64 |
| perhitungan ilmiah | f64 |
| uang | integer dalam satuan terkecil |
| 1 karakter teks | char |
Patokan yang saya pakai: mulai dari i32 untuk angka biasa, lalu pindah ke tipe lain hanya kalau ada alasan yang bisa dijelaskan, misalnya rentang nilai yang lebih besar atau indeks koleksi.
Latihan
Latihan berikut bisa dikerjakan dengan berkas tunggal, tanpa proyek cargo. Setiap hasil cetak sebaiknya dibandingkan dengan angka pada tabel di bab ini.
- Cetak ukuran
i16,u16,f32, danisizedengansize_of, lalu bandingkan dengan tabel di bab ini. - Hitung
0.1 + 0.7dan bandingkan dengan0.8memakai toleransi1e-9. Cetak hasil perbandingannya. - Tulis 1 angka yang sama dalam 4 basis, lalu cetak keempatnya untuk memastikan nilainya sama.
- Cetak
charberisi huruf Latin, aksara Jawa, dan emoji, lalu periksa ukuran tipe itu tetap 4 byte.
Ringkasan
Integer punya ukuran yang tertulis di namanya, dan rentangnya bisa dibaca dari MIN dan MAX. Nilai yang melewati batas menghentikan program pada build debug dan berputar pada build release, sedangkan checked_add membuat perilaku itu eksplisit.
f32 dan f64 menyimpan pecahan dalam biner, sehingga 0.1 + 0.2 tidak sama dengan 0.3 dan perbandingan memakai toleransi. bool hanya berisi true atau false, dan char berukuran 4 byte karena menyimpan 1 karakter Unicode, bukan 1 byte ASCII.
Referensi
- The Rust Programming Language. Data Types.
- The Rust Reference. Types.
- Standard library. Primitive i32.
- Standard library. Primitive f64.
- Standard library. Primitive char.