Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

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

PanjangBertandaTanpa Tanda
8-biti8u8
16-biti16u16
32-biti32u32
64-biti64u64
128-biti128u128
Bergantung arsitekturisizeusize

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 angkaContoh
Desimal98_222
Heksadesimal0xff
Oktal0o77
Biner0b1111_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_*, seperti wrapping_add.
  • Mengembalikan nilai None jika terjadi overflow, dengan method checked_*.
  • 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.