DEV Community: Adi Purwanto

Stage 5 - Conditional Expression | Belajar Rust #6

Adi Purwanto — Sat, 22 Jan 2022 06:51:10 +0000

Sebenarnya conditional itu kayak kekuatan super, kalian bisa menggunakan conditional untuk membuat keputusan. Kekuatan ini bekerja dengan cara melalukan pengecekan pada condition of the expression dan bertindak sesuai dengan condition of the expression tersebut.

Tipe-tipe dari conditional expression

if expression
if let expression
match expression

1. If expression

Rust memiliki berbagai macam conditional menggunakan if statement. Apa saja sih, yok kita bahas satu-persatu 🥳

a. If expression

if expression memerlukan suatu kondisi/ condition. Jika condition di dalam if expression bernilai true, maka block of code akan dieksekusi.

→ Contoh

fn main() {
  let mahasiswa = "Adi";

  if mahasiswa == "Adi" {
    println!("Mahasiswa ini bernama {}", mahasiswa);
  }
}

→ Output

Mahasiswa ini bernama Adi

b. If...else expression

if...else memiliki kegunaan yang melengkapi kekosongan if expression, jika kondisi yang berada di if expression bernilai false, maka statement yang berada di dalam block else akan dieksekusi.

→ Contoh

fn main() {
  let mahasiswa = "Adi";

  if mahasiswa == "Adi" {
    println!("Mahasiswa ini bernama {}", mahasiswa);
  } else {
    println!("Wahh mahasiswa ini gak bernama");
  }
}

→ Output

Mahasiswa ini bernama Adi

c. If...else if...else expression

Jika kita memiliki banyak atau lebih dari satu kondisi yang perlu kita cek, maka menggunakan if...else if...else merupakan pilihan yang sangat tepat.

→ Contoh

fn main() {
  let mahasiswa = "Yusuf";

  if mahasiswa == "Adi" {
    println!("Mahasiswa ini bernama {}", mahasiswa);
  } else if mahasiswa == "Yusuf" {
     println!("Mahasiswa ini bernama {}", mahasiswa);
  } else {
    println!("Wahh mahasiswa ini gak bernama");
  }
}

→ Output

Mahasiswa ini bernama Yusuf

d. Nested if expression

Kita bisa melakukan nested/ bersarang if expression, yang dimaksud nested adalah kita dapat menggunakan if expression di dalam body if expression yang lain.

Note: Kalian bisa membuat banyak level nesting, sesuai kebutuhan.

→ Contoh

fn main() {
  let mahasiswa = "Adi";
  let mahasiswa_2 = "Yusuf";

  if mahasiswa == "Adi" {
    if mahasiswa_2 == "Yusuf" {
      println!("Mahasiswa ini bernama {}", mahasiswa_2);
    }
    println!("Mahasiswa ini bernama {}", mahasiswa);
  } else {
    println!("Wahh mahasiswa ini gak bernama")
  }
}

→ Output

Mahasiswa ini bernama Yusuf
Mahasiswa ini bernama Adi

e. Shorthand if

Kita sebagai warga netizen atau warga +62, kita sangat malas mengetik if-else yang sangat panjang, spesial untuk warga +62 kita bisa menggunakan shorthand if.

→ Contoh

fn main() {
  let mahasiswa = "Adi";

  let hasil = if mahasiswa == "Adi" { "Your so handsome, Adi" } else { "I,m pretty handsome" };
  println!("{}", hasil);
}

→ Output

Your so handsome, Adi

2. If let expression

If let merupakan conditional expression yang memungkinkan pattern matching. Block of code dalam konstruk dijalankan jika pola dalam kondisi cocok dengan scrutinee expression. Aduh bingung ya, yuk langsung ke contoh dengan beberapa kasus.

a. Pattern is matched

→ Contoh

fn main() {
  // scrutinee expression
  let mahasiswa = ("Adi", "sistem informasi", "yogyakarta");

  if let  ("Adi", "sistem informasi", "yogyakarta") = mahasiswa {
    println!("{:?}", mahasiswa);
  } else {
    println!("Value tidak berjodoh");
  }
}

→ Output

("Adi", "sistem informasi", "yogyakarta")

→ Contoh value pertama atau kedua match

fn main() {
  // scrutinee expression
  let mahasiswa = ("Adi", "sistem informasi", "yogyakarta");

  if let  ("Adi", "sistem informasi", z) = mahasiswa {
    println!("Nilai tampil {}", z);
  } else {
    println!("Value tidak berjodoh");
  }
}

→ Output

Nilai tampil yogyakarta

→ Contoh value pertama match

fn main() {
  // scrutinee expression
  let mahasiswa = ("Adi", "sistem informasi", "yogyakarta");

  if let  ("Adi", y, z) = mahasiswa {
    println!("Nilai tampil {}, {}", y, z);
  } else {
    println!("Value tidak berjodoh");
  }
}

→ Output

Nilai tampil sistem informasi, yogyakarta

b. Pattern is not matched

→ Contoh

fn main() {
  // scrutinee expression
  let mahasiswa = ("Adi", "sistem informasi", "yogyakarta");

  if let  ("Yusuf", y, z) = mahasiswa {
    println!("Nilai tampil {}, {}", y, z);
  } else {
    println!("Value tidak berjodoh");
  }
}

→ Output

Value tidak berjodoh

c. Pattern is replaced with `_`

Kita bisa menggunakan _ untuk kasus ketika pattern tidak terdefinisi.

→ Contoh

fn main() {
  // scrutinee expression
  let mahasiswa = ("Adi", "sistem informasi", "yogyakarta");

  if let _ = mahasiswa {
    println!("{:?}", mahasiswa);
  } else {
    println!("Value tidak berjodoh");
  }
}

→ Output

warning: irrefutable `if let` pattern
 --> src/main.rs:5:6
  |
5 |   if let  _ = mahasiswa {
  |      ^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(irrefutable_let_patterns)]` on by default

("Adi", "sistem informasi", "yogyakarta")

Note: Kenapa compiler mendeteksi warning ⚠️, dikarenakan Rust compiler mengeluh, kalian itu gak masuk akal makai if let dengan irrefutable pattern

3. Match expression

Match expression mengecek jika value saat ini cocok dengan value yang berada di dalam list. Jika kalian sudah pernah mempelajari beberapa bahasa pemrograman seperti C++, maka match expression mirip dengan switch. Expression ini membuat code lebih compact dari pada mengunakan if/else.

→ Contoh

fn main() {
  let x = 2;

  match x {
    1 => println!("Adi"),
    2 => println!("Purwanto"),
    3 => println!("Sistem"),
    _ => println!("Informasi") // ini akan dieksekusi jika value tidak ada yang macth
  };
}

→ Output

Purwanto

→ Contoh

fn main() {
  let x = 10;

  let value = match x {
    1 => "Adi",
    2 => "Purwanto",
    3 => "Sistem",
    _ => "Informasi" // ini akan dieksekusi jika value tidak ada yang macth
  };

  println!("{}", value);
}

→ Output

Informasi

Contoh

Contoh kali ini kita akan membuat program pengecekan apakah bilangan tersebut ganjil atau genap.

Input

integer

Output

Angka x adalah ganjil atau Angka x adalah genap

Note: Yuk kerjakan dulu, lalu beri tahu jawabannya di kolom discussion bagaimana cara solve the problem diatas.

→ Penyelesaian jika ada yang mentok

fn main() {
  // input
  let x:i32 = 6;

  if x % 2 != 0 {
    println!("Angka {} adalah ganjil", x);
  } else {
    println!("Angka {} adalah genap", x);
  }
}

→ Output

Angka 6 adalah genap

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

Stage 3 - Data Types

Stage 4 - Operators

Twitter

Buy me a coffe

Stage 4 - Operators | Belajar Rust #5

Adi Purwanto — Tue, 18 Jan 2022 10:48:45 +0000

Operators merupakan sebuah simbol yang mengambil satu atau lebih values dan kemudian mengeluarkan value lainnya, operator memberitahukan compiler untuk melakukan beberapa operasi. Rust memiliki banyak operators yang berbeda untuk melakukan berbagai macam operasi. Operators memiliki dua kategori berdasarkan number of operands, yaitu unary dan binary operators.

Unary operators → operators yang bekerja pada single operand
- Borrow expression → &, &mut;
- Dereference expression → *;
- Negation expression → !;
- Logical negation expression.
Binary operators → operators yang menangani dua operands
- Arithmetic expression → +, -, *, /, %;
- Logical expression → &&, ||;
- Comparison expression → >, <, >=, <=, !=, ==;
- Assignment expression → =;
- Compound assignment expression → -=, +=, /=, *=, %=;
- Bitwise expression → &, |, ^;
- Typecast expression → as.

Kita bahas satu-persatu dari list operators diatas berikut.

1. Arithmetic operators

Ketika kita ingin menggunakan operasi aritmatika anak sd, kita bisa menggunakan arithmetic operators.

operand 1 [...] operand 2 // [+, -, *, %, atau /]

Operator	Operation	Explanation
+	Addition	Menambah dua operand
-	Subtraction	Mengurangi dua operand
/	Division	Membagi dua operand
*	Multiplication	Mengkalikan dua operand
%	Modulus	Hasil sisa bagi dua operand

→ Contoh

fn main() {
  let x = 8;
  let y = 4;

  println!("x: {} dan y: {}", x, y);
  println!("x + y = {}", x + y);
  println!("x - y = {}", x - y);
  println!("x / y = {}", x / y);
  println!("x * y = {}", x * y);
  println!("x % y = {}", x % y);
}

→ Output

x: 8 dan y: 4
x + y = 12
x - y = 4
x / y = 2
x * y = 32
x % y = 0

2. Logical operators

Operators ini memiliki tugas untuk mengoperasikan true/ false values.

operand 1 [...] operand 2 // [&&, ||] -> binary operators
operand 2 [...] operand 1 // [!] -> unary operators

Operator	Operation	Explanation
&&	AND	true jika kedua operand true

!	NOT	Negasi value dari single operand

→ Contoh

fn main() {
  let x = false;
  let y = true;

  println!("x: {} dan y: {}", x, y);
  println!("x && y = {}", x && y);
  println!("x || y = {}", x || y);
  println!("!y = {}", !y);
}

→ Output

x: false dan y: true
x && y = false
x || y = true
!y = false

3. Comparison operators

Operators ini digunakan untuk melakukan komparasi values dari dua operands.

operand 1 [...] operand 2 // [<, >, <=, >=, ==, atau !=]

Operator	Operation	Explanation
>	Greater than	true jika salah satu operand lebih besar dari operand satunya
<	Lesser than	true jika salah satu operand lebih kecil dari operand satunya
>=	Greater than equal to	true jika salah satu operand lebih besar atau sama dengan dari operand satunya
<=	Lesser than equal to	true jika salah satu operand lebih kecil atau sama dengan dari operand satunya
==	Equals to	true jika kedua operand sama
!=	Not equal to	true jika kedua operand tidak sama

→ Contoh

fn main() {
  let x = 8;
  let y = 7;

  println!("x: {} dan y: {}", x, y);
  println!("x > y = {}", x > y);
  println!("x < y = {}", x < y);
  println!("x >= y = {}", x >= y);
  println!("x <= y = {}", x <= y);
  println!("x == y = {}", x == y);
  println!("x != y = {}", x != y);
}

→ Output

x: 8 dan y: 7
x > y = true
x < y = false
x >= y = true
x <= y = false
x == y = false
x != y = true

4. Bitwise operators

Operators ini menghandle binary representation dari operands.

operand 1 [...] operand 2 // [&, |, ^] -> binary operators
[...] operand 1 // [!, <<, >>] -> unary operators

Operator	Operation	Explanation
&	AND	Bitwise AND kedua operands
		OR
^	XOR	Bitwise XOR kedua operands
!	NOT	Inverse bits dari operand
<<	Left shift	Memindahkan semua bit dalam operand pertama ke kiri dengan jumlah tempat yang ditentukan dalam operand kedua. Bit baru diisi dengan nol. Menggeser nilai ke kiri satu posisi sama dengan mengalikannya dengan 2, menggeser dua posisi sama dengan mengalikannya dengan 4, dan seterusnya.
>>	Right shift	Nilai operand kiri dipindahkan ke kanan dengan jumlah bit yang ditentukan oleh operand kanan.

→ Contoh

fn main() {
  let x = 8;
  let y = 7;

  println!("x: {} dan y: {}", x, y);
  println!("x & y = {}", x & y);
  println!("x | y = {}", x | y);
  println!("x ^ y = {}", x ^ y);
  println!("!y = {}", !y);
  println!("x << 4 = {}", x << 4);
  println!("x >> 2 = {}", x >> 2);
}

→ Output

x: 8 dan y: 7
x & y = 0
x | y = 15
x ^ y = 15
!y = -8
x << 4 = 128
x >> 2 = 2

5. Assignment dan compound assignment operators

a. Assignment operator

Operator ini digunakan untuk menyimpan value ke dalam variable.

operand 1 = operand 2

→ Contoh

fn main() {
  let x = 8;
  let y = 7;
  let z = x + y;

  println!("x: {}, y: {}, dan z:{}", x, y, z);
}

→ Output

x: 8, y: 7, dan z:15

b. Compound assignment operator

Operator ini memiliki tugas untuk melakukan operasi dan kemudian menetapkan nilai tersebut ke operand.

operand 1 [...] operand 2 // [+=, -=, /=, *=, &=, !=, ^=, <<=, atau >>=]
// contoh a *= x -> a = a * x

→ Contoh

fn main() {
  let mut x = 8;

  println!("x: {}", x);
  x += 1;
  println!("x: {}", x);
  x -= 2;
  println!("x: {}", x);
  x *= 2;
  println!("x: {}", x);
  x /= 7;
  println!("x: {}", x);
}

→ Output

x: 8
x: 9
x: 7
x: 14
x: 2

6. Type casting operator

Operator ini diperlukan ketika kita ingin mengkonversi data type dari variable ke data type yang lain.

operand as datatype

→ Contoh

fn main() {
  let x = 15;
  let y = (x as f64) / 4.0;

  println!("x: {} dan y: {}", x, y);
}

→ Output

x: 15 dan y: 3.75

📝 Data types apa saja yang bisa kita casting?

Integer ke floating-point dan sebaliknya

Integer ke string

📝 Data types apa saja yang tidak bisa kita casting?

String (&str) atau character tidak bisa ke integer atau float

Character tidak bisa ke String dan sebaliknya

7. Borrowing dan dereferencing operators

a. Borrowing operator

Borrowing atau yang artinya reference pada binding data asli atau share the data.

Jika kalian pernah menggunakan C, References sama seperti pointers dalam C

let operand 1 = [&, atau &mut] operand 2

Operator	Operation	Explanation
&	shared borrow	operand bisa membaca data dari operand lainnya
&mut	mutable borrow	operand bisa membaca dan mengubah data dari perand lainnya

b. Dereferencing operator

Setelah Anda memiliki mutable reference ke suatu variabel, dereferencing adalah istilah yang digunakan untuk merujuk pada perubahan nilai referenced variabel menggunakan address yang disimpan dalam referring variabel.

let operand 1 = &mut operand 2;
*operand 1 = operand 2 // mengubah value dari variable yang di borrow

→ Contoh

fn main() {
    let x = 14;
    let mut y = 12;
    //immutable reference to a variable
    let a = &x;
    println!("Value of a:{}", a); 
    println!("Value of x:{}", x); // x value remains the same since it is immutably borrowed
    //mutable reference to a variable
    let b = &mut y;
    println!("Value of b:{}", b);

    *b = 11; // derefencing 
    println!("Value of b:{}", b); // updated value of b
    println!("Value of y:{}", y); // y value can be changed as it is mutuably borrowed
}

→ Output

Value of a:14
Value of x:14
Value of b:12
Value of b:11
Value of y:11

8. Precedence dan associativity

a. Precedence

Ini menentukan operasi mana yang dilakukan pertama kali dalam ekspresi dengan lebih dari satu operator. Operator berikut merupakan urutan prioritas mereka dari tertinggi ke terendah.

Unary
- Logical/Bitwise NOT - !
- Derereference - *
- Borrow - &, &mut
Binary
- Typecast - as
- Multiplication- *,Division - /, Remainder - %
- Addition -+, Subtraction - -
- Left Shift - <<, Right Shift - >>
- Bitwise AND - &
- Bitwise XOR - ^
- Bitwise OR - |
- Comparison - == != < > <= >=
- Logical AND - &&
- Logical OR - ||
- Range - start .. stop
- Assignment/Compound Assignment - = += = = /= %= &= |= ^= <<= >>=

Note: Operator yang ditulis pada baris yang sama memiliki urutan prioritas yang sama.

b. Associativity

Jika dua atau lebih operator dengan precedence yang sama muncul dalam sebuah pernyataan, maka operator mana yang akan dievaluasi terlebih dahulu ditentukan oleh associativity.

Left to Right Associativity

Left associativity terjadi ketika expression dievaluasi dari kiri ke kanan. Expression seperti a ~ b ~ c, dalam hal ini, akan ditafsirkan sebagai (a ~ b) ~ c di mana ~ dapat berupa operator apa pun. Operator di bawah ini dapat dirantai sebagai left associative.

as
*, /, %
+, -
<< >>
&
^
|
&&
||

→ Contoh

fn main() {
    println!("Jawaban UAS : {}",( 10 + 5 ) * 8 / 7 & 8);
}

→ Output

Jawaban UAS : 0

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

Stage 3 - Data Types

Twitter

Buy me a coffe

Stage 3 - Data Types | Belajar Rust #4

Adi Purwanto — Tue, 18 Jan 2022 01:57:23 +0000

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.

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

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

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

Stage 1

Stage 2 - Variables

Twitter

Buy me a coffe

Stage 2 - Variables | Belajar Rust #3

Adi Purwanto — Mon, 17 Jan 2022 18:40:30 +0000

Sekarang kita akan masuk kedalam konsep dimana kita akan sangat membutuhkannya, di sesi ini kita akan mengulik apa itu variables dan bagaimana variables bisa melakukan store data.

1. Variables

Sebenarnya kita dapat membuat analogi variable itu sebagai kotak pindahan terlakban (transfer box ← * bener gak ya bahasa inggrisnya) yang memiliki isi (value) dan diberi nama (identifier) setiap kotaknya, agar kita mengetahui apa saja isi (value) didalamnya. Seperti analogi tersebut, di mana kita tidak bisa mengubah isi variable (immutable by default) karena kotak pindahan tersebut terlakban.

a. Membuat sebuah variable

Membuat variable dalam Rust itu sangat mudah, kita bisa menggunakan let (declaration statement) binding yang disertai dengan nama variable.

let nama_variable ;

let → identifier

nama_variable → variable name

; → jangan lupa titik koma kata Pak Sandhika Galih

Dalam Rust menulis nama variable menggunakan convention yang ditetapkan yaitu snake_case

snake_case

Semua huruf diwajibkan atau fardhu ain mengunganakn lower case.

Semua kata wajib hukumnya dipisah dengan menggunakan underscore ( _ ).

b. Inisialisasi variable

Kita dapat menginisialisasikan sebuah variable dengan memberikan nilai (value) ke variable ketika dideklarasikan. Value akan terikat ke variable tersebut.

let ganteng = "Adi";

let → identifier

ganteng → variable name

“Adi” → variable value

; → jangan lupa titik koma kata Pak Sandhika Galih

→ Contoh

fn main() {
  let ganteng = "Adi";
  println!("Orang terganteng se-RT adalah {}", ganteng);
}

→ Output

Orang terganteng se-RT adalah Adi

Note: Begini kawan, sangat tidak saya rekomendasikan untuk membuat variable yang tidak diinisialisasi terlebih dahulu.

c. Membuat multiple variables

Hmm apakah mungkin kita dapat assign multiple variables? Jawabannya pasti mungkin dong, buat apa aku bikin kalo gak mungkin, ohh aku.

let (ganteng, level, tempat) = ("Adi", "maksimal", "RT");

let → identifier

ganteng → variable name 1

level → variable name 2

tempat → variable name 3

"Adi" → variable value 1

“maksimal” → variable value 2

“RT” → variable value 3

→ Contoh

fn main() {
  let (ganteng, level, tempat) = ("Adi", "maksimal", "RT");
  println!("Orang terganteng tingkat {1} se-{2} adalah {0}", ganteng, level, tempat);
}

→ Output

Orang terganteng tingkat maksimal se-RT adalah Adi

Note: Kalau kita tetap ngeyel un-assigned atau tidak memakai variable, pasti kalian dapat teguran warning dari Rust compiler. Biar gak kena teguran lagi kita bisa sogok dia dengan nulis expression #[allow(unused_variables, unused_mut)] di awal dari kode program. Ingat catatan diatas nda baik hukumnya kalo ngeyel masih un-assigned atau tidak memakai variables.

d. Membuka lakban kotak/ membuat variable mutable

Waitt judul apaan ini, bukannya di awal dibilangin kan variable itu immutable. Tapi tunggu dulu kan namanya semua orang pasti ingin berubah, ya variable juga dong ingin menjadi seseorang yang lebih baik toh wkwk (ketawa khas +62). Jadi intinya kita bisa dah bikin variable yang mutable dengan cara membuat identifier let yang disertai dengan mut keyword dan nama variable.

let mut ganteng = "Adi";

let mut → identifier untuk mutable variable

ganteng → variable name

"Adi" → variable value

→ Contoh

fn main() {
  let mut ganteng = "Adi";
  println!("Orang terganteng adalah {}", ganteng);
  ganteng = "Purwanto";
  println!("Orang terganteng adalah {}", ganteng);
}

→ Output

Orang terganteng adalah Adi
Orang terganteng adalah Purwanto

2. Scope dan Shadowing

a. Scope dari sebuah variable

Scope dari sebuah variable itu mengacu pada visibility dari sebuah variable, atau program mana sih yang bisa mengakses variable tersebut. Semua hal itu tuh tergantung dimana kita mendeklarasikan si variable ini. variable akan memiliki scope global jika kita tidak mendeklarasikannya di dalam { }, block of code.

Terdapat dua types dari variables berdasarkan scopenya.

1). Local variable

Local variable adalah variable yang berada di dalam block of code { } , kita tidak dapat mengakses variable diluar kurung kurawal. Jadi setelah kurung kurawal tutup }, sebenarnya variable itu dibebaskan dan memori untuk variable tidak dialokasikan.

2). Global variable

Jadi, global variable itu semacam kebalikan dari local variable, dimana variable yang dideklarasikan di luar block of code dan bisa diakses di dalam block berikutnya itu bisa kita sebut sebagai global variables.

→ Contoh error

fn main() {
    {
        let dalam = 10; // * local variable
    }
    println!("{}", dalam);
}

→ Output

  |
5 |     println!("{}", dalam);
  |                    ^^^^^ not found in this scope

→ Contoh beneran

fn main() {
  let luar = 100;
    {
        let dalam = 10;
      println!("{}", dalam);
      println!("{}", luar);
    }
  println!("{}", luar);
}

→ Output

10
100
100

b. Shadowing

Variable shadowing adalah teknik yang mana sebuah variable yang dideklarasi di dalam scope memiliki nama yang sama seperti variable yang di deklarasi di luar scope. Udah gitu aja 😉.

→ Contoh

fn main() {
  let luar = 100; // * variable luar di luar block
    {
        let dalam = 10;
        let luar = 50; // * variable luar di dalam block
      println!("{}", dalam);
      println!("{}", luar);
    }
  println!("{}", luar);
}

→ Output

10
50
100

Untuk stage 2 ini saya memiliki tantangan, yok di coba terus upload hasilnya di Discussion 🔥.

Tantangan:

Dekalarsikan sebuah variable learning_purpose yang berisi tujuan kalian belajar rust, lalu jangan lupa print di console/ terminal kalian.

Note: Jangan lupa kasih tulisan mission passed!

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

Twitter

Buy me a coffe

Stage 1 - Introduction | Belajar Rust #2

Adi Purwanto — Fri, 14 Jan 2022 21:01:26 +0000

Untuk stage ini masih sangat "Easy Peasy Lemon Squeezy”, dalam stage ini saya akan membahas hal-hal basic mengenai Rust. Jika kalian kepo saya menggunakan Replit untuk menulis code-nya, jika kalian ingin menggunakan local text-editor silahkan saja, tapi jangan lupa install Rust-nya loh wajib hukumnya, banyak tutorial di google dan youtube kok.

Semua Rust code ditulis didalam file dengan .rs extension

1. Program Pertama Saya

fn main() {
    println!("Halo, dunia!");
}

fn → function notation

main() → mendeklarasi sebuah main function

Anatomi dari Program Halo, dunia!

main function adalah awal dari setiap program Rust.
Apa saja yang diisi dalam sepasang kurung kurawal {} merupakan block of code.
println! macro menerima string “Halo, dunia!” dan memunculkannya di screen/ terminal.

Apa sih macro?

Macro merupakan sebuah expression yang memiliki tanda seru (bukan berarti dia asik loh tapi tanda ! ← itu) sebelum kurung (), contohnya.

macro_name!();

Compile dan Run Program

➜  ~ rustc src/main.rs 
➜  ~ ./main 
Halo, dunia!

2. Formating Dasar

Sekarang saya ingin mengenalkan kepada kalian bagaimana untuk format sebuat statement di Rust dengan gaya yang beda-beda. Di bab 1 (anggap aja bab kali ye) kita sudah mengetahui bagaimana cara print sebuah string ke console . “Tapi kan saya gak mungkin mau print string/ kata statik saja?”, eittss tenang saja kita bisa kok print strings dalam format tertentu menggunakan placeholders yang sudah disediakan oleh Rust.

println!("{}", 18);

{} → Placeholder notation

18 → Placeholder value

Note: Rust tidak mengijinkan kita sekalipun/ haram hukumnya untuk print numbers maupun variables secara langsung di println!() macro. Kita perlu placeholder {} untuk print numbers maupun variables.

Single Placeholder

Ketika kita ingin melakukan print sebuah single value kita bisa menggunakan single placeholder

fn main() {
    println!("Tanggal: {}", 18);
}

→ Output

Tanggal: 18

Multiple Placeholders

Selain single placeholder, kita juga bisa menggunakan multiple placeholders di println!() macro. Jumlah dari placeholders harus/ wajib (fardhu ain) sama dengan jumlah values yang akan di print.

fn main() {
    println!("My name is {}, you can call me {}", "Adi", "Kincup");
}

→ Output

My name is Adi, you can call me Kincup

Positional Arguments

Kita bisa menspesifikan dimana posisi sebuah values berada. Setiap value kita diberikan nomor berdasarkan urutan. Value pertama diberi nilai 0, berikutnya diberi nilai 1, dan seterusnya berurutan.

Kenapa?

Values bisa di taruh di urutan mana saja

Kita bisa menulis value 1 kali dan digunakan beberapa kali

fn main() {
    println!("My name is {1}, you can call me {0} or {1}", "Adi", "Kincup");
}

→ Output

My name is Kincup, you can call me Adi or Kincup

Named Arguments

Kita bisa juga memberikan nama argument dan assign sebuah value. Konsep yang diberikan mirip dengan positional arguments namun kita bisa assign value secara explicit.

fn main() {
    println!("My name is {name}, you can call me {call} or {name}", name = "Adi",call = "Kincup");
}

→ Output

My name is Adi, you can call me Kincup or Adi

Placeholder Traits

Kita bisa mengkonversi value ke binary, hexadecimal, atau octal

fn main() {
    println!("Umur : 23, biner: {:b}, hexa: {:x}, octal: {:o}", 23, 23, 23);
}

→ Output

Umur : 23, biner: 10111, hexa: 17, octal: 27

Basic Math

Kita bisa melakukan kalkulasi basic dan placeholder akan menunjukan hasilnya.

fn main() {
    println!("{} * {} = {}", 2, 3, 2 * 3);
}

→ Output

2 * 3 = 6

Placeholder for a Debug Trait

Jika kita ingin mencoba/ testing print banyak nilai namun kita malas menggunakan multiple placeholders, kita bisa menggunakan single placeholder dengan bantuann debug trait ({:?}).

fn main() {
    println!("{:?}", ("I am super very handsome!", 100));
}

→ Output

("I am super very handsome!", 100)

3. Printing Style

Macro	Printing style
print!()	print string ke console
println!()	sama seperti print!(), namun menambahkan enter atau baris baru di akhir string
eprint!()	print dengan status error
eprintln!()	sama seperti eprint!(), namun menambahkan enter atau baris baru di akhir

4. Comments

Comments merupakan instruksi yang bisa dibaca oleh programmer untuk membantu menjelaskan mengenai code. Comments tidak dibaca oleh compiler.

Line Comments //

Comments ini sangat direkomendasikan untuk mengkomentari sebuah line single

// ini fungsi main loh
fn main() {
  // ini fakta
    println!("{:?}", ("I am super very handsome!", 100)); // jangan lupa ini fakta
}

→ Output

("I am super very handsome!", 100)

Block Comments /* . . . */

Comments ini digunakan untuk men-disable large chunk of code.

// ini fungsi main loh
fn main() {
  // ini fakta
    /* 
  println!("{:?}", ("I am super very handsome!", 100));
  */ 
}

→ Output

Doc Comments /// or //!

→ Outer Doc Comments (///) → ditulis di luar blok code.

→ Inner Doc Comments (//!) → ditulis di dalam blok code.

/// ini outer doc comment
/// jangan lupa loh
fn main() {
  //! ini fakta
  //! ditulis fakta aja
    println!("{:?}", ("I am super very handsome!", 100)); 
}

→ Output

("I am super very handsome!", 100)

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

Twitter

Buy me a coffe

If you don't know me, then, you would not know who I am | Belajar Rust #1

Adi Purwanto — Fri, 14 Jan 2022 19:14:50 +0000

Ujar pepatah yang ada di Indonesia “tak kenal maka tak sayang” . Sebelum kita mempelajari lebih lanjut tentang rust, ada kalanya kita mengetahui terlebih dahulu tentang rust.

Sejarah Rust

Rust sendiri tercipta karena proyek personal dari seorang jenius yang bernama Graydon Hoare, kita sebut saja Hoare. Hoare bekerja di Mozilla yang mana merupakan organisasi nirlaba di balik Firefox. Proyek personal ini kemudian dilirik oleh Mozilla, yang kemudian berujung kebaikan dimana Mozilla mensponsori proyek ini pada tahun 2009 dan diumumkan pada tahun 2010. Stable release pertama Rust meluncur pada tanggal 15 Mei 2015.

Apa Itu Rust?

Rust merupakan bahasa pemrograman sistem yang aman dan concurrent. Concurrent computing adalah bentuk komputasi di mana beberapak komputasi dijalankan secara bersamaan. Rust sendiri terinspirasi dari beberapa bahasa pemrograman, seperti.

System Programming Languages : (C, C++)
Functional Programming Languages : (Meta Language, Haskell, Erlang)

Statistik Rust

Survey membuktikan bahwa Rust merupakan bahasa yang paling dicintai pada tahun 2021.

Sumber : stackoverflow

Rust Itu Digunakan Untuk Apa sih?

Rust sendiri banyak digunakan di beberapa proyek, yaitu:

cross-platform command line support
embedded systems programming
building powerful web applications
building distributed online services

Dan yang sangat terbaru kita bisa membuat smart contracts solana menggunakan Rust.

Saat ini banyak perusahaan yang menggunakan Rust dalam production dan building apps mereka. Seperti, DropBox, Atlassian, dan Amazon’s Firecracker.

Apa yang Membuat Rust Berbeda?

Sekian banyaknya bahasa pemrograman, apa sih sebenarnya yang membuat Rust berbeda? berikut ini beberapa fakta kenapa Rust berbeda.

Kecepatan

Rust tidak membayar untuk abstraksi, hanya untuk fitur yang benar-benar digunakan. Ini meningkatkan kualitas kode dan keterbacaan tanpa mengorbankan biaya runtime.

Keamanan

Rust tidak memiliki garbage collector. Ini menggunakan konsep ownership dan borrowing (kita bahas nanti ditunggu aja) untuk memastikan keamanan memori. Di Rust, objek dikelola oleh bahasa pemrograman dari awal hingga akhir. Mengalokasikan jumlah memori yang tepat yang dibutuhkan dan tidak secara otomatis dialokasikan oleh sistem saat tidak lagi digunakan.

Cargo Manager

Rust menyediakan cargo manager yang dimana berperan sebagai penyedia libraries dan frameworks yang membantu developer untuk membuat aplikasi warbyasah, cargo manager juga berperan mendistribusikan code ke end-users.

Pesan Error

Pesan error di Rust itu sangat menarik, pesan ini ditampilkan menggunakan warna. Rust tidak hanya menampilkan baris yang salah namun Rust memberitahukan kita apa saja type of error-nya.

Threads without Data Races

Data race adalah kondisi dimana dua atau lebih thread dapat mengakses lokasi memori yang sama. Rust menggunakan konsep ownership untuk menghindari balapan data (nanti ownership dibahas pas udah jago dikit).

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

#samasamabelajar

Twitter

Buy me a coffe

DEV Community: Adi Purwanto

Stage 5 - Conditional Expression | Belajar Rust #6

1. If expression

a. If expression

b. If...else expression

c. If...else if...else expression

d. Nested if expression

e. Shorthand if

2. If let expression

a. Pattern is matched

b. Pattern is not matched

c. Pattern is replaced with _

3. Match expression

Contoh

Stage 4 - Operators | Belajar Rust #5

1. Arithmetic operators

2. Logical operators

3. Comparison operators

4. Bitwise operators

5. Assignment dan compound assignment operators

a. Assignment operator

b. Compound assignment operator

6. Type casting operator

7. Borrowing dan dereferencing operators

a. Borrowing operator

b. Dereferencing operator

8. Precedence dan associativity

a. Precedence

b. Associativity

Stage 3 - Data Types | Belajar Rust #4

1. Integers

a. Dynamic size types

b. Fixed size types

2. Floats

3. Character dan String

a. Character

b. String

4. Boolean

5. Arrays

a. Mendefinisikan dan print array

b. Akses sebuah element dan length dari array

c. Membuat array menjadi mutable

d. Slice array

6. Tuples

a. Mendefinisikan dan mengakses tuple

b. Membuat tuple mutable

Constant Variables

Perbedaan const dan let variables

Stage 2 - Variables | Belajar Rust #3

1. Variables

a. Membuat sebuah variable

b. Inisialisasi variable

c. Membuat multiple variables

d. Membuka lakban kotak/ membuat variable mutable

2. Scope dan Shadowing

a. Scope dari sebuah variable

b. Shadowing

Stage 1 - Introduction | Belajar Rust #2

1. Program Pertama Saya

2. Formating Dasar

3. Printing Style

4. Comments

If you don't know me, then, you would not know who I am | Belajar Rust #1

Sejarah Rust

Apa Itu Rust?

Statistik Rust

Rust Itu Digunakan Untuk Apa sih?

Apa yang Membuat Rust Berbeda?

Kecepatan

Keamanan

Cargo Manager

Pesan Error

Threads without Data Races

c. Pattern is replaced with `_`

Perbedaan `const` dan `let` variables