MulaiCode
JavaScript

JS BigInt

Pelajari cara menggunakan tipe data BigInt di JavaScript untuk angka yang sangat besar.

JavaScript BigInt untuk Pemula

BigInt adalah tipe data di JavaScript yang memungkinkan kita bekerja dengan angka yang sangat besar. Berbeda dengan tipe data Number biasa yang memiliki batasan, BigInt bisa menampung angka sebesar apapun.

Mengapa Kita Butuh BigInt? 🤔

JavaScript Number hanya bisa menangani angka hingga 9.007.199.254.740.991 (atau 2^53-1). Untuk nilai yang lebih besar, kita perlu menggunakan BigInt!

Ini penting untuk kasus seperti:

  • ID unik dalam database besar
  • Timestamp dengan presisi tinggi
  • Kriptografi dan kode keamanan
  • Kalkulasi ilmiah dengan angka sangat besar

1. Cara Membuat BigInt

Ada dua cara mudah untuk membuat BigInt:

// Cara 1: Tambahkan huruf 'n' di akhir angka
const bigInt1 = 123n;
 
// Cara 2: Gunakan fungsi BigInt()
const bigInt2 = BigInt(123);
const bigInt3 = BigInt("123");
 
console.log(bigInt1); // Output: 123n
console.log(typeof bigInt1); // Output: bigint

Penjelasan:

  • Menambahkan 'n' di akhir: cara paling cepat untuk membuat BigInt
  • Fungsi BigInt(): berguna untuk mengkonversi Number atau String menjadi BigInt
  • Tipe data akan terlihat sebagai "bigint" (bukan "number")

2. Mengapa Kita Perlu BigInt? Lihat Perbandingan!

// Contoh kesalahan dengan Number biasa
const besar = 9007199254740991; // Nilai aman maksimum
console.log(besar); // Output: 9007199254740991
console.log(besar + 1); // Output: 9007199254740992
console.log(besar + 2); // Output: 9007199254740992 (🚨 Seharusnya berbeda!)
 
// Solusi dengan BigInt
const besarBigInt = 9007199254740991n;
console.log(besarBigInt); // Output: 9007199254740991n
console.log(besarBigInt + 1n); // Output: 9007199254740992n
console.log(besarBigInt + 2n); // Output: 9007199254740993n (✅ Nilai tepat!)

Penjelasan:

JavaScript Number kehilangan akurasi untuk angka yang sangat besar. Perhatikan bahwa (besar + 1) dan (besar + 2) menghasilkan nilai yang sama, yang jelas salah! Dengan BigInt, kalkulasi tetap akurat meskipun angkanya sangat besar.

3. Operasi Dasar dengan BigInt

// Operasi matematika sederhana
const a = 10n;
const b = 3n;
 
console.log(`${a} + ${b} = ${a + b}`); // Output: 10n + 3n = 13n
console.log(`${a} - ${b} = ${a - b}`); // Output: 10n - 3n = 7n
console.log(`${a} × ${b} = ${a * b}`); // Output: 10n × 3n = 30n
console.log(`${a} ÷ ${b} = ${a / b}`); // Output: 10n ÷ 3n = 3n
console.log(`${a} % ${b} = ${a % b}`); // Output: 10n % 3n = 1n
console.log(`${a} ** ${b} = ${a ** b}`); // Output: 10n ** 3n = 1000n

Penjelasan:

Operasi matematika dengan BigInt mirip dengan Number biasa.

⚠️ Perhatikan hasil pembagian (10n ÷ 3n):

  • Hasil menjadi 3n, bukan 3.33n
  • BigInt selalu membulatkan ke bawah (floor division)
  • BigInt tidak mendukung bilangan desimal

4. Kesalahan Umum dengan BigInt

// KESALAHAN #1: Mencampur BigInt dengan Number
const bigInt = 10n;
const number = 5;
 
try {
  console.log(bigInt + number); // Error!
} catch (error) {
  console.log("Error: " + error.message);
  // Output: Error: Cannot mix BigInt and other types, use explicit conversions
}
 
// KESALAHAN #2: Menggunakan Math dengan BigInt
try {
  console.log(Math.sqrt(4n)); // Error!
} catch (error) {
  console.log("Error: " + error.message);
  // Output: Error: Cannot convert a BigInt value to a number
}

Solusi untuk Kesalahan Umum:

// Solusi untuk Kesalahan #1:
// Konversi dulu ke tipe yang sama
console.log(bigInt + BigInt(number)); // Output: 15n
// atau
console.log(Number(bigInt) + number); // Output: 15
 
// Solusi untuk Kesalahan #2:
// Konversi BigInt ke Number untuk Math
console.log(Math.sqrt(Number(4n))); // Output: 2

5. Perbandingan dengan BigInt

const bigInt = 10n;
const number = 10;
 
// Perbandingan nilai
console.log(`${bigInt} == ${number}: ${bigInt == number}`);
// Output: 10n == 10: true
 
// Perbandingan nilai DAN tipe
console.log(`${bigInt} === ${number}: ${bigInt === number}`);
// Output: 10n === 10: false
 
// Perbandingan besar-kecil
console.log(`${bigInt} > ${number - 5}: ${bigInt > number - 5}`);
// Output: 10n > 5: true
console.log(`${bigInt} < ${number + 5}: ${bigInt < number + 5}`);
// Output: 10n < 15: true

Penjelasan:

  • == hanya membandingkan nilai, mengabaikan tipe data
  • === membandingkan nilai DAN tipe data (10n dan 10 punya tipe berbeda)
  • BigInt dan Number bisa dibandingkan dengan operator >, <, >=, <=

6. Contoh Nyata: Menghitung ID Produk

// Simulasi ID produk di database besar
const productId = 9007199254740992n;
 
// Mencari ID produk berikutnya
const nextProductId = productId + 1n;
 
// Membuat string untuk ditampilkan
console.log(`ID Produk: ${productId.toString()}`);
// Output: ID Produk: 9007199254740992
console.log(`ID Produk Berikutnya: ${nextProductId.toString()}`);
// Output: ID Produk Berikutnya: 9007199254740993
 
// Memeriksa apakah ini ID valid
const isValid = nextProductId > productId;
console.log(`Apakah ID valid? ${isValid}`);
// Output: Apakah ID valid? true

Penjelasan:

Dalam situasi nyata, kita sering perlu bekerja dengan ID atau angka besar lainnya. Perhatikan penggunaan .toString() untuk mengonversi BigInt menjadi string saat menampilkannya. Ini contoh sederhana, tapi menunjukkan keunggulan BigInt untuk ID unik dalam skala besar.

7. Konversi BigInt ke Tipe Data Lain

const bigIntVal = 123456789n;
 
// BigInt ke String
const strVal = bigIntVal.toString();
console.log(strVal); // Output: "123456789" (tanpa n)
console.log(typeof strVal); // Output: string
 
// BigInt ke Number (hati-hati jika nilai terlalu besar!)
const numVal = Number(bigIntVal);
console.log(numVal); // Output: 123456789
console.log(typeof numVal); // Output: number
 
// Hati-hati dengan nilai yang terlalu besar!
const hugeBigInt = 9007199254740993n;
console.log(Number(hugeBigInt)); // Output: 9007199254740992 (tidak akurat!)

Penjelasan:

  • Untuk menampilkan BigInt tanpa akhiran 'n', gunakan .toString()
  • Saat mengonversi BigInt ke Number, hati-hati dengan nilai yang melebihi MAX_SAFE_INTEGER
  • Jika nilai BigInt terlalu besar, konversi ke Number bisa menyebabkan kehilangan presisi

8. Tips untuk BigInt

✅ Lakukan:

  • Tambahkan n di akhir semua angka saat bekerja dengan BigInt
  • Gunakan konversi eksplisit saat mencampur BigInt dan Number
  • Ingat bahwa pembagian BigInt selalu membulatkan ke bawah
  • Gunakan .toString() untuk menampilkan BigInt tanpa akhiran 'n'

❌ Hindari:

  • Mencampur BigInt dan Number tanpa konversi
  • Menggunakan fungsi Math dengan BigInt
  • Mengharapkan hasil desimal dari operasi BigInt
  • Mengonversi BigInt yang sangat besar ke Number

Latihan Singkat

Pertanyaan 1:

Apa output dari kode berikut?

console.log(5n / 2n);

Petunjuk: Ingat bahwa pembagian BigInt selalu membulatkan ke bawah.

Jawaban: Output adalah 2n (karena BigInt membulatkan ke bawah)

Pertanyaan 2:

Bagaimana cara memperbaiki kode ini?

const result = 10n + 5;

Petunjuk: Kode ini akan error karena mencampur tipe data. Ubah salah satu nilai agar tipenya sama.

Jawaban:

const result = 10n + 5n; // Konversi 5 ke BigInt
// atau
const result = Number(10n) + 5; // Konversi 10n ke Number

JS Number Properties

Pelajari properti bawaan dari objek Number di JavaScript seperti MAX_VALUE, MIN_VALUE, dan lainnya.

JS Arrays

Pelajari cara membuat dan menggunakan array di JavaScript dengan contoh praktis.

On this page