1.js中数字
1.数字存储
Javascript中所有数字的存储都是64位浮点数。整数也一样。
1 === 1.0 // true
2. 数字大小范围
可以表示的最大正数和最小负数
(-Math.pow(2, 1024), Math.pow(2,1024)) // 开区间
// 等同于
-Number.MAX_VALUE ~ Number.MAX_VALUE // -(2**1023)*1.9999999999999998 ~ (2**1023)*1.9999999999999998
// 如果等于Math.pow(2,1024)，正向溢出Infinity
Number.POSITIVE_INFINITY
// 如果-Math.pow(2, 1024)
Number.NEGATIVE_INFINITY
小数的最小取值，即可以取到的最小的正数
Math.pow(2, -1074); // 5e-324
// 还可以表示为
Number.MIN_VALUE // 5e-324 Math.pow(2, -1075); // 0
// 指数大于-1075的可以计算，<=1075"负向溢出"，等于0
3. 数字精度
js中64位存储位，有52位用于精度，加上默认的1，一共53位用于表示精度。
可以表示的正负数的精度大小：
-Math.pow(2, 53) ~ Math.pow(2, 53); // 开区间；（-9007199254740992， 9007199254740992），
// 也可以表示成闭区间
[-Math.pow(2, 53)+1, Math.pow(2, 53)-1],
// 即[-9007199254740991, 9007199254740991]
// 可以表示成-Number.MAX_SAFE_INTEGER~ Number.MAX_SAFE_INTEGER
由上面可知，精度最大是16位的十进制数，超过16位的十进制数就会失去精度。
4. 科学计数法
js在下面两种情况下，会将数字自动转为科学技术法表示：
1）数字大小超过21位
100000000000000000000 // 21位
1000000000000000000000 // 22位，1e+21
2)小数点后的0超过5位,小数点前也是0
0.000001 // 0.000001
0.0000001 // 1e-7
之所以要注意科学计数法的原因是，有的时候在运算中，js自动进行类型转换，会导致意外结果。
比如5中使用解析函数,parseInt等
5. 字符串解析成数字
Number.parseInt(str[, N进制数])--字符串解析成十进制整数
功能和parseInt一样；但是最好使用Number.parseInt()，代码模块化
将N（2-36）进制的字符串转为十进制的正数，如果第一个参数不是字符串，先转为字符串
Number.parseInt(0.0000003); //
// 这个属于科学计数法的第二种情况，js自动转为3e-7, 函数将其转为'3e-7'
// 等同于
Number.parseInt('3e-7'); //3 只解析数字的部分 Number.parseInt(''); // NaN
Number.parseInt(12.45); //
Number.parseInt('12ddd'); //
其他进制转十进制
Number.parseInt(22.45); //
Number.parseInt(22.45, 2); // NaN, 无效的二进制数
Number.parseInt(22.45, 8); // 18, 将8进制的22转为十进制
Number.parseFloat(str) --- 将字符串转为浮点数
有几个特殊值需要注意
Number.parseFloat(''); // NaN Number('') === 0
Number.parseFloat(null); // NaN Number(null) === 0
Number.parseFloat([]); // NaN Number([]) === 0
// undefined时，和Number()相同
Number.parseFloat(undefined);// NaN
Number.parseFloat(true); // NaN Number(true) === 1
Number.parseFloat('12.45f'); // 12.45 区别于Number('12.45f') ===NaN
6. 特殊数值
1. NaN
NaN不等于自身；但是Object.is中相等；
Object.is(NaN, NaN); //true
NaN === NaN; // false
一些特殊值之间运算后NaN
5-'x'; // NaN
0/0; //NaN
0*Infinity; // NaN
null*Infinity; // NaN 相当于0*Infinity
Infinity-Infinity; //NaN
Infinity/Infinity; //NaN
undefined+Infinity; //NaN 相当于 NaN + Infinity
NaN和任意值的运算结果都是NaN
2.+0和-0
两者相等，有两种特殊情况
// 1)在Object.is()中不相等
Object.is(+0, -0); // false
// 2) 非零值除
9/0 ;// Infinity
9/-0; // -Infinity
2. Number对象
既是构造函数，还可以作为工具函数。
1. 静态方法
1. Number.isNaN(param)/isNaN(param)---判断是否NaN
两者的区别是，前者先判断参数类型，类型不是NaN，直接返回false,不会进行转化；
isNaN会先将参数转为数值，然后再判断
Number.isNaN('d'); //false
isNaN('d'); // true
2.Number.isFinite(param)/isFinite(param) --判断值是否有限
除了Infinity, -Infinity, NaN, undefined，其他的数值全部返回true;
区别：前者先判断值类型，值类型不是number，直接返回false;
后者如果不是数值类型，先转化为数值类型
Number.isFinite('12'); // false
isFinite('12'); // true
3.Number.parseInt()/ Number.parseFloat()
4.Number.isInteger(number)--判断一个值是否是整数
先判断数据类型，如果数据类型不符合，直接返回false;
然后判断是否为整数，或者其他的特殊情况
Number.isInteger(true); // false
Number.isInteger(''); //false
Number.isInteger(25.0); //true js中25.0===25
Number.isInteger(Number.MIN_VALUE*0.5); // true 当小于最小正数
Number.isInteger(1.0000000000000004); //false 小数点后16位
Number.isInteger(1.00000000000000004); // true 小数点后17位
5. Number.isSafeInteger(number)--判断整数是否在精度范围
先判断数据类型，后判断是否在精度范围内的整数,-2^53到2^53之间（不含两个端点)。
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(9007199254740993 - 990)
// true
9007199254740993 - 990
// 返回结果 9007199254740002
// 正确答案应该是 9007199254740003
2. 实例方法
1.toString([N进制])--将数值转为N进制字符串
默认转为10进制，指定后转为指定的进制
(0x11).toString(); // "17"
(0x11).toString(2); // "10001"
2. toFixed(number) --将数值转为固定小数位数的字符串
(10.005).toFixed(2); // "10.01"
3. toExponential(number)--转为科学计数法表示的字符串
number表示小数的个数
(10).toExponential(2); // "1.00e+1"
4. toPrecision(number)--转为固定有效数字的字符串
number表示所有有效数字的长度
(10).toPrecision(5); // "10.000"
3.Math对象
Math就是一个对象，不是构造函数。
1.静态属性--只读属性
1. Math.PI---