Tipe Data Rust — Rust

Tipe Data di Rust Rust adalah bahasa statically typed — compiler harus tahu tipe setiap variabel. Namun Rust juga punya type inference yang cerdas. Tipe…

Tiap nilai di Rust punya tipe: jenis datanya (angka bulat, angka desimal, teks, benar/salah) sekaligus ukurannya di memori. Tipe ditentukan saat compile, dan compiler menebaknya kalau kamu gak menulisnya. Bayangin wadah-wadah di dapur Kedai Martabak Bang Rusdi. Rak telur cuma muat 255 butir, laci kas muat jutaan rupiah, gelas takar untuk sirup punya garis desimal, dan papan BUKA/TUTUP cuma punya dua sisi. Tiap wadah dipilih sesuai isinya, dan isi yang melebihi wadah bakal tumpah. Wadah itu tipe, isinya nilai.

🧪 Tebakan cepat: stok telur disimpan sebagai u8, isinya 250. Lalu kiriman 10 butir datang dan ditambahkan. Waktu cargo run, apa yang tercetak: 260, 4, atau program berhenti dengan error? Tebak dulu, jawabannya ada di bagian "Angka yang meluap".

Angka bulat (integer)

Tipe Bisa minus? Rentang
u8 tidak 0 sampai 255
i32 ya -2.147.483.648 sampai 2.147.483.647
u32 tidak 0 sampai 4.294.967.295
i64 ya sekitar ±9,2 juta triliun

Huruf i artinya signed (boleh minus), u artinya unsigned (gak boleh minus), dan angkanya jumlah bit. Ada juga i8, i16, i128, u16, u64, u128, dan usize (dipakai untuk panjang dan posisi). Kalau kamu gak menulis tipenya, angka bulat jadi i32.

fn main() {
    let porsi = 2;
    let harga_manis: u32 = 32_000;
    let stok_telur: u8 = 250;
    println!("{} {} {}", porsi, harga_manis, stok_telur);
    println!("{} {}", 32000 / 3, 32000 % 3);
}

2 32000 250
10666 2

Desimal, bool, char, dan teks

fn main() {
    let rating: f64 = 4.8;
    let buka: bool = true;
    let kode_menu: char = 'T';
    println!("{} {} {}", rating, buka, kode_menu);
    println!("{} {}", 7.0 / 2.0, 42.0);
    println!("{} {}", "Crêpe".len(), "Crêpe".chars().count());
}

4.8 true T
3.5 42
6 5

Konversi tipe: as dan parse

Rust gak pernah mengubah tipe diam-diam. porsi * rating dengan porsi: u32 dan rating: f64 ditolak: cannot multiply `u32` by `f64` . Kamu yang mengubahnya:

fn main() {
    let porsi: u32 = 2;
    let porsi_f64 = porsi as f64;
    println!("{}", porsi_f64 * 4.8);

    let nota = "38000";
    let harga: u32 = nota.parse().unwrap();
    println!("{}", harga * 2);

    let rating = 4.8;
    let bintang = rating as i32;
    println!("{}", bintang);
}

9.6
76000
4

Angka yang meluap

Ini program tebakan tadi. Jumlah kiriman dibaca dari teks nota, jadi nilainya baru diketahui saat program jalan:

fn main() {
    let stok_telur: u8 = 250;
    println!("Stok telur: {}", stok_telur);
    let datang: u8 = "10".parse().unwrap();
    let stok_baru = stok_telur + datang;
    println!("Stok telur: {}", stok_baru);
}

$ cargo run
   Compiling kedai v0.1.0 (/home/kamu/kedai)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.51s
     Running `target/debug/kedai`
Stok telur: 250

thread 'main' (23111499) panicked at src/main.rs:5:21:
attempt to add with overflow
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

250 + 10 = 260, padahal u8 cuma sampai 255. Ini overflow: hasilnya gak muat di tipenya. Di build biasa (debug), Rust memeriksanya dan program panic: berhenti saat jalan dengan pesan attempt to add with overflow di src/main.rs baris 5 kolom 21. Baris pertama sempat tercetak, karena panic terjadi di runtime. Angka dalam kurung setelah 'main' nomor thread, beda tiap kali jalan.

$ cargo run --release
   Compiling kedai v0.1.0 (/home/kamu/kedai)
    Finished `release` profile [optimized] target(s) in 0.68s
     Running `target/release/kedai`
Stok telur: 250
Stok telur: 4

Di build --release, pemeriksaan itu dimatikan supaya cepat, dan angkanya berputar: setelah 255 kembali ke 0, jadi 260 jadi 260 - 256 = 4. Program jalan terus dengan stok yang salah. Itu jawaban tebakannya: tergantung cara build-nya, panic atau 4, tapi gak pernah 260. Kalau kedua angka ditulis langsung di kode (let datang: u8 = 10;), compiler sudah melihatnya saat compile dan menolak: this arithmetic operation will overflow. Obatnya pilih wadah yang cukup: u32 muat sampai 4 miliar lebih.

Tuple dan array

fn main() {
    let pesanan: (&str, u32, bool) = ("Martabak telur", 2, true);
    println!("{} x{}", pesanan.0, pesanan.1);

    let harga: [u32; 3] = [32000, 38000, 5000];
    println!("Es teh: {}", harga[2]);
    println!("Jumlah menu: {}", harga.len());
}

Martabak telur x2
Es teh: 5000
Jumlah menu: 3

⚠️ Jebakan yang sering ketemu

TL;DR: Tiap nilai punya tipe yang pasti saat compile. Angka bulat default i32 (signed 32-bit), u8 cuma 0 sampai 255, u32 0 sampai 4,29 miliar. Desimal default f64, bool cuma true/false, char satu karakter berkutip tunggal (4 byte), teks berkutip ganda bertipe &str dan .len()-nya menghitung byte UTF-8. Pembagian integer membuang pecahan. Tipe gak pernah berubah sendiri: as mengubah antar-angka dan memotong desimal (3.7 as i32 = 3), .parse().unwrap() mengubah teks jadi angka dengan tipe tujuan yang ditulis. Overflow membuat panic di debug (attempt to add with overflow) dan berputar diam-diam di release. Tuple dibaca dengan .0, .1, array dengan [0], keduanya mulai dari 0.

Yang akan kamu pelajari