Ngitung Pake JavaScript: Angka, Operasi Matematika, dan Objek Math!

Selain teks (string), tipe data yang bakal sering banget kita pake di JavaScript adalah Number (Angka). JavaScript pake tipe Number ini buat ngewakilin semua jenis angka, baik itu bilangan bulat (integer kayak 10, -5), maupun bilangan desimal (floating-point kayak 3.14, 0.5).

Di bagian ini, kita bakal ngoprek lebih dalem soal angka di JavaScript, dari operasi matematika dasar (yang sebagian udah kita singgung di materi Operator) sampe kenalan sama "kalkulator canggih" bawaan JavaScript, yaitu objek Math.

Tipe Data Number Sekilas Lagi

• Satu Tipe buat Semua Angka: Gak kayak beberapa bahasa pemrograman lain yang punya tipe beda buat integer (int), float (float), double (double), di JavaScript semuanya cukup pake tipe Number.

  let jumlahSiswa = 30;        // Integer
  let hargaProduk = 12500.75;  // Floating-point
  let suhuMinus = -5.5;      // Angka negatif
  console.log(typeof jumlahSiswa); // Output: "number"
  console.log(typeof hargaProduk); // Output: "number"

• Angka yang Sangat Besar atau Sangat Kecil: JavaScript bisa nanganin angka yang gede banget atau kecil banget pake notasi eksponensial (e).

  let angkaBesar = 1.23e6; // Sama kayak 1.23 * 10^6 = 1230000
  let angkaKecil = 5e-3;   // Sama kayak 5 * 10^-3 = 0.005
  console.log(angkaBesar);
  console.log(angkaKecil);

• Ketelitian (Precision Issues): Karena cara komputer nyimpen angka floating-point di memori (pake standar IEEE 754), kadang ada isu ketelitian kecil pas ngelakuin operasi sama angka desimal.

  console.log(0.1 + 0.2); // Outputnya mungkin 0.30000000000000004, bukan 0.3 persis!

  Ini hal yang umum di banyak bahasa pemrograman, bukan cuma JavaScript. Kalau butuh presisi tinggi banget (misal buat keuangan), biasanya orang pake library khusus atau ngolah angka sebagai integer (misal, simpen harga dalam sen). Buat sebagian besar kasus sehari-hari, ini gak terlalu jadi masalah besar.

Operator Aritmatika (Review Singkat)

Kita udah bahas ini di materi Operator, tapi sekadar ngingetin lagi operator buat ngitung:

• + (Penjumlahan)
• - (Pengurangan)
• * (Perkalian)
• / (Pembagian)
• % (Modulus / Sisa Bagi)
• ** (Pangkat)
• ++ (Increment)
• -- (Decrement)

let a = 10;
let b = 4;
console.log("a + b =", a + b); // 14
console.log("a * b =", a * b); // 40
console.log("a % b =", a % b); // 2 (10 dibagi 4 sisa 2)
console.log("a ** b =", a ** b); // 10000 (10 pangkat 4)

Nilai Angka Spesial: Infinity, -Infinity, dan NaN

Selain angka biasa, tipe Number juga punya beberapa nilai spesial:

1. Infinity: Mewakili nilai positif tak terhingga. Biasanya muncul kalau hasil perhitungan lebih gede dari angka terbesar yang bisa diwakilin JavaScript.

   console.log(1 / 0);        // Output: Infinity
   console.log(Number.MAX_VALUE * 2); // Output: Infinity (MAX_VALUE adalah angka terbesar yang bisa)

2. -Infinity: Mewakili nilai negatif tak terhingga.

   console.log(-1 / 0);       // Output: -Infinity

3. NaN (Not a Number):

   • Ini nilai spesial yang nunjukin kalau hasil operasi matematika itu bukan angka yang valid secara matematis.
   • Contohnya:

     console.log(0 / 0);              // Output: NaN
     console.log("Halo" * 5);         // Output: NaN (string dikali angka)
     console.log(Math.sqrt(-1));      // Output: NaN (akar dari angka negatif)
     console.log(parseInt("bukan angka")); // Output: NaN

   • PENTING: NaN itu unik. Dia gak sama dengan apa pun, termasuk dirinya sendiri!

     console.log(NaN === NaN); // Output: false!

   • Buat ngecek apakah sebuah nilai itu NaN, pake fungsi bawaan isNaN() atau Number.isNaN() (lebih direkomendasikan).

     let hasil = 0 / 0;
     console.log(isNaN(hasil));          // Output: true
     console.log(Number.isNaN(hasil));   // Output: true (lebih ketat, gak ngelakuin konversi tipe)

Objek Math: Kalkulator Canggih Bawaan JavaScript

JavaScript punya objek global bawaan namanya Math yang isinya banyak banget properti konstanta matematika dan metode (fungsi) matematika yang berguna. Kamu gak perlu bikin objek Math baru, tinggal pake aja langsung.

Beberapa properti dan metode Math yang sering dipake:

• Konstanta:

  • Math.PI: Nilai Pi (π ≈ 3.14159)
  • Math.E: Bilangan Euler (e ≈ 2.718)
  • Math.SQRT2: Akar kuadrat dari 2 (√2 ≈ 1.414)
  • Dll.

• Metode Pembulatan:

  • Math.round(x): Bulatin x ke integer terdekat. (0.5 ke atas dibuletin ke atas).
  • Math.ceil(x) (Ceiling): Bulatin x ke atas ke integer terdekat.
  • Math.floor(x): Bulatin x ke bawah ke integer terdekat.
  • Math.trunc(x): Ngilangin bagian desimalnya aja (ngambil bagian integernya). (ES6)

  console.log(Math.round(4.7));  // Output: 5
  console.log(Math.round(4.2));  // Output: 4
  console.log(Math.ceil(4.2));   // Output: 5
  console.log(Math.floor(4.7));  // Output: 4
  console.log(Math.trunc(4.7));  // Output: 4
  console.log(Math.trunc(-4.2)); // Output: -4

• Metode Lainnya:

  • Math.pow(x, y): Sama kayak x ** y (x pangkat y).
  • Math.sqrt(x): Akar kuadrat dari x.
  • Math.abs(x): Nilai absolut (mutlak) dari x (selalu positif).
  • Math.min(nilai1, nilai2, ...): Ngembaliin nilai terkecil dari daftar angka.
  • Math.max(nilai1, nilai2, ...): Ngembaliin nilai terbesar dari daftar angka.
  • Math.random(): Ngembaliin angka acak (random) antara 0 (inklusif) dan 1 (eksklusif). Super berguna buat game atau simulasi!

  console.log(Math.pow(2, 3));      // Output: 8 (2 pangkat 3)
  console.log(Math.sqrt(16));       // Output: 4
  console.log(Math.abs(-5));        // Output: 5
  console.log(Math.min(10, 5, 20)); // Output: 5
  console.log(Math.max(10, 5, 20)); // Output: 20
   
  // Dapetin angka acak integer antara 1 dan 10:
  let angkaAcak = Math.floor(Math.random() * 10) + 1; 
  console.log("Angka acak (1-10):", angkaAcak);

  • Masih banyak lagi metode Math lain kayak fungsi trigonometri (sin, cos, tan), logaritma (log), dll.

Konversi ke Tipe Number

Kadang kita dapet data dalam bentuk string tapi sebenernya itu angka (misalnya, input dari form). Kita perlu ngubah (konversi) string itu jadi Number biar bisa diitung.

• Number(string): Fungsi global buat ngonversi string jadi angka. Kalau stringnya gak bisa dikonversi, hasilnya NaN.
• parseInt(string, radix): Ngonversi string jadi integer (bilangan bulat). Dia bakal berhenti pas nemu karakter non-angka pertama. radix itu basis angkanya (opsional, defaultnya 10 buat desimal).
• parseFloat(string): Ngonversi string jadi angka floating-point (desimal).

let umurString = "25";
let umurAngka = Number(umurString);
console.log(umurAngka + 5); // Output: 30
 
let tinggiString = "170.5cm";
let tinggiAngkaInt = parseInt(tinggiString); // cuma ngambil "170"
let tinggiAngkaFloat = parseFloat(tinggiString); // ngambil "170.5"
console.log(tinggiAngkaInt);   // Output: 170
console.log(tinggiAngkaFloat); // Output: 170.5
 
console.log(Number("Halo"));   // Output: NaN
console.log(parseInt("100px20")); // Output: 100

Ngecek Apakah Angka Itu Integer atau Finite

• Number.isInteger(nilai): (ES6) Ngembaliin true kalau nilai itu integer, false kalau bukan.
• Number.isFinite(nilai): (ES6) Ngembaliin true kalau nilai itu angka yang finite (bukan Infinity, -Infinity, atau NaN), false kalau bukan. Ini lebih aman daripada isFinite() global yang bisa ngonversi tipe dulu.

console.log(Number.isInteger(10));    // Output: true
console.log(Number.isInteger(10.5));  // Output: false
console.log(Number.isFinite(100 / 0)); // Output: false (karena hasilnya Infinity)
console.log(Number.isFinite(123));    // Output: true

Angka dan operasi matematika ini adalah tulang punggung dari banyak logika pemrograman. Dengan ngertiin tipe Number, berbagai operator aritmatika, objek Math yang super berguna, dan cara konversi tipe, kamu udah siap buat ngelakuin berbagai macam perhitungan di kode JavaScript-mu.

Jangan lupa soal NaN dan Infinity, dan selalu hati-hati sama isu presisi kalau kerja sama angka desimal yang butuh akurasi tinggi!