Tipe Primitif | Faisal Affan

Versi Bahasa Indonesia. Baca dalam Bahasa Inggris

Setiap nilai di Rust memiliki tipe data tertentu, yang memberi tahu Rust jenis data apa yang sedang ditentukan sehingga ia tahu bagaimana bekerja dengan data tersebut.

Referensi:

Ringkasan

Tipe Skalar

Tipe skalar mewakili satu nilai. Rust memiliki empat tipe skalar utama:

Integer adalah angka tanpa komponen pecahan.
Floating points: Rust memiliki dua tipe primitif untuk angka floating-point (f32, f64), yaitu angka dengan titik desimal.
Character: char
- Kita menentukan literal char dengan tanda kutip tunggal '.
- Berukuran empat byte dan mewakili Unicode Scalar Value, yang berarti dapat mewakili lebih dari sekedar ASCII.
- Huruf beraksen; karakter Cina, Jepang, dan Korea; emoji; dan zero-width spaces semuanya adalah nilai char yang valid di Rust.
Boolean tipe bool di Rust memiliki dua kemungkinan nilai: true dan false. Boolean berukuran satu byte.

Tipe Compound

Tuple:
- Tuple adalah cara umum untuk mengelompokkan sejumlah nilai dengan berbagai tipe menjadi satu tipe compound.
- Tuple memiliki panjang tetap: setelah dideklarasikan, mereka tidak dapat bertambah atau berkurang ukurannya.
Array:
- Setiap elemen dari sebuah array harus memiliki tipe yang sama.
- Tidak seperti array di beberapa bahasa lain, array di Rust memiliki panjang tetap.
Slice:
- Slice memungkinkan kamu mereferensi urutan elemen yang berurutan dalam sebuah koleksi daripada seluruh koleksi.
- Slice adalah semacam reference, jadi ia tidak memiliki ownership.
- Kita membuat slice menggunakan range dalam kurung siku dengan menentukan [starting_index..ending_index], di mana starting_index adalah posisi pertama dalam slice dan ending_index adalah satu lebih dari posisi terakhir dalam slice.

primitive_types1.rs

fn main() {
    let is_morning = true;
    if is_morning {
        println!("Good morning!");
    }

    // Define a boolean variable with the name `is_evening` before the `if` statement below.
    // The value of the variable should be the negation (opposite) of `is_morning`.
    let is_evening = !is_morning;
    if is_evening {
        println!("Good evening!");
    }
}

Di latihan ini kita hanya perlu mendefinisikan variabel is_evening yang seharusnya merupakan kebalikan dari is_morning.
Kita melakukannya dengan menggunakan let is_evening = !is_morning;.

primitive_types2.rs

fn main() {
    // Note the _single_ quotes, these are different from the double quotes
    // you've been seeing around.
    let my_first_initial = 'C';
    if my_first_initial.is_alphabetic() {
        println!("Alphabetical!");
    } else if my_first_initial.is_numeric() {
        println!("Numerical!");
    } else {
        println!("Neither alphabetic nor numeric!");
    }

    // TODO: Analogous to the example before, declare a variable called `your_character`
    // below with your favorite character.
    // Try a letter, try a digit (in single quotes), try a special character, try a character
    // from a different language than your own, try an emoji 😉
    // let your_character = '';
    let your_character = '😻';
    if your_character.is_alphabetic() {
        println!("Alphabetical!");
    } else if your_character.is_numeric() {
        println!("Numerical!");
    } else {
        println!("Neither alphabetic nor numeric!");
    }
}

Di latihan ini kita dapat mencoba nilai apa yang dapat diwakili oleh char.
Tipe char Rust berukuran empat byte dan mewakili Unicode Scalar Value, yang berarti dapat mewakili lebih dari sekedar ASCII.
Huruf beraksen; karakter Cina, Jepang, dan Korea; emoji; dan zero-width spaces semuanya adalah nilai char yang valid di Rust.

primitive_types3.rs

fn main() {
    // TODO: Create an array called `a` with at least 100 elements in it.
    // let a = ???
    let a = [1; 100];
    if a.len() >= 100 {
        println!("Wow, that's a big array!");
    } else {
        println!("Meh, I eat arrays like that for breakfast.");
        panic!("Array not big enough, more elements needed");
    }
}

Di latihan ini kita perlu menginisialisasi array dengan panjang setidaknya 100.
Array di Rust memiliki beberapa cara inisialisasi.
```
let a = [1, 2, 3, 4, 5];
let b: [i32; 5] = [1, 2, 3, 4, 5];
let c = [1; 100];
```
1. Inisialisasi semua nilai di dalam kurung siku [].
2. Mendefinisikan tipe dan panjang [i32; 5].
3. Inisialisasi array untuk berisi nilai yang sama untuk setiap elemen dengan menentukan nilai awal, diikuti titik koma, dan kemudian panjang array dalam kurung siku [1; 100].
Jadi kita hanya perlu menggunakan opsi terakhir untuk menginisialisasi array dengan nilai yang sama dengan panjang 100 atau lebih.

primitive_types4.rs

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    #[test]
    fn slice_out_of_array() {
        let a = [1, 2, 3, 4, 5];

        // TODO: Get a slice called `nice_slice` out of the array `a` so that the test passes.
        // let nice_slice = ???
        let nice_slice = &a[1..4];
        assert_eq!([2, 3, 4], nice_slice);
    }
}

Slice memungkinkan kamu mereferensi urutan elemen yang berurutan dalam sebuah koleksi daripada seluruh koleksi.
Slice adalah semacam reference, jadi ia tidak memiliki ownership.
Kita membuat slice menggunakan range dalam kurung siku dengan menentukan [starting_index..ending_index], di mana starting_index adalah posisi pertama dalam slice dan ending_index adalah satu lebih dari posisi terakhir dalam slice.
Jadi di latihan ini kita hanya perlu mengambil nilai index 1 hingga 4 dari array a.
```
let nice_slice = &a[1..4];
```

primitive_types5.rs

fn main() {
    let cat = ("Furry McFurson", 3.5);

    // TODO: Destructure the `cat` tuple in one statement so that the println works.
    // let /* your pattern here */ = cat;
    let (name, age) = cat;
    println!("{name} is {age} years old");
}

Di latihan ini kita perlu mengekstrak variabel tuple.
Untuk mendapatkan nilai individu dari sebuah tuple, kita dapat menggunakan pattern matching untuk mendestruktur nilai tuple, seperti ini:
```
let (name, age) = cat;
```

primitive_types6.rs

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    #[test]
    fn indexing_tuple() {
        let numbers = (1, 2, 3);

        // TODO: Use a tuple index to access the second element of `numbers`
        // and assign it to a variable called `second`.
        // let second = ???;
        let second = numbers.1;
        assert_eq!(second, 2, "This is not the 2nd number in the tuple!");
    }
}

Kita juga dapat mengakses elemen tuple secara langsung dengan menggunakan titik (.) diikuti dengan index dari nilai yang ingin kita akses.
Di latihan ini kita perlu mengambil nilai kedua dari tuple yaitu index 1 maka let second = numbers.1;.