Foundation

BAB 8: Operator

Operator di Rust: aritmetika dengan pembagian bulat, perbandingan, logika, bitwise, penugasan gabungan, prioritas, dan kesalahan tipe saat mencampur angka.

Operator aritmetika di Rust terlihat sama seperti di bahasa lain, sampai pembagian melibatkan 2 bilangan bulat: 7 / 2 menghasilkan 3, bukan 3.5. Hasil itu bukan pembulatan, melainkan pembagian bulat yang membuang sisa, dan sisa itu diambil terpisah dengan %.

Bab ini membahas 5 kelompok operator, yaitu aritmetika, perbandingan, logika, bitwise, dan penugasan gabungan, ditambah prioritas dan kesalahan tipe yang muncul saat mencampur angka. Semua contoh dikompilasi dan dijalankan dengan rustc 1.100.0.

Operator aritmetika

RSRUST
fn main() {
    let a: i32 = 7;
    let b: i32 = 2;
    println!("7 / 2 = {}", a / b);
    println!("7 % 2 = {}", a % b);
    println!("7.0 / 2.0 = {}", 7.0_f64 / 2.0_f64);
}
CodeTEXT
7 / 2 = 3
7 % 2 = 1
7.0 / 2.0 = 3.5

Pada 2 bilangan bulat, hasil pembagian dibulatkan ke bawah menuju nol, dan sisanya bisa diambil dengan %. Untuk hasil pecahan, minimal 1 operand harus bertipe float, misalnya dengan menulis 7.0 atau mengubah tipe memakai as.

OperatorArtiContohHasil
+penjumlahan7 + 29
-pengurangan7 - 25
*perkalian7 * 214
/pembagian7 / 23
%sisa bagi7 % 21

Pembagian dengan nol

Pembagian bilangan bulat dengan 0 tidak menghasilkan nilai, dan kompilator bisa menolaknya lebih awal kalau nilainya diketahui saat kompilasi:

RSRUST
fn main() {
    let n = 0;
    let a = 10 / n;
    println!("{a}");
}
CodeTEXT
error: this operation will panic at runtime
 --> bagi_nol.rs:3:13
  |
3 |     let a = 10 / n;
  |             ^^^^^^ this operation will panic at runtime

Kalau nilai 0 baru diketahui saat program berjalan, kesalahannya muncul sebagai panic:

CodeTEXT
thread 'main' panicked at bagi_nol2.rs:4:26:
attempt to divide by zero

Pada float, pembagian dengan 0 tidak panic dan menghasilkan inf, karena float punya nilai khusus untuk itu:

RSRUST
fn main() {
    let f = 10.0 / 0.0;
    println!("{f}");
}
CodeTEXT
inf

Perbedaan perilaku ini penting saat memvalidasi masukan: pembagian dengan 0 pada integer menghentikan program, sedangkan pada float menyebarkan nilai tak hingga.

Operator perbandingan

Operator perbandingan selalu menghasilkan bool:

RSRUST
fn main() {
    let x = 5;
    let y = 3;
    println!("{} {} {} {}", x > y, x < y, x == y, x != y);
}
CodeTEXT
true false false true

Hasil bool inilah yang dipakai di if pada bab 9. Karena perbandingan menghasilkan tipe yang jelas, tidak ada ruang untuk menganggap angka 1 sebagai benar seperti di bahasa lain.

Operator logika

3 operator logika bekerja pada bool, dan punya perilaku berhenti lebih awal (short circuit):

OperatorArtiBerhenti lebih awal
&&danya, kalau sisi kiri false
||atauya, kalau sisi kiri true
!bukantidak berlaku
RSRUST
fn main() {
    let benar = true;
    let salah = false;
    println!("{} {} {}", benar && salah, benar || salah, !benar);
}
CodeTEXT
false true false

Perilaku berhenti lebih awal terlihat pada ekspresi seperti salah && fungsi_lambat(): fungsi_lambat() tidak dipanggil sama sekali, karena hasil akhirnya sudah pasti false. Sifat ini dipakai untuk memeriksa kondisi murah lebih dulu sebelum kondisi mahal.

Operator bitwise

Operator bitwise bekerja pada representasi biner bilangan bulat:

RSRUST
fn main() {
    let p: u8 = 0b1100;
    let q: u8 = 0b1010;
    println!("and {} or {} xor {} geser kiri {}", p & q, p | q, p ^ q, p << 1);
}
CodeTEXT
and 8 or 14 xor 6 geser kiri 24

Angka 0b1100 dan 0b1010 di-AND menghasilkan 0b1000 yang bernilai 8, di-OR menghasilkan 0b1110 yang bernilai 14, dan di-XOR menghasilkan 0b0110 yang bernilai 6. Menggeser 0b1100 ke kiri 1 bit menghasilkan 0b11000, yaitu 24.

Operator ini dipakai saat nilainya memang berhubungan dengan bit, misalnya izin akses yang disimpan sebagai penanda, atau pengaturan warna.

Penugasan gabungan

Penugasan gabungan menggabungkan operasi dengan penyimpanan, dan menuntut variabel yang mut:

RSRUST
fn main() {
    let mut n = 10;
    n += 5;
    n -= 3;
    n *= 2;
    println!("n = {n}");
}
CodeTEXT
n = 24

Urutannya: 10 ditambah 5 menjadi 15, dikurangi 3 menjadi 12, lalu dikali 2 menjadi 24. Bentuk n += 5 setara dengan n = n + 5, tetapi lebih ringkas dan tidak mengulang nama variabel.

Tidak ada operator ++ dan --

Rust tidak menyediakan ++ atau --. Menulisnya ditolak, dan pesan kompilator langsung menunjukkan penggantinya:

RSRUST
fn main() {
    let mut i = 0;
    i++;
    println!("{i}");
}
CodeTEXT
error: Rust has no postfix increment operator
 --> plusplus.rs:3:6
  |
3 |     i++;
  |      ^^ not a valid postfix operator
  |
help: use `+= 1` instead

Bentuk yang benar adalah i += 1. Keputusan ini disengaja: ++ di bahasa lain punya 2 bentuk yang berbeda hasilnya, yaitu menambah sebelum dan sesudah nilai dipakai, dan perbedaan itu sering menjadi sumber kesalahan.

Prioritas operator

Operator dikerjakan sesuai prioritas, dan tanda kurung dipakai untuk mengubah urutan:

RSRUST
fn main() {
    println!("tanpa kurung {}", 2 + 3 * 4);
    println!("dengan kurung {}", (2 + 3) * 4);
}
CodeTEXT
tanpa kurung 14
dengan kurung 20

Perkalian dikerjakan sebelum penjumlahan, sehingga contoh pertama bernilai 14. Kalau maksudnya menjumlahkan lebih dulu, tanda kurung membuat maksud itu terlihat jelas, dan pembaca tidak perlu mengingat urutan prioritas.

Mencampur tipe angka

Rust tidak mengubah tipe angka secara otomatis. Menambahkan integer dengan float ditolak:

RSRUST
fn main() {
    let x = 1 + 1.5;
    println!("{x}");
}
CodeTEXT
error[E0277]: cannot add a float to an integer
 --> campur_tipe.rs:2:15
  |
2 |     let x = 1 + 1.5;
  |               ^ no implementation for `{integer} + {float}`
  |
  = help: the trait `Add<{float}>` is not implemented for `{integer}`

Perbaikannya menyeragamkan tipe, misalnya 1.0 + 1.5 atau 1 + 3 / 2. Kesalahan seperti ini sering muncul saat nilai berasal dari 2 sumber berbeda, misalnya 1 dari perhitungan integer dan 1 dari hasil pembacaan berkas.

Ringkasan

Pembagian 2 bilangan bulat menghasilkan bilangan bulat, dan sisanya diambil dengan %. Pembagian integer dengan 0 menghentikan program, sedangkan pembagian float dengan 0 menghasilkan inf.

Perbandingan dan logika menghasilkan bool, dengan && dan || berhenti lebih awal. Operator bitwise bekerja pada representasi biner, penugasan gabungan menuntut variabel mut, dan prioritas operator bisa diubah dengan tanda kurung. Mencampur integer dengan float ditolak E0277 dan harus diselesaikan dengan menyamakan tipe.

Latihan

  1. Hitung 17 / 5, 17 % 5, dan 17.0 / 5.0, lalu jelaskan ketiga hasilnya.
  2. Buat penanda izin memakai bitwise: gabungkan 3 nilai bit dengan |, lalu periksa salah satunya dengan &.
  3. Tulis ekspresi 2 + 3 * 4 - 6 / 2 tanpa kurung, lalu ulangi dengan kurung yang mengubah hasilnya menjadi 14.
  4. Coba let x = 5 + 2.0; dan catat nomor kesalahan yang muncul.

Referensi

  1. The Rust Programming Language. Operators and Symbols.
  2. The Rust Reference. Operator expressions.
  3. The Rust Programming Language. Data Types.