写在前面，最最常用几个方法：

绝对值：Math.abs(x)

最大值：Math.max([x[, y[, …]]])

最小值：Math.min([x[, y[, …]]])

随机值：Math.random()

向上取整：Math.ceil(x)

向下取整：Math.floor(x)

四舍五入：Math.round(x)

1.概述

Math是一个内置对象，它拥有一些数学常数属性和数学函数方法。Math 不是一个函数对象。Math 用于 Number 类型。

Math 不是一个构造器。Math 的所有属性与方法都是静态的。Math 的常量是使用 JavaScript 中的全精度浮点数来定义的。

2.方法

需要注意的是，三角函数 sin()、cos()、tan()、asin()、acos()、atan() 和 atan2()返回的值是弧度而非角度。

若要转换，弧度除以 (Math.PI / 180) 即可转换为角度，同理，角度乘以这个数则能转换为弧度。

很多 Math 函数都有一个精度，而且这个精度在不同实现中也是不相同的。这意味着不同的浏览器会给出不同的结果，甚至，在不同的系统或架构下，相同的 JS 引擎也会给出不同的结果！

2.1 常用方法

Math.abs(x)   返回一个数的绝对值。

Math.abs('-1');     // 1

Math.abs(-2);       // 2

Math.abs(null);     // 0

Math.abs("string"); // NaN

Math.abs();         // NaN

Math.ceil(x)   返回大于一个数的最小整数，即一个数向上取整后的值。

Math.ceil(.95);        // expected output: 1

Math.ceil(4);        // expected output: 4

Math.ceil(7.004);    // expected output: 8

Math.ceil(-7.004);    // expected output: -7

Math.floor(x)   返回小于一个数的最大整数，即一个数向下取整后的值。

Math.floor( 45.95);     // 45

Math.floor( 45.05);        // 45

Math.floor( 4 );         // 4

Math.floor(-45.05);     // -46

Math.floor(-45.95);     // -46

Math.max([x[, y[, …]]])   返回零到多个数值中最大值。

Math.max(10, 20);   //  20

Math.max(-10, -20); // -10

Math.max(-10, 20);  //  20

Math.min([x[, y[, …]]])   返回零到多个数值中最小值。

Math.max(10, 20);   //  10

Math.max(-10, -20); // -20

Math.max(-10, 20);  //  -10

Math.random()   返回一个 0 到 1 ([0, 1))之间的伪随机数。

Math.random();            // eg:0.3807786079066584

Math.round(x)   返回四舍五入后的整数。

Math.round(20.49);        // 20

Math.round(20.5);        // 21

Math.round(-20.5);        // -20

Math.round(-20.51);        // -21

2.2 其余方法

Math.acos(x)   返回一个数的反余弦值。

Math.acos(-2);  // NaN

Math.acos(-1);  // 3.141592653589793

Math.acos(0);   // 1.5707963267948966

Math.acos(0.5); // 1.0471975511965979

Math.acos(1);   // 0

Math.acos(2);   // NaN

对于小于 -1 或大于 1 的值，Math.acos 返回 NaN。

Math.acosh(x)   返回一个数的反双曲余弦值。

Math.acosh(0.5); // NaN

Math.acosh(1);   // 0

Math.acosh(2);   // 1.3169578969248166

当参数小于1时， Math.acosh()将返回NaN。

Math.asin(x)   返回一个数的反正弦值。

Math.asin(-2);  // NaN

Math.asin(-1);  // -1.5707963267948966 (-pi/2)

Math.asin(0);   // 0

Math.asin(0.5); // 0.5235987755982989

Math.asin(1);   // 1.570796326794897 (pi/2)

Math.asin(2);   // NaN

对于小于 -1 或大于 1 的参数值，Math.asin 返回 NaN。

Math.asinh(x)   返回一个数的反双曲正弦值。

Math.asinh(1);  // 0.881373587019543

Math.asinh(0);  // 0

Math.atan(x)   返回一个数的反正切值。

Math.atan(1);  // 0.7853981633974483

Math.atan(0);  // 0

Math.atanh(x)   返回一个数的反双曲正切值。

Math.atanh(-2);  // NaN

Math.atanh(-1);  // -Infinity

Math.atanh(0);   // 0

Math.atanh(0.5); // 0.5493061443340548

Math.atanh(1);   // Infinity

Math.atanh(2);   // NaN

对于大于1或是小于－1的值，函数返回 NaN 。

Math.atan2(y, x)   返回 y/x 的反正切值。

Math.atan2(90, 15) // 1.4056476493802699

Math.atan2(15, 90) // 0.16514867741462683

Math.atan2( ±0, -0 )               // ±PI.

Math.atan2( ±0, +0 )               // ±0.

Math.atan2( ±0, -x )               // ±PI for x > 0.

Math.atan2( ±0, x )                // ±0 for x > 0.

Math.atan2( -y, ±0 )               // -PI/2 for y > 0.

Math.atan2( y, ±0 )                // PI/2 for y > 0.

Math.atan2( ±y, -Infinity )        // ±PI for finite y > 0.

Math.atan2( ±y, +Infinity )        // ±0 for finite y > 0.

Math.atan2( ±Infinity, x )         // ±PI/2 for finite x.

Math.atan2( ±Infinity, -Infinity ) // ±3*PI/4.

Math.atan2( ±Infinity, +Infinity ) // ±PI/4.

Math.cbrt(x)   返回一个数的立方根。cbrt 是 “cube root” 的缩写, 意思是立方根。

Math.cbrt(NaN); // NaN

Math.cbrt(-1); // -1

Math.cbrt(-0); // -0

Math.cbrt(-Infinity); // -Infinity

Math.cbrt(0); // 0

Math.cbrt(1); // 1

Math.cbrt(Infinity); // Infinity

Math.cbrt(null); // 0

Math.cbrt(2);  // 1.2599210498948734

Math.clz32(x) 返回一个 32 位整数的前导零的数量。

Math.clz32(1)                // 31

Math.clz32(1000)             // 22

Math.clz32()                 // 32

[NaN, Infinity, -Infinity, 0, -0, null, undefined, "foo", {}, []].filter(function (n) {

return Math.clz32(n) !== 32

})                           // []

Math.clz32(true)             // 31

Math.clz32(3.5)

Math.cos(x) 返回一个数的余弦值。

Math.cos(0);           // 1

Math.cos(1);           // 0.5403023058681398

Math.cos(Math.PI);     // -1

Math.cos(2 * Math.PI); // 1

Math.cosh(x) 返回一个数的双曲余弦值。可通过函数模拟实现：

Math.cosh = Math.cosh || function(x) {

var y = Math.exp(x);

return (y + 1 / y) / 2;

};

Math.cosh(0);  // 1

Math.cosh(1);  // 1.5430806348152437

Math.cosh(-1); // 1.543080634815243

Math.exp(x) 返回欧拉常数的参数次方，Ex，其中 x 为参数，E 是欧拉常数(2.718…，自然对数的底数)。

Math.exp(-1); // 0.36787944117144233

Math.exp(0);  // 1

Math.exp(1);  // 2.718281828459045

Math.expm1(x) 返回 exp(x) - 1 的值。其中 x 是该函数的参数, E 是自然对数的底数 2.718281828459045.

Math.expm1(1)     // 1.7182818284590453

Math.expm1(-38)   // -1

Math.expm1("-38") // -1

Math.expm1("foo") // NaN

Math.fround(x)   返回最接近一个数的单精度浮点型表示。

数字1.5可以在二进制数字系统中精确表示，32位和64位的值相同：

Math.fround(1.5); // 1.5

Math.fround(1.5) === 1.5; // true

但是，数字1.337却无法在二进制数字系统中精确表示，所以32位和64位的值是不同的：

Math.fround(1.337); // 1.3370000123977661

Math.fround(1.337) === 1.337; // false

在某些精度不高的场合下，可以通过将二个浮点数转换成32位浮点数进行比较，以解决64位浮点数比较结果不正确的问题：

0.1 + 0.2 == 0.3;    //false

function equal(v1, v2) {

return Math.fround(v1) == Math.fround(v2);

}

equal(0.1 + 0.2, 0.3);   //true

Math.hypot([x[, y[, …]]])   返回其所有参数平方和的平方根。

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, +'foo' => NaN

Math.hypot(3, 4, '5');   // 7.0710678118654755, +'5' => 5

Math.hypot(-3);          // 3, the same as Math.abs(-3)

Math.imul(x, y)   返回 32 位整数乘法的结果。

Math.log(x)   返回一个数的自然对数(㏒e，即 ㏑)。

Math.log(-1); // NaN, out of range

Math.log(0); // -Infinity

Math.log(1); // 0

Math.log(10); // 2.302585092994046

Math.log1p(x)   返回一个数加 1 的和的自然对数(㏒e，即 ㏑)。

Math.log1p(Math.E-1)  // 1

Math.log1p(0)         // 0

Math.log1p("0")       // 0

Math.log1p(-1)        // -Infinity

Math.log1p(-2)        // NaN

Math.log1p("foo")     // NaN

如果参数的值小于 -1, 则返回 NaN。

Math.log10(x)   返回一个数以 10 为底数的对数。

Math.log10(10)   // 1

Math.log10(100)  // 2

Math.log10("100")// 2

Math.log10(1)    // 0

Math.log10(0)    // -Infinity

Math.log10(-2)   // NaN

Math.log10("foo")// NaN

Math.log2(x)   返回一个数以 2 为底数的对数。

Math.log2(2)     // 1

Math.log2(1024)  // 10

Math.log2(1)     // 0

Math.log2(0)     // -Infinity

Math.log2(-2)    // NaN

Math.log2("1024")// 10

Math.log2("foo") // NaN

Math.pow(x, y)   返回一个数的 y 次幂。

Math.pow(7, 3);        // 343

Math.pow(4, 0.5);    // 2

Math.pow(7, -2);    // 0.02040816326530612 (1/49)

Math.pow(-7, 0.5);    // NaN

Math.random()   返回一个 0 到 1 ([0, 1))之间的伪随机数。

Math.random();            // eg:0.3807786079066584

Math.sign(x)   返回一个数的符号，得知一个数是正数、负数还是 0。此函数共有5种返回值, 分别是 1, -1, 0, -0, NaN. 代表的各是正数, 负数, 正零, 负零, NaN。

Math.sign(3);     //  1

Math.sign(-3);    // -1

Math.sign("-3");  // -1

Math.sign(0);     //  0

Math.sign(-0);    // -0

Math.sign(NaN);   // NaN

Math.sign("foo"); // NaN

Math.sign();      // NaN

Math.sin(x)   返回一个数的正弦值。

Math.sin(0);           // 0

Math.sin(1);           // 0.8414709848078965

Math.sin(Math.PI / 2); // 1

Math.sinh(x)   返回一个数的双曲正弦值。 双曲正弦的图像如下:

Math.sinh(0)      // 0

Math.sinh(1)      // 1.1752011936438014

Math.sinh("-1")   // -1.1752011936438014

Math.sinh("foo")  // NaN

Math.sqrt(x)   返回一个数的平方根。

Math.sqrt(9); // 3

Math.sqrt(2); // 1.414213562373095

Math.sqrt(1);  // 1

Math.sqrt(0);  // 0

Math.sqrt(-1); // NaN

Math.sqrt(-0); // -0

Math.tan(x) 返回一个数的正切值。 Math.tanh(x)   返回一个数的双曲正切值。

Math.tanh(0);        // 0

Math.tanh(Infinity); // 1

Math.tanh(1);        // 0.7615941559557649

Math.toSource()   返回字符串 “Math”。 Math.trunc(x)   返回一个数的整数部分，仅仅是删除掉数字的小数部分和小数点，不管参数是正数还是负数。传入该方法的参数会被隐式转换成数字类型。

Math.trunc(13.37)    // 13

Math.trunc(42.84)    // 42

Math.trunc(0.123)    //  0

Math.trunc(-0.123)   // -0

Math.trunc("-1.123") // -1

Math.trunc(NaN)      // NaN

Math.trunc("foo")    // NaN

Math.trunc()         // NaN

3.属性

Math.E   欧拉常数，也是自然对数的底数，约等于 2.718。 Math.LN2   2 的自然对数，约等于 0.693。 Math.LN10   10 的自然对数，约等于 2.303。 Math.LOG2E   以 2 为底的 E 的对数，约等于 1.443。 Math.LOG10E   以 10 为底的 E 的对数，约等于 0.434。 Math.PI   圆周率，一个圆的周长和直径之比，约等于 3.14159。 Math.SQRT1_2   二分之一 ½ 的平方根，同时也是 2 的平方根的倒数，约等于 0.707。 Math.SQRT2   2 的平方根，约等于 1.414。