Tipe data di Rust

Setiap nilai di Rust punya tipe, yaitu label yang memberi tahu compiler jenis data apa itu (bilangan bulat, bilangan desimal, teks, true/false, dan sebagainya). Dengan mengetahui tipenya, Rust bisa mengecek kesalahan di kodemu sebelum program dijalankan.

Seperti yang sudah kamu lihat di variabel, biasanya Rust bisa menebak (infer) tipenya untukmu. Tapi akan sangat membantu kalau kamu mengenal nama tipe-tipe utamanya, karena kamu akan melihatnya di pesan error dan di signature fungsi.

Integer (bilangan bulat)

Integer adalah angka tanpa titik desimal, seperti 42 atau -7. Rust punya beberapa tipe integer yang berbeda dalam hal ukuran dan apakah boleh berisi angka negatif:

Tipe	Signed?	Penggunaan umum
i32	Ya (bisa negatif)	Default. Pakai ini kecuali kamu punya alasan untuk tidak memakainya
u32	Tidak (0 ke atas)	Hitungan, ukuran, hal-hal yang tidak mungkin negatif
i64 / u64	Ya / Tidak	Angka yang sangat besar
usize	Tidak	Indeks untuk mengakses koleksi

fn main() {
    let temperature = -5;      // i32 secara default
    let count: u32 = 100;      // unsigned, ditulis secara eksplisit
    println!("{temperature} derajat, jumlahnya {count}");
}

Output:

-5 derajat, jumlahnya 100

▶ Coba sendiri

Catatan

“Signed” berarti angkanya bisa negatif; “unsigned” (tipe-tipe berawalan u) berarti hanya nol atau positif. Kalau ragu, i32 adalah pilihan default yang aman.

Floating-point (bilangan desimal)

Untuk angka dengan titik desimal, pakai tipe floating-point. Ada dua: f64 (default, presisi ganda) dan f32.

fn main() {
    let pi = 3.14159;      // f64 secara default
    let price: f32 = 9.99;
    println!("Pi adalah {pi}, harganya {price}");
}

Output:

Pi adalah 3.14159, harganya 9.99

▶ Coba sendiri

Tetap pakai f64 kecuali kamu memang butuh f32 yang lebih kecil. f64 lebih presisi dan sama cepatnya di hardware modern. Ingat juga bahwa di kode, desimal selalu ditulis dengan titik (3.14), bukan koma.

Boolean

Boolean (bool) adalah tipe paling sederhana: isinya hanya true atau false. Kamu akan terus memakainya di statement if dan berbagai kondisi.

fn main() {
    let is_logged_in = true;
    let has_permission: bool = false;
    println!("sudah login: {is_logged_in}, punya izin: {has_permission}");
}

Output:

sudah login: true, punya izin: false

▶ Coba sendiri

Karakter

char menyimpan satu karakter, ditulis dengan tanda kutip tunggal ' '. Sebuah char di Rust bisa berisi satu Unicode scalar value apa pun. Itu mencakup kebanyakan emoji, meskipun beberapa emoji yang kompleks (seperti bendera atau emoji yang tersusun dari beberapa karakter yang digabung) tidak muat dalam satu char.

fn main() {
    let letter = 'R';
    let symbol = '$';
    let crab = '🦀';
    println!("{letter} {symbol} {crab}");
}

Output:

R $ 🦀

▶ Coba sendiri

Perhatian

Tanda kutip tunggal ('R') untuk satu char. Tanda kutip ganda ("R") untuk teks (string). Tertukar antara keduanya adalah kesalahan yang umum di awal belajar.

String (teks)

Teks di Rust ditulis dengan tanda kutip ganda. Ada dua tipe string yang akan kamu temui:

• &str: sebuah string slice, biasanya teks yang kamu tulis langsung di dalam kode (disebut “string literal”).
• String: teks yang dimiliki sendiri (owned) dan bisa bertambah panjang, yang bisa kamu ubah dan susun sedikit demi sedikit.

fn main() {
    let greeting = "Halo";              // &str
    let mut name = String::from("Ferris"); // String
    name.push_str(" si kepiting");      // String bisa bertambah panjang
    println!("{greeting}, {name}!");
}

Output:

Halo, Ferris si kepiting!

▶ Coba sendiri

Jangan pusingkan perbedaan &str dan String dulu. Perbedaannya berkaitan dengan ownership (kepemilikan), yang akan segera kamu pelajari. Untuk sekarang: pakai "..." untuk teks, dan pakai String saat kamu perlu menyusun atau mengubahnya.

Anotasi tipe

Hampir selalu Rust bisa menebak tipenya. Tapi kadang Rust butuh petunjuk, misalnya saat mengubah teks menjadi angka (kamu akan melihatnya di halaman Konversi tipe). Kamu menambahkan tipe dengan titik dua:

let x: i32 = 42;
let y: f64 = 3.5;
let active: bool = true;

Referensi cepat

Tipe	Isinya	Contoh
i32	Bilangan bulat (default)	let n = 42;
u32	Bilangan bulat non-negatif	let n: u32 = 42;
f64	Bilangan desimal (default)	let pi = 3.14;
bool	true atau false	let ok = true;
char	Satu karakter	let c = 'A';
&str	Teks literal	let s = "hi";
String	Teks yang bisa bertambah panjang	let s = String::from("hi");

Latihan

1. Profil pemain

Gambarkan sebuah karakter game dengan satu variabel untuk setiap tipe: nama (&str), level (i32), persentase nyawa (f64), penanda is_online (bool), dan huruf peringkat (char). Cetak semuanya dalam satu baris. Petunjuk: char memakai tanda kutip tunggal, teks memakai tanda kutip ganda.

Lihat solusi

fn main() {
    let name = "Ferris";   // &str
    let level = 7;         // i32
    let health = 82.5;     // f64
    let is_online = true;  // bool
    let rank = 'A';        // char

    println!("{name} | level {level} | {health}% | online: {is_online} | peringkat {rank}");
}

Output:

Ferris | level 7 | 82.5% | online: true | peringkat A

▶ Coba sendiri

2. Susun sebuah kalimat

Mulai dengan String::from("Rust"), lalu tambahkan " itu cepat" dan " dan aman", kemudian cetak hasilnya. Petunjuk: String-nya harus dideklarasikan dengan mut supaya push_str bisa mengubahnya.

Lihat solusi

fn main() {
    let mut sentence = String::from("Rust");
    sentence.push_str(" itu cepat");
    sentence.push_str(" dan aman");
    println!("{sentence}");
}

Output:

Rust itu cepat dan aman

▶ Coba sendiri

Ringkasan

• Setiap nilai punya tipe; biasanya Rust menebaknya sendiri.
• Bilangan bulat → i32 (default). Bilangan desimal → f64 (default).
• bool berisi true/false; char adalah satu karakter dalam tanda kutip tunggal.
• Teks ditulis dalam tanda kutip ganda: &str untuk literal, String untuk teks yang bisa bertambah panjang.

Kuis singkat

Kuis singkat

1. Apa tipe integer default di Rust kalau kamu tidak menuliskannya?

u32 i32 i64

2. Bagaimana Rust membedakan literal char dan literal string?

Tidak ada bedanya, keduanya ditulis dengan cara yang sama Literal char memakai tanda kutip tunggal, literal string memakai tanda kutip ganda Literal char memakai tanda kutip ganda, literal string memakai tanda kutip tunggal

3. Tipe mana yang berupa teks milik sendiri (owned), bisa bertambah panjang, dan bisa diubah?

&str String char

4. Apa tipe floating-point default di Rust?

f32 f64 f128

5. Tipe apa yang akan ditebak Rust untuk let greeting = "Halo";?

String &str char

Skor: 0 / 5

Bacaan lebih lanjut

• Data Types — The Rust Book (bahasa Inggris): semua tipe skalar beserta ukuran dan rentangnya, plus integer overflow dan tipe gabungan (tuple dan array).
• Primitives — Rust by Example (bahasa Inggris): contoh yang bisa dijalankan untuk setiap tipe dasar, dilanjutkan dengan literal seperti 1_000 dan 0x80.
• i32 — standard library docs (bahasa Inggris): nilai terkecil dan terbesar (i32::MIN, i32::MAX) serta banyak method yang dimiliki angka.
• char — standard library docs (bahasa Inggris): apa itu Unicode scalar value, dan kenapa sebuah char selalu berukuran 4 byte.
• String — standard library docs (bahasa Inggris): hubungan String dengan &str, dan semua method untuk menyusun dan mengubah teks.