Rust - Tipe Data
Tags: rust, programming, beginners, codenewbie
Published: 2021-06-13 20:46:09

## Tipe Data

> Semua materi merupakan rangkuman belajar.
>
> Untuk bacaan yang lebih langkap & update, dipersilahkan akses pada
> [The Book](https://doc.rust-lang.org/stable/book/ch03-02-data-types.html##data-types)

Yang perlu kita garis bawahi peratama kali adalah
__Rust merupakan *statically typed language*__.

Meski setiap variable mempunyai tipe data,
kita tetap dapat menuliskan variable tanpa tipe datanya
```rust
let name = "Abdul";
```
Hal ini memungkinkan karena _compiler_ membaca tipe data dari nilai yang kita berikan.

Namun ada saat kita __harus__ menuliskannya, seperti saat kita ingin parse suatu nilai
```rust
let birth_date: u8 = "22".parse().expect("Not a number!");
```
Karena fungsi `parse` di sini membaca target _parsing_ dari _variable_-nya.

Adapun tipe data dalam Rust terbagi menjadi beberapa berikut:
1. __Scalar Types__, merupakan tipe data dengan satu nilai
    - Integer
    - Floating-point number
    - Boolean
    - Character
2. __Compound Types__, merupakan kelompok dari beberapa nilai
    - Tuple
    - Array

Sebelum lebih jauh,
tipe data yang kita bahas di sini adalah tipe data yang tersimpan dalam __stack allocation memory__.
Mudahnya _mungkin_ variable yang lebih _"mudah"_, _"murah"_  dan _"cepat"_ untuk diakses oleh aplikasi,
dalam hal ini, bahasa itu sendiri.
Konsep dari _"stack & heap allocation memory"_ merupakan konsep umum, 
yang _mungkin_ akan dibahas nanti dalam sesi tersendiri.

Dan adapun beberapa tipe data yang teman-teman sudah familiar dalam bahasa pemrograman lain seperti "String", "Object/Map", dan lainnya akan kita bahas juga dalam sesi terpisah.


Ok, lanjut....

#### Integer

Merupakan angka tanpa koma.

Terkelompok dalam
- _Unsigned_, ditandai dengan `u`
    Formula jangkauannya 0 sampai 2<sup>n</sup>-1
    Digunakan untuk angga positif (unsigned - tanpa perlu tanda, dipastikan positif)
- _Signed_, ditandai dengan `i`
    Formula jangkauannya -(2<sup>n-1</sup>) sampai 2<sup>n-1</sup>-1
    Digunakan untuk angga negatif & positif (signed - diperlukan tanda)

| Length | Unsigned | Signed |
| ------ |:-------- |:------ |
| 8-bit  | u8       | i8     |
| 16-bit | u16      | i16    |
| 32-bit | u32      | i32    |
| 64-bit | u64      | i64    |
| 128-bit| u128     | i128   |
| arch   | usize    | isize  |

Contoh penerapan formulanya, 8-bit
- Unsigned 
  - 0 sampai 2<sup>8</sup>-1 
  - 0 sampai 255.
- Signed
  - -(2<sup>8-1</sup>) sampai 2<sup>8-1</sup>-1
  - -(2<sup>7</sup>) sampai 2<sup>7</sup>-1
  - -128 sampai 127

Begitu seterusnya sampai 128 yak,
bukan berarti kita harus menghitungnya bila akan define sebuah integer ya,
cukup _googling_ saja jangkauannya,
hal ini cukup sebagai pengetahuan saja.

Adapun untuk `usize` & `isize`
nilai jangkauannya akan menyesuaikan pada architecture device, 64 atau 32

Selain decimal/nilai angka pada umumnya,
kita pun dapan menuliskan hex, octal, binary & byte pada integer

| Number literals |	Example     | Tanda |
| --------------- |:----------- |:----- |
| Hex             |	0xff        | 0x    |
| Octal           |	0o77        | 0o    |
| Binary          |	0b1111_0000 | 0b    |
| Byte (u8 only)  |	b'A'        | b     |
| Decimal         |	98_222      |       |


Seperti beberapa bahasa pemrograman lain,
Rust juga mendukung penggunaan `_` pada angka,
sebagai pembantu dalam pembacaan angka,
biasa digunakan untuk memisahkan ribuan.

> __Integer Overflow__
> 
> Seperti kita tahu, setiap nilai memiliki jangkauannya masing-masing.
> Maka bagaimana bila kita memasukkan nilai lebih dari jangkauannya?
> 
> Terdapat 2 kondisi
> 1. Debug Mode
>     Pada debug mode, akan terjadi _panic runtime_,
>     hal ini terjadi agar developer _aware_ dengan overflow,
>     sehingga barangkali akan mengubahnya
> 2. Release Mode, saat compile dengan `--release` flag
>     Pada mode ini, bila terjadi _overflow_,
>     maka nilainya akan _wrap around_ ke nilai minimumnya.
>     Sebagai contoh, bila u8 dengan jangkauan 0 sampai 255 
>     ditambah atau diisi sehingga nilainya menjadi 256,
>     maka nilainya akan _wrap around_ menjadi 0,
>     257 menjadi 1, 258 menjadi 2, dan seterusnya
> 
> Karenanya, bijaklah dalam memilih tipe data, ok....


### Floating-point Number

Merupakan tipe data angka yang dapat menampung koma.

Terbagi menjadi 2
1. `f32`
    - 32-bits
    - single precision float
2. `f64`
    - 64-bits
    - double precision float

Saat kita membuat float data type tanpa menuliskan tipe datanya,
maka secaa default tipe datanya adalah `f64`.
Hal ini memungkinkan variable menampung dengan nilai presisi yang lebih,
dengan perbedaan kecepatan yang tidak terlalu signifikan.
```rust
fn main() {
  let x = 2.0; // f64
  let y: f32 = 3.0; // f32
}  
```

Untuk jangkauan lebih detail dapat dibaca pada link [berikut](https://en.wikipedia.org/wiki/IEEE_754).


### Boolean

Ditandai dengan keyword `bool`. 
Tentu hanya memiliki 2 nilai, `true` atau `false`


### Character

Ditandai dengan tanda petik tunggal
```rust
fn main() {
   let c = 'z';
   let emoji = '😆';
}
```
Char pada Rust mewakili [_Unicode Scalar Value_](https://en.wikipedia.org/wiki/List_of_Unicode_characters).
Yang artinya Karakter bahasa seperti China, Jepang, bahkan emoji dapat ditampung pada tipe data ini.


Untuk menghindari panjang & lamanya bahasan, 
sisa dari tipe data di atas akan ditulis dalam sesi selanjutnya.


Terima kasih.