Operator #

Rust adalah bahasa pemrograman yang mendukung berbagai macam operator, yang digunakan untuk melakukan operasi dasar pada data. Operator di Rust dibagi menjadi beberapa kategori, termasuk operator aritmetika, operator logika, operator perbandingan, operator bitwise, operator assignment, dan lainnya. Setiap operator memiliki fungsi dan kegunaan yang spesifik dalam bahasa ini.

Operator Aritmetika #

Operator aritmetika digunakan untuk melakukan operasi matematis pada angka. Rust mendukung operator aritmetika dasar seperti penjumlahan, pengurangan, perkalian, pembagian, dan modulus.

Penjumlahan (+): Menambah dua nilai.
```
let sum = 5 + 10; // 15
```
Pengurangan (-): Mengurangkan satu nilai dari nilai lainnya.
```
let difference = 10 - 4; // 6
```
Perkalian (*): Mengalikan dua nilai.
```
let product = 4 * 7; // 28
```
Pembagian (/): Membagi satu nilai dengan nilai lainnya. Pembagian integer menghasilkan nilai integer (hasil pembulatan ke bawah).
```
let quotient = 56 / 8; // 7
let float_quotient = 5.0 / 2.0; // 2.5
```
Modulus (%): Menghasilkan sisa dari pembagian dua nilai.
```
let remainder = 43 % 5; // 3
```

Operator Perbandingan #

Operator perbandingan digunakan untuk membandingkan dua nilai. Hasil dari perbandingan adalah nilai boolean (true atau false).

Sama dengan (==): Memeriksa apakah dua nilai sama.
```
let is_equal = 5 == 5; // true
```
Tidak sama dengan (!=): Memeriksa apakah dua nilai berbeda.
```
let is_not_equal = 5 != 6; // true
```
Lebih besar dari (>): Memeriksa apakah nilai di kiri lebih besar dari nilai di kanan.
```
let is_greater = 10 > 8; // true
```
Lebih kecil dari (<): Memeriksa apakah nilai di kiri lebih kecil dari nilai di kanan.
```
let is_less = 3 < 5; // true
```
Lebih besar atau sama dengan (>=): Memeriksa apakah nilai di kiri lebih besar atau sama dengan nilai di kanan.
```
let is_greater_or_equal = 10 >= 10; // true
```
Lebih kecil atau sama dengan (<=): Memeriksa apakah nilai di kiri lebih kecil atau sama dengan nilai di kanan.
```
let is_less_or_equal = 3 <= 5; // true
```

Operator Logika #

Operator logika digunakan untuk menggabungkan ekspresi boolean.

Dan (&&): Mengembalikan true jika kedua operand adalah true.
```
let result = true && false; // false
```
Atau (||): Mengembalikan true jika salah satu operand adalah true.
```
let result = true || false; // true
```
Tidak (!): Mengembalikan kebalikan dari nilai boolean.
```
let result = !true; // false
```

Operator Bitwise #

Operator bitwise digunakan untuk memanipulasi bit individual dari angka integer. Ini termasuk operasi AND, OR, XOR, NOT, serta shift bit.

AND bitwise (&): Melakukan operasi AND pada masing-masing bit dari operand.
```
let result = 0b1100 & 0b1010; // 0b1000 (8 dalam desimal)
```
OR bitwise (|): Melakukan operasi OR pada masing-masing bit dari operand.
```
let result = 0b1100 | 0b1010; // 0b1110 (14 dalam desimal)
```
XOR bitwise (^): Melakukan operasi XOR pada masing-masing bit dari operand.
```
let result = 0b1100 ^ 0b1010; // 0b0110 (6 dalam desimal)
```
NOT bitwise (~): Melakukan operasi NOT pada masing-masing bit (membalikkan bit).
```
let result = !0b1100; // 0b...11110011 (dalam representasi komplemen dua)
```

Left Shift (<<): Menggeser bit-bit ke kiri sebanyak n posisi.

let result = 0b0001 << 2; // 0b0100 (4 dalam desimal)

Right Shift (>>): Menggeser bit-bit ke kanan sebanyak n posisi.
```
let result = 0b1000 >> 2; // 0b0010 (2 dalam desimal)
```

Operator Assignment #

Operator assignment digunakan untuk menetapkan nilai ke variabel, sering kali digabungkan dengan operator lain untuk melakukan operasi tertentu sekaligus menetapkan hasilnya.

Assignment (=): Menetapkan nilai ke variabel.
```
let x = 5;
```
Assignment dengan Penjumlahan (+=): Menambahkan nilai ke variabel dan menetapkan hasilnya.
```
let mut x = 5;
x += 2; // x sekarang 7
```
Assignment dengan Pengurangan (-=): Mengurangkan nilai dari variabel dan menetapkan hasilnya.
```
let mut x = 5;
x -= 2; // x sekarang 3
```
Assignment dengan Perkalian (*=): Mengalikan nilai ke variabel dan menetapkan hasilnya.
```
let mut x = 5;
x *= 2; // x sekarang 10
```
Assignment dengan Pembagian (/=): Membagi nilai dari variabel dan menetapkan hasilnya.
```
let mut x = 10;
x /= 2; // x sekarang 5
```
Assignment dengan Modulus (%=): Menetapkan sisa dari pembagian variabel dengan nilai lain.
```
let mut x = 10;
x %= 3; // x sekarang 1
```
Assignment dengan Bitwise AND (&=): Melakukan operasi AND bitwise dan menetapkan hasilnya.
```
let mut x = 0b1010;
x &= 0b1100; // x sekarang 0b1000
```
Assignment dengan Bitwise OR (|=): Melakukan operasi OR bitwise dan menetapkan hasilnya.
```
let mut x = 0b1010;
x |= 0b1100; // x sekarang 0b1110
```
Assignment dengan Bitwise XOR (^=): Melakukan operasi XOR bitwise dan menetapkan hasilnya.
```
let mut x = 0b1010;
x ^= 0b1100; // x sekarang 0b0110
```
Assignment dengan Left Shift (<<=): Menggeser bit ke kiri dan menetapkan hasilnya.
```
let mut x = 0b0001;
x <<= 2; // x sekarang 0b0100
```
Assignment dengan Right Shift (>>=): Menggeser bit ke kanan dan menetapkan hasilnya.
```
let mut x = 0b1000;
x >>= 2; // x sekarang 0b0010
```

Operator Range #

Operator range (.. dan ..=) digunakan untuk membuat rentang angka, yang sering digunakan dalam loop for.

Range Inklusif-inklusif (..): Membuat rentang dari nilai awal hingga nilai sebelum nilai akhir (eksklusif).
```
for i in 1..5 {
    println!("{}", i); // 1, 2, 3, 4
}
```
Range Inklusif-eksklusif (..=): Membuat rentang dari nilai awal hingga nilai akhir (inklusif).
```
for i in 1..=5 {
    println!("{}", i); // 1, 2, 3, 4, 5
}
```

Operator Dereference dan Reference #

Rust menggunakan operator dereference (*) dan reference (&) untuk bekerja dengan pointer dan referensi.

Reference (&): Mengambil referensi dari nilai.

let x = 5;
let y = &x; // y adalah referensi ke x

Dereference (*): Mengambil

nilai yang dirujuk oleh pointer atau referensi.

let x = 5;
let y = &x;
let z = *y; // z sekarang 5, yang merupakan nilai dari y

Operator Lainnya #

Selain operator dasar, Rust juga memiliki beberapa operator lain yang berguna dalam berbagai konteks.

Ternary-like Operator (If-Else Expression): Rust tidak memiliki operator ternary (?:) seperti bahasa lain, tetapi if-else dapat digunakan sebagai ekspresi.
```
let x = 10;
let y = if x > 5 { "Besar" } else { "Kecil" };
```

Casting (as): Mengubah tipe data dari satu tipe ke tipe lainnya.

let x = 5.0;
let y = x as i32; // y sekarang 5, dalam tipe i32

Operator Penggabungan String #

Rust memungkinkan penggabungan string menggunakan operator + dan makro format!.

Penggabungan dengan +:

let hello = String::from("Hello, ");
let world = String::from("world!");
let greeting = hello + &world; // "Hello, world!"

Penggabungan dengan format!:

let hello = String::from("Hello, ");
let world = String::from("world!");
let greeting = format!("{}{}", hello, world); // "Hello, world!"

Catatan:

hello + &world mengharuskan world menjadi referensi karena + memindahkan hello.
format! mengembalikan string baru tanpa memindahkan variabel asli.

Kesimpulan #

Rust menyediakan berbagai operator yang memungkinkan Anda untuk melakukan operasi matematika, logika, bitwise, manipulasi string, dan banyak lagi. Memahami bagaimana dan kapan menggunakan setiap operator ini adalah dasar penting untuk menulis kode Rust yang efisien dan aman. Selain operator-operator dasar ini, Rust juga memungkinkan Anda untuk membuat operator khusus (misalnya, implementasi trait Add, Mul, dll.), yang memungkinkan pengembang untuk mendefinisikan perilaku operator untuk tipe data kustom.

« Tipe Data

Seleksi Kondisi »