Foundation

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.

RSRUST
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);
}
CodeTEXT
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.

TipeUkuran terukurRentang
i81 byte-128 sampai 127
u81 byte0 sampai 255
i324 byte-2.147.483.648 sampai 2.147.483.647
i648 bytesekitar -9,2 triliun sampai 9,2 triliun
i12816 bytesekitar -1,7 kali 10 pangkat 38
usize8 byte0 sampai batas alamat mesin

Tanpa anotasi, angka bulat dianggap i32. Untuk memilih tipe lain, tulis akhiran pada angka atau anotasi pada variabel:

RSRUST
fn main() {
    let kecil = 5u8;
    let besar = 5_i64;
    println!("{} {}", kecil, besar);
}
CodeTEXT
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.

RSRUST
fn main() {
    let mut n: u8 = 255;
    n += 1;
    println!("{n}");
}

Pada build debug, program berhenti dan mencetak:

CodeTEXT
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.

RSRUST
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);
}
CodeTEXT
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:

RSRUST
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);
}
CodeTEXT
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:

RSRUST
fn main() {
    let sudah_bayar = true;
    let jumlah = 3;
    println!("{} {}", sudah_bayar, jumlah > 2);
}
CodeTEXT
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:

RSRUST
fn main() {
    let huruf = 'A';
    let aksara = 'ꦄ';
    let emoji = '🦀';
    println!("{huruf} {aksara} {emoji}");
    println!("{:?}", std::char::from_u32('ꦄ' as u32));
}
CodeTEXT
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.

Angka bulat bisa ditulis dalam basis desimal, heksadesimal, oktal, dan biner. Semuanya bernilai sama, dan yang berbeda hanya cara penulisannya:

RSRUST
fn main() {
    println!("{} {} {} {}", 255, 0xff, 0o377, 0b1111_1111);
    println!("{}", b'A');
}
CodeTEXT
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

KebutuhanTipe yang dipakai
penghitung dan indeks koleksiusize
angka umum tanpa alasan khususi32
nilai yang nilainya besari64 atau i128
nilai yang tidak boleh negatifu32 atau u64
perhitungan ilmiahf64
uanginteger dalam satuan terkecil
1 karakter tekschar

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.

  1. Cetak ukuran i16, u16, f32, dan isize dengan size_of, lalu bandingkan dengan tabel di bab ini.
  2. Hitung 0.1 + 0.7 dan bandingkan dengan 0.8 memakai toleransi 1e-9. Cetak hasil perbandingannya.
  3. Tulis 1 angka yang sama dalam 4 basis, lalu cetak keempatnya untuk memastikan nilainya sama.
  4. Cetak char berisi 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

  1. The Rust Programming Language. Data Types.
  2. The Rust Reference. Types.
  3. Standard library. Primitive i32.
  4. Standard library. Primitive f64.
  5. Standard library. Primitive char.