recursal/MDN huggingface dataset:
Array.prototype[@@unscopables]
==============================

`Array.prototype` 的 **`@@unscopables`** 数据属性被所有 `Array` 实例共享。它包含在 ES2015 版本之前 ECMAScript 标准中未收纳的属性名，并且这些属性被排除在由 `with` 语句绑定的环境中。

值
-

一个 `null` 原型对象，包含下面给出的属性名称，且它们的值都设置为 `true`。

| `Array.prototype[@@unscopables]` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 是 |

描述
--

在 `with` 语句绑定中未包含的 `Array` 默认属性包括：

* `at()`
* `copyWithin()`
* `entries()`
* `fill()`
* `find()`
* `findIndex()`
* `findLast()`
* `findLastIndex()`
* `flat()`
* `flatMap()`
* `includes()`
* `keys()`
* `toReversed()`
* `toSorted()`
* `toSpliced()`
* `values()`

`Array.prototype[@@unscopables]` 是一个只包含所有上述属性且对应值为 `true` 的空对象。它的原型是 `null`，因此不会意外地使 `Object.prototype` 属性（比如 `toString`）变为非作用域属性，而令在 `with` 语句中调用数组的 `toString()` 方法仍然有效。

请参阅 `Symbol.unscopables` 了解如何为自定义对象设置非作用域属性。

示例
--

假设下面的 `keys.push('something')` 是在 ECMAScript 2015 之前编写的代码中调用的。


```js
var keys = [];

with (Array.prototype) {
  keys.push("something");
}
```


当 ECMAScript 2015 引入 `Array.prototype.keys()` 方法时，如果 `@@unscopables` 数据属性也没有被引入，那么 `keys.push('something')` 调用将会出现问题——因为 JavaScript 运行时会将 `keys` 解释为 `Array.prototype.keys()` 方法，而不是示例代码中定义的 `keys` 数组。

因此，`Array.prototype` 的 `@@unscopables` 数据属性使得 ECMAScript 2015 中引入的 `Array` 属性在 `with` 语句绑定时被忽略，从而使得在 ECMAScript 2015 之前编写的代码继续按预期工作，而不会出现问题。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype-@@unscopables |

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

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

参见
--

* `core-js` 中 `Array.prototype[@@unscopables]` 的 polyfill
* 索引集合类
* `Array`
* `with`
* `Symbol.unscopables`
Array.prototype.toSpliced()
===========================

`Array` 实例的 **`toSpliced()`** 方法是 `splice()` 方法的复制版本。它返回一个新数组，并在给定的索引处删除和/或替换了一些元素。

语法
--


```js
toSpliced(start)
toSpliced(start, deleteCount)
toSpliced(start, deleteCount, item1)
toSpliced(start, deleteCount, item1, item2, itemN)
```

### 参数

`start`

从 0 开始计算的索引，表示要开始改变数组的位置，它会被转换为整数。

* 如果 `start < 0`，则从数组末尾开始计数，使用 `start + array.length`。
* 如果 `start < -array.length` 或者省略了 `start`，则使用 `0`。
* 如果 `start >= array.length`，不会删除任何元素，但该方法将表现为添加元素的函数，添加提供的所有元素。

`deleteCount` 可选

一个整数，指示数组中要从 `start` 删除的元素数量。

如果 `deleteCount` 被省略了，或者如果它的值大于或等于由 `start` 指定的位置到数组末尾的元素数量，将会删除从 `start` 到数组末尾的所有元素。但是，如果你想要传递任何 `itemN` 参数，则应向 `deleteCount` 传递 `Infinity` 值，以删除 `start` 之后的所有元素，因为显式的 `undefined` 会转换为 `0`。

如果 `deleteCount` 是 `0` 或者负数，则不会删除元素。在这种情况下，你应该指定至少一个新元素（见下文）。

`item1`, …, `itemN` 可选

元素将从 `start` 开始添加到数组当中。

如果你没有指定任何元素，`toSpliced()` 只会从数组中删除元素。

### 返回值

一个新数组，由 `start` 之前的所有元素、`item1`、`item2`、...、`itemN`，以及 `start + deleteCount` 之后的所有元素组成。

描述
--

`toSpliced()` 方法与 `splice()` 类似，可以同时完成多个操作：在数组中给定的索引开始移除指定数量的元素，然后在相同的索引处插入给定的元素。但是，它返回一个新数组，而不是修改原始数组。因此，此方法不会返回已删除的元素。

`toSpliced()` 方法不会产生稀疏数组。如果原始数组是稀疏的，在新数组中空槽将会被替换成 `undefined`。

`toSpliced()` 方法是通用的。它只期望 `this` 值具有 `length` 属性和整数键属性。

示例
--

### 删除、添加和替换元素

你可以通过使用 `toSpliced()` 来删除、添加和替换数组中的元素，并生成一个新的数组，这比使用 `slice()` 和 `concat()` 更高效。


```js
const months = ["Jan", "Mar", "Apr", "May"];

// 在索引 1 处添加一个元素
const months2 = months.toSpliced(1, 0, "Feb");
console.log(months2); // ["Jan", "Feb", "Mar", "Apr", "May"]

// 从第 2 个索引开始删除两个元素
const months3 = months2.toSpliced(2, 2);
console.log(months3); // ["Jan", "Feb", "May"]

// 在索引 1 处用两个新元素替换一个元素
const months4 = months3.toSpliced(1, 1, "Feb", "Mar");
console.log(months4); // ["Jan", "Feb", "Mar", "May"]

// 原数组不会被修改
console.log(months); // ["Jan", "Mar", "Apr", "May"]
```

### 在稀疏数组上使用 toSpliced()

`toSpliced()` 方法总是会生成一个密集的数组。


```js
const arr = [1, , 3, 4, , 6];
console.log(arr.toSpliced(1, 2)); // [1, 4, undefined, 6]
```

### 对非数组对象调用 toSpliced()

`toSpliced()` 方法将会读取 `this` 的 `length` 属性。然后，它读取所需的整数键属性并将其写入新数组。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  0: 5,
  2: 4,
};
console.log(Array.prototype.toSpliced.call(arrayLike, 0, 1, 2, 3));
// [2, 3, undefined, 4]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.tospliced |

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

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

参见
--

* `core-js` 中 `Array.prototype.toSpliced` 的 polyfill
* `Array.prototype.splice()`
* `Array.prototype.toReversed()`
* `Array.prototype.toSorted()`
* `Array.prototype.with()`
Array.prototype.at()
====================

Baseline 2022
-------------

Newly availableSince March 2022, this feature works across the latest devices and browser versions. This feature might not work in older devices or browsers.

* Learn more
* See full compatibility
* Report feedback
**`at()`** 方法接收一个整数值并返回该索引对应的元素，允许正数和负数。负整数从数组中的最后一个元素开始倒数。

尝试一下
----

语法
--


```js
at(index)
```

### 参数

`index`

要返回的数组元素的索引（从零开始），会被转换为整数。负数索引从数组末尾开始计数——如果 `index < 0`，则会访问 `index + array.length` 位置的元素。

### 返回值

返回数组中与给定索引匹配的元素。如果 `index < -array.length` 或 `index >= array.length`，则总是返回 `undefined`，而不会尝试访问相应的属性。

描述
--

在传递非负数时，`at()` 方法等价于括号表示法。例如，`array[0]` 和 `array.at(0)` 均返回第一个元素。但是，当你需要从数组的末端开始倒数时，则不能使用 Python 和 R 语言中支持的 `array[-1]`，因为方括号内的所有值都会被视为字符串属性，因此你最终读取的是 `array["-1"]`，这只是一个普通的字符串属性而不是数组索引。

通常的做法是访问 `length` 并将其减去从末端开始的相对索引。例如，`array[array.length - 1]`。`at()` 方法允许使用相对索引，因此上面的示例可以简化为 `array.at(-1)`。

`at()` 方法是通用的。其仅期望 `this` 具有 `length` 属性和以整数为键的属性。

示例
--

### 返回数组的最后一个值

下面的示例提供了一个函数，它返回在一个指定的数组中找到的最后一个元素。


```js
// 数组及数组元素
const cart = ["apple", "banana", "pear"];

// 一个函数，用于返回给定数组的最后一个元素
function returnLast(arr) {
  return arr.at(-1);
}

// 获取 'cart' 数组的最后一个元素
const item1 = returnLast(cart);
console.log(item1); // 输出：'pear'

// 在 'cart' 数组中添加一个元素
cart.push("orange");
const item2 = returnLast(cart);
console.log(item2); // 输出：'orange'
```

### 比较不同的数组方法

这个示例比较了选择 `Array` 中倒数第二个元素的不同方法。虽然下面显示的所有方法都是可行的，但这个示例凸显了 `at()` 方法的简洁性和可读性。


```js
// 数组及数组元素
const colors = ["red", "green", "blue"];

// 使用长度属性
const lengthWay = colors[colors.length - 2];
console.log(lengthWay); // 输出：'green'

// 使用 slice() 方法。注意会返回一个数组
const sliceWay = colors.slice(-2, -1);
console.log(sliceWay[0]); // 输出：'green'

// 使用 at() 方法
const atWay = colors.at(-2);
console.log(atWay); // 输出：'green'
```

### 在非数组对象上调用 at()

`at()` 方法读取 `this` 的 `length` 属性并计算需要访问的索引。


```js
const arrayLike = {
  length: 2,
  0: "a",
  1: "b",
};
console.log(Array.prototype.at.call(arrayLike, -1)); // "b"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.at |

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

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

参见
--

* `core-js` 中 `Array.prototype.at` 的 polyfill
* 索引集合类
* `Array`
* `Array.prototype.findIndex()`
* `Array.prototype.indexOf()`
* `TypedArray.prototype.at()` (en-US)
* `String.prototype.at()`
Array.prototype.toLocaleString()
================================

**`toLocaleString()`** 方法返回一个字符串，表示数组中的所有元素。每个元素通过调用它们自己的 `toLocaleString` 方法转换为字符串，并且使用特定于语言环境的字符串（例如逗号“,”）分隔开。

尝试一下
----

语法
--


```js
toLocaleString()
toLocaleString(locales)
toLocaleString(locales, options)
```

### 参数

`locales` 可选

带有 BCP 47 语言标签的字符串，或者此类字符串的数组。对于 `locales` 参数的一般形式和说明，可以参见 `Intl` 主页面的参数说明。

`options` 可选

一个具有配置属性的对象。对于数字，请参见 `Number.prototype.toLocaleString()`；对于日期，请参见 `Date.prototype.toLocaleString()`。

### 返回值

一个字符串，表示数组中的所有元素。

描述
--

`Array.prototype.toLocaleString` 方法遍历数组内容，并使用提供的 `locales` 和 `options` 参数调用每个元素的 `toLocaleString` 方法，通过由实现定义的分隔符（例如逗号“,”）将转换后的字符串拼接起来。请注意，该方法本身不会使用这两个参数——它只是将其传递给每个元素的 `toLocaleString()`。分隔符的选择取决于主机当前的语言环境，而不是 `locales` 参数。

如果一个元素是 `undefined`、`null`，它会被转换为空字符串，而不是 `"null"` 或者 `"undefined"`。

当用于稀疏数组时，`toLocaleString()` 方法迭代时会把空槽当作 `undefined` 一样处理它。

`toLocaleString()` 方法是通用的。它只期望 `this` 值具有 `length` 属性和整数键属性。

示例
--

### 使用 locales 和 options

数组元素通过使用它们的 `toLocaleString` 方法转换为字符串。

* `Object`：`Object.prototype.toLocaleString()`
* `Number`：`Number.prototype.toLocaleString()`
* `Date`：`Date.prototype.toLocaleString()`

始终显示 `prices` 数组中字符串和数字的货币符号：


```js
const prices = ["￥7", 500, 8123, 12];
prices.toLocaleString("ja-JP", { style: "currency", currency: "JPY" });

// "￥7,￥500,￥8,123,￥12"
```


更多示例请参见 `Intl.NumberFormat` 和 `Intl.DateTimeFormat` 页面。

### 在稀疏数组中使用 toLocaleString()

`toLocaleString()` 将空槽视为 `undefined` ，并生成一个额外的分隔符：


```js
console.log([1, , 3].toLocaleString()); // '1,,3'
```

### 在非数组对象中使用 toLocaleString()

`toLocaleString()` 方法读取 `this` 的 `length` 属性，然后访问每个整数索引。


```js
const arrayLike = {
  length: 3,
  0: 1,
  1: 2,
  2: 3,
};
console.log(Array.prototype.toLocaleString.call(arrayLike));
// 1,2,3
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.tolocalestring |
| ECMAScript Internationalization API Specification # sup-array.prototype.tolocalestring |

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

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

参见
--

* 索引集合类
* `Array`
* `Array.prototype.toString()`
* `TypedArray.prototype.toLocaleString()`
* `Intl`
* `Intl.ListFormat`
* `Object.prototype.toLocaleString()`
* `Number.prototype.toLocaleString()`
* `Date.prototype.toLocaleString()`
Array.prototype.values()
========================

**`values()`** 方法返回一个新的*数组迭代器*对象，该对象迭代数组中每个元素的值。

尝试一下
----

语法
--


```js
values()
```

### 返回值

一个新的可迭代迭代器对象。

描述
--

`Array.prototype.values()` 是 `Array.prototype[@@iterator]()` 的默认实现。


```js
Array.prototype.values === Array.prototype[Symbol.iterator]; // true
```


当应用于稀疏数组时，`values()` 方法会将空槽作为 `undefined` 迭代。

`values()` 方法是通用的。它只需要 `this` 值具有 `length` 属性和整数键属性。

示例
--

### 使用 for...of 循环进行迭代

由于 `values()` 返回一个可迭代迭代器对象，你可以使用 `for...of` 循环来迭代它。


```js
const arr = ["a", "b", "c", "d", "e"];
const iterator = arr.values();

for (const letter of iterator) {
  console.log(letter);
} // "a" "b" "c" "d" "e"
```

### 使用 next() 迭代

由于返回值也是一个迭代器，你可以直接调用其 `next()` 方法。


```js
const arr = ["a", "b", "c", "d", "e"];
const iterator = arr.values();
iterator.next(); // { value: "a", done: false }
iterator.next(); // { value: "b", done: false }
iterator.next(); // { value: "c", done: false }
iterator.next(); // { value: "d", done: false }
iterator.next(); // { value: "e", done: false }
iterator.next(); // { value: undefined, done: true }
console.log(iterator.next().value); // undefined
```

### 重复使用可迭代对象

**警告：** 数组迭代器对象应该是一次性使用的对象。不要重复使用它。

`values()` 返回的可迭代对象是不可重复使用的。当 `next().done = true` 或 `currentIndex > length` 时，`for...of` 循环结束，进一步迭代它没有任何效果。


```js
const arr = ["a", "b", "c", "d", "e"];
const values = arr.values();
for (const letter of values) {
  console.log(letter);
}
// "a" "b" "c" "d" "e"
for (const letter of values) {
  console.log(letter);
}
// undefined
```


如果使用 `break` 语句提前结束迭代，当继续迭代时，迭代器可以从当前位置恢复迭代。


```js
const arr = ["a", "b", "c", "d", "e"];
const values = arr.values();
for (const letter of values) {
  console.log(letter);
  if (letter === "b") {
    break;
  }
}
// "a" "b"

for (const letter of values) {
  console.log(letter);
}
// "c" "d" "e"
```

### 迭代期间的修改操作

`values()` 返回的数组迭代器对象中没有存储任何值；但是它存储了用于创建它的数组的地址，并在每次迭代中读取当前访问的索引。因此，它的迭代输出取决于在迭代时存储在该索引中的值。如果数组中的值发生了改变，数组迭代器对象的值也会改变。


```js
const arr = ["a", "b", "c", "d", "e"];
const iterator = arr.values();
console.log(iterator); // Array Iterator { }
console.log(iterator.next().value); // "a"
arr[1] = "n";
console.log(iterator.next().value); // "n"
```

### 迭代稀疏数组

`values()` 会访问空槽并将其视为 `undefined`。


```js
for (const element of [, "a"].values()) {
  console.log(element);
}
// undefined
// 'a'
```

### 在非数组对象上调用 values()

`values()` 方法读取 `this` 的 `length` 属性，然后访问每个整数索引。


```js
const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
};
for (const entry of Array.prototype.values.call(arrayLike)) {
  console.log(entry);
}
// a
// b
// c
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.values |

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

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

参见
--

* `core-js` 中 `Array.prototype.values` 的 polyfill
* 索引集合类
* `Array`
* `Array.prototype.entries()`
* `Array.prototype.keys()`
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype.values()`
* 迭代协议
Array.prototype.pop()
=====================

**`pop()`** 方法从数组中删除**最后一个**元素，并返回该元素的值。此方法会更改数组的长度。

尝试一下
----

语法
--


```js
pop()
```

### 返回值

从数组中删除的元素（当数组为空时返回 `undefined`）。

描述
--

`pop()` 方法从一个数组中删除并返回最后一个元素给调用者。如果你在空数组上调用 `pop()`，它会返回 `undefined`。

`Array.prototype.shift()` 和 `pop()` 有类似的行为，但是它是作用在数组的第一个元素上的。

`pop()` 是修改方法。其改变了 `this` 的长度和内容。如果你想要 `this` 不变，但是返回一个新的最后一个元素被移除的数组，你可以使用 `arr.slice(0, -1)` 来代替。

`pop()` 方法是通用的。它只期望 `this` 值具有 `length` 属性和整数键属性。虽然字符串也是类数组对象，但是由于其不能被修改，所以 `pop()` 方法并不能应用在字符串上。

示例
--

### 删除掉数组的最后一个元素

下面的代码首先创建了一个拥有四个元素的数组 `myFish`，然后删除掉它的最后一个元素。


```js
const myFish = ["angel", "clown", "mandarin", "sturgeon"];

const popped = myFish.pop();

console.log(myFish); // ['angel', 'clown', 'mandarin' ]

console.log(popped); // 'sturgeon'
```

### 在非数组对象上调用 pop()

`pop()` 方法会读取 `this` 上的 `length` 属性。如果规范化的 length 属性为 0，`length` 会被再次设置为 0（鉴于之前可能是负数或者 `undefined`）。否则，返回并删除位于 `length - 1` 处的属性。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  2: 4,
};
console.log(Array.prototype.pop.call(arrayLike));
// 4
console.log(arrayLike);
// { length: 2, unrelated: 'foo' }

const plainObj = {};
// 没有 length 属性，所以长度为 0
Array.prototype.pop.call(plainObj);
console.log(plainObj);
// { length: 0 }
```

### 以类数组的方式使用对象

`push` 和 `pop` 方法是通用的，我们可以利用这一点来编写更灵活的代码——如以下示例所示。

请注意，在此示例中，我们不会创建数组来存储对象集合。相反，我们将集合存储在对象本身上，并在 `Array.prototype.push` 和 `Array.prototype.pop` 上使用 `call` 来欺骗这些方法，让它们认为我们正在处理一个数组。


```js
const collection = {
  length: 0,
  addElements(...elements) {
    // 每次添加元素时
    // obj.length 都会自动增加

    // 返回 push 方法的返回值，即 length 属性的新值
    return [].push.call(this, ...elements);
  },
  removeElement() {
    // 每次移除元素时
    // obj.length 都会自动减少

    // 返回 pop 方法的返回值，即被移除的元素
    return [].pop.call(this);
  },
};

collection.addElements(10, 20, 30);
console.log(collection.length); // 3
collection.removeElement();
console.log(collection.length); // 2
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.pop |

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

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

参见
--

* 索引集合类
* `Array`
* `Array.prototype.push()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
* `Array.prototype.splice()`
Math.expm1()
============

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

语法
--
```

Math.expm1(x)
```

### 参数

`x`

任意数字。

描述
--

参数 `x` 会被自动类型转换成 `number` 类型。

`expm1` 是 "exponent minus 1" 的缩写。

示例
--


```js
Math.expm1(-Infinity); // -1
Math.expm1(-1); // -0.6321205588285577
Math.expm1(-0); // -0
Math.expm1(0); // 0
Math.expm1(1); // 1.718281828459045
Math.expm1(Infinity); // Infinity
```

规范
--

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

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

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

参见
--

* `Math` 对象。
Math.SQRT1\_2
=============

概述
--

**`Math.SQRT1_2`** 属性表示 1/2 的平方根，约为 0.707：


Math.SQRT1\_2

=

1
2

=

1

2

≈
0.707

\mathtt{\mi{Math.SQRT1\_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707



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

描述
--

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

示例
--

### 示例：使用 `SQRT1_2`

下面的函数返回 1/2 的平方根：


```js
function getRoot1\_2() {
  return Math.SQRT1\_2;
}

getRoot1\_2(); // 0.7071067811865476
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt1\_2 |

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

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

参见
--

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

**`Math.tanh()`** 函数将会返回一个数的双曲正切函数值，公式如下：



tanh
x
=

sinh
x

cosh
x

=

e
x

-

e

-
x


e
x

+

e

-
x

=

e

2
x

-
1

e

2
x

+
1

\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}

尝试一下
----

语法
--
```

Math.tanh(x)
```

### 参数

`x`

待计算的数字。

### 返回值

所给数字的双曲正切值。

描述
--

因为 `tanh()` 是 `Math` 的静态方法，所以总应该直接调用 `Math.tanh()` ，而不是创建 `Math` 对象再调用该方法（`Math` 不是一个构造函数）。

示例
--

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


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

向下兼容
----

`tanh()` 可以通过 `Math.exp()` 函数实现：


```js
Math.tanh =
  Math.tanh ||
  function (x) {
    var a = Math.exp(+x),
      b = Math.exp(-x);
    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b);
  };
```

规范
--

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

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

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

参见
--

* `Math.acosh()`
* `Math.asinh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
Math.atanh()
============

**`Math.atanh()`** 函数返回一个数值反双曲正切值，即：



∀
x
∊

(

-
1
,
1

)

,

Math.atanh
(
x
)

=
arctanh
(
x
)
=
 the unique 

y

such that

tanh
(
y
)
=
x

\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ the unique } ; y ; \text{such that} ; \tanh(y) = x

语法
--
```

Math.atanh(x)
```

### 参数

`x`

一个数值

描述
--

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

示例
--

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


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

规范
--

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

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

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

参见
--

* `Math.acosh()`
* `Math.asinh()`
* `Math.cosh()`
* `Math.sinh()`
* `Math.tanh()`
Math.ceil()
===========

**`Math.ceil()`** 静态方法总是向上舍入，并返回大于等于给定数字的最小整数。

尝试一下
----

语法
--


```js
Math.ceil(x)
```

### 参数

`x`

一个数值。

### 返回值

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

描述
--

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

示例
--

### 使用 Math.ceil()


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

规范
--

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

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

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

参见
--

* `Math.abs()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.LN2
========

概述
--

**`Math.LN2`** 属性表示 2 的自然对数，约为 0.693：


Math.LN2

=
ln
(
2
)
≈
0.693

\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693



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

描述
--

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

示例
--

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

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


```js
function getNatLog2() {
  return Math.LN2;
}

getNatLog2(); // 0.6931471805599453
```

规范
--

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

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

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

参见
--

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

概述
--

**`Math.SQRT2`** 属性表示 2 的平方根，约为 1.414：

描述
--

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

示例
--

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

下面的函数返回 2 的平方根：


```js
function getRoot2() {
  return Math.SQRT2;
}

getRoot2(); // 1.4142135623730951
```

规范
--

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

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

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

参见
--

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

**`Math.hypot()`** 函数返回所有参数的平方和的平方根，即：


𝙼𝚊𝚝𝚑.𝚑𝚢𝚙𝚘𝚝
(

v
1

,

v
2

,
…
,

v
n

)

=

∑

i
=
1

n

v
i
2

=

v
1
2

+

v
2
2

+
…
+

v
n
2

\mathtt{\operatorname{Math.hypot}(v\_1, v\_2, \dots, v\_n)} = \sqrt{\sum\_{i=1}^n v\_i^2} = \sqrt{v\_1^2 + v\_2^2 + \dots + v\_n^2}

尝试一下
----

语法
--
```

Math.hypot([value1[,value2, ...]])
```

### 参数

`value1, value2, ...`

任意个数字。

### 返回值

将所提供的参数求平方和后开平方根。如果有参数不能转换为数字，则返回 `NaN`。

描述
--

计算直角三角形的斜边，或复数的幅值时可以使用函数 `Math.sqrt(v1*v1 + v2*v2)` ，其中 v1 和 v2 是三角形的两个直角边或复数的实部和虚部。如果想计算更多维度，那么只需要在后面添加更多的数的平方就可以了，比如 `Math.sqrt(v1*v1 + v2*v2 + v3*v3 + v4*v4)`。

本函数比 `Math.sqrt()` 更简单也更快，你只需要调用 `Math.hypot(v1, v2)` 或 `Math.hypot(v1, v2, v3, v4, ...)`。

它还避免了幅值过大的问题。JS 中最大的双精度浮点数是 `Number.MAX_VALUE = 1.797...e+308`。如果你的数字比约 1e154 大，计算其平方值会返回 Infinity，使你的结果出现问题。比如，`Math.sqrt(1e200*1e200 + 1e200*1e200) = Infinity`。如果你改用 `hypot()` 函数，你可以得到正确的答案：`Math.hypot(1e200, 1e200) = 1.4142...e+200`。在数字非常小的时候同样如此，比如 `Math.sqrt(1e-200*1e-200 + 1e-200*1e-200) = 0`，但 `Math.hypot(1e-200, 1e-200) = 1.4142...e-200` 则是正确的结果。

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

如果不传入任何参数，则返回 +0。

如果参数列表中有至少一个参数不能被转换为数字，则返回 `NaN`。

如果只传入一个参数，`Math.hypot(x)` 等同于 `Math.abs(x)`。

示例
--

### Using `Math.hypot()`


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

向下兼容
----

此函数可以使用如下代码模拟：


```js
if (!Math.hypot)
  Math.hypot = function () {
    var y = 0,
      i = arguments.length;
    while (i--) y += arguments[i] \* arguments[i];
    return Math.sqrt(y);
  };
```


另一种避免结果溢出的实现：


```js
if (!Math.hypot)
  Math.hypot = function (x, y) {
    // https://bugzilla.mozilla.org/show\_bug.cgi?id=896264#c28
    var max = 0;
    var s = 0;
    for (var i = 0; i < arguments.length; i += 1) {
      var arg = Math.abs(Number(arguments[i]));
      if (arg > max) {
        s \*= (max / arg) \* (max / arg);
        max = arg;
      }
      s += arg === 0 && max === 0 ? 0 : (arg / max) \* (arg / max);
    }
    return max === 1 / 0 ? 1 / 0 : max \* Math.sqrt(s);
  };
```

规范
--

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

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

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

参见
--

* `Math.abs()`
* `Math.pow()`
* `Math.sqrt()`
Math.E
======

概述
--

**`Math.E`** 属性表示自然对数的底数（或称为基数），e，约等于 2.718。


Math.E

=
e
≈
2.718

\mathtt{\mi{Math.E}} = e \approx 2.718



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

描述
--

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

示例
--

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

下面的函数返回 e：


```js
function getNapier() {
  return Math.E;
}

getNapier(); // 2.718281828459045
```

规范
--

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

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

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

参见
--

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

概述
--

**`Math.log2()`** 函数返回一个数字以 2 为底的对数。

语法
--
```

Math.log2(x)
```

### 参数

`x`

任意数字。

描述
--

如果传入的参数小于 0，则返回 `NaN`.

示例
--


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

规范
--

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

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

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

参见
--

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