JavaScript - BigInt: Xử lý Số học Lớn

Xin chào các bạn đang học lập trình! Hôm nay, chúng ta sẽ bắt đầu một chuyến hành trình thú vị vào thế giới của những con số rất, rất lớn trong JavaScript. Hãy chuẩn bị, vì chúng ta sắp khám phá ra miền đất kỳ diệu của BigInt!

BigInt là gì?

Hãy tưởng tượng bạn đang đếm sao trên bầu trời đêm. Bạn đếm và đếm, nhưngSuddenly, máy tính của bạn nói "Vô cực". Thật khó chịu, phải không? Đó là lúc BigInt đến để cứu giúp!

BigInt là một loại số đặc biệt trong JavaScript có thể đại diện cho các số nguyên có độ dài tùy ý. Không giống như các số thông thường, có giới hạn, BigInt có thể xử lý các số lớn như trí tưởng tượng (hoặc bộ nhớ của máy tính) của bạn cho phép.

Tại sao chúng ta cần BigInt?

Trong JavaScript, các số thông thường được lưu trữ trong 64 bit, có nghĩa là chúng có giá trị số nguyên an toàn tối đa là 9.007.199.254.740.991. Đó là một con số lớn, nhưng trong thế giới máy tính, đôi khi chúng ta cần phải lớn hơn!

Hãy xem会发生什么 khi chúng ta cố gắng vượt qua giới hạn này:

console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992 (Oops! Kết quả相同)

Như bạn có thể thấy, JavaScript không thể đại diện chính xác các số vượt quá giới hạn này. Đó là lúc BigInt tỏa sáng!

Khai báo và Khởi tạo

Tạo một BigInt dễ dàng như bánh. Bạn có hai tùy chọn:

1. Thêm 'n' vào cuối một số nguyên
2. Sử dụng hàm BigInt()

Hãy thử cả hai:

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

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

Chú ý đến 'n' ở cuối? Đó là cách JavaScript biết rằng đó là một BigInt!

Các thao tác cơ bản

Bây giờ chúng ta đã có các số lớn, hãy làm một chút toán học!

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 (Phân chia nguyên)
console.log(a % b);  // 1234567890n

Nhớ rằng, BigInts luôn là số nguyên. Khi chia, kết quả được làm tròn xuống đến số nguyên gần nhất.

So sánh

So sánh BigInts cũng giống như so sánh các số thông thường:

console.log(5n > 4n);   // true
console.log(5n < 4n);   // false
console.log(5n === 5);  // false (khác loại)
console.log(5n == 5);   // true (ép kiểu)

Chú ý đến hai dòng cuối cùng. BigInts và số thông thường được coi là bằng nhau khi sử dụng ==, nhưng không bằng nhau khi sử dụng ===. Điều này là vì === kiểm tra cả giá trị và loại.

Chuyển đổi

Đôi khi bạn cần chuyển đổi giữa BigInts và số thông thường. Dưới đây là cách:

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

console.log(regularNum);  // 123456789

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

Hãy cẩn thận khi chuyển đổi các BigInt lớn thành số thông thường, vì bạn có thể mất精度!

Ví dụ

Hãy áp dụng kiến thức về BigInt của chúng ta với một số ví dụ thực tế:

1. Tính Factorials

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

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

Hàm này có thể tính factorials của các số lớn hơn nhiều so với các số có thể với số thông thường trong JavaScript!

2. Làm việc với các số nguyên tố rất lớn

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

Hàm này có thể kiểm tra tính nguyên tố cho các số vượt xa giới hạn của số thông thường!

Xử lý Lỗi với BigInt

Khi làm việc với BigInts, có một số điều cần lưu ý:

try {
const result = 1n + 1;  // Điều này sẽ gây ra lỗi
} catch (error) {
console.log("Error:", error.message);  // Không thể trộn BigInt và các loại khác
}

try {
const result = Math.sqrt(4n);  // Điều này cũng sẽ gây ra lỗi
} catch (error) {
console.log("Error:", error.message);  // Không thể chuyển đổi giá trị BigInt thành số
}

Nhớ rằng, BigInts chỉ có thể được sử dụng với các BigInt khác cho các thao tác toán học, và nhiều hàm Math không hỗ trợ BigInts.

Phương thức BigInt

Dưới đây là bảng các phương thức BigInt thường được sử dụng:

Phương thức	Mô tả	Ví dụ
BigInt()	Tạo một giá trị BigInt	BigInt(123)
BigInt.asIntN()	Đóng gói một giá trị BigInt thành số nguyên dấu từ -2^(n-1) đến 2^(n-1)-1	BigInt.asIntN(3, 5n) // 5n
BigInt.asUintN()	Đóng gói một giá trị BigInt thành số nguyên không dấu từ 0 đến 2^n-1	BigInt.asUintN(3, 5n) // 5n
BigInt.prototype.toString()	Trả về một biểu diễn chuỗi của giá trị BigInt	(123n).toString() // "123"
BigInt.prototype.valueOf()	Trả về giá trị nguyên thủy của một đối tượng BigInt	Object(123n).valueOf() // 123n

Và đó là tất cả, các bạn! Bây giờ bạn đã được trang bị để xử lý các số lớn hơn cả các vì sao trên bầu trời. Nhớ rằng, với quyền lực lớn đi kèm với trách nhiệm lớn - hãy sử dụng BigInt của bạn một cách khôn ngoan!

Chúc các bạn vui vẻ lập trình, và số của bạn luôn lớn như giấc mơ của bạn!

Credits: Image by storyset