JavaScript - BigInt: Mengelola Angka yang Sangat Besar

Hai teman-teman pengembang! Hari ini, kita akan memulai perjalanan yang menarik ke dunia angka yang sangat, sangat besar di JavaScript. Siapkan sabuk pengaman Anda, karena kita akan mengeksplorasi realm yang menarik dari BigInt!

Apa Itu BigInt?

Bayangkan Anda menghitung bintang di langit malam. Anda menghitung dan menghitung, tetapi tiba-tiba kalkulator Anda mengatakan "Infinity". Frustrasi, kan? Itu adalah tempat BigInt datang untuk menyelamatkan!

BigInt adalah jenis numerik khusus di JavaScript yang dapat merepresentasikan integer panjang sewenang-wenangnya. Tidak seperti angka biasa, yang memiliki batasan, BigInt dapat menangani angka sebanyak imajinasi Anda (atau memori komputer Anda) mengijinkan.

Mengapa Kita Butuh BigInt?

Di JavaScript, angka biasa disimpan dalam 64 bit, yang artinya mereka memiliki nilai integer maksimum aman sebesar 9,007,199,254,740,991. Itu adalah angka besar, tetapi di dunia komputasi, kadang-kadang kita perlu mengambil nilai yang lebih besar!

mari lihat apa yang terjadi saat kita mencoba melampaui batas ini:

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992 (Ups! Hasil yang sama)

Seperti yang Anda lihat, JavaScript tidak dapat merepresentasikan angka di atas batas ini secara akurat. Itu adalah tempat BigInt bercahaya!

Deklarasi dan Inisialisasi

Membuat BigInt adalah hal yang mudah seperti roti. Anda memiliki dua pilihan:

1. Menambahkan 'n' di akhir sebuah integer
2. Menggunakan fungsi BigInt()

mari coba keduanya:

const bigNumber1 = 1234567890123456789012345678901234567890n;
const bigNumber2 = BigInt("9007199254740991");

console.log(bigNumber1); // 1234567890123456789012345678901234567890n
console.log(bigNumber2); // 9007199254740991n

Perhatikan 'n' di akhir? Itu cara JavaScript mengetahui itu adalah BigInt!

Operasi Dasar

Sekarang kita memiliki angka besar, mari lakukan beberapa operasi matematika!

const a = 1234567890n;
const b = 9876543210n;

console.log(a + b);  // 11111111100n
console.log(a - b);  // -8641975320n
console.log(a * b);  // 12193263111263526900n
console.log(a / b);  // 0n (Pembagian bulat)
console.log(a % b);  // 1234567890n

Ingat, BigInts selalu adalah bilangan bulat. Saat membagi, hasilnya akan dibulatkan ke bilangan bulat terdekat.

Perbandingan

Membandingkan BigInts adalah sama seperti membandingkan angka biasa:

console.log(5n > 4n);   // true
console.log(5n < 4n);   // false
console.log(5n === 5);  // false (jenis yang berbeda)
console.log(5n == 5);   // true (koersi jenis)

Perhatikan dua baris terakhir. BigInts dan angka biasa dianggap sama saat menggunakan ==, tetapi tidak saat menggunakan ===. Ini karena === memeriksa kesamaan nilai dan jenis.

Konversi

Kadang-kadang Anda perlu mengkonversi antara BigInts dan angka biasa. Ini cara nya:

const bigNum = 123456789n;
const regularNum = Number(bigNum);

console.log(regularNum);  // 123456789

const backToBigInt = BigInt(regularNum);
console.log(backToBigInt);  // 123456789n

Hati-hati saat mengkonversi BigInt besar ke angka biasa, karena Anda mungkin kehilangan presisi!

Contoh

mari gunakan pengetahuan BigInt kita dengan beberapa contoh dunia nyata:

1. Menghitung Faktorial

function factorial(n) {
if (n === 0n) return 1n;
return n * factorial(n - 1n);
}

console.log(factorial(20n));  // 2432902008176640000n

Fungsi ini dapat menghitung faktorial angka yang jauh lebih besar daripada yang mungkin dengan angka biasa JavaScript!

2. Menggunakan Angka Prima yang Sangat Besar

function isPrime(n) {
if (n <= 1n) return false;
for (let i = 2n; i * i <= n; i++) {
if (n % i === 0n) return false;
}
return true;
}

const largeNumber = 2n ** 100n - 1n;
console.log(isPrime(largeNumber) ? "Prime" : "Not Prime");  // Not Prime

Fungsi ini dapat memeriksa prima bagi angka jauh di atas batas angka biasa JavaScript!

Penanganan Kesalahan dengan BigInt

Saat bekerja dengan BigInts, ada beberapa hal yang perlu dipantau:

try {
const result = 1n + 1;  // Ini akan melempar kesalahan
} catch (error) {
console.log("Error:", error.message);  // Tidak dapat mencampur BigInt dan jenis lain
}

try {
const result = Math.sqrt(4n);  // Ini juga akan melempar kesalahan
} catch (error) {
console.log("Error:", error.message);  // Tidak dapat mengkonversi nilai BigInt ke number
}

Ingat, BigInt hanya dapat digunakan dengan operasi aritmetik lainnya yang jenisnya BigInt, dan banyak fungsi Math tidak mendukung BigInt.

Metode BigInt

Berikut adalah tabel metode BigInt yang paling umum digunakan:

Metode	Deskripsi	Contoh
BigInt()	Membuat nilai BigInt	BigInt(123)
BigInt.asIntN()	Mengembalikan BigInt ke bilangan bulat terbatas antara -2^(n-1) dan 2^(n-1)-1	BigInt.asIntN(3, 5n) // 5n
BigInt.asUintN()	Mengembalikan BigInt ke bilangan bulat tak terbatas antara 0 dan 2^n-1	BigInt.asUintN(3, 5n) // 5n
BigInt.prototype.toString()	Mengembalikan representasi string dari nilai BigInt	(123n).toString() // "123"
BigInt.prototype.valueOf()	Mengembalikan nilai primitif dari objek BigInt	Object(123n).valueOf() // 123n

Dan itu adalah dia, teman-teman! Anda sekarang dilengkapi untuk menangani angka yang lebih besar dari bintang di langit. Ingat, dengan kekuatan yang besar datang tanggung jawab besar - gunakan BigInt Anda bijaksana!

Semangat coding, dan mayang angka Anda selalu sebesar mimpi Anda!

Credits: Image by storyset