js：坐标轴上的数值

js数值怎么和数学结合起来，在坐标轴上体现？先画个图。

1、原点0--js中的正零和负零

数学中的原点0，在js内部实际上存在2个0：一个是+0，一个是-0，区别就是64位浮点数表示法的符号位不同。它们是等价的。一般它俩都会被当做正常的0。

-0 === +0 // true
0 === -0 // true
0 === +0 // true

 唯一有区别的场合是，+0或-0当作分母，返回的值是不相等的。

(1 / +0) === (1 / -0) // false

1 / +0 // Infinity
1 / -0 // -Infinity

 === 无法区分+0和-0，ES6部署的Object.is方法可以。

Object.is(+0, -0) // false

2、正无穷/负无穷--js中的 Infinity 和 - Infinity

数学中的无穷∞，js用Infinity表示。

如果一个数大于等于2的1024次方，那么就会发生"正向溢出"，即 JavaScript 无法表示这么大的数，这时就会返回Infinity。

坐标轴上 [ 2^1024, +∞) 范围内都会返回 Infinity。

Math.pow(2, 1024) // Infinity

Infinity用来表示两种场景：

• 一个正的数值太大，或一个负的数值太小，无法表示；
• 非0数值除以0，得到 Infinity

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

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

Infinity大于一切数值（除了NaN），-Infinity小于一切数值（除了NaN）。

Infinity > 1000 // true
-Infinity < -1000 // true

Infinity与NaN比较，总是返回false。

Infinity > NaN // false
-Infinity > NaN // false

Infinity < NaN // false
-Infinity < NaN // false

3、Math.pow(2, -1075)--负向溢出

一个数小于等于2的-1075次方，会发生为"负向溢出"，即 JavaScript 无法表示这么小的数，这时会直接返回0。

坐标轴上[0,  2^-1075]范围内都会返回0。

Math.pow(2, -1075) // 0

4、NaN："非数字"（Not a Number）---五行之外，图示中不在坐标轴上

NaN是 js的特殊数值，是唯一一个不等于任何值的特殊存在。

typeof NaN // 'number'
NaN === NaN // false

单纯的数学运算，js几乎没有可能抛出错误。计算算不出结果，返回个NaN可还行。

5 - 'x'             // NaN --- 字符串x 解析成数字出错

// 一些数学函数参数不在作用域内，运算结果会出现NaN
Math.acos(2)        // NaN --- 相当于 y = acos(x), 参数区间在[-1, 1]
Math.log(-1)        // NaN --- 相当于 y = ln(x),   参数区间在[0, +∞)
Math.sqrt(-1)       // NaN --- 相当于 y = √x,      参数区间在[0, +∞)

// 0 、Infinity 计算返回NaN的场景【null转为数值时是0，0的场合同样适用null】
0 / 0               // NaN
0 * Infinity        // NaN
Infinity - Infinity // NaN
Infinity / Infinity // NaN 

parseInt('abc')     // NaN --- 参数的第一个字符不能转化为数字(后面跟着数字的正负号除外)
parseInt('10', 37)  // NaN --- parseInt第二个参数需是2到36之间的整数
parseInt('546', 2)  // NaN --- 2表示546是二进制字符串，5不是合法的二进制数值

 NaN与任何数（包括它自己）的运算，得到的都是NaN。

NaN + 32 // NaN
NaN - 32 // NaN
NaN * 32 // NaN
NaN / 32 // NaN

// undefined 转为数值时是NaN
let x  // undefined
x + 32 // NaN
x - 32 // NaN
x * 32 // NaN
x / 32 // NaN

判断一个值是否为NaN？

• isNaN()：只对数值有效，如果传入其他值，会先进行类型转换，转成数值。【有坑】
• Number.isNaN()：只对数值有效，且只有对于NaN才返回true，非NaN一律返回false。
• 利用NaN为唯一不等于自身的值的这个特点，进行判断。

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

isNaN('Hello')        // true --- 相当于 isNaN(Number('Hello'))
Number.isNaN('Hello') // false


// NaN为唯一不等于自身的值
function myIsNaN(value) {
  return value !== value;
}

判断数组的成员是否有NaN？

数组的indexOf方法不太行，因该方法内部使用的是严格相等运算符

[NaN].indexOf(NaN) // -1 

ES6有方法弥补

[NaN].includes(NaN)                     // true
[NaN].findIndex(y => Object.is(NaN, y)) // 0

Object.is(NaN, NaN)                     // true

5、Number.MAX_VALUE --- 最大的正数【最接近Infinity的正数】

Number.MAX_VALUE            // 1.7976931348623157e+308
Number.MAX_VALUE < Infinity // true

 Number.MAX_VALUE到底多大？

Number.MAX_VALUE.toString(2)
-> "1111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"

var a = Number.MAX_VALUE.toString(2).split("") , b = [ a.filter(function(i){return i==0}).length , a.filter(function(i){return i==1}).length ] ; b
-> [971, 53]

Number.MAX_VALUE === (Math.pow(2,53)-1)*Math.pow(2,971)
-> true

6、Number.MIN_VALUE --- 最小的正数【最接近0的正数】

Number.MIN_VALUE     // 5e-324
Number.MAX_VALUE > 0 // true

 Number.MIN_VALUE到底多小？

Number.MIN_VALUE === Math.pow(2, -1074) // true

7、Number.MAX_SAFE_INTEGER 和 Number.MIN_SAFE_INTEGER

JS 能够准确表示的整数范围在-2^53到2^53之间（不含两个端点），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

由于2的53次方是一个16位的十进制数值，所以简单的法则就是，JavaScript 对15位的十进制数都可以精确处理。

提问：JavaScript 里最大的安全的整数为什么是2的53次方减一？

回答：因为2的53次方不安全。根据双精度浮点数的构成，精度位数是 53 bit。安全数的意思是在 -2^53 ~ 2^53 内的整数(不包括边界)与唯一的双精度浮点数互相对应。js中 Math.pow(2, 53) 和 Math.pow(2, 53) + 1 相等，对应了同一个双精度浮点数。所以 Math.pow(2, 53) 就不是安全数了。

8、Number.EPSILON

Number.EPSILON表示 1 与大于 1 的最小浮点数之间的差。它是 js能够表示的最小精度。

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

引入那么小的量的目的，在于为浮点数计算，设置一个误差范围。误差如果小于这个值，就可以认为不存在误差了。

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

0.1 + 0.2                        // 0.30000000000000004
0.1 + 0.2 - 0.3                  // 5.551115123125783e-17

0.1 + 0.2 - 0.3 <  Number.EPSILON * Math.pow(2, 2) // true

The End

参考连接：

数值 - JavaScript 教程 - 网道

图解：JavaScript中Number的一些表示上/下限 - SegmentFault 思否