JavaScript BigInt: Menguasai Aritmetika Bilangan Bulat Besar

JavaScript, meskipun merupakan bahasa yang serbaguna, memiliki batasan saat menangani bilangan bulat yang sangat besar. Tipe `Number` standar hanya dapat secara akurat merepresentasikan bilangan bulat hingga batas tertentu, yang dikenal sebagai `Number.MAX_SAFE_INTEGER`. Di luar batas ini, perhitungan menjadi tidak presisi, yang mengarah pada hasil yang tidak terduga. Di sinilah BigInt datang untuk menyelamatkan. Diperkenalkan dalam ECMAScript 2020, BigInt adalah objek bawaan yang menyediakan cara untuk merepresentasikan dan memanipulasi bilangan bulat dengan ukuran arbitrer, melampaui batasan tipe `Number` standar.

Memahami Kebutuhan akan BigInt

Sebelum BigInt, pengembang JavaScript harus bergantung pada pustaka atau implementasi kustom untuk menangani kalkulasi bilangan bulat besar. Solusi-solusi ini sering kali datang dengan overhead kinerja dan peningkatan kompleksitas. Pengenalan BigInt menyediakan cara asli dan efisien untuk bekerja dengan bilangan bulat besar, membuka kemungkinan untuk aplikasi di berbagai domain, termasuk:

Kriptografi: Menangani bilangan prima besar secara aman sangat penting untuk algoritma kriptografi.
Perhitungan Keuangan: Merepresentasikan nilai moneter yang besar secara akurat tanpa kehilangan presisi.
Komputasi Ilmiah: Melakukan perhitungan kompleks yang melibatkan angka yang sangat besar atau kecil.
Stempel Waktu Presisi Tinggi: Merepresentasikan stempel waktu dengan presisi nanodetik.
Pembuatan ID: Membuat pengidentifikasi yang unik dan sangat besar.

Membuat Nilai BigInt

Ada dua cara utama untuk membuat nilai BigInt di JavaScript:

Menggunakan konstruktor `BigInt()`: Konstruktor ini dapat mengonversi nilai angka, string, atau boolean menjadi BigInt.
Menggunakan sufiks `n`: Menambahkan `n` ke literal bilangan bulat akan membuat BigInt.

Contoh:

Menggunakan konstruktor `BigInt()`:


const bigIntFromNumber = BigInt(12345678901234567890);
const bigIntFromString = BigInt("98765432109876543210");
const bigIntFromBoolean = BigInt(true); // Menghasilkan 1n
const bigIntFromFalseBoolean = BigInt(false); // Menghasilkan 0n

console.log(bigIntFromNumber); // Keluaran: 12345678901234567890n
console.log(bigIntFromString); // Keluaran: 98765432109876543210n
console.log(bigIntFromBoolean); // Keluaran: 1n
console.log(bigIntFromFalseBoolean); // Keluaran: 0n

Menggunakan sufiks `n`:


const bigIntLiteral = 12345678901234567890n;
console.log(bigIntLiteral); // Keluaran: 12345678901234567890n

Catatan Penting: Anda tidak bisa langsung mencampur nilai BigInt dan Number dalam operasi aritmetika. Anda perlu secara eksplisit mengonversinya ke tipe yang sama sebelum melakukan perhitungan. Mencoba mencampurnya secara langsung akan menghasilkan `TypeError`.

Operasi Aritmetika BigInt

BigInt mendukung sebagian besar operator aritmetika standar, termasuk:

Penjumlahan (`+`)
Pengurangan (`-`)
Perkalian (`*`)
Pembagian (`/`)
Sisa Bagi (`%`)
Perpangkatan (`**`)

Contoh:


const a = 12345678901234567890n;
const b = 98765432109876543210n;

const sum = a + b;
const difference = a - b;
const product = a * b;
const quotient = a / 2n; // Catatan: Pembagian memotong ke arah nol
const remainder = a % 7n;
const power = a ** 3n; // Perpangkatan bekerja seperti yang diharapkan

console.log("Jumlah:", sum); // Keluaran: Jumlah: 111111111011111111100n
console.log("Selisih:", difference); // Keluaran: Selisih: -86419753208641975320n
console.log("Hasil Kali:", product); // Keluaran: Hasil Kali: 1219326311370217957951669538098765432100n
console.log("Hasil Bagi:", quotient); // Keluaran: Hasil Bagi: 6172839450617283945n
console.log("Sisa Bagi:", remainder); // Keluaran: Sisa Bagi: 5n
console.log("Pangkat:", power); // Keluaran: Pangkat: 187641281029182300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

Pertimbangan Penting:

Pembagian: Pembagian dengan nilai BigInt memotong ke arah nol. Ini berarti bagian desimal dari hasilnya dibuang. Jika Anda memerlukan pembagian yang lebih presisi, pertimbangkan untuk menggunakan pustaka yang mendukung aritmetika presisi arbitrer.
Operator Unary Plus (+): Operator unary plus (+) tidak dapat digunakan dengan nilai BigInt karena akan bertentangan dengan kode asm.js lawas. Gunakan fungsi konversi `Number()` untuk mengonversi BigInt ke Number jika Anda memerlukan representasi numerik (dengan pemahaman bahwa Anda mungkin kehilangan presisi).
Operator Bitwise: BigInt juga mendukung operator bitwise seperti `&`, `|`, `^`, `~`, `<<`, dan `>>`. Operator ini bekerja seperti yang diharapkan pada representasi biner dari nilai BigInt.

Operator Perbandingan

Anda dapat menggunakan operator perbandingan standar (`==`, `!=`, `<`, `>`, `<=`, `>=`) untuk membandingkan nilai BigInt dengan nilai BigInt lain atau bahkan dengan nilai Number. Namun, waspadai potensi pemaksaan tipe (type coercion).

Contoh:


const a = 10n;
const b = 20n;
const c = 10;

console.log(a == b);   // Keluaran: false
console.log(a != b);   // Keluaran: true
console.log(a < b);    // Keluaran: true
console.log(a > b);    // Keluaran: false
console.log(a <= b);   // Keluaran: true
console.log(a >= b);   // Keluaran: false

console.log(a == c);   // Keluaran: true (pemaksaan tipe)
console.log(a === c);  // Keluaran: false (tidak ada pemaksaan tipe)

Praktik Terbaik: Gunakan kesetaraan ketat (===) dan ketidaksetaraan ketat (!==) untuk menghindari pemaksaan tipe yang tidak terduga saat membandingkan nilai BigInt dan Number.

Mengonversi antara BigInt dan Number

Meskipun operasi aritmetika langsung antara BigInt dan Number tidak diizinkan, Anda dapat mengonversi antara kedua tipe tersebut. Namun, waspadai potensi kehilangan presisi saat mengonversi BigInt ke Number jika nilai BigInt melebihi `Number.MAX_SAFE_INTEGER`.

Contoh:


const bigIntValue = 9007199254740991n; // Number.MAX_SAFE_INTEGER
const numberValue = Number(bigIntValue); // Mengonversi BigInt ke Number
console.log(numberValue); // Keluaran: 9007199254740991

const largerBigIntValue = 9007199254740992n; // Melebihi Number.MAX_SAFE_INTEGER
const largerNumberValue = Number(largerBigIntValue);
console.log(largerNumberValue); // Keluaran: 9007199254740992 (mungkin tidak presisi)

const numberToBigInt = BigInt(12345); // Mengonversi Number ke BigInt
console.log(numberToBigInt); // Keluaran: 12345n

Kasus Penggunaan dan Contoh

Kriptografi

Algoritma kriptografi sering kali bergantung pada bilangan prima yang sangat besar untuk keamanan. BigInt menyediakan cara untuk merepresentasikan dan memanipulasi angka-angka ini secara efisien.


// Contoh: Menghasilkan pasangan kunci sederhana (tidak aman)
function generateKeyPair() {
  const p = 281n; // Sebuah bilangan prima
  const q = 283n; // Bilangan prima lain
  const n = p * q; // Modulus
  const totient = (p - 1n) * (q - 1n); // Fungsi totient Euler

  // Pilih e (eksponen publik) sedemikian rupa sehingga 1 < e < totient dan gcd(e, totient) = 1
  const e = 17n;

  // Hitung d (eksponen pribadi) sedemikian rupa sehingga (d * e) % totient = 1
  let d = 0n;
  for (let i = 1n; i < totient; i++) {
    if ((i * e) % totient === 1n) {
      d = i;
      break;
    }
  }

  return {
    publicKey: { n, e },
    privateKey: { n, d },
  };
}

const keyPair = generateKeyPair();
console.log("Kunci Publik:", keyPair.publicKey);
console.log("Kunci Pribadi:", keyPair.privateKey);

Catatan: Ini adalah contoh yang disederhanakan hanya untuk tujuan demonstrasi. Kriptografi dunia nyata menggunakan bilangan prima yang jauh lebih besar dan algoritma yang lebih canggih.

Perhitungan Keuangan

Saat berurusan dengan sejumlah besar uang, terutama dalam transaksi internasional, presisi sangat penting. BigInt dapat mencegah kesalahan pembulatan dan memastikan perhitungan yang akurat.


// Contoh: Menghitung bunga majemuk
function calculateCompoundInterest(principal, rate, time) {
  const principalBigInt = BigInt(principal * 100); // Konversi ke sen
  const rateBigInt = BigInt(rate * 10000);       // Konversi ke sepersepuluh ribu persen
  const timeBigInt = BigInt(time);

  let amount = principalBigInt;
  for (let i = 0n; i < timeBigInt; i++) {
    amount = amount * (10000n + rateBigInt) / 10000n;
  }

  const amountInDollars = Number(amount) / 100;
  return amountInDollars;
}

const principal = 1000000; // $1,000,000
const rate = 0.05;    // Tingkat bunga 5%
const time = 10;     // 10 tahun

const finalAmount = calculateCompoundInterest(principal, rate, time);
console.log("Jumlah Akhir:", finalAmount); // Keluaran: Jumlah Akhir: 1628894.6267774413 (kira-kira)

Dalam contoh ini, kami mengonversi pokok dan suku bunga menjadi nilai BigInt untuk menghindari kesalahan pembulatan selama perhitungan. Hasilnya kemudian dikonversi kembali menjadi Number untuk ditampilkan.

Bekerja dengan ID Besar

Dalam sistem terdistribusi, menghasilkan ID unik di beberapa server bisa menjadi tantangan. Menggunakan BigInt memungkinkan Anda membuat ID yang sangat besar yang kemungkinannya kecil untuk bertabrakan.


// Contoh: Menghasilkan ID unik berdasarkan stempel waktu dan ID server
function generateUniqueId(serverId) {
  const timestamp = BigInt(Date.now());
  const serverIdBigInt = BigInt(serverId);
  const random = BigInt(Math.floor(Math.random() * 1000)); // Tambahkan sedikit keacakan

  // Gabungkan nilai-nilai untuk membuat ID unik
  const uniqueId = (timestamp << 20n) + (serverIdBigInt << 10n) + random;
  return uniqueId.toString(); // Kembalikan sebagai string untuk penanganan yang mudah
}

const serverId = 123; // Contoh ID server
const id1 = generateUniqueId(serverId);
const id2 = generateUniqueId(serverId);

console.log("ID Unik 1:", id1);
console.log("ID Unik 2:", id2);

BigInt dan JSON

Nilai BigInt tidak didukung secara native oleh JSON. Mencoba melakukan serialisasi objek JavaScript yang berisi BigInt menggunakan `JSON.stringify()` akan menghasilkan `TypeError`. Untuk menangani nilai BigInt saat bekerja dengan JSON, Anda memiliki beberapa pilihan:

Konversi ke String: Konversi BigInt ke string sebelum serialisasi. Ini adalah pendekatan yang paling umum dan lugas.
Serialisasi/Deserialisasi Kustom: Gunakan fungsi serialisasi/deserialisasi kustom untuk menangani nilai BigInt.

Contoh:

Mengonversi ke String:


const data = {
  id: 12345678901234567890n,
  name: "Example Data",
};

// Konversi BigInt ke string sebelum serialisasi
data.id = data.id.toString();

const jsonData = JSON.stringify(data);
console.log(jsonData); // Keluaran: {"id":"12345678901234567890","name":"Example Data"}

// Saat deserialisasi, Anda perlu mengonversi string kembali menjadi BigInt
const parsedData = JSON.parse(jsonData, (key, value) => {
  if (key === "id") {
    return BigInt(value);
  }
  return value;
});

console.log(parsedData.id); // Keluaran: 12345678901234567890n

Serialisasi/Deserialisasi Kustom (menggunakan `replacer` dan `reviver`):


const data = {
  id: 12345678901234567890n,
  name: "Example Data",
};

// Serialisasi kustom
const jsonData = JSON.stringify(data, (key, value) => {
  if (typeof value === 'bigint') {
    return value.toString();
  } else {
    return value;
  }
});

console.log(jsonData);

// Deserialisasi kustom
const parsedData = JSON.parse(jsonData, (key, value) => {
    if (typeof value === 'string' && /^[0-9]+$/.test(value)) { //periksa apakah itu angka dan string
      try {
        return BigInt(value);
      } catch(e) {
          return value;
      }
    }
    return value;
});

console.log(parsedData.id);

Kompatibilitas Browser

BigInt didukung secara luas di browser modern. Namun, penting untuk memeriksa kompatibilitas untuk browser atau lingkungan yang lebih lama. Anda dapat menggunakan alat seperti Can I use untuk memverifikasi dukungan browser. Jika Anda perlu mendukung browser lama, Anda mungkin mempertimbangkan untuk menggunakan polyfill, tetapi sadarilah bahwa polyfill dapat memengaruhi kinerja.

Pertimbangan Kinerja

Meskipun BigInt menyediakan cara yang kuat untuk bekerja dengan bilangan bulat besar, penting untuk menyadari implikasi kinerja yang potensial.

Operasi BigInt bisa lebih lambat daripada operasi Number standar.
Mengonversi antara BigInt dan Number juga dapat menimbulkan overhead.

Oleh karena itu, gunakan BigInt hanya jika diperlukan, dan optimalkan kode Anda untuk kinerja jika Anda melakukan sejumlah besar operasi BigInt.

Kesimpulan

BigInt adalah tambahan yang berharga untuk JavaScript, memungkinkan pengembang untuk menangani aritmetika bilangan bulat besar dengan presisi. Dengan memahami fitur, batasan, dan kasus penggunaannya, Anda dapat memanfaatkan BigInt untuk membangun aplikasi yang kuat dan akurat di berbagai domain, termasuk kriptografi, perhitungan keuangan, dan komputasi ilmiah. Ingatlah untuk mempertimbangkan kompatibilitas browser dan implikasi kinerja saat menggunakan BigInt dalam proyek Anda.

Eksplorasi Lebih Lanjut

Panduan ini memberikan gambaran komprehensif tentang BigInt di JavaScript. Jelajahi sumber daya yang tertaut untuk informasi lebih mendalam dan teknik-teknik lanjutan.