Math方法【吕钒的后花园】

Math方法

发表于 2018-06-28 | 更新于 2020-07-16

前端资料JavaScript

JavaScript

Math 属性

常用属性

Math.PI

圆周率，一个圆的周长和直径之比，约等于 3.14159.

Math.PI 运算

Math.PI; //Expected 3.141592653589793, got 3.141592653589793

Math.sin(0); //Expected 0, got 0
Math.sin(Math.PI / 2); //Expected 1, got 1
Math.sin(Math.PI); //Expected 0, got 1.2246063538223773e-16
Math.sin((Math.PI * 3) / 2); //Expected -1, got -1
Math.sin(Math.PI * 2); //Expected 0, got -2.4492127076447545e-16

Math.cos(0); //Expected 1, got 1
Math.cos(Math.PI / 2); //Expected 0, got 6.123031769111886e-17
Math.cos(Math.PI); //Expected -1, got -1
Math.cos((Math.PI * 3) / 2); //Expected 0, got -1.836909530733566e-16
Math.cos(Math.PI * 2); //Expected 1, got 1

Math.sqrt(x); //平方根
Math.pow(x, y); //x的y次方
Math.round(x); //四舍五入为整数

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.SQRT1_2

1/2 的平方根, 约等于 0.707.

Math.SQRT2

2 的平方根,约等于 1.414.

Math 方法

常用方法

Math.random()

一个浮点型伪随机数字在 0（包括 0）和 1（不包括）之间

Math.sin(x)

返回正弦值.

Math.sin(0); // 0
Math.sin(1); // 0.8414709848078965

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

Math.cos(x)

返回 x 的余弦值。返回一个 -1 到 1 之间的数值，表示角度（单位：弧度）的余弦值

Math.cos(0); // 1
Math.cos(1); // 0.5403023058681398

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

Math.tan(x)

返回 x 的正切值.

Math.floor(x)

返回小于或等于 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.ceil(x)

返回 x 向上取整后的值。大于或等于给定数字的最小整数

Math.ceil(0.95); // 1
Math.ceil(4); // 4
Math.ceil(7.004); // 8
Math.ceil(-0.95); // -0
Math.ceil(-4); // -4
Math.ceil(-7.004); // -7

Math.round(x)

返回四舍五入后的整数.

1 2	Math.round(49.49); // 49 Math.round(20.9); // 21

Math.abs(x)

返回 x 的绝对值.

Math.abs("-1"); // 1
Math.abs(-2); // 2
Math.abs(null); // 0
Math.abs("string"); // NaN
Math.abs(); // NaN

Math.log(x)

返回一个数的自然对数（loge，即 ln）。

Math.log(-1); // NaN, out of range
Math.log(0); // -Infinity
Math.log(1); // 0
Math.log(10); // 2.302585092994046

Math.log10(x)

返回以 10 为底数的 x 的对数。如果传入的参数小于 0, 则返回 NaN

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 为底数的 x 的对数。如果传入的参数小于 0, 则返回 NaN

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.max([x[,y[,…]]])

返回 0 个到多个数值中最大值.

1
2
3

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

Math.min([x[,y[,…]]])

返回 0 个到多个数值中最小值.

1
2
3

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

Math.pow(x,y)

返回 x 的 y 次幂.

// 如果 x 是 7 ，且 y 是 2，则 raisePower 函数返回 49 （7 的 2 次幂）
function raisePower(x, y) {
  return Math.pow(x, y);
}

Math.sqrt(x)

返回 x 的平方根.

Math.sqrt(9); // 3
Math.sqrt(2); // 1.414213562373095

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

不常用方法

Math.acos(x)

返回 x 的反余弦值。以 -1 到 1 的一个数为参数，返回一个 0 到 pi （弧度）的数值。如果传入的参数值超出了限定的范围，将返回 NaN

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

Math.acosh(x)

返回 x 的反双曲余弦值。当参数小于 1 时， Math.acosh()将返回 NaN。

Math.acosh(-1); // NaN
Math.acosh(0); // NaN
Math.acosh(0.5); // NaN
Math.acosh(1); // 0
Math.acosh(2); // 1.3169578969248166

Math.asin(x)

返回 x 的反正弦值。接受 -1 到 1 之间的数值作为参数，返回一个介于 - π2 到 π2 弧度的数值。如果接受的参数值超出范围，则返回 NaN

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

Math.asinh(x)

返回 x 的反双曲正弦值.

Math.asinh(1); // 0.881373587019543
Math.asinh(0); // 0

/* 由于arsinh(x)=ln(x+ 根号(x^2+1) ) ，因此该函数可以被如下的函数所模拟：*/
Math.asinh =
  Math.asinh ||
  function(x) {
    if (x === -Infinity) {
      return x;
    } else {
      return Math.log(x + Math.sqrt(x * x + 1));
    }
  };

Math.atan(x)

以介于 -PI/2 与 PI/2 弧度之间的数值来返回 x 的反正切值.

1 2	Math.atan(1); // 0.7853981633974483 Math.atan(0); // 0

Math.atanh(x)

返回 x 的反双曲正切值。对于大于 1 或是小于－1 的值，函数返回 NaN

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

Math.atan2(y, x)

返回 y/x 的反正切值。
返回一个 -pi 到 pi 之间的数值，表示点 (x, y) 对应的偏移角度。这是一个逆时针角度，以弧度为单位，正 X 轴和点 (x, y) 与原点连线之间。注意此函数接受的参数：先传递 y 坐标，然后是 x 坐标。
atan2 接受单独的 x 和 y 参数，而 atan 接受两个参数的比值

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)

返回 x 的立方根。参数 x 会被自动类型转换成 number 类型

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 位整数的前导零的数量。
如果 x 不是数字类型, 则它首先会被转换成数字类型, 然后再转成 32 位无符号整形数字。
如果转换后的 32 位无符号整形数字是 0, 则返回 32, 因为此时所有位上都是 0。
NaN, Infinity, -Infinity 这三个数字转成 32 位无符号整形数字后都是 0。
这个函数主要用于那些编译目标为 JS 语言的系统中, 比如 Emscripten。

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); // 30

Math.cosh(x)

返回 x 的双曲余弦值.

1
2
3

Math.cosh(0); // 1
Math.cosh(1); // 1.5430806348152437
Math.cosh(-1); // 1.5430806348152437

Math.exp(x)

返回 Ex, 当 x 为参数, E 是欧拉常数 (2.718…), 自然对数的底.

1
2
3

Math.exp(-1); // 0.36787944117144233
Math.exp(0); // 1
Math.exp(1); // 2.718281828459045

Math.expm1(x)

返回 exp(x)-1 的值.

Math.expm1(1); // 1.7182818284590453
Math.expm1(-38); // -1
Math.expm1("-38"); // -1
Math.expm1("foo"); // NaN

Math.fround(x)

返回数字的最接近的单精度浮点型表示。

JavaScript 内部使用 64 位的双浮点数字，支持很高的精度。但是，有时你需要用 32 位浮点数字，比如你从一个 Float32Array 读取值时。这时会产生混乱：检查一个 64 位浮点数和一个 32 位浮点数是否相等会失败，即使二个数字几乎一模一样。

要解决这个问题，可以使用 Math.fround() 来将 64 位的浮点数转换为 32 位浮点数。在内部，JavaScript 继续把这个数字作为 64 位浮点数看待，仅仅是在尾数部分的第 23 位执行了“舍入到偶数”的操作，并将后续的尾数位设置为 0。如果数字超出 32 位浮点数的范围，则返回 Infinity 或 -Infinity。

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

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

2 ** 150; // 1.42724769270596e+45
Math.fround(2 ** 150); // Infinity

Math.fround("abc"); // NaN
Math.fround(NaN); // NaN

// 在某些精度不高的场合下，可以通过将二个浮点数转换成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)

返回 32 位整数乘法的结果。

Math.imul(2, 4); // 8
Math.imul(-1, 8); // -8
Math.imul(-2, -2); // 4
Math.imul(0xffffffff, 5); //-5
Math.imul(0xfffffffe, 5); //-10

Math.log1p(x)

返回 1 加上一个数字的的自然对数（loge，即 ln）。如果参数的值小于 -1, 则返回 NaN

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

Math.sign(x)

返回 x 的符号函数, 判定 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.sinh(x)

返回 x 的双曲正弦值.

Math.sinh(0); // 0
Math.sinh(1); // 1.1752011936438014
Math.sinh("-1"); // -1.1752011936438014
Math.sinh("foo"); // NaN

Math.tanh(x)

返回 x 的双曲正切值.

1
2
3

Math.tanh(0); // 0
Math.tanh(Infinity); // 1
Math.tanh(1); // 0.7615941559557649

Math.toSource()

返回字符串 “Math”.

Math.trunc(x)

返回 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

本文作者: 吕钒

本文链接: https://fan-lv.github.io/2018/06/28/前端资料-JavaScript-Math方法/