recursal/MDN huggingface dataset:
Math.log1p()
============

概述
--

**`Math.log1p()`** 函数返回一个数字加 1 后的自然对数 (底为 `E`), 既`log(x+1)`.

语法
--


```js
Math.log1p(x)
```

### 参数

`x`

任意数字。

描述
--

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

函数 `y = log(x+1)` 的图形是这样的：

![log(x+1)](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p/logx1.jpg)

示例
--


```js
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
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log1p |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Math.log1p` 的 polyfill
* `Math.exp()`
* `Math.log()`
* `Math.expm1()`
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`
Math.asinh()
============

**`Math.asinh()`** 返回一个数值的反双曲正弦值，即：



Math.asinh
(
x
)

=
arsinh
(
x
)
=
 the unique 

y

such that

sinh
(
y
)
=
x

\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } ; y ; \text{such that} ; \sinh(y) = x

尝试一下
----

语法
--
```

Math.asinh(x)
```

### 参数

`x`

一个数值。

### 返回值

返回指定数值的反双曲正弦值。

描述
--

由于 `asinh()` 是 `Math` 的静态方法，所以应该像这样使用：`Math.asinh()`，而不是作为你创建的 `Math` 实例的方法（`Math` 不是一个构造函数）。

示例
--

### 使用 `Math.asinh()`


```js
Math.asinh(-Infinity); // -Infinity
Math.asinh(-1); // -0.881373587019543
Math.asinh(-0); // -0
Math.asinh(0); // 0
Math.asinh(1); // 0.881373587019543
Math.asinh(Infinity); // Infinity
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.asinh |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Math.asinh` 的 polyfill
* `Math.acosh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
* `Math.tanh()`
Math.sinh()
===========

概述
--

**`Math.sinh()`** 函数返回一个数字 (单位为角度) 的双曲正弦值。

语法
--
```

Math.sinh(x)
```

### 参数

`x`

任意数字 (单位为度).

描述
--

双曲正弦的图像如下：

![](http://upload.wikimedia.org/wikipedia/commons/1/17/Sinh.png)

示例
--


```js
Math.sinh(-Infinity); // -Infinity
Math.sinh(-0); // -0
Math.sinh(0); // 0
Math.sinh(1); // 1.1752011936438014
Math.sinh(Infinity); // Infinity
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sinh |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Math.sinh` 的 polyfill
* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.tan()`
Math.floor()
============

**`Math.floor()`** 函数总是返回小于等于一个给定数字的最大整数。

尝试一下
----

语法
--


```js
Math.floor(x)
```

### 参数

`x`

一个数字。

### 返回值

小于等于 `x` 的最大整数。它的值与 `-Math.ceil(-x)` 相同。

描述
--

因为 `floor()` 是 `Math` 的静态方法，所以你应始终使用 `Math.floor()`，而不是作为你创建的 `Math` 对象的方法（`Math` 不是构造函数）。

示例
--

### 使用 Math.floor()


```js
Math.floor(-Infinity); // -Infinity
Math.floor(-45.95); // -46
Math.floor(-45.05); // -46
Math.floor(-0); // -0
Math.floor(0); // 0
Math.floor(4); // 4
Math.floor(45.05); // 45
Math.floor(45.95); // 45
Math.floor(Infinity); // Infinity
```

### 十进制调整

在本例中，我们实现了一个名为 `decimalAdjust()` 的方法，它是 `Math.floor()`、`Math.ceil()` 和 `Math.round()` 的增强方法。三个 `Math` 函数总是将输入调整为个位数，`decimalAdjust` 接受 `exp` 参数，该参数指定小数点左侧应该调整的位数。例如，`-1` 表示它将在小数点后留下一位数字（如 "× 10-1"）。此外，它还允许你通过 `type` 参数选择调整方式——`round`、`bottom` 或 `ceiling`。

它是这样做的：将数字乘以 10 的幂，然后四舍五入到最接近的整数，然后除以 10 的幂。为了更好地保持精度，它利用了数字的 `toString()` 方法，该方法使用科学记数法表示任意数字（如 `6.02e23`）。


```js
/\*\*
 \* Adjusts a number to the specified digit.
 \*
 \* @param {"round" | "floor" | "ceil"} type The type of adjustment.
 \* @param {number} value The number.
 \* @param {number} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {number} The adjusted value.
 \*/
function decimalAdjust(type, value, exp) {
  type = String(type);
  if (!["round", "floor", "ceil"].includes(type)) {
    throw new TypeError(
      "The type of decimal adjustment must be one of 'round', 'floor', or 'ceil'.",
    );
  }
  exp = Number(exp);
  value = Number(value);
  if (exp % 1 !== 0 || Number.isNaN(value)) {
    return NaN;
  } else if (exp === 0) {
    return Math[type](value);
  }
  const [magnitude, exponent = 0] = value.toString().split("e");
  const adjustedValue = Math[type](`${magnitude}e${exponent - exp}`);
  // Shift back
  const [newMagnitude, newExponent = 0] = adjustedValue.toString().split("e");
  return Number(`${newMagnitude}e${+newExponent + exp}`);
}

// Decimal round
const round10 = (value, exp) => decimalAdjust("round", value, exp);
// Decimal floor
const floor10 = (value, exp) => decimalAdjust("floor", value, exp);
// Decimal ceil
const ceil10 = (value, exp) => decimalAdjust("ceil", value, exp);

// Round
round10(55.55, -1); // 55.6
round10(55.549, -1); // 55.5
round10(55, 1); // 60
round10(54.9, 1); // 50
round10(-55.55, -1); // -55.5
round10(-55.551, -1); // -55.6
round10(-55, 1); // -50
round10(-55.1, 1); // -60
// Floor
floor10(55.59, -1); // 55.5
floor10(59, 1); // 50
floor10(-55.51, -1); // -55.6
floor10(-51, 1); // -60
// Ceil
ceil10(55.51, -1); // 55.6
ceil10(51, 1); // 60
ceil10(-55.59, -1); // -55.5
ceil10(-59, 1); // -50
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.floor |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.abs()`
* `Math.ceil()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.sign()
===========

**`Math.sign()`** 函数返回一个数字的符号，指示数字是正数，负数还是零。

语法
--
```

Math.sign(x);
```

### 参数

`x`

任意数字。

描述
--

因为 `sign` 是 `Math` 的一个静态方法，所以你应该使用 Math.sign()，而不是作为你创建的一个 Math 对象的一种方法（Math 不是一个构造函数）。

而不是作为你创建的 Math 对象的一种方法（Math 不是构造函数）。

此函数共有 5 种返回值，分别是 **1, -1, 0, -0, NaN.** 代表的各是**正数，负数，正零，负零，NaN**。

传入该函数的参数会被**隐式转换**成数字类型。

示例
--

### 使用 Math.sign()


```js
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
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sign |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Math.sign` 的 polyfill
* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.trunc()`
Math.atan2()
============

概述
--

**`Math.atan2()`** 返回从原点 (0,0) 到 (x,y) 点的线段与 x 轴正方向之间的平面角度 (弧度值)，也就是 Math.atan2(y,x)

语法
--
```

Math.atan2(y, x)
```

参数
--

`y, x`

数值

描述
--

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

`atan2` 接受单独的 x 和 y 参数，而 `atan` 接受两个参数的比值。

由于 `atan2` 是 `Math` 的静态方法，所以应该像这样使用：`Math.atan2()`，而不是作为你创建的 `Math` 实例的方法。

示例
--

### 示例：使用 `Math.atan2`


```js
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.
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atan2 |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.trunc()
============

**`Math.trunc()`** 方法会将数字的小数部分去掉，只保留整数部分。

语法
--
```

Math.trunc(value)
```

### 参数

`value`

任意数字

### 返回值

给定数字的整数部分

描述
--

不像 `Math` 的其他三个方法： `Math.floor()`、`Math.ceil()`、`Math.round()` ，`Math.trunc()` 的执行逻辑很简单，仅仅是**删除**掉数字的小数部分和小数点，不管参数是正数还是负数。

传入该方法的参数会被隐式转换成数字类型。

因为 `trunc()` 是 `Math` 对象的静态方法，你必须用 `Math.trunc()` 来使用，而不是调用你创建的 `Math` 对象的一个实例方法（`Math` 没有构造函数）

示例
--


```js
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
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.trunc |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Math.trunc` 的 polyfill
* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
Math.exp()
==========

概述
--

**`Math.exp()`** 函数返回 `e^x`，`x` 表示参数，`e` 是欧拉常数（Euler's constant），自然对数的底数。

语法
--


```js
Math.exp(x)
```

### 参数

`x`

一个数值

描述
--

由于 `exp` 是 `Math` 的静态方法，所以应该像这样使用：`Math.exp()`，而不是作为你创建的 `Math` 实例的方法。

示例
--

### 示例：使用 `Math.exp`


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

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.exp |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.E`
* `Math.expm1()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()`
* `Math.log2()`
* `Math.pow()`
Math.LN10
=========

概述
--

**`Math.LN10`** 属性表示 10 的自然对数，约为 2.302：


Math.LN10

=
ln
(
10
)
≈
2.302

\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302



| `Math.LN10` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

由于 `LN10` 是 `Math` 的静态属性，所以应该像这样使用：`Math.LN10`，而不是作为你创建的 `Math` 实例的属性（`Math` 不是构造函数）。

示例
--

### 示例：使用 `Math.LN10`

下面的函数返回 10 的自然对数：


```js
function getNatLog10() {
  return Math.LN10;
}

getNatLog10(); // 2.302585092994046
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ln10 |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
Math.pow()
==========

**`Math.pow()`** 函数返回基数（`base`）的指数（`exponent`）次幂，即 `base^exponent`。

尝试一下
----

语法
--
```

Math.pow(base, exponent)
```

### 参数

`base`

基数

`exponent`

指数

描述
--

由于 `pow` 是 `Math` 的静态方法，所以应该像这样使用：`Math.pow()`，而不是作为你创建的 `Math` 对象的方法。

示例
--

### 使用 `Math.pow`


```js
function raisePower(x, y) {
  return Math.pow(x, y);
}
```


如果 `x` 是 2，且 `y` 是 7，则 raisePower 函数返回 128（2 的 7 次幂）。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.pow |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.cbrt()`
* `Math.exp()`
* `Math.log()`
* `Math.sqrt()`
* 乘方（`**`）
Math.fround()
=============

概述
--

**`Math.fround()`** 可以将任意的数字转换为离它最近的单精度浮点数形式的数字。

语法
--


```js
Math.fround(doubleFloat)
```

### 参数

`doubleFloat`

一个 `Number`。若参数为非数字类型，则会被转投成数字。无法转换时，设置成`NaN`。

### 返回值

指定数字最接近的 32 位单精度浮点数表示。

描述
--

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

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

因为`fround()` 是`Math` 的静态方法，你必须通过 `Math.fround()` 来使用，而不是调用你创建的`Math` 对象的一个实例方法（`Math`不是一个构造函数）。

示例
--

### 使用 Math.fround()

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


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


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


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


2^150 超出 32 位浮点，所以返回`Infinity`：


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


如果参数无法转换成数字，或者为 `NaN`（`NaN`），`Math.fround()` 会返回 `NaN`：


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


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


```js
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
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.fround |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `core-js` 中 `Math.fround` 的 polyfill
* `Math.round()`
Math.tan()
==========

概述
--

**`Math.tan()`** 方法返回一个数值的正切值。

语法
--
```

Math.tan(x)
```

### 参数

`x`

一个数值，表示一个角（单位：弧度）。

描述
--

`tan` 方法返回一个数值，表示一个角的正切值。

由于 `tan` 是 `Math` 的静态方法，所以应该像这样使用 `Math.tan()`，而不是作为你创建的 `Math` 实例的方法。

示例
--

### 示例：使用 `Math.tan`

下面的函数返回变量 `x` 的正切值：


```js
function getTan(x) {
  return Math.tan(x);
}
```


由于 `Math.tan()` 函数接受弧度数值，但是通常使用度更方便，下面的函数可以接受以度为单位的数值，将其转为弧度，然后返回其正切值。


```js
function getTanDeg(deg) {
  var rad = (deg \* Math.PI) / 180;
  return Math.tan(rad);
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.tan |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Math.PI
=======

概述
--

**`Math.PI`** 表示一个圆的周长与直径的比例，约为 3.14159：


Math.PI

=
π
≈
3.14159

\mathtt{\mi{Math.PI}} = \pi \approx 3.14159



| `Math.PI` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

由于 `PI` 是 `Math` 的静态属性，所以应该像这样使用：`Math.PI`，而不是作为你创建的 `Math` 实例的属性（`Math` 不是构造函数）。

示例
--

### 使用 `Math.PI`

下面的函数使用 Math.PI 计算给定半径的圆周长：


```js
function calculateCircumference(radius) {
  return 2 \* Math.PI \* radius;
}

calculateCircumference(1); // 6.283185307179586
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.pi |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math`
Math.sin()
==========

概述
--

**`Math.sin()`** 函数返回一个数值的正弦值。

语法
--
```

Math.sin(x)
```

### 参数

`x`

一个数值（以弧度为单位）。

描述
--

`sin` 方法返回一个 -1 到 1 之间的数值，表示给定角度（单位：弧度）的正弦值。

由于 `sin` 是 `Math` 的静态方法，所以应该像这样使用：`Math.sin()`，而不是作为你创建的 `Math` 实例的方法。

示例
--

### 示例：使用 `Math.sin`


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

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

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sin |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.tan()`
Math.cbrt()
===========

**`Math.cbrt()`** 函数返回任意数字的立方根。

语法
--
```

Math.cbrt(x)
```

### 参数

`x`

任意数字。

### 返回值

给定数字的立方根

描述
--

该方法为 Math 的静态方法，因此请直接通过 Math.cbrt() 方式调用。

而不是作为你创建的 Math 对象的方法 (Math 不是构造函数)。

cbrt 是 "cube root" 的缩写，意思是立方根。

示例
--

### 使用 Math.cbrt()


```js
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.2599210498948732
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cbrt |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.pow()`
* `Math.sqrt()`
Math.log()
==========

概述
--

**`Math.log()`** 函数返回一个数的自然对数，即：



∀
x
>
0
,

Math.log
(
x
)

=
ln
(
x
)
=
the unique

y

such that

e
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} ; y ; \text{such that} ; e^y = x

语法
--
```

Math.log(x)
```

### 参数

`x`

一个数字。

描述
--

如果指定的 `number` 为负数，则返回值为 `NaN`。

由于 `log` 是 `Math` 的静态方法，所以应该像这样使用：`Math.log()`，而不是作为你创建的 `Math` 对象的方法。

示例
--

### 示例 1:使用`Math.log`

下面的函数返回指定变量的自然对数：


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

### 示例 2：使用 `Math.log` 时基于不同的底数

下面的函数返回以 `x` 为底 `y` 的对数（即 logx y）：


```js
function getBaseLog(x, y) {
  return Math.log(y) / Math.log(x);
}
```


如果你运行 `getBaseLog(10, 1000)`，则会返回 `2.9999999999999996`，非常接近实际答案：3，原因是浮点数精度问题。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.exp()`
* `Math.log1p()`
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`
Math.LOG2E
==========

概述
--

**`Math.LOG2E`** 属性表示以 2 为底数，e 的对数，约为 1.442：


Math.LOG2E

=

log
2

(
e
)
≈
1.442

\mathtt{\mi{Math.LOG2E}} = \log\_2(e) \approx 1.442



| `Math.LOG2E` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

由于 `LOG2E` 是 `Math` 的静态属性，所以应该像这样使用：`Math.LOG2E`，而不是作为你创建的 `Math` 对象的属性（`Math` 不是一个构造函数）。

示例
--

### 示例：使用 `Math.LOG2E`

下面的函数返回以 2 为底数，E 的对数：


```js
function getLog2e() {
  return Math.LOG2E;
}

getLog2e(); // 1.4426950408889634
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log2e |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.exp()`
* `Math.log()`
* `Math.log2()`
Math.LOG10E
===========

概述
--

**`Math.LOG10E`** 属性表示以 10 为底数，e 的对数，约为 0.434：


Math.LOG10E

=

log
10

(
e
)
≈
0.434

\mathtt{\mi{Math.LOG10E}} = \log\_10(e) \approx 0.434



| `Math.LOG10E` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

描述
--

由于 `LOG10E` 是 `Math` 的静态属性，所以应该像这样使用：`Math.LOG10E`，而不是作为你创建的 `Math` 实例的属性（`Math` 不是一个构造函数）。

示例
--

### 示例：使用 `Math.LOG10E`

下面的函数返回以 10 为底数，E 的对数：


```js
function getLog10e() {
  return Math.LOG10E;
}

getLog10e(); // 0.4342944819032518
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log10e |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
Math.acos()
===========

概述
--

**`Math.acos()`** 返回一个数的反余弦值（单位为弧度），即：



∀
x
∊
[

-
1

;
1
]
,

Math.acos
(
x
)

=
arccos
(
x
)
=
 the unique 

y
∊
[
0
;
π
]

such that

cos
(
y
)
=
x

\forall x \in [{-1};1],;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } ; y \in [0; \pi] , \text{such that} ; \cos(y) = x

语法
--
```

Math.acos(x)
```

参数
--

`x`

一个数值

描述
--

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

由于 `acos` 是 `Math` 的静态方法，所以应该像这样使用：`Math.acos()`，而不是作为你创建的 `Math` 实例的属性（`Math` 不是一个构造函数）。

示例
--

### 示例：使用 `Math.acos`


```js
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`。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.acos |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.cos()
==========

概述
--

**`Math.cos()`** 函数返回一个数值的余弦值。

语法
--
```

Math.cos(x)
```

### 参数

`x`

一个以弧度为单位的数值。

描述
--

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

由于 `cos` 是 `Math` 的静态方法，所以应该像这样使用：`Math.cos()`，而不是作为你创建的 `Math` 实例的方法。

示例
--

### 示例：使用 `Math.cos`


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

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

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cos |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.sin()`
* `Math.tan()`
Math.abs()
==========

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

尝试一下
----

语法
--


```js
Math.abs(x)
```

### 参数

`x`

一个数字。

### 返回值

`x` 的绝对值。如果 `x` 是负数（包括 `-0`），则返回 `-x`。否则，返回 `x`。

描述
--

由于 `abs()` 是 `Math` 中的一个静态方法，所以你应该通过 `Math.abs()` 调用，而不是作为你创建的 `Math` 对象的方法（`Math` 不是构造器）。

示例
--

### 使用 Math.abs()


```js
Math.abs(-Infinity); // Infinity
Math.abs(-1); // 1
Math.abs(-0); // 0
Math.abs(0); // 0
Math.abs(1); // 1
Math.abs(Infinity); // Infinity
```

### 强制转换参数

`Math.abs()` 将其参数强制转换为数字。无法强制转换的值将变成 `NaN`，使 `Math.abs()` 也返回 `NaN`。


```js
Math.abs("-1"); // 1
Math.abs(-2); // 2
Math.abs(null); // 0
Math.abs(""); // 0
Math.abs([]); // 0
Math.abs([2]); // 2
Math.abs([1, 2]); // NaN
Math.abs({}); // NaN
Math.abs("string"); // NaN
Math.abs(); // NaN
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.abs |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.round()
============

**`Math.round()`** 函数返回一个数字四舍五入后最接近的整数。

语法
--
```

Math.round(x)
```

### 参数

`x`

一个数值。

### 返回值

给定数字的值四舍五入到最接近的整数。

描述
--

如果参数的小数部分大于 0.5，则舍入到相邻的绝对值更大的整数。如果参数的小数部分小于 0.5，则舍入到相邻的绝对值更小的整数。如果参数的小数部分恰好等于 0.5，则舍入到相邻的在正无穷（+∞）方向上的整数。**注意，与很多其他语言中的`round()` 函数不同，`Math.round()` 并不总是舍入到远离 0 的方向（尤其是在负数的小数部分恰好等于 0.5 的情况下）。**

因为 `round()` 是 `Math` 的静态方法，你应该直接使用 `Math.round()`，而不是作为你创建的 `Math` 对象的一个实例方法来使用（`Math`没有构造函数）。

示例
--


```js
x = Math.round(20.49); //20
x = Math.round(20.5); //21
x = Math.round(-20.5); //-20
x = Math.round(-20.51); //-21
```

### 小数舍入


```js
// 闭包
(function () {
  /\*\*
 \* Decimal adjustment of a number.
 \*
 \* @param {String} type The type of adjustment.
 \* @param {Number} value The number.
 \* @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {Number} The adjusted value.
 \*/
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Shift
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Shift back
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005\*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```


或：


```js
function round(number, precision) {
  return Math.round(+number + "e" + precision) / Math.pow(10, precision);
  //same as:
  //return Number(Math.round(+number + 'e' + precision) + 'e-' + precision);
}

round(1.005, 2); //1.01
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.round |

浏览器兼容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

参见
--

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`