JavaScript Dasar: Operator Aritmetika

JavaScript mendukung operasi aritmetika. JavaScript dapat melakukan operasi dasar matematika seperti penjumlahan, pengurangan, perkalian, pembagian, dan banyak lagi. 

Operator dan Operand

Bilangan yang dioperasi disebut `operand`. `Operator` adalah simbol-simbol yang digunakan untuk melakukan operasi pada operand. 

Operand dapat berupa variabel atau literal. 

a + b; // Variabel sebagai operand

1 + 2; // Numeric literal sebagai operand

Variabel `a` dan `b` dan bilangan `1` dan `2` adalah operand, `+` adalah operator penjumlahan (addition). 

Berikut daftar Operator Aritmetika dalam JavaScript: 

Operator	Deskripsi
+	Penjumlahan (Addition)
-	Pengurangan (Subtraction)
*	Perkalian (Multiplication)
**	Perpangkatan (Exponentiation)
/	Pembagian (Division)
%	Sisa Bagi (Modulus)
++	Increment
--	Decrement

Penjumlahan 

Operator penjumlahan ( + ) menjumlahkan dua bilangan. 

let a = 2 + 3;

let b = 5 + 2;

let c = a + b;

Pengurangan

Operator pengurangan ( - ) melakukan pengurangan dua buah bilangan. 

let a = 3;

let b = 2;

let subs = a - b; // Hasil: 1

console.log(subs);

Perkalian

Operator perkalian bukanlah huruf ( x ), melainkan bintang atau asterisk ( * ). 

let multiply = 12 * 2;

Perpangkatan

Exponential operator (**) digunakan untuk memangkatkan bilangan basis dengan bilangan eksponen. Operator ini hadir dalam ECMAScript 2016 sebagai bentuk sederhana dari metode `Math.pow()`. 

// Menggunakan Exponential Operator

let result1 = 2 ** 3;

console.log(result1); // Output: 8

// Menggunakan Math.pow()

let result2 = Math.pow(2, 3);

console.log(result2); // Output: 8

Pada contoh `2 ** 3`, 2 adalah basis, 3 adalah eksponen. Pada `Math.pow(2, 3)`, parameter pertama adalah basis, parameter kedua adalah eksponen. 

Pembagian

Operator pembagian menggunakan simbol garis miring atau slash ( / ). 

let divide = 12 / 2;

Modulus

Operasi modulus menghasilkan sisa dari operasi pembagian. Operasi modulus dilambangkan dengan simbol persen (%) di beberapa bahasa pemrograman, termasuk JavaScript. 

let hasilBagi = 10 / 3; // 3.33333...

let sisaBagi = 10 % 3; // 1

console.log(hasilBagi);

console.log(sisaBagi);

Dari contoh di atas, 10 dibagi 3 hanya akan dapat dibagi sebanyak 3 kali dan menyisakan 1 yang tidak dapat dibagi lagi. Maka dari itu, hasil modulus 10 dengan 3 adalah 1. 

Increment

Increment hanya berlaku untuk variabel numerik. Nilai selain numerik akan menghasilkan Not a Number (NaN), sedangkan literal tidak dapat dioperasikan, akan menyebabkan error. 

Increment menjumlahkan nilai dalam variabel dengan bilangan 1. 

let a = 2;

a++;

console.log(a)// `a` sekarang 3

Decrement

Sama seperti increment, decrement menerima satu operand yang berupa variabel numerik. Decrement mengurangkan operand dengan 1. 

let b = 4;

b--;

console.log(b) // `b` sekarang 3

Operator `increment` dan `decrement` termasuk dalam `unary operator`. Yaitu operator yang hanya menerima satu operand. 

Mereka memiliki sub-tipe, yaitu `prefix` (++a atau --a) dan `posfix` (a++ atau a--). 

Kamu akan mempelajarinya dalam artikel terpisah. 

Operator Precedence (Prioritas Operator) 

Setiap operator memiliki level prioritas yang berbeda. Dalam sebuah ekspresi aritmatika yang melibatkan lebih dari satu operator, operator dengan level prioritas lebih tinggi akan dievaluasi lebih dulu. 

Contohnya ketika terdapat penjumlahan dan perkalian: 

let hasil = 10 + 2 * 5;

console.log(hasil);

Perkalian (*) memiliki precedence atau prioritas yang lebih tinggi daripada penjumlahan (+), sehingga `2 * 5` akan dievaluasi lebih dulu. 

Jika operator memiliki precedence yang sama, maka akan dievaluasi berurutan dari kiri ke kanan. 

let hasil = 10 / 2 * 5; // `10 / 2 = 5`, lalu `5 * 5 = 25`

console.log(hasil);

Kita bisa mengubah precedence dengan tanda kurung atau parentheses ` ( ) `. 

let hasil = (10 + 2) * 5;

console.log(hasil);

Sekarang penjumlahan akan dihitung lebih dulu. 

Ini sama seperti yang diajarkan di sekolah. Bahwa perkalian dan pembagian akan dihitung lebih dulu daripada penjumlahan dan pengurangan.  Dan tanda kurung akan menjadikan sebuah operasi dilakukan lebih dulu. 

Jika kamu sudah memahami itu dengan baik, kamu akan lebih mudah memahami precedence dalam operasi aritmetika di JavaScript.  

Berikut tabel prioritas operator atau Operator Precedence untuk operator-operator aritmetika: 

Operator	Symbol	Precedence
Exponentiation	**	13
Multiplication	*	12
Division	/	12
Modulus	%	12
Addition	+	11
Subtraction	-	11

Operator-operator lain seperti `unary`, `logical` dan `ternary` juga memiliki precedence masing-masing. Kita akan membahasnya di lain artikel. 

Tapi jika kamu penasaran, lihat tabel lengkapnya.