typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
6 là một đối tượng trình bao bọc nguyên thủy được sử dụng để biểu diễn và thao tác các giá trị typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
7 nguyên thủy - quá lớn để được biểu diễn bằng nguyên thủy typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
8. is a primitive wrapper object used to represent and manipulate primitive
typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
7 values — which are
too large to be represented by the typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
8 primitive.
Sự mô tảMột giá trị lớn, đôi khi cũng chỉ được gọi là Bigint, là một nguyên thủy typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
7, được tạo bằng cách nối thêm typeof Object(1n) === 'object' // true
0 đến cuối của một số nguyên theo nghĩa đen hoặc bằng cách gọi hàm typeof Object(1n) === 'object' // true
1 (không có toán tử typeof Object(1n) === 'object' // true
2) và cho nó một giá trị số nguyên hoặc giá trị chuỗi.BigInt value, also sometimes just called a BigInt, is a typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
7 primitive, created by appending typeof Object(1n) === 'object' // true
0 to the end of an integer literal, or by calling the
typeof Object(1n) === 'object' // true
1 function (without the typeof Object(1n) === 'object' // true
2 operator) and giving it an integer value or string value.const previouslyMaxSafeInteger = 9007199254740991n
const alsoHuge = BigInt(9007199254740991)
// 9007199254740991n
const hugeString = BigInt("9007199254740991")
// 9007199254740991n
const hugeHex = BigInt("0x1fffffffffffff")
// 9007199254740991n
const hugeOctal = BigInt("0o377777777777777777")
// 9007199254740991n
const hugeBin = BigInt("0b11111111111111111111111111111111111111111111111111111")
// 9007199254740991n
Các giá trị lớn tương tự như các giá trị số theo một số cách, nhưng cũng khác nhau trong một vài vấn đề chính: giá trị lớn không thể được sử dụng với các phương thức trong đối tượng typeof Object(1n) === 'object' // true
3 tích hợp và không thể được trộn với giá trị số trong các hoạt động; Họ phải được ép buộc theo cùng một loại. Tuy nhiên, hãy cẩn thận cưỡng chế các giá trị qua lại vì độ chính xác của giá trị lớn có thể bị mất khi nó bị ép buộc theo giá trị số.Loại thông tinKhi được kiểm tra so với typeof Object(1n) === 'object' // true
4, giá trị lớn (typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
7 nguyên thủy) sẽ cho typeof Object(1n) === 'object' // true
6:typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
Một giá trị lớn cũng có thể được bọc trong một typeof Object(1n) === 'object' // true
7:typeof Object(1n) === 'object' // true
Người vận hànhCác toán tử sau đây có thể được sử dụng với các giá trị lớn hoặc các giá trị lớn được bao bọc đối tượng: + * - % **
Các toán tử bitwise cũng được hỗ trợ, ngoại trừ typeof Object(1n) === 'object' // true
8 (không thay đổi bên phải), vì mọi giá trị lớn được ký kết.
Ngoài ra, không được hỗ trợ là nhà điều hành Unary ( typeof Object(1n) === 'object' // true
9), để không phá vỡ Asm.js.const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
Nhà điều hành + * - % **
0 cũng hoạt động như mong đợi với toàn bộ số - nhưng các hoạt động có kết quả phân số sẽ bị cắt ngắn khi được sử dụng với giá trị lớn - chúng sẽ không trả về bất kỳ chữ số phân số nào.const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
So sánhMột giá trị lớn không hoàn toàn bằng với giá trị số, nhưng nó là một cách lỏng lẻo như vậy: 0n === 0
// false
0n == 0
// true
Giá trị số và giá trị lớn có thể được so sánh như bình thường: 1n < 2
// true
2n > 1
// true
2 > 2
// false
2n > 2
// false
2n >= 2
// true
Các giá trị lớn và giá trị số có thể được trộn trong các mảng và được sắp xếp:
const mixed = [4n, 6, -12n, 10, 4, 0, 0n]
// [4n, 6, -12n, 10, 4, 0, 0n]
mixed.sort() // default sorting behavior
// [ -12n, 0, 0n, 10, 4n, 4, 6 ]
mixed.sort((a, b) => a - b)
// won't work since subtraction will not work with mixed types
// TypeError: can't convert BigInt value to Number value
// sort with an appropriate numeric comparator
mixed.sort((a, b) => (a < b) ? -1 : ((a > b) ? 1 : 0))
// [ -12n, 0, 0n, 4n, 4, 6, 10 ]
Lưu ý rằng so sánh với ____ các giá trị lớn ____ 27 hoạt động như với các đối tượng khác, chỉ biểu thị sự bình đẳng khi so sánh cùng một thể hiện đối tượng: Object(0n) === 0n // false
Object(0n) === Object(0n) // false
const o = Object(0n)
o === o // true
Điều kiệnGiá trị Bigint tuân theo các quy tắc chuyển đổi giống như số khi: - Nó được chuyển đổi thành
+ * - % **
2: thông qua hàm + * - % **
2; - khi được sử dụng với các toán tử logic
+ * - % **
4, + * - % **
5 và + * - % **
6; hoặc - Trong một thử nghiệm có điều kiện như một tuyên bố
+ * - % **
7.
Cụ thể, chỉ + * - % **
8 là giả; Mọi thứ khác là sự thật.typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
0
Cưỡng chế lớnNhiều hoạt động tích hợp mong đợi Bigint đầu tiên ép buộc lập luận của họ với Bigint. Hoạt động có thể được tóm tắt như sau:
- Bigint được trả lại như-is.
+ * - % **
9 và const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
0 ném const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
1.const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
2 biến thành const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
3; const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
4 biến thành + * - % **
8.- Chuỗi được chuyển đổi bằng cách phân tích cú pháp chúng như thể chúng chứa một số nguyên theo nghĩa đen. Bất kỳ lỗi phân tích cú pháp dẫn đến
const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
6. Cú pháp là một tập hợp con của các chữ số chuỗi, trong đó các điểm thập phân hoặc các chỉ báo số mũ không được phép. - Các con số ném
const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
1 để ngăn chặn sự ép buộc ngầm ngoài dự đoán gây mất độ chính xác. - Biểu tượng ném
const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
1. - Các đối tượng trước tiên được chuyển đổi thành nguyên thủy bằng cách gọi
const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
9 của chúng (với const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
0 là gợi ý), const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
1 và const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
2, theo thứ tự đó. Kết quả nguyên thủy sau đó được chuyển đổi thành một Bigint. Cách tốt nhất để đạt được hiệu ứng gần như tương tự trong JavaScript là thông qua hàm typeof Object(1n) === 'object' // true
1: const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
4 sử dụng cùng một thuật toán để chuyển đổi const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
5, ngoại trừ các số không ném const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
1, nhưng được chuyển đổi thành BigS nếu chúng là số nguyên.Lưu ý rằng các hoạt động tích hợp mong đợi Bigint thường cắt giảm độ rộng cố định sau khi ép buộc. Điều này bao gồm const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
7, const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
8 và các phương pháp của const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
9 và 0n === 0
// false
0n == 0
// true
0.Người xây dựngtypeof Object(1n) === 'object' // true
1Tạo ra một giá trị lớn mới. Phương pháp tĩnhconst expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
7Kẹp một giá trị lớn thành giá trị số nguyên đã ký và trả về giá trị đó. const expected = 4n / 2n
// 2n
const truncated = 5n / 2n
// 2n, not 2.5n
8Kẹp một giá trị lớn vào một giá trị số nguyên không dấu và trả về giá trị đó.
Phương pháp thể hiện0n === 0
// false
0n == 0
// true
4Trả về một chuỗi với một biểu diễn nhạy cảm với ngôn ngữ của giá trị lớn này. Ghi đè phương thức 0n === 0
// false
0n == 0
// true
5.0n === 0
// false
0n == 0
// true
6Trả về một chuỗi đại diện cho giá trị lớn này trong radix được chỉ định (cơ sở). Ghi đè phương thức 0n === 0
// false
0n == 0
// true
7.0n === 0
// false
0n == 0
// true
8Trả về giá trị lớn này. Ghi đè phương thức 0n === 0
// false
0n == 0
// true
9.Cưỡng chếBởi vì việc ép buộc giữa các giá trị số và các giá trị Bigint có thể dẫn đến mất độ chính xác, nên những điều sau đây được khuyến nghị: - Chỉ sử dụng giá trị lớn khi các giá trị lớn hơn 2^53 được mong đợi một cách hợp lý.
- Đừng ép buộc giữa các giá trị lớn và giá trị số.
Mật mãCác hoạt động được hỗ trợ trên các giá trị lớn không phải là thời gian không đổi và do đó mở ra các cuộc tấn công thời gian. Do đó, JavaScript Bigint có thể nguy hiểm khi sử dụng trong mật mã mà không giảm thiểu các yếu tố. Như một ví dụ rất chung chung, kẻ tấn công có thể đo lường chênh lệch thời gian giữa 1n < 2
// true
2n > 1
// true
2 > 2
// false
2n > 2
// false
2n >= 2
// true
0 và 1n < 2
// true
2n > 1
// true
2 > 2
// false
2n > 2
// false
2n >= 2
// true
1, và suy ra mức độ bí mật, chẳng hạn như khóa riêng, dựa trên thời gian trôi qua. Nếu bạn vẫn phải sử dụng Bigint, hãy xem Câu hỏi thường gặp về thời gian tấn công để được tư vấn chung về vấn đề này.Sử dụng trong JSONSử dụng 1n < 2
// true
2n > 1
// true
2 > 2
// false
2n > 2
// false
2n >= 2
// true
2 với bất kỳ giá trị lớn nào sẽ tăng const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// 9007199254740992n
const theFuture = previousMaxSafe + 2n
// 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// 18014398509481982n
const subtr = multi - 10n
// 18014398509481972n
const mod = multi % 10n
// 2n
const bigN = 2n ** 54n
// 18014398509481984n
bigN * -1n
// -18014398509481984n
1, vì các giá trị lớn không được tuần tự hóa trong JSON theo mặc định. Tuy nhiên, 1n < 2
// true
2n > 1
// true
2 > 2
// false
2n > 2
// false
2n >= 2
// true
2 cụ thể để lại một cửa hậu cho các giá trị lớn: nó sẽ cố gắng gọi phương thức 1n < 2
// true
2n > 1
// true
2 > 2
// false
2n > 2
// false
2n >= 2
// true
5 của Bigint. .typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
1Thay vì ném, 1n < 2
// true
2n > 1
// true
2 > 2
// false
2n > 2
// false
2n >= 2
// true
2 hiện tạo ra một chuỗi như thế này:typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
2Nếu bạn không muốn vá 1n < 2
// true
2n > 1
// true
2 > 2
// false
2n > 2
// false
2n >= 2
// true
8, bạn có thể sử dụng tham số 1n < 2
// true
2n > 1
// true
2 > 2
// false
2n > 2
// false
2n >= 2
// true
9 của const mixed = [4n, 6, -12n, 10, 4, 0, 0n]
// [4n, 6, -12n, 10, 4, 0, 0n]
mixed.sort() // default sorting behavior
// [ -12n, 0, 0n, 10, 4n, 4, 6 ]
mixed.sort((a, b) => a - b)
// won't work since subtraction will not work with mixed types
// TypeError: can't convert BigInt value to Number value
// sort with an appropriate numeric comparator
mixed.sort((a, b) => (a < b) ? -1 : ((a > b) ? 1 : 0))
// [ -12n, 0, 0n, 4n, 4, 6, 10 ]
0 để tuần tự hóa các giá trị lớn:typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
3Nếu bạn có dữ liệu JSON chứa các giá trị mà bạn biết sẽ là số nguyên lớn, bạn có thể sử dụng tham số const mixed = [4n, 6, -12n, 10, 4, 0, 0n]
// [4n, 6, -12n, 10, 4, 0, 0n]
mixed.sort() // default sorting behavior
// [ -12n, 0, 0n, 10, 4n, 4, 6 ]
mixed.sort((a, b) => a - b)
// won't work since subtraction will not work with mixed types
// TypeError: can't convert BigInt value to Number value
// sort with an appropriate numeric comparator
mixed.sort((a, b) => (a < b) ? -1 : ((a > b) ? 1 : 0))
// [ -12n, 0, 0n, 4n, 4, 6, 10 ]
1 của const mixed = [4n, 6, -12n, 10, 4, 0, 0n]
// [4n, 6, -12n, 10, 4, 0, 0n]
mixed.sort() // default sorting behavior
// [ -12n, 0, 0n, 10, 4n, 4, 6 ]
mixed.sort((a, b) => a - b)
// won't work since subtraction will not work with mixed types
// TypeError: can't convert BigInt value to Number value
// sort with an appropriate numeric comparator
mixed.sort((a, b) => (a < b) ? -1 : ((a > b) ? 1 : 0))
// [ -12n, 0, 0n, 4n, 4, 6, 10 ]
2 để xử lý chúng:typeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
4Tính toán số nguyên tốtypeof 1n === 'bigint' // true
typeof BigInt('1') === 'bigint' // true
5Thông số kỹ thuật
| Sự chỉ rõ |
|---|
Đặc tả ngôn ngữ Ecmascript # Sec-Bigint-Enjects
# sec-bigint-objects
|
Tính tương thích của trình duyệt webBảng BCD chỉ tải trong trình duyệt
Tại sao Bigint được sử dụng trong JavaScript?
Bigint là một đối tượng trình bao bọc nguyên thủy được sử dụng để đại diện và điều khiển các giá trị lớn nguyên thủy - quá lớn để được biểu diễn bằng số nguyên thủy.to represent and manipulate primitive bigint values — which are too large to be represented by the number primitive.
JavaScript có thể xử lý Bigint không?
Bigint là một đối tượng tích hợp trong JavaScript cung cấp một cách để biểu diễn toàn bộ số lớn hơn 253-1.Số lớn nhất mà JavaScript có thể thể hiện một cách đáng tin cậy với số nguyên thủy là 253-1, được biểu thị bằng hằng số MAX_SAFE_Integer. that provides a way to represent whole numbers larger than 253-1. The largest number that JavaScript can reliably represent with the Number primitive is 253-1, which is represented by the MAX_SAFE_INTEGER constant.
Kiểu dữ liệu Bigint là gì?
Kiểu dữ liệu Bigint lưu trữ các số nguyên từ -(2 63 -1) đến 2 63 -1, đó là từ9,223,372,036,854,775,807 đến 9.223.372.036.854.775.807, trong tám bytes.Kiểu dữ liệu này có lợi thế lưu trữ so với INT8 và lợi thế cho một số hoạt động số học và so sánh sắp xếp so với các loại dữ liệu int8 và thập phân.stores integers from -(2 63 -1) to 2 63 -1, which is –9,223,372,036,854,775,807 to 9,223,372,036,854,775,807, in eight bytes. This data type has storage advantages over INT8 and advantages for some arithmetic operations and sort comparisons over INT8 and DECIMAL data types.
Bigint trong JavaScript W3Schools là gì?
Các biến Bigint của JavaScript được sử dụng để lưu trữ các giá trị số nguyên lớn quá lớn để được biểu diễn bằng một số JavaScript bình thường.Số nguyên JavaScript chỉ chính xác lên đến 15 chữ số.used to store big integer values that are too big to be represented by a a normal JavaScript Number . JavaScript integers are only accurate up to 15 digits. | 
