Stage 4 - Operators | Belajar Rust #5

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

→ 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

→ 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 !=]

→ 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

→ 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

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