Stage 3 - Data Types | Belajar Rust #4
Tags: rust, belajarrustbahasaindonesia, tipedatarust, permrogramanrust
Published: 2022-01-18 01:57:23

**Jeng A**: Reneo jeng, ngerti ra’ sih? Sakjane Rust kuwi sebuah bahasa yang **statically typed**, jadi si Rust iki jeng kudu ngerti semua type dari variables waktu di compile.

**Jeng B**: Ishh aya-aya wae si Rust ini mah, jadi kumaha jeng maksudnya mah?

**Jeng A**: nihh ndelo’i fotone jeng, uwis kesebar neng kabeh wargo ndeso. 


![tipe data](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9z9bviccmspb2dxd1oqc.png)

**Jeng B**: Wahh kabar hangat nih jeng, yuk share di grup pkk ibu-ibu, hayukk.

Seperti dialog para jeng-jenglot di atas, sebenarnya kita bisa mendefinisikan sebuah type di Rust.  Namun bagaimana sih cara mendefinisikan sebuah type di Rust? Caranya ada 2, yaitu.

- **Definisi Implicit**
    
    Rust itu lebih pinter dari ane, jadi dia itu dapat menyimpulkan type dari value yang diberikan kepada variable
    
    → Syntax
    
    ```rust
    let variable_name = value;
    ```
    
- **Definisi Explicit**
    
    Kita bisa memberi tahu compiler secara eksplisit type apa yang akan kita pakai ke variable.
    
    → Syntax
    
    ```rust
     let variable_name:datatype = value;
    ```
    

Yuk lanjut ke tipe data dalam Rust, seperti yang kita tau sebenarnya beberapa bahasa program memiliki type data buil-in dari bahasa tersebut. Rust juga memiliki built-in type data tersebut, kita bisa menyebutnya sebagai **Primitive Types**. Ada berbagai macam type data yang digunakan untuk tujuan yang berbeda, bisa kita lihat di table berikut ini.

| Types | Description | Lists | Example |
| --- | --- | --- | --- |
| Scalar | Menyimpan single value | Integers | 100, -100 |
|  |  | Floats | 99.9, -99.9 |
|  |  | Character | A, a, $, 😯 |
|  |  | Boolean | True, False |
| Compound | Mengelompokkan beberapa value dalam satu variable | Array | [1, 2, 3, 4, 5] |
|  |  | Tuple | (”Adi”, 183, “70kg”, 23) |

## 1. Integers

Integer merupakan data types yang **menyimpan bilangan bulat**. Berdasarkan jumlah bits yang ditempati variable dalam memori integer dalam Rust memiliki dua tipe, yaitu.

> **Note:** `i` menunjukan signed letter yang artinya kita dapat mendefinisikan bilangan negatif (-1) atau positif (1)/ `-n <= 0 <= n`, sedangan `u` menunjukan unsigned letter yang artinya kita hanya dapat mendefinisikan bilangan tidak bertanda/ `n >= 0`.
> 

### a. Dynamic size types

Size pada tipe ini tergantung pada arsitektur mesin yang menaunginya.

| Signed/Unsigned | Size (bits) | Syntax | Description |
| --- | --- | --- | --- |
| i | size | isize | tipe integer pointer-sized signed |
| u | size | usize | tipe integer pointer-sized unsigned |

### b. Fixed size types

Kita dapat membuat size pada data types menjadi fix dalam bits yang spesifik. 

| Signed (i)/ Unsigned (u) | Size (bits) | Syntax | Description |
| --- | --- | --- | --- |
| i | 8 | i8 | tipe integer 8-bit signed |
|  | 16 | i16 | tipe integer 16-bit signed |
|  | 32 | i32 | tipe integer 32-bit signed |
|  | 64 | i64 | tipe integer 64-bit signed |
| u | 8 | u8 | tipe integer 8-bit unsigned |
|  | 16 | u16 | tipe integer 16-bit unsigned |
|  | 32 | u32 | tipe integer 32-bit unsigned |
|  | 64 | u64 | tipe integer 64-bit unsigned |

→ Contoh

```rust
fn main() {
  let a:i32 = -100;
  let b:u32 = 40;
  let c:isize = 30;
  let d:usize = 10;

  println!("a: {}", a);
  println!("b: {}", b);
  println!("c: {}", c);
  println!("d: {}", d);
}
```

→ Output

```bash
a: -100
b: 40
c: 30
d: 10
```

## 2. Floats

Floats/ floating point merupakan angka dengan pecahan (99.9). Float memiliki 2 sub tipe berdasarkan jumlah bits yang bisa distore, yaitu.

- single-precision `f32`
- double-precision `f64`

→ Contoh

```rust
fn main() {
  let a:f32 = 83.8;
  let b:f64 = 9203.99;

  println!("a: {}", a);
  println!("b: {}", b);
}
```

→ Output

```bash
a: 83.8
b: 9203.99
```

## 3. Character dan String

### a. Character

Character/ char merupakan variable yang digunakan untuk menyimpan single character value. Value yang disimpan ke variable char diapit oleh single quote(`’ ‘`).

```rust
let char_saya_loh:char = 'g';
```

> `'g'` → character diapit dengan single quotes
> 

→ Contoh

```rust
fn main() {
  let a:char = 'H';
  let b:char = '😆';

  println!("a: {}", a);
  println!("b: {}", b);
}
```

→ Output

```bash
a: H
b: 😆
```

> **Note:** Char dalam Rust memerlukan sampai dengan 4 bytes untuk sebuah character, jadi kita dapat menyimpan lebih seperti emoji, chinese, korean, dan japanese character tidak hanya ASCII value.
> 

### b. String

String merupakan kumpulan characters yang diapit oleh double quotes (`” “`).

```rust
let string_saya_loh:&str = "Aku Ganteng";
```

→ Contoh

```rust
fn main() {
  let a:&str = "Aku Ganteng";
  let b:char = '😆';

  println!("{} {}", a, b);
}
```

→ Output

```bash
Aku Ganteng 😆
```

## 4. Boolean

Data type boolean merupakan tipe data yang suanggattt mudah, bolean bisa take sebuah value antara `true` atau `false`. Kita juga bisa mendapatkan hasil boolean dengan melakukan perbandingan dua buah nilai.

→ Contoh

```rust
fn main() {
  let a:bool = true;
  let b:bool = 10 > 100;

  println!("Aku ganteng ? {} , aku jelek? {}", a, b);
}
```

→ Output

```bash
Aku ganteng ? true , aku jelek? false
```

## 5. Arrays

Array itu apa? simak yuk! (bukan ujian mandiri masuk kampus ya).

- kumpulan elemen dari tipe yang sama,
- Hanya dapat memiliki panjang yang tetap (fixed length),
- Setiap elemen memiliki index,
- Elemen pertama selalu berada pada index 0, dan
- Array memiliki sifat immutable secara default.

```rust
// Array of size 5
[1, 2, 3, 4, 5] // index secara berurutan -> 0, 1, 2, 3, 4
```

### a. Mendefinisikan dan print array

Dalam Rust, untuk mendefinisikan sebuah array kita perlu mendefiniskan **type** dan **size** dari array yang akan kita definisikan. Array memiliki elemen yang ditutup dengan square brackets `[ ]`, jumlah elemen dalam array harus sama  dengan size yang kita definisikan.

```rust
let arr:[char; 3] = ["A", "d", "i"];
```

> `let` → identifier
> 
> 
> `arr` → variable name
> 
> `char` → fixed data type
> 
> `3` → size of array
> 
> `["A", "d", "i"]` → elements of array
> 

Kita dapat print semua array menggunakan debug traits.

→ Contoh

```rust
fn main() {
  let arr:[i32; 5] = [3, 2, 1, 3, 2];

  println!("{:?}", arr);
}
```

→ Output

```bash
[3, 2, 1, 3, 2]
```

### b. Akses sebuah element dan length dari array

Kita dapat mengakses sebuah elemen dari array dengan cara menuliskan nama array yang diikuti dengan nomor index.

→ Contoh

```rust
fn main() {
  let arr:[i32; 5] = [3, 2, 1, 3, 2];

  println!("Elemen pertama : {}", arr[0]); // index dimulai dari 0 kayak spbu
  println!("Elemen ketiga : {}", arr[2]);
  println!("Length arr : {}", arr.len()); // print length dari array arr

  let ara = [3; 10]; // inisialisasi array jika ingin sama semua nilai
  println!("Elemen kedua : {}", ara[1]);
  println!("{:?}", ara);
  println!("Length ara : {}", ara.len()); // print length dari array ara
}
```

→ Output

```bash
Elemen pertama : 3
Elemen ketiga : 1
Length arr : 5
Elemen kedua : 3
[3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
Length ara : 10
```

### c. Membuat array menjadi mutable

Di course berikutnya kita sudah mengenal `mut` keyword untuk membuat variable menjadi mutable. Kita juga bisa mengimplementasikan `mut` keyword ke array.

→ Contoh

```rust
fn main() {
  let mut arr:[i32; 5] = [3, 2, 1, 3, 2];

  println!("Elemen pertama : {}", arr[0]); // index dimulai dari 0 kayak spbu
  println!("Elemen ketiga : {}", arr[2]);

  arr[2] = 10;
  println!("Elemen ketiga : {}", arr[2]);
}
```

→ Output

```bash
Elemen pertama : 3
Elemen ketiga : 1
Elemen ketiga : 10
```

### d. Slice array

Apa sih itu slice? kita lihat list dibawah ini, cekidot.

- Portion dari sebuah array,
- Memungkinkan untuk refer ke subset dari lokasi memori yang berdekatan,
- Size dari slice tidak diketahui pada saat kompilasi, dan
- Two-word object, yang pertama adalah data pointer dan yang kedua adalah length dari slice.

```rust
let slice_array_loh:&[u32]=&arr[1..4];
```

> `slice_array_loh` → variable name
> 
> 
> `&arr` → array referred
> 
> `1` → starting index (termasuk)
> 
> `4` → ending index (tidak termasuk)
> 

→ Contoh

```rust
fn main() {
  let arr:[u32; 5] = [3, 2, 1, 3, 2];
  let slice_array:&[u32]=&arr;
  let slice_array_loh:&[u32]=&arr[1..4];

  println!("Slice array loh: {:?}", slice_array_loh);
  println!("Slice array: {:?}", slice_array);
}
```

→ Output

```bash
Slice array loh: [2, 1, 3]
Slice array: [3, 2, 1, 3, 2]
```

> Object pointer adalah object bahasa pemrograman yang menunjuk ke lokasi memori data.
> 
> 
> **Note:** Jika range elemen tidak ditentukan, maka slice akan mengambil seluruh array.
> 

## 6. Tuples

Tuple itu apa? simak yuk! (bukan ujian mandiri masuk kampus ya, kayak dejavu 🤔).

- kumpulan elemen dari tipe yang tidak sama (bisa memiliki berbagai macam data type),
- Hanya dapat memiliki panjang yang tetap (fixed length),
- Setiap elemen memiliki index,
- Elemen pertama selalu berada pada index 0, dan
- Tuple memiliki sifat immutable secara default.

```rust
// Tuple of size 4
("Adi", 100, '%', "ganteng") // index secara berurutan -> 0, 1, 2, 3
```

### a. Mendefinisikan dan mengakses tuple

- Mendefinisikan tuple tanpa menspesifikan type.
    
    ```rust
    let nama_tuple = ("Adi", 100, '%', "ganteng");
    ```
    
- Mendefinisikan tuple dengan menspesifikan type.
    
    ```rust
    let nama_tuple:(&str, u32, char, &str) = ("Adi", 100, '%', "ganteng");
    ```
    
- Mengakses elemen tuple menggunakan dot operator (`.`).
    
    ```rust
    nama_tuple.0 // nama_tuple.indexvalue
    ```
    
- Mengakses elemen tuple menggunakan destructure.
    
    ```rust
    let nama_tuple:(&str, u32, char, &str) = ("Adi", 100, '%', "ganteng");
    let (nama, angka, parameter, nilai) = nama_tuple;
    ```
    
    → Contoh
    
    ```rust
    fn main() {
      let nama_tuple = ("Adi", 100, '%', "ganteng");
      println!("Nama saya adalah {}", nama_tuple.0);
    
      let nama_tuple:(&str, u32, char, &str) = ("Adi", 100, '%', "keren");
      let (nama, angka, parameter, nilai) = nama_tuple;
      println!("Nama : {}", nama);
      println!("Nilai : {}{}", angka, parameter);
      println!("Sifat : {}", nilai);
      println!("{:?}", nama_tuple); // akses semua elemen menggunakan debug trait
    }
    ```
    
    → Output
    
    ```bash
    Nama saya adalah Adi
    Nama : Adi
    Nilai : 100%
    Sifat : keren
    ("Adi", 100, '%', "keren")
    ```
    

### b. Membuat tuple mutable

Sama seperti lainnya untuk membuat mutable kita bisa menambahkan keyword `mut`.

→ Contoh

```rust
fn main() {
  let mut nama_tuple = ("Adi", 100, '%', "ganteng");
  println!("Nama saya adalah {}", nama_tuple.0);
  nama_tuple.0 = "Purwanto";
  println!("Nama saya adalah {}", nama_tuple.0);
}
```

→ Output

```bash
Nama saya adalah Adi
Nama saya adalah Purwanto
```

## Constant Variables

Constant variables adalah variable yang tidak bisa kita ubah value-nya ketika kita deklarasikan. Bisa di definisikan sebagai global dan local scope.

```rust
const NAMA_SAYA:&str = "Adi";
```

> `const` → identifier
> 
> 
> `nama` → variable name
> 
> `&str` → type
> 
> `"Adi"` → variable value
> 

→ Contoh

```rust
const NAMA_SAYA:&str = "Adi";
fn main() {
  const PACAR_SAYA:&str = "Emma Stone";
  println!("Nama: {}", NAMA_SAYA);
  println!("Pacar: {}", PACAR_SAYA);
}
```

→ Output

```bash
Nama: Adi
Pacar: Emma Stone
```

> **Naming Convention:** Nama variable constant ditulis dengan convention **SCREAMING_SNAKE_CASE**.
> 
> - Semua huruf diwajibkan upper case,
> - Semua kata wajib dipisah dengan sebuah underscore (`_`).

### Perbedaan `const` dan `let` variables

| Declaration | Scope | Mutability | Shadowing | Set value at runtime | Data type |
| --- | --- | --- | --- | --- | --- |
| const | global dan local | tidak bisa mutable | tidak bisa | sebelum program running | wajib |
| let | local | bisa mutable dengan mut keyword | bisa | bisa | tidak wajib |

---

Jika ada kesalahan dalam menyampaikan konsep dan penulisan mohon bantuannya di kolom discussion 🤗. Terima kasih.

> `#samasamabelajar`
> 

---

> **LIST COURSE:**
> 
> 
> **[If you don't know me, then, you would not know who I am](https://dev.to/myusufadp/if-you-dont-know-me-then-you-would-not-know-who-i-am-learn-rust-1-ah4)**
> 
> **[Stage 1](https://dev.to/myusufadp/stage-1-belajar-rust-2-5al5)**
> 
> **[Stage 2 - Variables](https://dev.to/myusufadp/stage-3-data-types-belajar-rust-4-2dhn-temp-slug-197874/edit)**
>

---

> [Twitter](https://twitter.com/myusufadp)
> 
> 
> [Buy me a coffe](https://saweria.co/myusufadp)
>