1 数值 number
- 1.1 数值储存
- 1.2 数值表示
- - 1.2.1 数值分隔符
- 1.3 特殊数值
- - 1.3.1 正零和负零
  - 1.3.2 NaN
  - 1.3.3 Infinity
- 1.4 数值相关的全局方法
- 1.5 Number 对象
- - 1.5.1 Number()
  - 1.5.2 Number 静态属性
  - 1.5.3 Number 静态方法
  - 1.5.4 Number 实例方法
  - 1.5.5 自定义方法
- 1.6 Math 对象
- - 1.6.1 Math 静态属性
  - 1.6.2 Math 静态方法
- 1.7 BigInt
- - 1.7.1 BigInt()
  - 1.7.2 BigInt 实例方法
  - 1.7.3 BigInt 静态方法

1 数值 number

js 数值
es6 数值

1.1 数值储存

JavaScript 内部，所有数字都是以 64 位浮点数形式储存，即使整数也是如此。所以，1与1.0是相同的，是同一个数。

0.1 + 0.2 === 0.3;
// false

0.3 / 0.1; 
// 2.9999999999999996

(0.3 - 0.2) === 0.2 - 0.1;
// false

你知道 0.1 + 0.2 !== 0.3 是进制问题，但你讲不出个所以然，是吧？
用了一天时间，我终于彻底搞懂了 0.1 + 0.2 是否等于 0.3！

JavaScript 采用 IEEE 745 标准的浮点数运算，会产生舍入误差
浮点数先转换为二进制，再运算

在这里插入图片描述

// 0.1 化为二进制：
0.000 11001100 11001100 11001100 11001100 11001100 11001100 1100 1100 11
// 0.1 保留 52 位有效数字：
0.000 11001100 11001100 11001100 11001100 11001100 11001100 1101 0

// 0.2 化为二进制：
0.00 11001100 11001100 11001100 11001100 11001100 11001100 1100 1100 11
// 0.2 保留 52 位有效数字：
0.00 11001100 11001100 11001100 11001100 11001100 11001100 1101 0

// 0.1+0.2：
0.000 11001100 11001100 11001100 11001100 11001100 11001100 1101 0
0.001 10011001 10011001 10011001 10011001 10011001 10011001 1010
————————————————————————————————————————————————————————————————————
0.010 01100110 01100110 01100110 01100110 01100110 01100110 0111 0
// 保留 52 位尾数
0.010 01100110 01100110 01100110 01100110 01100110 01100110 100 即
0.0 10011001 10011001 10011001 10011001 10011001 10011001 1010 0
// 转十进制
0.30000000000000004

// 解决方法
let value = value * Math.pow(10, props.precision);
let stepValue = stepValue * Math.pow(10, props.precision);

showValue = value + stepValue;

showValue = (showValue / Math.pow(10, props.precision)).toFixed(
  props.precision
);

showValue = Number(showValue);

1.2 数值表示

字面形式
- 十进制：没有前导 0 的数值。
- 八进制：有前缀0o或0O的数值，或者有前导 0、且只用到 0-7 的八个阿拉伯数字的数值。
- 十六进制：有前缀0x或0X的数值。
- 二进制：有前缀0b或0B的数值。
科学计数法表示

123e3; // 123000
123e-3; // 0.123
3.1e12;
0.1e-23;

从 ES5 开始，在严格模式之中，八进制就不再允许使用前缀0表示，ES6 进一步明确，要使用前缀0o表示。

1.2.1 数值分隔符

允许 JavaScript 的数值使用下划线（_）作为分隔符 12345_00 === 1_234_500
数值分隔符只是一种书写便利，对于 JavaScript 内部数值的存储和输出，并没有影响。
不能放在数值的最前面（leading）或最后面（trailing）。
不能两个或两个以上的分隔符连在一起。
小数点的前后不能有分隔符。
科学计数法里面，表示指数的e或E前后不能有分隔符。

下面三个将字符串转成数值的函数，不支持数值分隔符。主要原因是语言的设计者认为，数值分隔符主要是为了编码时书写数值的方便，而不是为了处理外部输入的数据。

Number()
parseInt()
parseFloat()

Number("123_456"); // NaN
parseInt("123_456"); // 123

1.3 特殊数值

1.3.1 正零和负零

几乎所有场合，正零和负零都会被当作正常的0
唯一有区别的场合是，+0或-0当作分母，返回的值是不相等的。
除以正零得到+Infinity，除以负零得到-Infinity。

1.3.2 NaN

NaN是 JavaScript 的特殊值，表示“非数字”（Not a Number），主要出现在将字符串解析成数字出错的场合。
NaN不是独立的数据类型，而是一个特殊数值，它的数据类型依然属于Number
NaN不等于任何值，包括它本身。

NaN === NaN; // false

1.3.3 Infinity

Infinity表示“无穷”，用来表示两种场景。
- 一种是一个正的数值太大，或一个负的数值太小，无法表示；
- 一种是非 0 数值除以 0，得到Infinity。
Infinity表示正的无穷，-Infinity表示负的无穷。

// 场景一
Math.pow(2, 1024);
// Infinity

// 场景二
0 / 0; // NaN
1 / 0; // Infinity

1.4 数值相关的全局方法

parseInt()方法用于将字符串转为整数。
parseFloat()方法用于将一个字符串转为浮点数。
isNaN()方法可以用来判断一个值是否为NaN。只对数值有效，如果传入其他值，会被先转成数值。
isFinite()方法返回一个布尔值，表示某个值是否为正常的数值。

isNaN("Hello"); // true
// 相当于
isNaN(Number("Hello")); // true

1.5 Number 对象

js Number 对象

1.5.1 Number()

Number() 将任意值转为数值: Number本身是一个函数，可以当作工具方法使用，将任何类型的值转为数值。
Number() 构造函数: Number不仅可以当作工具函数使用，还可以当作构造函数使用，即前面可以使用new命令。构造数值对象，用于生成值为数值的对象

1.5.2 Number 静态属性

Number.POSITIVE_INFINITY：正的无限，指向Infinity。
Number.NEGATIVE_INFINITY：负的无限，指向-Infinity。
Number.NaN：表示非数值，指向NaN。
Number.MIN_VALUE：表示最小的正数（即最接近 0 的正数，在 64 位浮点数体系中为5e-324），相应的，最接近 0 的负数为-Number.MIN_VALUE。
Number.MAX_SAFE_INTEGER：表示能够精确表示的最大整数，即9007199254740991。
Number.MIN_SAFE_INTEGER：表示能够精确表示的最小整数，即-9007199254740991。
Number.EPSILON：ES6 在Number对象上面，新增一个极小的常量，表示 1 与大于 1 的最小浮点数之间的差
- 对于 64 位浮点数来说，大于 1 的最小浮点数相当于二进制的1.00..001，小数点后面有连续 51 个零。这个值减去 1 之后，就等于 2 的 -52 次方。
- 引入一个这么小的量的目的，在于为浮点数计算，设置一个误差范围
Number.MAX_SAFE_INTEGER：=== Math.pow(2, 53) - 1
Number.MIN_SAFE_INTEGER：=== -Number.MAX_SAFE_INTEGER
- JavaScript 能够准确表示的整数范围在-2^53到2^53之间（不含两个端点），超过这个范围，无法精确表示这个值
- 这两个常量，用来表示这个范围的上下限

1.5.3 Number 静态方法

Number.isSafeInteger()则是用来判断一个整数是否落在上述范围之内。
Number.isFinite()用来检查一个数值是否为有限的（finite），即不是Infinity。
Number.isNaN()用来检查一个值是否为NaN。
- 它们与传统的全局方法isFinite()和isNaN()的区别在于
  - 传统方法先调用Number()将非数值的值转为数值，再进行判断
  - 而这两个新方法只对数值有效，
  - Number.isFinite()对于非数值一律返回false,
  - Number.isNaN()只有对于NaN才返回true，非NaN一律返回false。
Number.parseInt()方法用于将字符串转为整数。
Number.parseFloat()方法用于将一个字符串转为浮点数。
- ES6 将全局方法parseInt()和parseFloat()，移植到Number对象上面，行为完全保持不变。
- 这样做的目的，是逐步减少全局性方法，使得语言逐步模块化。
Number.isInteger()用来判断一个数值是否为整数。

1.5.4 Number 实例方法

Number.prototype.toString() 用来将一个数值转为字符串形式，(10).toString() // "10"
- 10一定要放在括号里，这样表明后面的点表示调用对象属性。如果不加括号，这个点会被 JavaScript 引擎解释成小数点，从而报错
Number.prototype.toFixed() 方法先将一个数转为指定位数的小数，然后返回这个小数对应的字符串。 (10.005).toFixed(2); // "10.01"
- 由于浮点数的原因，小数5的四舍五入是不确定的，使用的时候必须小心。
Number.prototype.toExponential() 将一个数转为科学计数法形式
Number.prototype.toPrecision()方法用于将一个数转为指定位数的有效数字。
Number.prototype.toLocaleString()方法接受一个地区码作为参数，返回一个字符串，表示当前数字在该地区的当地书写形式。

1.5.5 自定义方法

与其他对象一样，Number.prototype对象上面可以自定义方法，被Number的实例继承。

1.6 Math 对象

js Math 对象

Math是 JavaScript 的原生对象，提供各种数学功能。该对象不是构造函数，不能生成实例，所有的属性和方法都必须在Math对象上调用

1.6.1 Math 静态属性

Math.E：常数e。 // 2.718281828459045
Math.LN2：2 的自然对数。 // 0.6931471805599453
Math.LN10：10 的自然对数。 // 2.302585092994046
Math.LOG2E：以 2 为底的e的对数。 // 1.4426950408889634
Math.LOG10E：以 10 为底的e的对数。 // 0.4342944819032518
Math.PI：常数π。 // 3.141592653589793
Math.SQRT1_2：0.5 的平方根。 // 0.7071067811865476
Math.SQRT2：2 的平方根。 // 1.4142135623730951

这些属性都是只读的，不能修改。

1.6.2 Math 静态方法

Math.abs()：绝对值
Math.ceil()：向上取整返回大于或等于参数值的最小整数（天花板值）
Math.floor()：向下取整返回小于或等于参数值的最大整数（地板值）
Math.max()：最大值
Math.min()：最小值
Math.pow()：幂运算 Math.pow(2, 3) // 8
Math.sqrt()：平方根
Math.log()：自然对数，返回以e为底的自然对数值
Math.exp()：e的指数
Math.round()：四舍五入 // 等同于 Math.floor(x + 0.5), Math.round(-1.5) // -1
Math.random()：随机数，返回 0 到 1 之间的一个伪随机数，可能等于 0，但是一定小于 1
Math.sin()：返回参数的正弦（参数为弧度值）
Math.cos()：返回参数的余弦（参数为弧度值）
Math.tan()：返回参数的正切（参数为弧度值）
Math.asin()：返回参数的反正弦（返回值为弧度值）
Math.acos()：返回参数的反余弦（返回值为弧度值）
Math.atan()：返回参数的反正切（返回值为弧度值）
Math.trunc()方法用于去除一个数的小数部分，返回整数部分。
Math.sign()方法用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。
Math.cbrt()方法用于计算一个数的立方根。
Math.clz32()方法将参数转为 32 位无符号整数的形式，然后返回这个 32 位值里面有多少个前导 0。
Math.imul()方法返回两个数以 32 位带符号整数形式相乘的结果，返回的也是一个 32 位的带符号整数。
Math.fround()方法返回一个数的 32 位单精度浮点数形式。
Math.hypot()方法返回所有参数的平方和的平方根。
Math.expm1(x)返回 e^x - 1，即Math.exp(x) - 1。
Math.log1p(x)方法返回1 + x的自然对数，即Math.log(1 + x)。如果x小于-1，返回NaN。
Math.log10(x)返回以 10 为底的x的对数。如果x小于 0，则返回 NaN。
Math.log2(x)返回以 2 为底的x的对数。如果x小于 0，则返回 NaN。
Math.sinh(x) 返回x的双曲正弦（hyperbolic sine）
Math.cosh(x) 返回x的双曲余弦（hyperbolic cosine）
Math.tanh(x) 返回x的双曲正切（hyperbolic tangent）
Math.asinh(x) 返回x的反双曲正弦（inverse hyperbolic sine）
Math.acosh(x) 返回x的反双曲余弦（inverse hyperbolic cosine）
Math.atanh(x) 返回x的反双曲正切（inverse hyperbolic tangent）

1.7 BigInt

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

为了与 Number 类型区别，BigInt 类型的数据必须添加后缀n。
BigInt 同样可以使用各种进制表示，都要加上后缀n。
BigInt 与普通整数是两种值，它们之间并不相等。
BigInt 可以使用负号（-），但是不能使用正号（+），因为会与 asm.js 冲突。

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

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

可以使用Boolean()、Number()和String()这三个方法，将 BigInt 可以转为布尔值、数值和字符串类型。
取反运算符（!）也可以将 BigInt 转为布尔值
BigInt 类型的+、-、*和**这四个二元运算符，与 Number 类型的行为一致。除法运算/会舍去小数部分，返回一个整数
不带符号的右移位运算符>>>，一元的求正运算符+。上面两个运算符用在 BigInt 会报错。前者是因为>>>运算符是不带符号的，但是 BigInt 总是带有符号的，导致该运算无意义，完全等同于右移运算符>>。后者是因为一元运算符+在 asm.js 里面总是返回 Number 类型，为了不破坏 asm.js 就规定+1n会报错。
BigInt 不能与普通数值进行混合运算。

1.7.1 BigInt()

JavaScript 原生提供BigInt函数，可以用它生成 BigInt 类型的数值。转换规则基本与Number()一致，将其他类型的值转为 BigInt。
BigInt()函数必须有参数，而且参数必须可以正常转为数值，

1.7.2 BigInt 实例方法

BigInt.prototype.toString() BigInt 继承了 Object 对象的两个实例方法。
BigInt.prototype.valueOf() BigInt 继承了 Object 对象的两个实例方法。
BigInt.prototype.toLocaleString() 它还继承了 Number 对象的一个实例方法。

1.7.3 BigInt 静态方法

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