es6字符串、数值新增方法总结

---

一、es6字符串的新增方法

1. 实例方法：includes(), startsWith(), endsWith()

传统上，JavaScript 只有indexOf方法，可以用来确定一个字符串是否包含在另一个字符串中。ES6 又提供了三种新方法：

• includes()：返回布尔值，表示是否找到了参数字符串，相当于 indexOf。
• startsWith()：返回布尔值，表示参数字符串是否在原字符串的头部。
• endsWith()：返回布尔值，表示参数字符串是否在原字符串的尾部。

let s = 'Hello world!';

s.startsWith('Hello')  // true
s.endsWith('!')  // true
s.includes('o')  // true

这三个方法都支持第二个参数，表示开始搜索的位置：

let s = 'Hello world!';

s.startsWith('world', 6) // true
s.endsWith('Hello', 5) // true
s.includes('Hello', 6) // false

上面代码表示，使用第二个参数n时，endsWith的行为与其他两个方法有所不同。它针对前n个字符，而其他两个方法针对从第n个位置直到字符串结束。

2. 实例方法：repeat()

repeat方法返回一个新字符串，表示将原字符串重复n次：

'x'.repeat(3) 	// "xxx"
'hello'.repeat(2) 	// "hellohello"
'na'.repeat(0) 	// ""

参数如果是小数，会被取整：

'na'.repeat(2.9)  // "nana"

如果repeat的参数是负数或者Infinity，会报错：

'na'.repeat(Infinity)
// RangeError
'na'.repeat(-1)
// RangeError

但是，如果参数是 0 到-1 之间的小数，则等同于 0，这是因为会先进行取整运算。0 到-1 之间的小数，取整以后等于-0，视同为 0：

'na'.repeat(-0.9) 	// ""

参数NaN等同于 0：

'na'.repeat(NaN) 	// ""

如果repeat的参数是字符串，则会先转换成数字：

'na'.repeat('na') 	// ""
'na'.repeat('3') 	// "nanana"

3. 实例方法：padStart()，padEnd()

ES2017 引入了字符串补全长度的功能。如果某个字符串不够指定长度，会在头部或尾部补全。padStart()用于头部补全，padEnd()用于尾部补全。

'x'.padStart(5, 'ab') 	// 'ababx'
'x'.padStart(4, 'ab') 	// 'abax'

'x'.padEnd(5, 'ab') 	// 'xabab'
'x'.padEnd(4, 'ab') 	// 'xaba'

上面代码中，padStart()和padEnd()一共接受两个参数，第一个参数是字符串补全生效的最大长度，第二个参数是用来补全的字符串。

如果原字符串的长度，等于或大于最大长度，则字符串补全不生效，返回原字符串。

'xxx'.padStart(2, 'ab')  // 'xxx'
'xxx'.padEnd(2, 'ab') 	// 'xxx'

如果用来补全的字符串与原字符串，两者的长度之和超过了最大长度，则会截去超出位数的补全字符串。

'abc'.padStart(10, '0123456789')
// '0123456abc'

如果省略第二个参数，默认使用空格补全长度。

'x'.padStart(4) 	// '   x'
'x'.padEnd(4) 	// 'x   '

padStart()的常见用途是为数值补全指定位数，下面代码生成 10 位的数值字符串。

'1'.padStart(10, '0') 	// "0000000001"
'12'.padStart(10, '0') 	// "0000000012"
'123456'.padStart(10, '0') 	// "0000123456"

另一个用途是补全时间格式的字符串的内容。

'12'.padStart(10, 'YYYY-MM-DD') 	// "YYYY-MM-12"
'09-12'.padStart(10, 'YYYY-MM-DD') 	// "YYYY-09-12"

4. 实例方法：trimStart()，trimEnd()

ES2019 对字符串实例新增了trimStart()和trimEnd()这两个方法。它们的行为与trim()一致，trimStart()消除字符串头部的空格，trimEnd()消除尾部的空格。它们返回的都是新字符串，不会修改原始字符串。

const s = '  abc  ';

s.trim() 	// "abc"
s.trimStart() 	// "abc  "
s.trimEnd() 	// "  abc"

上面代码中，trimStart()只消除头部的空格，保留尾部的空格。trimEnd()只消除尾部的空格，保留头部的空格。

除了空格键，这两个方法对字符串的 tab 键、换行符等不可见的空白符号也有效。

浏览器还部署了额外的两个方法，trimLeft()是trimStart()的别名，trimRight()是trimEnd()的别名。

5. 实例方法：replaceAll()

历史上，字符串的实例方法replace()只能替换第一个匹配。

'aabbcc'.replace('b', '_')      // 'aa_bcc'

上面例子中，replace()只将第一个b替换成下划线。

如果要替换所有的匹配，不得不使用正则表达式的g修饰符：

'aabbcc'.replace(/b/g, '_')		// 'aa__cc'

正则表达式毕竟不是那么方便和直观，ES2021 引入了replaceAll()方法，可以一次性替换所有匹配：

'aabbcc'.replaceAll('b', '_')		// 'aa__cc'

它的用法与replace()相同，返回一个新字符串，不会改变原字符串。

String.prototype.replaceAll(searchValue, replacement)

上面代码中，searchValue是搜索模式，可以是一个字符串，也可以是一个全局的正则表达式（必须带有g修饰符）。

如果searchValue是一个不带有g修饰符的正则表达式，replaceAll()会报错，这一点跟replace()不同：

// 不报错
'aabbcc'.replace(/b/, '_')
// aa_bcc

// 报错
'aabbcc'.replaceAll(/b/, '_')
// Uncaught TypeError: String.prototype.replaceAll called with a non-global RegExp argument

上面例子中，/b/不带有g修饰符，会导致replaceAll()报错。

replaceAll()的第二个参数replacement除了为字符串，也可以是一个函数，该函数的返回值将替换掉第一个参数searchValue匹配的文本。

'aabbcc'.replaceAll('b', () => '_')      // 'aa__cc'

上面例子中，replaceAll()的第二个参数是一个函数，该函数的返回值会替换掉所有b的匹配。

6. 实例方法：at()

at()方法接受一个整数作为参数，返回参数指定位置的字符，支持负索引（即倒数的位置）。

const str = 'hello';
str.at(1) // "e"
str.at(-1) // "o"

如果参数位置超出了字符串范围，at()返回undefined。

'hello'.at(5)    // undefined

二、数值的扩展

1. 数值分隔符

欧美语言中，较长的数值允许每三位添加一个分隔符（通常是一个逗号），增加数值的可读性。比如，1000可以写作1,000。

ES2021，允许 JavaScript 的数值使用 下划线（_） 作为分隔符。

let budget = 1_000_000_000_000;
budget === 10 ** 12     // true

这个数值分隔符没有指定间隔的位数，也就是说，可以每三位添加一个分隔符，也可以每一位、每两位、每四位添加一个。

123_00 === 12_300 		// true

12345_00 === 123_4500 	// true
12345_00 === 1_234_500 	// true

小数和科学计数法也可以使用数值分隔符。

// 小数
0.000_001

// 科学计数法
1e10_000

数值分隔符有几个使用注意点：

• 不能放在数值的最前面（leading）或最后面（trailing）；
• 不能两个或两个以上的分隔符连在一起；
• 小数点的前后不能有分隔符；
• 科学计数法里面，表示指数的e或E前后不能有分隔符；

下面的写法都会报错：

// 全部报错

// 不能放在数值的最前面或最后面
_1464301
1464301_

// 不能两个或两个以上的分隔符连在一起
123__456

// 小数点的前后不能有分隔符
3_.141
3._141

// 指数的e或E前后不能有分隔符
1_e12
1e_12

除了十进制，其他进制的数值也可以使用分隔符。

// 二进制
0b1010_0001_1000_0101
// 十六进制
0xA0_B0_C0

可以看到，数值分隔符可以按字节顺序分隔数值，这在操作二进制位时，非常有用。

注意，分隔符不能紧跟着进制的前缀0b、0B、0o、0O、0x、0X。

// 报错
0_b111111000
0b_111111000

数值分隔符只是一种书写便利，对于 JavaScript 内部数值的存储和输出，并没有影响。

let num = 12_345;

num 	// 12345
num.toString() 	// 12345

上面示例中，变量 num 的值为 12_345，但是内部存储和输出的时候，都不会有数值分隔符。

下面三个将字符串转成数值的函数，不支持数值分隔符：

• Number()
• parseInt()
• parseFloat()

Number('123_456') 	// NaN
parseInt('123_456') 	// 123

主要原因是语言的设计者认为，数值分隔符主要是为了编码时书写数值的方便，而不是为了处理外部输入的数据。

2. Number.isFinite(), Number.isNaN()

ES6 在Number对象上，新提供了Number.isFinite()和Number.isNaN()两个方法。

Number.isFinite()用来检查一个数值是否为有限的（finite），即不是Infinity。

Number.isFinite(15); 		   // true
Number.isFinite(0.8); 		   // true
Number.isFinite(NaN); 		   // false
Number.isFinite(Infinity); 	   // false
Number.isFinite(-Infinity);   // false
Number.isFinite('foo'); 	  // false
Number.isFinite('15'); 		 // false
Number.isFinite(true); 		 // false

注意，如果参数类型不是数值，Number.isFinite一律返回false。

Number.isNaN()用来检查一个值是否为 NaN。

Number.isNaN(NaN) 				// true
Number.isNaN(15) 				// false
Number.isNaN('15') 				// false
Number.isNaN(true) 				// false
Number.isNaN(9/NaN) 			// true
Number.isNaN('true' / 0) 		// true
Number.isNaN('true' / 'true') 	// true

如果参数类型不是 NaN，Number.isNaN一律返回false。

它们与传统的全局方法isFinite()和isNaN()的区别在于，传统方法先调用Number()将非数值的值转为数值，再进行判断，而这两个新方法只对数值有效，Number.isFinite()对于非数值一律返回false, Number.isNaN()只有对于NaN才返回true，非NaN 一律返回false。

isFinite(25) 			// true
isFinite("25") 			// true

Number.isFinite(25) 	// true
// 只对数值有效
Number.isFinite("25") 	// false

isNaN(NaN) 				// true
isNaN("NaN") 			// true

Number.isNaN(NaN) 		// true
// 只对数值有效
Number.isNaN("NaN") 	// false

3. Number.parseInt(), Number.parseFloat()

ES6 将全局方法parseInt()和parseFloat()，移植到Number对象上面，行为完全保持不变。

// ES5的写法
parseInt('12.34') // 12
parseFloat('123.45#') // 123.45

// ES6的写法
Number.parseInt('12.34') // 12
Number.parseFloat('123.45#') // 123.45

这样做的目的，是逐步减少全局性方法，使得语言逐步模块化。

Number.parseInt === parseInt // true
Number.parseFloat === parseFloat // true

4. Number.isInteger()

Number.isInteger()用来判断一个数值是否为整数。

Number.isInteger(25) // true
Number.isInteger(25.1) // false

JavaScript 内部，整数和浮点数采用的是同样的储存方法，所以 25 和 25.0 被视为同一个值。

Number.isInteger(25) // true
Number.isInteger(25.0) // true

如果参数不是数值，Number.isInteger返回false。

Number.isInteger() // false
Number.isInteger(null) // false
Number.isInteger('15') // false
Number.isInteger(true) // false

注意，由于 JavaScript 采用 IEEE 754 标准，数值存储为64位双精度格式，数值精度最多可以达到 53 个二进制位（1 个隐藏位与 52 个有效位）。如果数值的精度超过这个限度，第54位及后面的位就会被丢弃，这种情况下，Number.isInteger可能会误判。

Number.isInteger(3.0000000000000002)   // true

总之，如果对数据精度的要求较高，不建议使用Number.isInteger()判断一个数值是否为整数。

5. Number.EPSILON

ES6 在Number对象上面，新增一个极小的常量Number.EPSILON。根据规格，它表示 1 与大于 1 的最小浮点数之间的差。

对于 64 位浮点数来说，大于 1 的最小浮点数相当于二进制的1.00…001，小数点后面有连续 51 个零。这个值减去 1 之后，就等于 2 的 -52 次方。

Number.EPSILON === Math.pow(2, -52)
// true
Number.EPSILON
// 2.220446049250313e-16
Number.EPSILON.toFixed(20)
// "0.00000000000000022204"

Number.EPSILON实际上是 JavaScript 能够表示的最小精度。误差如果小于这个值，就可以认为已经没有意义了，即不存在误差了。

引入一个这么小的量的目的，在于为浮点数计算，设置一个误差范围。我们知道浮点数计算是不精确的。

0.1 + 0.2
// 0.30000000000000004

0.1 + 0.2 - 0.3
// 5.551115123125783e-17

5.551115123125783e-17.toFixed(20)
// '0.00000000000000005551'

上面代码解释了，为什么比较0.1 + 0.2与0.3得到的结果是false。

0.1 + 0.2 === 0.3 	// false

Number.EPSILON可以用来设置“能够接受的误差范围”。比如，误差范围设为 2 的-50 次方（即Number.EPSILON * Math.pow(2, 2)），即如果两个浮点数的差小于这个值，我们就认为这两个浮点数相等。

5.551115123125783e-17 < Number.EPSILON * Math.pow(2, 2)
// true

因此，Number.EPSILON的实质是一个可以接受的最小误差范围。我们可以利用它，为浮点数运算创建一个误差检查函数：

function withinErrorMargin (left, right) {
  return Math.abs(left - right) < Number.EPSILON * Math.pow(2, 2);
}

0.1 + 0.2 === 0.3 // false
withinErrorMargin(0.1 + 0.2, 0.3) // true

1.1 + 1.3 === 2.4 // false
withinErrorMargin(1.1 + 1.3, 2.4) // true

6. 安全整数 和 Number.isSafeInteger

JavaScript 能够准确表示的整数范围在 -2^53 到 2^53 之间（不含两个端点），超过这个范围，无法精确表示这个值。

Math.pow(2, 53) // 9007199254740992

9007199254740992  // 9007199254740992
9007199254740993  // 9007199254740992

Math.pow(2, 53) === Math.pow(2, 53) + 1
// true
9007199254740992 === 9007199254740993
// true

上面代码中，超出 2 的 53 次方之后，哪怕新增一个数都不精确了。

ES6 引入了 Number.MAX_SAFE_INTEGER 和 Number.MIN_SAFE_INTEGER 这两个常量，用来表示这个范围的上下限。

Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1
// true
Number.MAX_SAFE_INTEGER === 9007199254740991
// true

Number.MIN_SAFE_INTEGER === -Number.MAX_SAFE_INTEGER
// true
Number.MIN_SAFE_INTEGER === - Math.pow(2, 53) + 1
// true
Number.MIN_SAFE_INTEGER === -9007199254740991
// true

上面代码中，可以看到 JavaScript 能够精确表示的极限。

Number.isSafeInteger()则是用来判断一个整数是否落在这个范围之内。

Number.isSafeInteger('a') // false
Number.isSafeInteger(null) // false
Number.isSafeInteger(NaN) // false
Number.isSafeInteger(Infinity) // false
Number.isSafeInteger(-Infinity) // false

Number.isSafeInteger(3) // true
Number.isSafeInteger(1.2) // false
Number.isSafeInteger(9007199254740990) // true
Number.isSafeInteger(9007199254740992) // false

Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1) // false
Number.isSafeInteger(Number.MIN_SAFE_INTEGER) // true
Number.isSafeInteger(Number.MAX_SAFE_INTEGER) // true
Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1) // false

这个函数的实现很简单，就是跟安全整数的两个边界值比较一下，实现如下：

Number.isSafeInteger = function (n) {
  return (typeof n === 'number' && Math.round(n) === n && n >= Number.MIN_SAFE_INTEGER && n <= Number.MAX_SAFE_INTEGER);
}

实际使用这个函数时，需要注意。验证运算结果是否落在安全整数的范围内，不要只验证运算结果，而要同时验证参与运算的每个值。

Number.isSafeInteger(9007199254740993)
// false
Number.isSafeInteger(990)
// true
Number.isSafeInteger(9007199254740993 - 990)
// true
9007199254740993 - 990
// 返回结果 9007199254740002
// 但正确答案应该是 9007199254740003

上面代码中，9007199254740993不是一个安全整数，但是Number.isSafeInteger会返回结果，显示计算结果是安全的。这是因为这个数超出了精度范围，导致在计算机内部以9007199254740992的形式储存，而9007199254740992是安全的。

9007199254740993 === 9007199254740992
// true

所以，如果只验证运算结果是否为安全整数，很可能得到错误结果。下面的函数可以同时验证两个运算数和运算结果。

function trusty (left, right, result) {
  if (Number.isSafeInteger(left) && Number.isSafeInteger(right) && Number.isSafeInteger(result)) {
    return result;
  }
  throw new RangeError('Operation cannot be trusted!');
}

trusty(9007199254740993, 990, 9007199254740993 - 990)
// RangeError: Operation cannot be trusted!

trusty(1, 2, 1 + 2)
// 3

7. Math 对象的扩展

ES6 在 Math 对象上新增了 17 个与数学相关的方法。所有这些方法都是静态方法，只能在 Math 对象上调用。

7.1 Math.trunc()

Math.trunc方法用于去除一个数的小数部分，返回整数部分。

Math.trunc(4.1) // 4
Math.trunc(4.9) // 4
Math.trunc(-4.1) // -4
Math.trunc(-4.9) // -4
Math.trunc(-0.1234) // -0

对于非数值，Math.trunc内部使用Number方法将其先转为数值。

Math.trunc('123.456') // 123
Math.trunc(true) //1
Math.trunc(false) // 0
Math.trunc(null) // 0

对于空值和无法截取整数的值，返回NaN。

Math.trunc(NaN);      // NaN
Math.trunc('foo');    // NaN
Math.trunc();         // NaN
Math.trunc(undefined) // NaN

对于没有部署这个方法的环境，可以用下面的代码模拟：

Math.trunc = Math.trunc || function(x) {
  return x < 0 ? Math.ceil(x) : Math.floor(x);
};

7.2 Math.sign()

Math.sign方法用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。

它会返回五种值：

• 参数为正数，返回 +1；
• 参数为负数，返回 -1；
• 参数为 0，返回 0；
• 参数为-0，返回-0;
• 其他值，返回NaN。

Math.sign(-5) // -1
Math.sign(5) // +1
Math.sign(0) // 0
Math.sign(-0) // -0
Math.sign(NaN) // NaN

如果参数是非数值，会自动转为数值。对于那些无法转为数值的值，会返回NaN。

Math.sign('')  // 0
Math.sign(true)  // +1
Math.sign(false)  // 0
Math.sign(null)  // 0
Math.sign('9')  // +1
Math.sign('foo')  // NaN
Math.sign()  // NaN
Math.sign(undefined)  // NaN

对于没有部署这个方法的环境，可以用下面的代码模拟：

Math.sign = Math.sign || function(x) {
  x = +x; // convert to a number
  if (x === 0 || isNaN(x)) {
    return x;
  }
  return x > 0 ? 1 : -1;
};

7.3 Math.cbrt()

Math.cbrt()方法用于计算一个数的立方根。

Math.cbrt(-1) // -1
Math.cbrt(0)  // 0
Math.cbrt(1)  // 1
Math.cbrt(2)  // 1.2599210498948732

对于非数值，Math.cbrt()方法内部也是先使用Number()方法将其转为数值。

Math.cbrt('8') // 2
Math.cbrt('hello') // NaN

对于没有部署这个方法的环境，可以用下面的代码模拟。

Math.cbrt = Math.cbrt || function(x) {
  var y = Math.pow(Math.abs(x), 1/3);
  return x < 0 ? -y : y;
};

7.4 Math.imul()

Math.imul方法返回两个数以 32 位带符号整数形式相乘的结果，返回的也是一个 32 位的带符号整数。

Math.imul(2, 4)   // 8
Math.imul(-1, 8)  // -8
Math.imul(-2, -2) // 4

如果只考虑最后 32 位，大多数情况下，Math.imul(a, b)与a * b的结果是相同的，即该方法等同于(a * b) | 0的效果（超过 32 位的部分溢出）。之所以需要部署这个方法，是因为 JavaScript 有精度限制，超过 2 的 53 次方的值无法精确表示。这就是说，对于那些很大的数的乘法，低位数值往往都是不精确的，Math.imul方法可以返回正确的低位数值。

(0x7fffffff * 0x7fffffff)|0 // 0

上面这个乘法算式，返回结果为 0。但是由于这两个二进制数的最低位都是 1，所以这个结果肯定是不正确的，因为根据二进制乘法，计算结果的二进制最低位应该也是 1。这个错误就是因为它们的乘积超过了 2 的 53 次方，JavaScript 无法保存额外的精度，就把低位的值都变成了 0。Math.imul方法可以返回正确的值 1。

Math.imul(0x7fffffff, 0x7fffffff) // 1

7.5 Math.fround()

Math.fround方法返回一个数的32位单精度浮点数形式。

对于32位单精度格式来说，数值精度是24个二进制位（1 位隐藏位与 23 位有效位），所以对于 -224 至 224 之间的整数（不含两个端点），返回结果与参数本身一致。

Math.fround(0)   // 0
Math.fround(1)   // 1
Math.fround(2 ** 24 - 1)   // 16777215

如果参数的绝对值大于 224，返回的结果便开始丢失精度。

Math.fround(2 ** 24)       // 16777216
Math.fround(2 ** 24 + 1)   // 16777216

对于没有部署这个方法的环境，可以用下面的代码模拟。

Math.fround = Math.fround || function (x) {
  return new Float32Array([x])[0];
};

7.6 Math.f16round()

ES2025 新增了 Math.f16round() 方法，返回最接近输入值的16位半精度浮点数。

Math.f16round(5) // 5
Math.f16round(5.05) // 5.05078125

16位浮点数共使用16个二进制位，其中指数使用5位，符号位使用1位，精度使用10位，因此可以表示 ±65,504 范围内的值，精度可以到达 1/1024。如果一个数超出了值的范围，则该方法返回 infinity。

Math.f16round(100000) // Infinity

7.7 Math.f16round()

Math.hypot方法返回所有参数的平方和的平方根。

Math.hypot(3, 4);        // 5
Math.hypot(3, 4, 5);     // 7.0710678118654755
Math.hypot();            // 0
Math.hypot(NaN);         // NaN
Math.hypot(3, 4, 'foo'); // NaN
Math.hypot(3, 4, '5');   // 7.0710678118654755
Math.hypot(-3);          // 3

上面代码中，3 的平方加上 4 的平方，等于 5 的平方。

如果参数不是数值，Math.hypot方法会将其转为数值。只要有一个参数无法转为数值，就会返回 NaN。

7.8 对数方法

ES6 新增了 4 个对数相关方法：

• Math.expm1(x)：返回 ex - 1，即Math.exp(x) - 1；

Math.expm1 = Math.expm1 || function(x) {
  return Math.exp(x) - 1;
};

• Math.log1p(x)：返回1 + x的自然对数，即Math.log(1 + x)。如果 x 小于-1，返回NaN。

Math.log1p = Math.log1p || function(x) {
  return Math.log(1 + x);
};

• Math.log10(x)：返回以 10 为底的 x 的对数。如果 x 小于 0，则返回 NaN。

Math.log10 = Math.log10 || function(x) {
  return Math.log(x) / Math.LN10;
};

• Math.log2(x)：返回以 2 为底的x的对数。如果 x 小于 0，则返回 NaN。

Math.log2 = Math.log2 || function(x) {
  return Math.log(x) / Math.LN2;
};

7.9 双曲函数方法

ES6 新增了 6 个双曲函数方法：

• Math.sinh(x)：返回 x 的双曲正弦；
• Math.cosh(x)：返回 x 的双曲余弦；
• Math.tanh(x)：返回 x 的双曲正切；
• Math.asinh(x)：返回 x 的反双曲正弦；
• Math.acosh(x)：返回 x 的反双曲余弦；
• Math.atanh(x)：返回 x 的反双曲正切；

8. BigInt 数据类型

JavaScript 所有数字都保存成 64 位浮点数，这给数值的表示带来了两大限制。一是数值的精度只能到 53 个二进制位（相当于 16 个十进制位），大于这个范围的整数，JavaScript 是无法精确表示，这使得 JavaScript 不适合进行科学和金融方面的精确计算。二是大于或等于2的1024次方的数值，JavaScript 无法表示，会返回Infinity。

// 超过 53 个二进制位的数值，无法保持精度
Math.pow(2, 53) === Math.pow(2, 53) + 1 // true

// 超过 2 的 1024 次方的数值，无法表示
Math.pow(2, 1024) // Infinity

ES2020 引入了一种新的数据类型 BigInt（大整数），来解决这个问题，这是 ECMAScript 的第八种数据类型。BigInt 只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。

const a1 = 2172141653n;
const b1 = 15346349309n;
const a2 = 2172141653;
const b2 = 15346349309;

// BigInt 可以保持精度
a1 * b1 // 33334444555566667777n

// 普通整数无法保持精度
a2 * b2 // 33334444555566670000

为了与 Number 类型区别，BigInt 类型的数据必须添加后缀 n。

1234 	// 普通整数
1234n 	// BigInt

// BigInt 的运算
1n + 2n 	// 3n

BigInt 同样可以使用各种进制表示，都要加上后缀 n。

0b1101n // 二进制
0o777n // 八进制
0xFFn // 十六进制

BigInt 与普通整数是两种值，它们之间并不相等。

42n === 42 // false

typeof运算符对于 BigInt 类型的数据返回bigint。

typeof 123n // 'bigint'

BigInt 可以使用负号（-），但是不能使用正号（+），因为会与 asm.js 冲突。

-42n // 正确
+42n // 报错

---

总结

上述方法在开发中用到的比较少，简单的了解下即可。

详情请查看：阮一峰老师的 ECMAScript 6 入门