Operator di Rust

Operator adalah simbol-simbol yang kamu pakai untuk berhitung, membandingkan nilai, dan menggabungkan kondisi. Kebanyakan akan terlihat familiar kalau kamu pernah memakai bahasa yang mirip C.

Operator aritmatika

fn main() {
    let a = 10;
    let b = 3;

    println!("{}", a + b); // 13
    println!("{}", a - b); // 7
    println!("{}", a * b); // 30
    println!("{}", a / b); // 3  (pembagian bilangan bulat, sisanya dibuang)
    println!("{}", a % b); // 1  (sisa bagi)
}

▶ Coba sendiri

Perhatian

a / b dengan dua integer menghasilkan pembagian bilangan bulat: 10 / 3 hasilnya 3, bukan 3.333.... Kalau kamu ingin hasil desimal, minimal salah satu sisinya harus berupa float: 10.0 / 3.0.

Operator perbandingan

Operator ini membandingkan dua nilai dan menghasilkan sebuah bool:

fn main() {
    let a = 5;
    let b = 8;

    println!("{}", a == b); // false
    println!("{}", a != b); // true
    println!("{}", a < b);  // true
    println!("{}", a > b);  // false
    println!("{}", a <= b); // true
    println!("{}", a >= b); // false
}

Kamu akan terus memakainya di dalam kondisi if, yang kita bahas di halaman If…Else.

Operator logika

Operator logika menggabungkan atau membalik nilai boolean:

fn main() {
    let is_logged_in = true;
    let is_admin = false;

    println!("{}", is_logged_in && is_admin); // false: keduanya harus true
    println!("{}", is_logged_in || is_admin); // true: minimal salah satunya true
    println!("{}", !is_admin);                // true: membalik false menjadi true
}

▶ Coba sendiri

• &&: dan (and). Bernilai true hanya kalau kedua sisinya true.
• ||: atau (or). Bernilai true kalau minimal salah satu sisinya true.
• !: bukan (not). Membalik true menjadi false, dan sebaliknya.

Operator penugasan

Selain = biasa, Rust punya operator singkat yang memperbarui sebuah variabel berdasarkan nilainya saat ini:

fn main() {
    let mut score = 10;

    score += 5; // sama dengan: score = score + 5
    score -= 2; // score = score - 2
    score *= 3; // score = score * 3
    score /= 2; // score = score / 2

    println!("{score}");
}

▶ Coba sendiri

Ingat, variabelnya butuh mut supaya semua operator ini bisa di-compile, karena kamu sedang mengubah nilainya.

Catatan

Rust tidak punya operator ++ atau --. Untuk menambahkan satu ke sebuah penghitung, tulis count += 1. Cuma lebih panjang satu karakter, dan tidak ada keraguan soal apa yang terjadi.

Urutan pengerjaan operator (precedence)

Kalau sebuah expression punya beberapa operator, Rust tidak sekadar mengerjakannya dari kiri ke kanan. Seperti matematika di sekolah, *, /, dan % dikerjakan lebih dulu daripada + dan -. Operator dengan tingkat yang sama dikerjakan dari kiri ke kanan. Tanda kurung selalu dikerjakan pertama, jadi pakai tanda kurung kapan pun kamu ingin urutan yang berbeda.

fn main() {
    let a = 2 + 3 * 4;            // * dulu: 2 + 12
    let b = (2 + 3) * 4;          // tanda kurung dulu: 5 * 4
    let c = 10 - 4 - 3;           // tingkat sama, kiri ke kanan: (10 - 4) - 3
    let d = 17 % 5 * 2;           // tingkat sama, kiri ke kanan: (17 % 5) * 2
    let ok = 1 + 1 == 2 && 3 > 2; // hitungan, lalu perbandingan, lalu &&

    println!("{a} {b} {c} {d} {ok}");
}

Output:

14 20 3 4 true

▶ Coba sendiri

Urutan lengkapnya, dari yang pertama sampai terakhir, kira-kira begini: aritmatika (* / %, lalu + -), kemudian perbandingan (== != < > <= >=), lalu &&, lalu ||, dan terakhir operator penugasan (= += -= dan kawan-kawannya). Itulah sebabnya 1 + 1 == 2 && 3 > 2 bisa jalan tanpa tanda kurung sama sekali. Meski begitu, kalau kamu sampai harus berhenti dan berpikir soal urutannya, tambahkan saja tanda kurung. Gratis, dan kodenya jadi lebih mudah dibaca.

Perhatian

Kamu tidak bisa merangkai perbandingan seperti di matematika. 1 < x < 5 adalah error saat compile (“comparison operators cannot be chained”, artinya operator perbandingan tidak bisa dirangkai). Tulis sebagai dua perbandingan yang digabung dengan &&: 1 < x && x < 5.

Latihan

1. Menit dan detik

Sebuah video berdurasi 125 detik. Simpan angka itu di sebuah variabel, lalu cetak berapa menit penuh dan sisa detiknya, misalnya 2 menit 5 detik. Petunjuk: pembagian bilangan bulat / menghasilkan menit penuhnya, dan % menghasilkan sisanya.

Lihat solusi

fn main() {
    let total_seconds = 125;

    let minutes = total_seconds / 60; // 2 (sisanya dibuang)
    let seconds = total_seconds % 60; // 5 (sisa baginya)

    println!("{minutes} menit {seconds} detik");
}

Output:

2 menit 5 detik

▶ Coba sendiri

2. Mencatat skor

Mulai score sebuah game dari 10. Tambahkan 25, kurangi 5, lalu kalikan dua, dengan memakai operator penugasan singkat. Cetak skornya, apakah skornya minimal 50, dan apakah skornya minimal 50 dan genap. Petunjuk: sebuah angka genap kalau score % 2 == 0.

Lihat solusi

fn main() {
    let mut score = 10;

    score += 25; // 35
    score -= 5;  // 30
    score *= 2;  // 60

    println!("skor: {score}");
    println!("lolos level? {}", score >= 50);
    println!("lolos dan genap? {}", score >= 50 && score % 2 == 0);
}

Output:

skor: 60
lolos level? true
lolos dan genap? true

▶ Coba sendiri

Ringkasan

• Aritmatika: + - * / %. Pembagian bilangan bulat membuang bagian desimalnya.
• Perbandingan: == != < > <= >=, semuanya menghasilkan bool.
• Logika: && (dan), || (atau), ! (bukan).
• Penugasan singkat: += -= *= /= memperbarui variabel mut secara langsung. Tidak ada ++.
• * / % dikerjakan sebelum + -, dan hitungan dikerjakan sebelum perbandingan serta &&/||. Kalau ragu, pakai tanda kurung.

Kuis singkat

Kuis singkat

1. Berapa hasil 10 / 3 kalau kedua sisinya integer?

3.333... 3 4

2. Tipe apa yang selalu dihasilkan operator perbandingan seperti == dan <?

i32 String bool

3. Apa syaratnya supaya score += 5; bisa di-compile?

score harus dideklarasikan dengan mut score harus bertipe f64 Tidak ada syarat khusus, selalu bisa di-compile

Skor: 0 / 3

Bacaan lebih lanjut

• B - Operators and Symbols — The Rust Book (bahasa Inggris): tabel satu halaman berisi semua operator di Rust dan fungsinya.
• Literals and operators — Rust by Example (bahasa Inggris): contoh singkat yang bisa dijalankan untuk operator aritmatika, logika, dan bitwise.
• Expression precedence — The Rust Reference (bahasa Inggris): urutan persis Rust mengerjakan operator, dari yang pertama sampai terakhir.
• Operator expressions — The Rust Reference (bahasa Inggris): aturan persis untuk setiap operator, termasuk apa yang terjadi saat integer overflow.