Number 对象，JS数学
一、 Number 对象
1. JavaScript 的 Number 对象
Number 对象是经过封装的能让你处理数字值的对象。Number 对象由 Number() 构造器创建。
Number 对象主要用于：
如果参数无法被转换为数字，则返回 NaN。
在非构造器上下文中 (如：没有 new 操作符)，Number 能被用来执行类型转换。
JavaScript 数字
JavaScript 数字可以使用也可以不使用小数点来书写：
var pi=3.14; // 使用小数点
var x=34; // 不使用小数点
极大或极小的数字可通过科学（指数）计数法来写：
var y=123e5; // 12300000
var z=123e-5; // 0.00123
2. 整数特性
2.1 取值范围
在JavaScript中，数字不分为整数类型和浮点型类型，所有的数字都是由 浮点型类型。JavaScript采用IEEE754标准定义的64位浮点格式表示数字，它能表示最大值为±1.7976931348623157 x 10308，最小值为±5 x 10 -324。
在解析序列化的JSON时，如果JSON解析器将它们强制转换为Number类型，那么超出此范围的整数值可能会被破坏。
2.2 精度
整数（不使用小数点或指数计数法）最多为 15 位。
实例
var x = 999999999999999; // x 为 999999999999999
var y = 9999999999999999; // y 为 10000000000000000
小数的最大位数是 17，但是浮点运算并不总是 100% 准确：
实例
var x = 0.2+0.1;
document.getElementById("demo").innerHTML = x; // 输出结果为 0.30000000000000004
解决方案 ：
方法一：指定要保留的小数位数(0.1+0.2).toFixed(1) = 0.3;这个方法toFixed是进行四舍五入的也不是很精准，对于计算金额这种严谨的问题，不推荐使用，而且不同浏览器对toFixed的计算结果也存在差异。
方法二：将浮点数乘以（扩大）10的n次方倍，把浮点数变为整数后再进行相应的运算，最后将得到的结果除以（缩小）10的n次方倍。
console.log( （1*10 - 0.8*10）/10 ); //输出 0.2
console.log( 6 * 0.7*10/10 ); //输出 4.2
console.log( (0.1*10 + 0.2*10)/10 ); //输出 0.3
console.log( （0.1 *10+ 0.7*10）/10 ); //输出 0.8
console.log( 1.2 *10/（0.2 *10） ); //输出 6
3. 转换数字字符串为数字
Number("123") // 123
Number("") // 0
Number("0x11") // 17注：0x代表十六进制的数字
Number("0b11") // 3 二进制
Number("0o11") // 9 八进制
Number("foo") // NaN
Number("100a") // NaN
4. 八进制和十六进制
如果前缀为 0，则 JavaScript 会把数值常量解释为八进制数，如果前缀为 0 和 "x"，则解释为十六进制数。
实例
var y = 0o377;
var z = 0xFF;
注意：绝不要在数字前面写零，除非您需要进行八进制转换。
默认情况下，JavaScript 数字为十进制显示。
但是你可以使用 toString() 方法 输出16进制、8进制、2进制。
实例
var myNumber=128;
myNumber.toString(16); // 返回 80
myNumber.toString(8); // 返回 200
myNumber.toString(2); // 返回 10000000
5. 无穷大（Infinity）
当数字运算结果超过了JavaScript所能表示的数字上限（溢出），结果为一个特殊的无穷大（infinity）值，在JavaScript中以Infinity表示。同样地，当负数的值超过了JavaScript所能表示的负数范围，结果为负无穷大，在JavaScript中以-Infinity表示。无穷大值的行为特性和我们所期望的是一致的：基于它们的加、减、乘和除运算结果还是无穷大（当然还保留它们的正负号）。
6. NaN - 非数字值
NaN 属性是代表非数字值的特殊值。该属性用于指示某个值不是数字。可以把 Number 对象设置为该值，来指示其不是数字值。
你可以使用 isNaN() 全局函数来判断一个值是否是 NaN 值。
var x = 1000 / "Apple";
isNaN(x); // 返回 true
var y = 100 / "1000";
isNaN(y); // 返回 false
除以0是无穷大，无穷大是一个数字:
var x = 1000 / 0;
isNaN(x); // 返回 false
7. 数字可以是数字或者对象
数字可以私有数据进行初始化，就像 x = 123;
JavaScript 数字对象初始化数据， var y = new Number(123);
var x = 123;
var y = new Number(123);
typeof(x) // 返回 Number
typeof(y) // 返回 Object
var x = 123;
var y = new Number(123);
(x === y) // 为 false，因为 x 是一个数字，y 是一个对象
8. 使用 Number 转换 Date 对象
下例使用 Number 作为函数来转换 Date 对象为数字值：
var d = new Date("December 17, 1995 03:24:00");
print(Number(d));
这将输出 "819199440000"。
9. toFixed() 方法
toFixed() 方法可把 Number 四舍五入为指定小数位数的数字。
语法
NumberObject.toFixed(num)
参数 描述
num 必需。规定小数的位数，是 0 ~ 20 之间的值，包括 0 和 20，有些实现可以支持更大的数值范围。如果省略了该参数，将用 0 代替。
返回值
返回 NumberObject 的字符串表示，不采用指数计数法，小数点后有固定的 num 位数字。如果必要，该数字会被舍入，也可以用 0 补足，以便它达到指定的长度。如果 num 大于 le+21，则该方法只调用 NumberObject.toString()，返回采用指数计数法表示的字符串。
实例，我们将把数字舍入为仅有一位小数的数字：
var num = new Number(13.37);
document.write (num.toFixed(1)) // 13.4
10. toPrecision() 方法
toPrecision() 方法可在对象的值超出指定位数时将其转换为指数计数法。
语法 number.toPrecision(x)
参数值
参数 描述
x 必需。规定必须被转换为指数计数法的最小位数。该参数是 1 ~ 21 之间（且包括 1 和 21）的值。有效实现允许有选择地支持更大或更小的 num。如果省略了该参数，则调用方法 toString()，而不是把数字转换成十进制的值。
返回值: String 指定精度的数字格式
用不同进制把数字格式化为指定的长度:
var num = new Number(13.3714);
var a = num.toPrecision();
var b = num.toPrecision(2);
var c = num.toPrecision(3);
var d = num.toPrecision(10);
a,b,c, 和 d 输出结果:
13.3714
13
13.4
13.37140000
二、 JavaScript Math（算数） 对象
Math 对象用于执行数学任务。
Math 对象并不像 Date 和 String 那样是对象的类，因此没有构造函数 Math()。
事例：
var x = Math.PI; // 返回PI
var y = Math.sqrt(16); // 返回16的平方根
1. Math 对象属性
|
属性
|
描述
|
|
E
|
返回算术常量 e，即自然对数的底数（约等于2.718）。Math.E
|
|
LN2
|
返回 2 的自然对数（约等于0.693）。
|
|
LN10
|
返回 10 的自然对数（约等于2.302）。
|
|
LOG2E
|
返回以 2 为底的 e 的对数（约等于 1.4426950408889634）。
|
|
LOG10E
|
返回以 10 为底的 e 的对数（约等于0.434）。
|
|
PI
|
返回圆周率（约等于3.14159）。
|
|
SQRT1_2
|
返回 2 的平方根的倒数（约等于 0.707）。
|
|
SQRT2
|
返回 2 的平方根（约等于 1.414）。
|
2. Math 对象方法
|
方法
|
描述
|
|
abs(x)
|
返回 x 的绝对值。
|
|
acos(x)
|
返回 x 的反余弦值。
|
|
asin(x)
|
返回 x 的反正弦值。
|
|
atan(x)
|
以介于 -PI/2 与 PI/2 弧度之间的数值来返回 x 的反正切值。
|
|
atan2(y,x)
|
返回从 x 轴到点 (x,y) 的角度（介于 -PI/2 与 PI/2 弧度之间）。
|
|
ceil(x)
|
对数进行上舍入。
|
|
cos(x)
|
返回数的余弦。
|
|
exp(x)
|
返回 Ex 的指数。
|
|
floor(x)
|
对 x 进行下舍入。
|
|
log(x)
|
返回数的自然对数（底为e）。
|
|
max(x,y,z,...,n)
|
返回 x,y,z,...,n 中的最高值。
|
|
min(x,y,z,...,n)
|
返回 x,y,z,...,n中的最低值。
|
|
pow(x,y)
|
返回 x 的 y 次幂。
|
|
random()
|
返回 0 ~ 1 之间的随机数。
|
|
round(x)
|
四舍五入取整。
|
|
sin(x)
|
返回数的正弦。
|
|
sqrt(x)
|
返回数的平方根。
|
|
tan(x)
|
返回角的正切。
|
1) abs() 方法
返回一个数的绝对值:
Math.abs(-7.25);
输出结果:
7.25
2) ceil() 方法
ceil() 方法[si:l]可对一个数进行上舍入，向上取整。
如果参数是一个整数，该值不变。
注意：ceil() 方法执行的是向上取整计算，它返回的是大于或等于函数参数，并且与之最接近的整数。
对一个数进行上舍入:
Math.ceil(1.4)
输出结果: 2
3) floor() 方法
floor() 方法返回小于等于输入值的最大整数。
如果传递的参数是一个整数，该值不变。
返回小于等于x的最大整数:
Math.floor(1.6);
以上实例将输出：1
4) round() 方法
round() 方法可把一个数字舍入为最接近的整数。
注意： 2.49 将舍入2 , 2.5 将舍入 3。
round() 方法可把一个数字舍入为最接近的整数：
Math.round(2.5);
输出结果： 3
5) random() 方法
random() 方法可返回介于 0（包含） ~ 1（不包含） 之间的一个随机数。
返回介于 0（包含） ~ 1（不包含） 之间的一个随机数：
Math.random();
输出结果：//随机数
取得介于 1 到 10 之间的一个随机数：
Math.floor((Math.random()*10)+1);
知识拓展：
属性
1. Number.EPSILON
两个可表示(representable)数之间的最小间隔。
这是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" toFixed() 方法可把 Number 四舍五入为指定小数位数的数字。
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 的实质是一个可以接受的最小误差范围。
2. Number.MAX_SAFE_INTEGER
JavaScript 中最大的安全整数 (253 - 1)。
MAX_SAFE_INTEGER 是一个值为 9007199254740991的常量。
因为Javascript的数字存储使用了IEEE 754中规定的双精度浮点数数据类型，而这一数据类型能够安全存储 -(253 - 1) 到 253 - 1 之间的数值（包含边界值）。
这里安全存储的意思是指能够准确区分两个不相同的值，例如 Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 将得到 true的结果，而这在数学上是错误的.
由于 MAX_SAFE_INTEGER 是Number的一个静态属性，所以不用自己动手为Number对象创建Number.MAX_SAFE_INTEGER这一属性，就可以直接使用它。
3. Number.MAX_VALUE
能表示的最大正数。最小的负数是 -MAX_VALUE。
MAX_VALUE 属性是 JavaScript 中可表示的最大的数。它的近似值为 1.7976931348623157 x 10308。
4. Number.MIN_SAFE_INTEGER
JavaScript 中最小的安全整数 (-(253 - 1)).
5. Number.MIN_VALUE
能表示的最小正数即最接近 0 的正数 (实际上不会变成 0)。它的近似值为 5 x 10-324。
最大的负数是 -MIN_VALUE。
6. Number.NaN
特殊的“非数字”值。
7. Number.NEGATIVE_INFINITY
特殊的负无穷大值，在溢出时返回该值。
Number.NEGATIVE_INFINITY 是一个特殊值，它在算术运算或函数生成一个比 JavaScript 能表示的最小负数还小的数（也就是比 -Number.MAX_VALUE 还小的数）时返回。
JavaScript 显示 NEGATIVE_INFINITY 时使用的是 -Infinity。这个值的算术行为和无穷大非常相似。例如，任何数乘无穷大结果仍为无穷大，任何数被无穷大除的结果为 0。
var x=(-Number.MAX_VALUE)*2
if (x==Number.NEGATIVE_INFINITY)
{
document.write("Value of x: " + x);
}
输出： Value of x: -Infinity
8. Number.POSITIVE_INFINITY
特殊的正无穷大值，在溢出时返回改值。
9. Number.prototype
Number 对象上允许的额外属性。
方法
1. Number.isNaN()
确定传递的值是否是 NaN。
2. Number.isFinite()
确定传递的值类型及本身是否是有限数。
3. Number.isInteger()
确定传递的值类型是“number”，且是整数。
Number.isInteger(25) // true
Number.isInteger(25.0) // true
Number.isInteger(25.1) // false
Number.isInteger("15") // false
Number.isInteger(true) // false
4. Number.isSafeInteger()
确定传递的值是否为安全整数 ( -(253 - 1) 至 253 - 1之间)。
5. Number.toInteger()
计算传递的值并将其转换为整数 (或无穷大)。
toFixed() 方法可把 Number 四舍五入为指定小数位数的数字。
语法
NumberObject.toFixed(num)
参数 描述
num 必需。规定小数的位数，是 0 ~ 20 之间的值，包括 0 和 20，有些实现可以支持更大的数值范围。如果省略了该参数，将用 0 代替。
返回值：
返回 NumberObject 的字符串表示，不采用指数计数法，小数点后有固定的 num 位数字。如果必要，该数字会被舍入，也可以用 0 补足，以便它达到指定的长度。如果 num 大于 le+21，则该方法只调用 NumberObject.toString()，返回采用指数计数法表示的字符串。
6. Number.parseFloat()
和全局对象 parseFloat() 一样。
parseFloat() 函数可解析一个字符串，并返回一个浮点数。
该函数指定字符串中的首个字符是否是数字。如果是，则对字符串进行解析，直到到达数字的末端为止，然后以数字返回该数字，而不是作为字符串。
语法
parseFloat(string)
参数 描述
string 必需。要被解析的字符串。
注意： 字符串中只返回第一个数字。
注意： 开头和结尾的空格是允许的。
注意： 如果字符串的第一个字符不能被转换为数字，那么 parseFloat() 会返回 NaN。
document.write(parseFloat("10") + "<br>");
document.write(parseFloat("10.33") + "<br>");
document.write(parseFloat("34 45 66") + "<br>");
document.write(parseFloat(" 60 ") + "<br>");
document.write(parseFloat("40 years") + "<br>");
document.write(parseFloat("He was 40") + "<br>");
以上实例输出结果:
10
10.33
34
60
40
NaN
7. Number.parseInt()
和全局对象 parseInt() 一样。
parseInt() 函数可解析一个字符串，并返回一个整数。
当参数 radix 的值为 0，或没有设置该参数时，parseInt() 会根据 string 来判断数字的基数。
当忽略参数 radix , JavaScript 默认数字的基数如下:
如果 string 以 "0x" 开头，parseInt() 会把 string 的其余部分解析为十六进制的整数。
如果 string 以 0 开头，那么 ECMAScript v3 允许 parseInt() 的一个实现把其后的字符解析为八进制或十六进制的数字。
如果 string 以 1 ~ 9 的数字开头，parseInt() 将把它解析为十进制的整数。
语法
parseInt(string, radix)
参数 描述
string 必需。要被解析的字符串。
radix 可选。表示要解析的数字的基数（进制）。该值介于 2 ~ 36 之间。
注意： 只有字符串中的第一个数字会被返回。
注意： 开头和结尾的空格是允许的。
注意：如果字符串的第一个字符不能被转换为数字，那么 parseInt() 会返回 NaN。
注意：在字符串以"0"为开始时旧的浏览器默认使用八进制基数。ECMAScript 5，默认的是十进制的基数。
document.write(parseInt("10") + "<br>");
document.write(parseInt("10.33") + "<br>");
document.write(parseInt("34 45 66") + "<br>");
document.write(parseInt(" 60 ") + "<br>");
document.write(parseInt("40 years") + "<br>");
document.write(parseInt("He was 40") + "<br>");
document.write("<br>");
document.write(parseInt("10",10)+ "<br>");
document.write(parseInt("010")+ "<br>");
document.write(parseInt("10",8)+ "<br>");
document.write(parseInt("0x10")+ "<br>");
document.write(parseInt("10",16)+ "<br>");
结果：
10
10
34
60
40
NaN
10
10
8
16
16
