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.

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
  

  let variable_name = value;
  

• Definisi Explicit

  Kita bisa memberi tahu compiler secara eksplisit type apa yang akan kita pakai ke variable.

  → Syntax
  

   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.

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.

b. Fixed size types

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

→ Contoh

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

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

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

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

→ Output

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(’ ‘).

let char_saya_loh:char = 'g';

'g' → character diapit dengan single quotes

→ Contoh

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

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

→ Output

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 (” “).

let string_saya_loh:&str = "Aku Ganteng";

→ Contoh

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

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

→ Output

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

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

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

→ Output

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.

// 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.

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

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

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

→ Output

[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

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

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

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

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.

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

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

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.

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

a. Mendefinisikan dan mengakses tuple

• Mendefinisikan tuple tanpa menspesifikan type.
  

  let nama_tuple = ("Adi", 100, '%', "ganteng");
  

• Mendefinisikan tuple dengan menspesifikan type.
  

  let nama_tuple:(&str, u32, char, &str) = ("Adi", 100, '%', "ganteng");
  

• Mengakses elemen tuple menggunakan dot operator (.).
  

  nama_tuple.0 // nama_tuple.indexvalue
  

• Mengakses elemen tuple menggunakan destructure.
  

  let nama_tuple:(&str, u32, char, &str) = ("Adi", 100, '%', "ganteng");
  let (nama, angka, parameter, nilai) = nama_tuple;
  

  → Contoh
  

  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
  

  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

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

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.

const NAMA_SAYA:&str = "Adi";

const → identifier

nama → variable name

&str → type

"Adi" → variable value

→ Contoh

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

→ Output

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

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

Stage 1

Stage 2 - Variables

Twitter

Buy me a coffe