阮一峰 - ES6 数值的扩展 Number 对象、Math对象、BigInt类型和对象

最新推荐文章于 2023-06-29 19:51:04 发布

唯一的wataru

最新推荐文章于 2023-06-29 19:51:04 发布

阅读量374

点赞数

分类专栏： ES6

本文链接：https://blog.csdn.net/qq_44869043/article/details/113526049

版权

ES6 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

整理自【阮一峰】数值的扩展:https://es6.ruanyifeng.com/#docs/number

1.二进制和八进制表示法

从 ES5 开始，严格模式下，八进制不能使用数字0 作前缀来表示。

ES6 明确，八进制要使用数字0和字母o(大小写都可)，即0o（0O）表示。

二进制要使用前缀 0b(或0B) 表示。

ES6中，要将 0b和0o前缀的字符串数值，转换为十进制，要使用 Number 方法。

Number(0B111) // 7
Number(0o10) // 8

2. Number.isFinite()和Number.isNaN()

Number.isFinite()：检查一个数值是否为有限的（finite），即不是Infinity。
```
Number.isFinite(15) // true
Number.isFinit(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
- 与传统 isFinite()的区别：
  - Number.isFinite() 只对数值有效，非数值一律返回 false
  - isFinite()：先用 Number() 将非数值转换为数值，再判断。

Number.isNaN()：检查一个值是否为 NaN

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

如果参数不是 NaN , Number.isNaN 一律返回 false

与传统 isNaN()的区别：

Number.isNaN() 只对数值有效，非数值一律返回 false
isNaN()：先用 Number() 将非数值转换为数值，再判断。

// isFinite
isFinite(15) // true
Number.isFinite(15) // true

isFinite('15') // true
Number.isFinite('15') // false

// isNaN()
isNaN(NaN) // true
Number.isNaN(NaN) // true

isNaN('NaN') // true
Number.isNaN('NaN') // false
Number.isNaN(1) // false ，不是 NaN

3. parseInt、parseFloat

Number.parseInt() === parseInt()
Number.parseFloat() === parseFloat()
ES6 将 parseInt 和 parseFloat 移植到 Number 对象上，行为完全保持不变。
- 原因：逐步减少全局性方法，使得语言逐步模块化。

4. Number.isInteger()

Number.isInteger() : 判断一个数值是否为 整数。
由于 JavaScript 的 IEEE 754 标准，数值存储为 64位双精度格式，Number.isInteger() 存在误判的可能。
- (1) 64位双精度格式：数值精度最多可达到 53 个二进制位（一个隐藏位和52个有效位）。如果数值的精度超过这个限度，第 54 位及后面的位就会被丢弃，从而导致数值不准的问题。
- ```
Number.isInteger(3.0000000000000002) // true
```
  - 原因：这个数值的小数精度达到了，小数点后16个十进制位，转成二进制位超过了 53 个二进制位，导致最后的那个 2 被丢弃了。
- (2) 如果一个数值的绝对值小于 JavaScript 能分辨的最小值（Number.MIN_VALUE(5E-324)），会被自动转为 0 ，这时 Number.isInteger() 会误判。
- ```
Number.isInteger(5E-324)  // false,不是整数
Number.isInteger(5E-325)  // true, 误判成整数
```
  - 原因： 5E-325 由于值太小，会被自动转为 0 ，因此返回 true。
如果对数据精度要求高，不建议 使用 Number.isInteger() 判断一个值是否为整数。

5.Number.EPSILON

Number.EPSILON ：一个极小的常量，表示 1 与大于 1 的最小浮点数之间的差。 ES6 在 Number 对象上新增的常量。
- 实质：在 JavaScript 中，是一个可以接受的最小误差范围。
对 64 位浮点数来说，大于 1 的最小浮点数相当于二进制的1.0000000000000000000000000000000000000000000000000001，小数点后有连续 51 个零。这个值减去 1 后，就等于 2 的 -52次方。

Number.EPSILON
// 2.220446049250313e-16
Math.pow(2,-52)
// 2.220446049250313e-16

Number.EPSILON === Math.pow(2,-52)
// true
Number.EPSILON.toFixed(30)
// "0.000000000000000222044604925031"

用途：可以用来设置 “能够接受的误差范围” 。比如将误差范围设置在 2 的 -50 次方【 Number.EPSILON * Math.pow(2,2）】，如果两个浮点数的差小于这个值，可认为此二者相等。

0.1 + 0.2 
// 5.551115123125783e-17

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


// 误差检查函数
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.4000000000000004
withinErrorMargin(1.1+1.3, 2.4) // true

6.安全整数和 Number.isSafeInteger()

JavaScript 能准确表示的整数范围在 2 $^{53 }$ -到 2 $^{-53}$ 之间（不含两个端点），超出范围无法精确表示这个值。
Number.MAX_SAFE_INTEGER：JavaScript 能准确表示的范围的 最大值。
Number.MIN_SAFE_INTEGER： JavaScript 能准确表示的范围的 最小值。

Number.isSafeInteger()：用来判断一个整数是否在 JavaScript 能准确表示的这个范围内。

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(9007199254740990) // true
Number.isSafeInteger(9007199254740992) // false,这个值是 2的53次方，端点值
Number.isSafeInteger(1.2) // false ,不是整数

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

// 最大安全整数 和 最小安全整数
Number.MAX_SAFE_INTEGER === Math.pow(2,53) - 1 // true
Number.MAX_SAFE_INTEGER === 9007199254740991 // true
Number.MIN_SAFE_INTEGER === -9007199254740991 // true

Number.MAX_SAFE_INTEGER === -Number.MIN_SAFE_INTEGER // true

Number.isSafeInteger()的实现：

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

Number.isSafeInteger() 注意事项：

使用 Number.isSafeInteger()时，需要验证：
- 1. 运算出的结果
  2. 参与运算的每个值。

Number.isSafeInteger(9007199254740993) // false,超出范围值
Number.isSafeInteger(990) // true

Number.isSafeInteger(9007199254740993 - 990) // true

9007199254740993 - 990 // 得出的值：900754740002，实际值应为900754740003

9007199254740993 超出精度范围，导致计算机内部以 9007199254740992存储，从而出现计算结果错误。
可使用下面的函数验证运算数和运算结果

// 简单判断函数 - 传 3 个参数进行判断
function simpleTrusty(left,right,result) {
 if (
    Number.isSafeInteger(left) &&
    Number.isSafeInteger(right) &&
    Number.isSafeInteger(result)
  ) {
    return result;
  }
  throw new RangeError('Operation cannot be trusted!');
}

// 较复杂判断函数 - 可传多个参数进行判断
function trusty() {
	let args = Array.prototype.slice.call(arguments)
    let result = args[args.length - 1]
    let isTrue = true;
    for (let ii = 0; ii < args.length-1 ;ii++) {
        let item = args [ii];
        if(!Number.isSafeInteger(item)) {
            isTrue = false
            break
        }
    }
    if(isTrue) {
        return result
    } else {
        throw new RangeError('Operation cannot be trusted!')
    }
}

trusty(9007199254740991, 990, 9007199254740991 - 990)
// 9007199254740001

trusty(9007199254740992, 990, 9007199254740992 - 990)
// RangeError: Operation cannot be trusted!
 
trusty(9007199254740991, 990, 1, 9007199254740991 - 990 - 1)
// 9007199254740000

7. Math 对象的扩展

Math 新增的 17 个静态方法，只能在 Math 上使用：
- 1.Math.trunc() ：用于去除一个数的小数部分，返回整数部分。参数为非数值时，内部先用Number方法转为数值，再去除小数，返回整数部分；无法转换为数值的，返回 NaN。
- 2.Math.sign()：用于判断一个数是正数、负数，还是零。非数值先转成数值，无法转成数值的返回 NaN
  - 参数为正数： +1；
  - 参数为负数： -1；
  - 参数为 0 ： 0；
  - 参数为 -0： -0；
  - 其他值，返回 NaN。
- 3.Math.cbrt()：用于计算一个数的立方根。参数为非数值时，内部先用Number方法转为数值，无法转换为数值的，返回 NaN。
- 4.Math.clz32()：计算一个数的 32 位二进制形式的前导 0 的个数。将参数转为 32 位无符号整数的形式，返回这个 32 位值里面有多少个前导 0。
  - clz32 : “count leading zero bits in 32-bite binary representation of a number”.(计算一个数的 32 位二进制形式的前导 0 的个数)
    - 0 的二进制形式全为 0，所以有 32 个前导 0；
    - 1 的二进制形式是0b1，只占 1 位，所以 32 位之中有 31 个前导 0；
    - 1000 的二进制形式是0b1111101000，一共有 10 位，所以 32 位之中有 22 个前导 0。
  - 对于小数，Math.clz32方法只考虑整数部分。对于空值或其他类型的值，Math.clz32方法会将它们先转为数值，然后再计算。
```
Math.clz32(3.2) // 30
Math.clz32(3.9) // 30
```
- 5.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
```
- 6.Math.fround()：返回一个数的32位单精度浮点数形式。对于 NaN 和 Infinity，此方法返回原值。对于其它类型的非数值，Math.fround 方法会先将其转为数值，再返回单精度浮点数。
  - 主要作用：将64位双精度浮点数转为32位单精度浮点数。如果小数的精度超过24个二进制位，返回值就会不同于原值，否则返回值不变（即与64位双精度值一致）。
  - 对于32位单精度格式来说，数值精度是24个二进制位（1 位隐藏位与 23 位有效位），所以对于 -2^24 至 2^24 之间的整数（不含两个端点），返回结果与参数本身一致。
```
Math.fround(0)   // 0
Math.fround(1)   // 1
Math.fround(2 ** 24 - 1)   // 16777215
```
    如果参数的绝对值大于 2 $^{24}$ ，返回的结果便开始丢失精度。
```
Math.fround(2 ** 24)       // 16777216
Math.fround(2 ** 24 + 1)   // 16777216
```
```
// 未丢失有效精度
Math.fround(1.125) // 1.125
Math.fround(7.25)  // 7.25

// 丢失精度
Math.fround(0.3)   // 0.30000001192092896
Math.fround(0.7)   // 0.699999988079071
Math.fround(1.0000000123) // 1
```
```
Math.fround(NaN)      // NaN
Math.fround(Infinity) // Infinity

Math.fround('5')      // 5
Math.fround(true)     // 1
Math.fround(null)     // 0
Math.fround([])       // 0
Math.fround({})       // NaN
```
    对于没有部署这个方法的环境，可以用下面的代码模拟。
```
Math.fround = Math.fround || function (x) {
  return new Float32Array([x])[0];
};
```
- 7.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。
对数方法
- 8.Math.expm1()：Math.expm1(x)返回 ex - 1，即Math.exp(x) - 1。
- 9.Math.log1p()：Math.log1p(x)方法返回1 + x的自然对数，即Math.log(1 + x)。如果x小于-1，返回NaN。
- 10.Math.log10()：Math.log10(x)返回以 10 为底的x的对数。如果x小于 0，则返回 NaN。
- 11.Math.log2()：Math.log2(x)返回以 2 为底的x的对数。如果x小于 0，则返回 NaN。
双曲函数方法
- 12.Math.sinh(x)：返回x的双曲正弦（hyperbolic sine）
- 13.Math.cosh(x)：返回x的双曲余弦（hyperbolic cosine）
- 14.Math.tanh(x)：返回x的双曲正切（hyperbolic tangent）
- 15.Math.asinh(x)：返回x的反双曲正弦（inverse hyperbolic sine）
- 16.Math.acosh(x)：返回x的反双曲余弦（inverse hyperbolic cosine）
- 17.Math.atanh(x)：返回x的反双曲正切（inverse hyperbolic tangent）

8.指数运算符

ES2016 新增了一个指数运算符（**）。多个指数运算符连用时，是从最右边开始计算的。

2 ** 2 // 4
2 ** 3 // 8

这个运算符的一个特点是右结合，而不是常见的左结合。多个指数运算符连用时，是从最右边开始计算的。

// 相当于 2 ** (3 ** 2)
2 ** 3 ** 2
// 512

上面代码中，首先计算的是第二个指数运算符，而不是第一个。

指数运算符可以与等号结合，形成一个新的赋值运算符（**=）。

let a = 1.5;
a **= 2;
// 等同于 a = a * a;

let b = 4;
b **= 3;
// 等同于 b = b * b * b;

9. BigInt 数据类型

简介

JavaScript 所有数字都保存成 64 位浮点数，这给数值的表示带来了两大限制。

一是数值的精度只能到 53 个二进制位（相当于 16 个十进制位），大于这个范围的整数，JavaScript 是无法精确表示的，这使得 JavaScript 不适合进行科学和金融方面的精确计算。

二是大于或等于2的1024次方的数值，JavaScript 无法表示，会返回Infinity。

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

JavaScript数据类型

字符串（String）、

数字(Number)、

布尔(Boolean)、

数组(Array)、

对象(Object)、

空（Null）、

未定义（Undefined）、

大整数 (BigInt)。

BigInt 和 Number 的区别

BigInt 类型的数据，必须添加后缀 n，Number 不需要加后缀。

BigInt 能计算超出 JavaScript 精度范围的数据，Number 不能。如计算 70的阶乘（70!）

let p = 1;
for (let i = 1; i <= 70; i++) {
  p *= i;
}
console.log(p); // 1.197857166996989e+100

let p = 1n;
for (let i = 1n; i <= 70n; i++) {
  p *= i;
}
console.log(p); 
// 11978571669969891796072783721689098736458938142546425857555362864628009582789845319680000000000000000n

BigInt 类型数据，只能使用 负号(-)，不能使用正号 (+)(因为会与 asm.js冲突)。Number 类型可以使用 负号 和 正号。
BigInt 类型的数据，在运算方面与 Number 几乎一致。只有两处不同，BigInt不能使用以下两种运算符：
- 不带符号的右移位运算符>>>，（BigInt 类型总是带符号，所以 >>> 运算无意义）
- 一元的求正运算符+，（与asm.js冲突，为了不破坏 asm.js规定 +1n会报错）
BigInt 使用除法，会舍去小数部分，返回一个整数。Number 不会舍去小数部分，返回计算结果。

BigInt 类型的特点

BigInt 类型数据不等于 Number 类型数据。故，BigInt 和 Number 不能混合运算。

1n === 1
// 报错 ，1n 和 1 的数据类型不同，二者不相等

1n + 1.3 // 报错

BigInt 能表示各进制的值，都要加上后缀 n 。

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

typeof运算符对于 BigInt 类型的数据返回 bigint。
BigInt 类型只表示 整数，不表示 小数，用 BigInt 表示小数会报错。
BigInt 能准确表示超出 JavaScript 精度范围的值。

BigInt 对象

JavaScript 原生提供BigInt对象，可以用作构造函数生成 BigInt 类型的数值。转换规则基本与Number()一致，将其他类型的值转为 BigInt。

BigInt(123) // 123n
BigInt('123') // 123n
BigInt(false) // 0n
BigInt(true) // 1n

BigInt()构造函数必须有参数，而且参数必须可以正常转为数值，下面的用法都会报错。

new BigInt() // TypeError
BigInt(undefined) //TypeError
BigInt(null) // TypeError
BigInt('123n') // SyntaxError
BigInt('abc') // SyntaxError

上面代码中，尤其值得注意字符串123n无法解析成 Number 类型，所以会报错。

参数如果是小数，也会报错。

BigInt(1.5) // RangeError
BigInt('1.5') // SyntaxError

BigInt 对象继承了 Object 对象的两个实例方法。

BigInt.prototype.toString()
BigInt.prototype.valueOf()

它还继承了 Number 对象的一个实例方法。

BigInt.prototype.toLocaleString()

此外，还提供了三个静态方法。

BigInt.asUintN(width, BigInt)：给定的 BigInt 转为 0 到 2 $^{width }$ - 1 之间对应的值。
BigInt.asIntN(width, BigInt)：给定的 BigInt 转为 -2width - 1 到 2 $^{width }$ - 1 - 1 之间对应的值。
BigInt.parseInt(string[, radix])：近似于Number.parseInt()，将一个字符串转换成指定进制的 BigInt。

const max = 2n ** (64n - 1n) - 1n;

BigInt.asIntN(64, max)
// 9223372036854775807n
BigInt.asIntN(64, max + 1n)
// -9223372036854775808n
BigInt.asUintN(64, max + 1n)
// 9223372036854775808n

上面代码中，max是64位带符号的 BigInt 所能表示的最大值。如果对这个值加1n，BigInt.asIntN()将会返回一个负值，因为这时新增的一位将被解释为符号位。而BigInt.asUintN()方法由于不存在符号位，所以可以正确返回结果。

如果BigInt.asIntN()和BigInt.asUintN()指定的位数，小于数值本身的位数，那么头部的位将被舍弃。

const max = 2n ** (64n - 1n) - 1n;

BigInt.asIntN(32, max) // -1n
BigInt.asUintN(32, max) // 4294967295n

上面代码中，max是一个64位的 BigInt，如果转为32位，前面的32位都会被舍弃。

下面是BigInt.parseInt()的例子。

// Number.parseInt() 与 BigInt.parseInt() 的对比
Number.parseInt('9007199254740993', 10)
// 9007199254740992
BigInt.parseInt('9007199254740993', 10)
// 9007199254740993n

上面代码中，由于有效数字超出了最大限度，Number.parseInt方法返回的结果是不精确的，而BigInt.parseInt方法正确返回了对应的 BigInt。

对于二进制数组，BigInt 新增了两个类型BigUint64Array和BigInt64Array，这两种数据类型返回的都是64位 BigInt。DataView对象的实例方法DataView.prototype.getBigInt64()和DataView.prototype.getBigUint64()，返回的也是 BigInt。

转换规则

可以使用Boolean()、Number()和String()这三个方法，将 BigInt 可以转为布尔值、数值和字符串类型。

Boolean(0n) // false
Boolean(1n) // true
Number(1n)  // 1
String(1n)  // "1"

上面代码中，注意最后一个例子，转为字符串时后缀n会消失。

另外，取反运算符（!）也可以将 BigInt 转为布尔值。

!0n // true
!1n // false

数学运算

数学运算方面，BigInt 类型的+、-、*和**这四个二元运算符，与 Number 类型的行为一致。除法运算/会舍去小数部分，返回一个整数。

9n / 5n
// 1n

几乎所有的数值运算符都可以用在 BigInt，但是有两个例外。

不带符号的右移位运算符>>>
一元的求正运算符+

上面两个运算符用在 BigInt 会报错。前者是因为>>>运算符是不带符号的，但是 BigInt 总是带有符号的，导致该运算无意义，完全等同于右移运算符>>。后者是因为一元运算符+在 asm.js 里面总是返回 Number 类型，为了不破坏 asm.js 就规定+1n会报错。

BigInt 不能与普通数值进行混合运算。

1n + 1.3 // 报错

上面代码报错是因为无论返回的是 BigInt 或 Number，都会导致丢失精度信息。比如(2n**53n + 1n) + 0.5这个表达式，如果返回 BigInt 类型，0.5这个小数部分会丢失；如果返回 Number 类型，有效精度只能保持 53 位，导致精度下降。

同样的原因，如果一个标准库函数的参数预期是 Number 类型，但是得到的是一个 BigInt，就会报错。

// 错误的写法
Math.sqrt(4n) // 报错

// 正确的写法
Math.sqrt(Number(4n)) // 2

上面代码中，Math.sqrt的参数预期是 Number 类型，如果是 BigInt 就会报错，必须先用Number方法转一下类型，才能进行计算。

asm.js 里面，|0跟在一个数值的后面会返回一个32位整数。根据不能与 Number 类型混合运算的规则，BigInt 如果与|0进行运算会报错。

1n | 0 // 报错

其他运算

BigInt 对应的布尔值，与 Number 类型一致，即0n会转为false，其他值转为true。

if (0n) {
  console.log('if');
} else {
  console.log('else');
}
// else

上面代码中，0n对应false，所以会进入else子句。

比较运算符（比如>）和相等运算符（==）允许 BigInt 与其他类型的值混合计算，因为这样做不会损失精度。

0n < 1 // true
0n < true // true
0n == 0 // true
0n == false // true
0n === 0 // false

BigInt 与字符串混合运算时，会先转为字符串，再进行运算。

'' + 123n // "123"

JavaScript 数据类型脑图（不包括 BigInt）

图片转载自 w3c school
在这里插入图片描述

唯一的wataru

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
阮一峰 - ES6 数值的扩展 Number 对象、Math对象、BigInt类型和对象

转载自【阮一峰】数值的扩展:https://es6.ruanyifeng.com/#docs/number1.二进制和八进制表示法从 ES5 开始，严格模式下，八进制不能使用数字0 作前缀来表示。 ES6 明确，八进制要使用数字0和字母o(大小写都可)，即0o（0O）表示。二进制要使用前缀 0b(或0B) 表示。 ES6中，要将 0b和0o前缀的字符串数值，转换为十进制，要使用 Number 方法。Number(0B111) // 7Number(0o10) // 82. Nu
复制链接

扫一扫