Number dan BigInt JavaScript: Float, Presisi, dan Integer Besar

Satu Tipe Number untuk Segalanya (Hampir)

Kebanyakan bahasa memberimu tipe terpisah untuk integer dan float. JavaScript, secara historis, hanya memberimu satu: Number. Entah kamu menulis 42, 3.14, atau -0.001, kamu mendapat tipe primitif yang sama, yaitu float double-precision IEEE 754 64-bit.

console.log(typeof 42);         // "number"
console.log(typeof 3.14);       // "number"
console.log(typeof -0.001);     // "number"
console.log(typeof NaN);        // "number"
console.log(typeof Infinity);   // "number"

Itu praktis: tidak perlu konversi antara int dan float, tidak ada overflow di 2^31. Tetapi representasi float punya konsekuensi, dan konsekuensi itu sering menjebak pemula. Tipe numerik kedua, BigInt, ditambahkan pada 2020 untuk menangani kasus-kasus di mana Number tidak memadai.

Kejutan Floating-Point

Jalankan ini:

console.log(0.1 + 0.2);
console.log(0.1 + 0.2 === 0.3);

Baris pertama mencetak 0.30000000000000004. Baris kedua mencetak false. Ini bukan keanehan JavaScript: Python, Java, C, dan bahasa apa pun yang memakai float IEEE 754 berperilaku sama.

Alasannya: 0.1 dan 0.2 tidak bisa direpresentasikan secara tepat dalam biner, sama seperti 1/3 tidak bisa ditulis secara tepat dalam desimal. Yang disimpan adalah pendekatan biner yang paling dekat, dan kesalahan kecil pun menumpuk. Model mentalnya: perlakukan nilai Number yang melibatkan desimal sebagai pendekatan yang kebetulan sangat dekat dengan apa yang kamu tulis.

Untuk uang, jangan simpan $19.99 sebagai 19.99. Simpan sen sebagai integer, yaitu 1999, lalu format saat ditampilkan. Itulah satu kebiasaan terbaik untuk menghindari bug float.

Membandingkan Float dengan Aman

Karena kesamaan tidak bisa diandalkan, bandingkan dengan toleransi saat kamu perlu:

const a = 0.1 + 0.2;
const b = 0.3;

const EPSILON = Number.EPSILON;
console.log(Math.abs(a - b) < EPSILON);  // true

Number.EPSILON adalah selisih terkecil antara 1 dan angka berikutnya yang bisa direpresentasikan, toleransi default yang wajar untuk nilai di sekitar 1. Untuk besaran yang sangat besar atau sangat kecil, kamu butuh toleransi yang menyesuaikan dengan input-nya.

Rentang Integer yang Aman

Integer sampai ukuran tertentu memang tepat dalam float 64-bit. Setelah itu, presisinya mulai hilang sedikit demi sedikit:

console.log(Number.MAX_SAFE_INTEGER);       // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 1);   // 9007199254740992
console.log(Number.MAX_SAFE_INTEGER + 2);   // 9007199254740992  (!)

console.log(Number.isSafeInteger(9007199254740991));  // true
console.log(Number.isSafeInteger(9007199254740993));  // false

2^53 - 1 adalah integer terakhir di mana setiap integer di bawahnya bisa direpresentasikan. Di atasnya, sebagian integer sama sekali tidak ada di tipe Number: nilainya dibulatkan ke tetangga terdekatnya. Itu bug perusakan data diam-diam yang tinggal menunggu waktu kalau kamu mem-parsing ID 64-bit dari database sebagai angka JSON biasa.

Kenalan dengan BigInt

BigInt adalah tipe primitif tersendiri untuk integer dengan presisi tak terbatas. Kamu membuatnya dengan menambahkan n pada literal integer, atau dengan memanggil BigInt(...):

const a = 9007199254740993n;
const b = BigInt("9007199254740993");
const c = BigInt(42);

console.log(a);           // 9007199254740993n
console.log(typeof a);    // "bigint"
console.log(a === b);     // true

BigInt tidak punya batas atas selain memori yang tersedia. BigInt adalah alat yang tepat untuk:

• ID database atau snowflake ID Twitter/X yang melebihi 2^53.
• Perhitungan kriptografi.
• Aritmetika integer apa pun di mana hasil yang tepat lebih penting daripada kecepatan mentah.

BigInt bukan alat yang tepat untuk counter sehari-hari, index array, atau uang dalam bentuk sen: Number biasa lebih cepat dan bisa bekerja sama dengan setiap API di bahasa ini.

Aritmetika BigInt

Semua operator yang biasa tetap berfungsi, asalkan kedua operand-nya BigInt:

const big = 10n ** 30n;
console.log(big);                 // 1000000000000000000000000000000n
console.log(big + 1n);            // 1000000000000000000000000000001n
console.log(big * 2n);            // 2000000000000000000000000000000n

console.log(7n / 2n);             // 3n  (integer division, truncated)
console.log(7n % 2n);             // 1n

Pembagian dibulatkan ke arah nol: tidak ada BigInt pecahan. Kalau kamu butuh pecahan, kamu kembali ke wilayah Number (atau memakai library desimal).

Jangan Campur Tipe

Aturan yang sering menjebak: kamu tidak bisa mencampur Number dan BigInt dalam ekspresi yang sama.

try {
    console.log(1n + 1);
} catch (err) {
    console.log(err.message);
}

// Convert explicitly:
console.log(1n + BigInt(1));      // 2n
console.log(Number(1n) + 1);      // 2

Perbandingan adalah satu-satunya pengecualian: <, >, == melakukan coercion lintas tipe:

console.log(1n < 2);       // true
console.log(1n == 1);      // true
console.log(1n === 1);     // false  (different types)

Jadi == menganggap keduanya sama, === tidak. Kalau kamu sudah memakai === di mana-mana (dan memang sebaiknya begitu), anggap perbandingan numerik antara kedua tipe ini sebagai tanda desain yang bermasalah: pilih satu sisi dan lakukan konversi.

Konversi di Antara Keduanya

Dua konversi, dua jebakan:

// Number -> BigInt: must be a safe integer, no decimals
console.log(BigInt(42));          // 42n
try { BigInt(3.14); } catch (e) { console.log(e.message); }

// BigInt -> Number: may lose precision
const huge = 9007199254740993n;
console.log(Number(huge));        // 9007199254740992  (!)

Konversi Number → BigInt itu ketat: desimal dan NaN memunculkan error. Konversi BigInt → Number lebih longgar tetapi bisa kehilangan data: apa pun di atas MAX_SAFE_INTEGER akan dibulatkan. Kalau kamu mengonversi BigInt yang kamu terima dari server, tanyakan pada dirimu apakah kamu benar-benar perlu melakukannya.

Nilai Number Khusus

Sekalian di sini, ada tiga nilai di tipe Number yang bukan angka dalam arti matematis:

console.log(1 / 0);              // Infinity
console.log(-1 / 0);             // -Infinity
console.log(0 / 0);              // NaN
console.log("abc" - 1);          // NaN

console.log(NaN === NaN);        // false  (!)
console.log(Number.isNaN(NaN));  // true

Infinity dan -Infinity muncul saat kamu membagi dengan nol atau melampaui rentang float. NaN ("not a number") muncul saat operasi aritmetika tidak menghasilkan hasil yang bermakna.

NaN terkenal tidak sama dengan dirinya sendiri. Itu bagian dari spesifikasi IEEE 754, bukan bug JS. Pakai Number.isNaN(x) untuk mengeceknya. isNaN global yang lebih lama mengubah argumennya terlebih dulu, sehingga memberi jawaban yang salah (isNaN("hello") mengembalikan true). Selalu utamakan versi Number.isNaN.

Mem-parsing Angka dari String

Input pengguna dan angka JSON sering datang sebagai string. Ada tiga cara untuk mengonversinya:

console.log(Number("42"));         // 42
console.log(Number("42px"));       // NaN   (strict)
console.log(parseInt("42px"));     // 42    (permissive, reads digits)
console.log(parseFloat("3.14em")); // 3.14
console.log(+"42");                // 42    (unary plus, same as Number)

console.log(Number(""));           // 0     (!)
console.log(Number(" "));          // 0     (!)

Number() itu ketat: apa pun yang bukan angka menghasilkan NaN, kecuali string kosong dan spasi, yang menghasilkan 0. parseInt dan parseFloat lebih pemaaf: keduanya membaca sejauh mungkin lalu berhenti. Pilih yang sesuai dengan maksudmu, dan cek NaN sebelum memakai hasilnya.

Untuk mem-parsing BigInt dari string, pakai BigInt("123"): ketat dan memunculkan error untuk input yang buruk.

Buku Aturan Singkat

• Untuk counter, matematika, koordinat, dan sebagian besar angka sehari-hari: pakai Number.
• Untuk uang: ubah ke sen dalam bentuk integer dan pakai Number, atau gunakan library desimal.
• Untuk integer yang lebih besar dari 2^53 (ID database, kripto, kombinatorika): pakai BigInt dengan akhiran n.
• Bandingkan float dengan toleransi, bukan ===.
• Cek hasil yang tidak valid dengan Number.isNaN dan Number.isFinite, bukan versi globalnya.
• Jangan campur Number dan BigInt dalam ekspresi yang sama: lakukan konversi secara eksplisit.

Berikutnya: null vs undefined

JavaScript punya dua cara untuk mengatakan "tidak ada nilai", yaitu null dan undefined, dan keduanya tidak bisa saling menggantikan. Berikutnya: arti masing-masing, perbedaannya, dan kapan memakai yang mana.