recursal/MDN huggingface dataset:
Groups and ranges
=================

组和范围表示表达式字符的 组和范围

尝试一下
----

类型
--

| 字符集 | 含义 |
| --- | --- |
| `*x*|*y*` | 
 匹配 "x" 或 "y" 任意一个字符。例如， `/green|red/` 在
 "green apple" 里匹配 "green"，且在 "red apple" 里匹配 "red" 。
  |
| `[xyz][a-c]` | 
 字符集。
 匹配任何一个包含的字符。你可以使用连字符来指定字符范围，但如果连字符显示为方括号中的第一个或最后一个字符，则它将被视为作为普通字符包含在字符集中的文字连字符。也可以在字符集中包含字符类。


 例如，`[abcd]` 是与`[a-d]`.一样的，它们会
 在"brisket" 中匹配 "b",在 "chop" 中匹配 "c" .


 例如，`[abcd-]` 和`[-abcd]` 将会在 "brisket"
 匹配 "b" , 在 "chop" 匹配 "c" , 并且匹配 "non-profit" 中的 "-"
 (连字符)


 例如，`[\w-]` 是字符集 \w 和
 “-”（连字符）的并集，与这种写法一样：
 `[A-Za-z0-9_-]`.。他们都会 在 "brisket"中匹配“b”, 在
 "chop"中匹配“c”, 在 "non-profit" 中匹配 "n"。
  |
| `[^xyz][^a-c]` | 
 一个否定的或被补充的字符集。也就是说，它匹配任何没有包含在括号中的字符。可以通过使用连字符来指定字符范围，但是如果连字符作为方括号中的第一个或最后一个字符出现，那么它将被视为作为普通字符包含在字符集中。例如，[^abc]
 和 [^a-c] 一样。它们最初匹配“bacon”中的“o”和“chop”中的“h”。


**备注：** ^ 字符也可以表示
 输入的起始 (en-US)

 |
| `(*x*)` | 
**捕获组：**匹配 x
 并记住匹配项。例如，/(foo)/匹配并记住“foo bar”中的“foo”


 正则表达式可以有多个捕获组。结果，匹配通常在数组中捕获的组，该数组的成员与捕获组中左括号的顺序相同。这通常只是捕获组本身的顺序。当捕获组被嵌套时，这一点非常重要。使用结果元素的索引
 (`[1], ..., [n]`) 或从预定义的
 `RegExp` 对象的属性 (`$1, ..., $9`).


 捕获组会带来性能损失。如果不需要收回匹配的子字符串，请选择非捕获括号
 (见下面)。


`String.match()`
 不会返回组，如果设置了 `/.../g` 标志。但是，你仍然可以使用
 `String.matchAll()`
 to get all matches.


 match() 不会返回组，如果/…但是，你仍然可以使用 String.matchAll()
 来获取所有匹配项。
  |
| `\*n*` | 
 其中 n 是一个正整数。对正则表达式中与 n
 括号匹配的最后一个子字符串的反向引用 (计算左括号)。例如，`/apple(,)\sorange\1/`
 匹配“apple, orange, cherry, peach”中的 "apple, orange,"，其中
 `\1` 引用了 之前使用 `()` 捕获的
 `,`
 |
| `(?<Name>x)` | 
**具名捕获组：**匹配"x"并将其存储在返回的匹配项的 groups
 属性中，该属性位于`<Name>`指定的名称下。尖括号 (`<`
 和 `>`) 用于组名。


 例如，使用正则 `/-(?<customName>\w)/` 匹配“web-doc”
 中的“d”

`'web-doc'.match(/-(?<customName>\w)/).groups //{customName:
"d"}` |
| `(?:*x*)` | **非捕获组：**匹配
 “x”，但不记得匹配。不能从结果数组的元素中收回匹配的子字符串 (`[1], ..., [n]`) or from the predefined `RegExp` object's properties (`$1, ..., $9`).
  |

示例
--

### 使用组


```js
let personList = `First\_Name: John, Last\_Name: Doe
First\_Name: Jane, Last\_Name: Smith`;

let regexpNames = /First\_Name: (\w+), Last\_Name: (\w+)/gm;
let match = regexpNames.exec(personList);
do {
  console.log(`Hello ${match[1]} ${match[2]}`);
} while ((match = regexpNames.exec(personList)) !== null);
```

### 使用命名组


```js
let users = `姓氏：李，名字：雷
姓氏：韩，名字：梅梅`;

let regexpNames = /姓氏：(?<first>.+)，名字：(?<last>.+)/gm;
let match = regexpNames.exec(users);

do {
  console.log(`Hello ${match.groups.first} ${match.groups.last}`);
} while ((match = regexpNames.exec(users)) !== null);

// Hellow 李 雷
// Hellow 韩 梅梅
```

参见
--

* 正则表达式指南
    + 字符类
    + 断言
    + 量词
    + Unicode 属性转义
* 正则构造函数
量词
==

量词表示要匹配的字符或表达式的数量。

尝试一下
----

类型
--

| Characters | Meaning |
| --- | --- |
| `*x**` | 
 将前面的项“x”匹配 0 次或更多次。例如，/bo\*/匹配“A ghost
 booooed”中的“boooo”和“A bird warbled”中的“b”，但在“A goat
 grunt”中没有匹配。
  |
| `*x*+` | 
 将前一项“x”匹配 1
 次或更多次。等价于 `{1,}`。例如，`/a+/` 匹配“candy”中的“a”和“caaaaaaandy”中的所有“a”。
  |
| `*x*?` | 
 将前面的项“x”匹配 0 或 1 次。例如，/e?le?/匹配 angel 中的 el 和 angle
 中的 le。


 如果立即在任何量词\*、+、?或{}之后使用，则使量词是非贪婪的
 (匹配最小次数)，而不是默认的贪婪的 (匹配最大次数)。
  |
| `*x*{*n*}` | 其中“n”是一个正整数，与前一项“x”的 n 次匹配。例如，`/a{2}/` 不匹配“candy”中的“a”，但它匹配“caandy”中的所有“a”，以及“caaandy”中的前两个“a”。 |
| `*x*{*n*,}` | 
 其中，“n”是一个正整数，与前一项“x”至少匹配“n”次。例如，`/a{2，}/`不匹配“candy”中的“a”，但匹配“caandy”和“caaaaaaandy”中的所有
 a。
  |
| `*x*{*n*,*m*}` | 
 其中，“n”是 0 或一个正整数，“m”是一个正整数，而 m > n
 至少与前一项“x”匹配，最多与“m”匹配。例如，/a{1,3}/不匹配“cndy”中的“a”，“candy”中的“a”，“caandy”中的两个“a”，以及“caaaaaaandy”中的前三个“a”。注意，当匹配“caaaaaaandy”时，匹配的是“aaa”，即使原始字符串中有更多的“a”。
  |
| `*x**?``*x*+?``*x*??``*x*{n}?``*x*{n,}?``*x*{n,m}?` | 
 默认情况下，像 `*` 和
 `+` 这样的量词是“贪婪的”，这意味着它们试图匹配尽可能多的字符串。?量词后面的字符使量词“非贪婪”：意思是它一旦找到匹配就会停止。例如，给定一个字符串“some
 <foo> <bar> new </bar> </foo> thing”:
 * `/<.*>/` will match "<foo> <bar> new
 </bar> </foo>"
* `/<.*?>/` will match "<foo>"
 |

举例说明
----

### 重复模式


```js
var wordEndingWithAs = /\w+a+/;
var delicateMessage = "This is Spartaaaaaaa";

console.table(delicateMessage.match(wordEndingWithAs)); // [ "Spartaaaaaaa" ]
```

### 计算字符集


```js
var singleLetterWord = /\b\w\b/g;
var notSoLongWord = /\b\w{1,6}\b/g;
var loooongWord = /\b\w{13,}\b/g;

var sentence = "Why do I have to learn multiplication table?";

console.table(sentence.match(singleLetterWord)); // ["I"]
console.table(sentence.match(notSoLongWord)); // [ "Why", "do", "I", "have", "to", "learn", "table" ]
console.table(sentence.match(loooongWord)); // ["multiplication"] 可选可选字符
```

### 可选字符


```js
var britishText = "He asked his neighbour a favour.";
var americanText = "He asked his neighbor a favor.";

var regexpEnding = /\w+ou?r/g;
// \w+ One or several letters
// o followed by an "o",
// u? optionally followed by a "u"
// r followed by an "r"

console.table(britishText.match(regexpEnding));
// ["neighbour", "favour"]

console.table(americanText.match(regexpEnding));
// ["neighbor", "favor"]
```

### 贪婪 与 非贪婪的


```js
var text = "I must be getting somewhere near the centre of the earth.";
var greedyRegexp = /[\w ]+/;
// [\w ] a letter of the latin alphabet or a whitespace
// + one or several times

console.log(text.match(greedyRegexp)[0]);
// "I must be getting somewhere near the centre of the earth"
// almost all of the text matches (leaves out the dot character)

var nonGreedyRegexp = /[\w ]+?/; // Notice the question mark
console.log(text.match(nonGreedyRegexp));
// "I"
// The match is the smallest one possible
```

参见
--

* Regular expressions guide
    + Character classes
    + Assertions
    + Unicode property escapes
    + Groups and ranges
* The `RegExp()` constructor
JavaScript 标准内置对象
=================

本章介绍和说明了 JavaScript 中所有的标准内置对象、以及它们的方法和属性。

这里的术语“全局对象”（或标准内置对象）不应与 **global 对象**混淆。这里的“全局对象”指的是**处在全局作用域里的多个对象**。

**global 对象**可以在全局作用域里通过使用 `this` 访问到（但只有在 ECMAScript 5 的非严格模式下才可以，在严格模式下得到的是 `undefined`）。其实全局作用域**包含**全局对象中的属性，包括它可能继承来的属性。

全局作用域中的其他对象则可由用户的脚本创建，或由宿主程序提供。浏览器环境中所提供的宿主对象的说明可以在这里找到：API 参考。

要了解关于 DOM 和核心 JavaScript 之间区别的更多信息，可参阅 JavaScript 技术概述。

标准内置对象分类
--------

### 值属性

这些全局属性返回一个简单值，这些值没有自己的属性和方法。

* `globalThis`
* `Infinity`
* `NaN`
* `undefined`
### 函数属性

全局函数可以直接调用，不需要在调用时指定所属对象，执行结束后会将结果直接返回给调用者。

* `eval()`
* `isFinite()`
* `isNaN()`
* `parseFloat()`
* `parseInt()`
* `decodeURI()`
* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()`
* `escape()` 
已弃用
* `unescape()` 
已弃用
### 基本对象

基本对象是定义或使用其他对象的基础。

* `Object`
* `Function`
* `Boolean`
* `Symbol`

#### 错误对象

错误对象是一种特殊的基本对象。它们拥有基本的 `Error` 类型，同时也有多种具体的错误类型。

* `Error`
* `AggregateError`
* `EvalError`
* `RangeError`
* `ReferenceError`
* `SyntaxError`
* `TypeError`
* `URIError`
* `InternalError` 
非标准
### 数字和日期对象

用来表示数字、日期和执行数学计算的对象。

* `Number`
* `BigInt`
* `Math`
* `Date`
### 字符串

这些对象表示字符串并支持操作字符串。

* `String`
* `RegExp`
### 可索引的集合对象

这些对象表示按照索引值来排序的数据集合，包括数组和类型数组，以及类数组结构的对象。

* `Array`
* `Int8Array`
* `Uint8Array`
* `Uint8ClampedArray`
* `Int16Array`
* `Uint16Array`
* `Int32Array`
* `Uint32Array`
* `BigInt64Array`
* `BigUint64Array` (en-US)
* `Float32Array`
* `Float64Array`
### 使用键的集合对象

这些集合对象在存储数据时会使用到键，包括可迭代的 `Map` 和 `Set`，支持按照插入顺序来迭代元素。

* `Map`
* `Set`
* `WeakMap`
* `WeakSet`
### 结构化数据

这些对象用来表示和操作结构化的缓冲区数据，或使用 JSON（JavaScript Object Notation）编码的数据。

* `ArrayBuffer`
* `SharedArrayBuffer`
* `Atomics`
* `DataView`
* `JSON`
### 内存管理对象

这些对象会与垃圾回收机制产生交互。

* `WeakRef`
* `FinalizationRegistry` (en-US)
### 控制抽象对象

控件抽象对象可以帮助构造代码，尤其是异步代码（例如不使用深度嵌套的回调）。

* `Iterator`
* `AsyncIterator`
* `Promise`
* `GeneratorFunction`
* `AsyncGeneratorFunction`
* `Generator`
* `AsyncGenerator`
* `AsyncFunction`
### 反射

* `Reflect`
* `Proxy`
### 国际化

ECMAScript 核心的附加功能，用于支持多语言处理。

* `Intl`
* `Intl.Collator`
* `Intl.DateTimeFormat`
* `Intl.DisplayNames`
* `Intl.DurationFormat` (en-US)
* `Intl.ListFormat`
* `Intl.Locale`
* `Intl.NumberFormat`
* `Intl.PluralRules`
* `Intl.RelativeTimeFormat`
* `Intl.Segmenter`
尾后逗号
====

**尾后逗号** （有时叫做“终止逗号”）在向 JavaScript 代码添加元素、参数、属性时十分有用。如果你想要添加新的属性，并且上一行已经使用了尾后逗号，你可以仅仅添加新的一行，而不需要修改上一行。这使得版本控制的代码比较（diff）更加清晰，代码编辑过程中遇到的麻烦更少。

JavaScript 一开始就支持数组字面量中的尾后逗号，随后向对象字面量（ECMAScript 5）中添加了尾后逗号。最近（ECMAScript 2017），又将其添加到函数参数中。

但是，JSON 不允许尾后逗号。

字面量中的尾后逗号
---------

### 数组

JavaScript 忽略数组中的尾后逗号：


```js
const arr = [
  1,
  2,
  3,
];

arr; // [1, 2, 3]
arr.length; // 3
```


如果使用了多于一个尾后逗号，会产生省略（elision，或者间隙 hole）。带有间隙的数组叫做*稀疏*数组（*sparse* 紧凑数组 *dense* array 没有省略/间隙）。例如，当使用 `Array.prototype.forEach()` 或 `Array.prototype.map()` 迭代数组时，会跳过数组间隙。


```js
const arr = [1, 2, 3, , ,];
arr.length; // 5
```

### 对象

从 ECMAScript 5 开始，对象字面值中的尾后逗号也是符合语法的：


```js
const object = {
  foo: "bar",
  baz: "qwerty",
  age: 42,
};
```

函数中的尾后逗号
--------

ECMAScript 2017 支持函数参数中的尾后逗号。

### 参数定义

下面的两个函数定义都是合法的，并且互相等价。尾后逗号并不影响函数定义，或者其 `arguments` 对象的 `length` 属性。


```js
function f(p) {}
function f(p,) {}

(p) => {};
(p,) => {};
```


尾后逗号也可用于类或对象的方法定义。


```js
class C {
  one(a,) {}
  two(a, b,) {}
}

const obj = {
  one(a,) {},
  two(a, b,) {},
};
```

### 函数调用

下面的两个函数调用都是合法的，并且互相等价。


```js
f(p);
f(p,);

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

### 不合法的尾后逗号

仅仅包含逗号的函数参数定义或者函数调用会抛出 `SyntaxError`。而且，当使用剩余参数的时候，并不支持尾后逗号：


```js
function f(,) {} // SyntaxError: missing formal parameter
(,) => {};       // SyntaxError: expected expression, got ','
f(,)             // SyntaxError: expected expression, got ','

function f(...p,) {} // SyntaxError: parameter after rest parameter
(...p,) => {}        // SyntaxError: expected closing parenthesis, got ','
```

解构中的尾后逗号
--------

在使用解构赋值时，尾后逗号也可以用于左侧：


```js
// 带有尾后逗号的数组解构
[a, b,] = [1, 2];

// 带有尾后逗号的对象解构
const o = {
  p: 42,
  q: true,
};
const { p, q, } = o;
```


同样地，在使用剩余参数时，会抛出 `SyntaxError`：


```js
const [a, ...b,] = [1, 2, 3];
// SyntaxError: rest element may not have a trailing comma
```

JSON 中的尾后逗号
-----------

对象中的尾后逗号仅仅在 ECMAScript 5 中引入。由于 JSON 基于 ES5 之前的语法， **JSON 中并不允许尾后逗号**。

下面两行都会抛出 `SyntaxError`：


```js
JSON.parse("[1, 2, 3, 4, ]");
JSON.parse('{"foo" : 1, }');
// SyntaxError JSON.parse: unexpected character
// at line 1 column 14 of the JSON data
```


去掉尾后逗号就行了：


```js
JSON.parse("[1, 2, 3, 4 ]");
JSON.parse('{"foo" : 1 }');
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # prod-Elision |
| ECMAScript Language Specification # prod-ObjectLiteral |
| ECMAScript Language Specification # prod-ArrayLiteral |
| ECMAScript Language Specification # prod-Arguments |
| ECMAScript Language Specification # prod-FormalParameters |
| ECMAScript Language Specification # prod-CoverParenthesizedExpressionAndArrowParameterList |
| ECMAScript Language Specification # prod-NamedImports |
| ECMAScript Language Specification # prod-NamedExports |
| ECMAScript Language Specification # prod-QuantifierPrefix |
| ECMAScript Language Specification # prod-annexB-InvalidBracedQuantifier |

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

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

参见
--

* ECMAScript 初始提案：函数的尾后逗号（由 Jeff Morrison 提出）
语句和声明
=====

JavaScript 应用程序是由许多语法正确的语句组成的。单个语句可以跨多行。如果每个语句用分号隔开，那么多个语句可以在一行中出现。本页的内容并不是一个关键字，而是一组关键字。

语句和声明（按类别分类）
------------

若需要按字母顺序排列的列表，请参阅左侧边栏。

### 控制流程

`Block`

一个块语句可以用来管理零个或多个语句。该区块是由一对大括号分隔。

`break`

终止当前的循环，switch 或 label 语句，使程序跳到下一个语句执行。

`continue`

终止执行当前或标签循环的语句，直接执行下一个迭代循环。

`Empty`

空语句用来表示没有语句的情况，尽管 JavaScript 语法期望有语句提供。

`if...else`

如果指定的条件是 true，则执行相匹配的一个语句，若为 false，则执行另一个语句。

`switch`

计算表达式，将子句于表达式的值做匹配，执行与该值相关联的语句。

`throw`

抛出一个用户定义的异常。

`try...catch`

标记一个语句块，并指定一个应该抛出异常的反馈。（Marks a block of statements to try, and specifies a response, should an exception be thrown.）

### 声明

`var`

声明一个变量，可同时将其初始化为一个值。

`let`

声明一个块级本地变量，可同时将其初始化为一个值。

`const`

声明一个只读的命名常量。

### 函数和类

`function`

声明一个指定参数的函数。

`function*`

生成器函数使迭代器更容易使用。

`async function`

使用指定的参数声明一个异步函数。

`return`

指定函数的返回值。

`class`

声明一个类。

### 迭代器

`do...while`

创建一个循环来执行语句，直到该语句条件表达式的值为 false。先执行语句，再执行条件表达式，该语句至少会执行一次。

`for`

创建一个由 3 个可选的表达式组成的循环，该循环用括号包裹，分号分割，并在循环体中执行语句。

`for...in`

无序遍历对象的可枚举属性。语句针对每个唯一的属性。

`for...of`

遍历可迭代的对象（包括 `数组`、类数组对象、迭代器和生成器)，对每个不同属性的属性，调用一个自定义的有执行语句的迭代钩子。

`for await...of`

在异步可迭代对象、类数组对象、迭代器和生成器上迭代，调用自定义迭代钩子，其中包含要为每个不同属性的值执行的语句。

`while`

创建一个循环语句，循环会一直持续到该语句条件表达式的值为 false。先执行条件表达式，然后执行语句。

### 其他

`debugger`

调用可用的调试功能。如果没有调试功能可用，该语句不生效。

`export`

用来导出函数，以便这些函数能够被导入到外部模块或其他脚本中。

`import`

用来引入外部的模块或另一个 script 中导出的函数。

`import.meta`

向 JavaScript 模块公开上下文特定的元数据的元属性。

`label`

带标识的语句，与 `break` 或 `continue` 语句一起使用。

`with` 
已弃用

拓展一个语句的作用域。

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

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

参见
--

* 表达式和操作符
escape()
========

**已弃用:** 不再推荐使用该特性。虽然一些浏览器仍然支持它，但也许已从相关的 web 标准中移除，也许正准备移除或出于兼容性而保留。请尽量不要使用该特性，并更新现有的代码；参见本页面底部的兼容性表格以指导你作出决定。请注意，该特性随时可能无法正常工作。

概览
--

废弃的 **`escape()`** 方法生成新的由十六进制转义序列替换的字符串。使用 `encodeURI` 或 `encodeURIComponent` 代替。

语法
--
```

escape(str)
```

### 参数

`str`

待编码的字符串。

描述
--

`escape` 函数是全局对象的属性。特色字符如：`@*_+-./` 被排除在外。

字符的 16 进制格式值，当该值小于等于 0xFF 时，用一个 2 位转义序列：`%xx` 表示。大于的话则使用 4 位序列：%**u**xxxx 表示。

示例
--


```js
escape("abc123"); // "abc123"
escape("äöü"); // "%E4%F6%FC"
escape("ć"); // "%u0107"

// special characters
escape("@\*\_+-./"); // "@\*\_+-./"
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-escape-string |

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

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

其他链接
----

* `encodeURI`
* `encodeURIComponent`
Math
====

**`Math`** 是一个内置对象，它拥有一些数学常数属性和数学函数方法。`Math` 不是一个函数对象。

`Math` 用于 `Number` 类型。它不支持 `BigInt`。

描述
--

与其他全局对象不同的是，`Math` 不是一个构造器。`Math` 的所有属性与方法都是静态的。引用圆周率的写法是 `Math.PI`，调用正余弦函数的写法是 `Math.sin(x)`，`x` 是要传入的参数。`Math` 的常量是使用 JavaScript 中的全精度浮点数来定义的。

属性
--

`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` 的平方根的倒数 


1

2

，约等于 `0.707`。


`Math.SQRT2`

`2` 的平方根，约等于 `1.414`。

方法
--

**备注：** 需要注意的是，三角函数 `sin()`、`cos()`、`tan()`、`asin()`、`acos()`、`atan()` 和 `atan2()` 返回的值是*弧度*而非角度。若要转换，弧度除以 `(Math.PI / 180)` 即可转换为角度，同理，角度乘以这个数则能转换为弧度。

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

`Math.abs(x)`

返回一个数的绝对值。

`Math.acos(x)`

返回一个数的反余弦值。

`Math.acosh(x)`

返回一个数的反双曲余弦值。

`Math.asin(x)`

返回一个数的反正弦值。

`Math.asinh(x)`

返回一个数的反双曲正弦值。

`Math.atan(x)`

返回一个数的反正切值。

`Math.atanh(x)`

返回一个数的反双曲正切值。

`Math.atan2(y, x)`

返回 `y/x` 的反正切值。

`Math.cbrt(x)`

返回一个数的立方根。

`Math.ceil(x)`

返回大于一个数的最小整数，即一个数向上取整后的值。

`Math.clz32(x)`

返回一个 32 位整数的前导零的数量。

`Math.cos(x)`

返回一个数的余弦值。

`Math.cosh(x)`

返回一个数的双曲余弦值。

`Math.exp(x)`

返回欧拉常数的参数次方，`E^x`，其中 `x` 为参数，`E` 是欧拉常数（2.718...，自然对数的底数）。

`Math.expm1(x)`

返回 `exp(x) - 1` 的值。

`Math.floor(x)`

返回小于一个数的最大整数，即一个数向下取整后的值。

`Math.fround(x)`

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

`Math.hypot([x[, y[, …]]])`

返回其所有参数平方和的平方根。

`Math.imul(x, y)`

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

`Math.log(x)`

返回一个数的自然对数（㏒e，即 ㏑）。

`Math.log1p(x)`

返回一个数加 1 的和的自然对数（㏒e，即 ㏑）。

`Math.log10(x)`

返回一个数以 10 为底数的对数。

`Math.log2(x)`

返回一个数以 2 为底数的对数。

`Math.max([x[, y[, …]]])`

返回零到多个数值中最大值。

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

返回零到多个数值中最小值。

`Math.pow(x, y)`

返回一个数的 y 次幂。

`Math.random()`

返回一个 0 到 1 之间的伪随机数。

`Math.round(x)`

返回四舍五入后的整数。

`Math.sign(x)`

返回一个数的符号，得知一个数是正数、负数还是 0。

`Math.sin(x)`

返回一个数的正弦值。

`Math.sinh(x)`

返回一个数的双曲正弦值。

`Math.sqrt(x)`

返回一个数的平方根。

`Math.tan(x)`

返回一个数的正切值。

`Math.tanh(x)`

返回一个数的双曲正切值。

`Math.toSource()`

返回字符串 `"Math"`。

`Math.trunc(x)`

返回一个数的整数部分，直接去除其小数点及之后的部分。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-math-object |

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

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

参见
--

* `Number`
Generator
=========

**`Generator`** 对象由生成器函数返回并且它符合可迭代协议和迭代器协议。

`Generator` 是隐藏类 `Iterator` 的子类。

尝试一下
----

构造函数
----

`Generator` 构造函数并不是全局可用的。`Generator` 的实例必须从生成器函数返回：


```js
function\* generator() {
  yield 1;
  yield 2;
  yield 3;
}

const gen = generator(); // "Generator { }"

console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // 3
```


实际上，并没有对应 `Generator` 构造函数的 JavaScript 实体。只有一个隐藏对象，其是所有由生成器函数创建的对象所共享的原型对象。这个对象通常被风格化为 `Generator.prototype` 来使其看起来像是一个类，但它更恰当的称呼应该是 `GeneratorFunction.prototype.prototype`，因为 `GeneratorFunction` 是一个实际的 JavaScript 实体。

实例属性
----

这些属性定义于 `Generator.prototype` 并由所有 `Generator` 实例所共享。

`Generator.prototype.constructor`

创建实例对象的构造函数。对于 `Generator` 实例，其初始值是 `GeneratorFunction.prototype`。

**备注：** `Generator` 对象不会存储创建它们的生成器函数的引用。

`Generator.prototype[@@toStringTag]`

`@@toStringTag` 属性的初始值是字符串 `"Generator"`。该属性被 `Object.prototype.toString()` 使用。

实例方法
----

*同时也从其父类 `Iterator` 继承实例方法*。

`Generator.prototype.next()`

返回 `yield` 表达式生成的值。

`Generator.prototype.return()`

类似于在当前的生成器主体的暂停位置插入 `return` 语句，该语句结束了生成器并且允许生成器与 `try...finally` 块相组合时，执行任何清理任务。

`Generator.prototype.throw()`

类似于在当前的生成器主体的暂停位置插入 `throw` 语句，该语句通知生成器有错误的情况并且允许其处理错误或执行清理并自行关闭。

示例
--

### 无穷迭代器

通过生成器函数，值只有在其被需要时才会进行计算。因此，生成器允许我们定义一个潜在的无穷数据结构。


```js
function\* infinite() {
  let index = 0;

  while (true) {
    yield index++;
  }
}

const generator = infinite(); // "Generator { }"

console.log(generator.next().value); // 0
console.log(generator.next().value); // 1
console.log(generator.next().value); // 2
// …
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator-objects |

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

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

参见
--

* `function*`
* `function*` 表达式
* `GeneratorFunction`
* 迭代器协议
Intl
====

**`Intl`** 对象是 ECMAScript 国际化 API 的一个命名空间，它提供了精确的字符串对比、数字格式化，和日期时间格式化。`Collator`，`NumberFormat` 和 `DateTimeFormat` 对象的构造函数是 `Intl` 对象的属性。本页文档内容包括了这些属性，以及国际化使用的构造器和其他语言的方法等常见的功能。

属性
--

`Intl.Collator`

collators 的构造函数，用于启用对语言敏感的字符串比较的对象。

`Intl.DateTimeFormat`

用于启用语言敏感的日期和时间格式的对象的构造函数。

`Intl.ListFormat`

Constructor for objects that enable language-sensitive list formatting.

`Intl.NumberFormat`

用于启用语言敏感数字格式的对象的构造函数。

`Intl.PluralRules`

用于启用多种敏感格式和多种语言语言规则的对象的构造函数。

`Intl.RelativeTimeFormat`

Constructor for objects that enable language-sensitive relative time formatting.

方法
--

`Intl.getCanonicalLocales()`

返回规范区域名称（canonical locale name）。

语言区域识别和判定
---------

国际化的构造函数和其他构造函数的几个语言敏感的方法（可参考下方的参见）一样，使用同样的模式来识别语言区域和确定使用哪一种语言格式：他们都接收 `locales` 和 `options` 参数，使用 `options.localeMatcher` 属性指定的一个算法来对比应用请求的和支持的语言区域，来确定使用哪一个语言区域。

### `locales` 参数

`locales` 参数必须是一个 BCP 47 语言标记的字符串，或者是一个包括多个语言标记的数组。如果 `locales` 参数未提供或者是 undefined，便会使用运行时默认的 locale。

一个 BCP 47 语言标记代表了一种语言或者区域（两者没有很大的区别）。在其最常见的格式中，它以这样的顺序囊括了这些内容：语言代码，脚本代码，和国家代码，全部由连字符分隔开。例如：

* `"hi"`：印地语 (primary language)。
* `"de-AT"`: 在奥地利使用的德语 (primary language with country code)。
* `"zh-Hans-CN"`：在中国使用的简体中文 (primary language with script and country codes)。

在 BCP 47 中表示语言，脚本，国家（区域）和变体（少用）的语言子标记含义可以在IANA 语言子标记注册 中找到。

BCP 47 也支持扩展，其中一个和 JavaScript 国际化方法相关的是："u"（Unicode）扩展。它可以用于请求一个自定义区域特定行为的 `Collator`，`NumberFormat`，或者 `DateTimeFormat` 对象。例如：

* `"de-DE-u-co-phonebk"`：使用德语的电话簿排序变体，这会把元音变音扩展成字符对：ä → ae, ö → oe, ü → ue。
* `"th-TH-u-nu-thai"`：在数字格式中使用泰语的数值表示（๐, ๑, ๒, ๓, ๔, ๕, ๖, ๗, ๘, ๙）
* `"ja-JP-u-ca-japanese"`：在日期和时间格式化中使用日本的日历表示方式，所以 2013 会表示为平成 25。
* `"en-GB-u-ca-islamic"`: use British English with the Islamic (Hijri) calendar, where the Gregorian date 14 October, 2017 is the Hijri date 24 Muharram, 1439.
### 语言区域判定

`locales` 参数，在除去所有的 Unicode 扩展之后，会被转化成来自应用的优先请求。运行时拿它和可用的语言区域做对比然后选择出最合适的一个。有两种匹配算法：“查找”匹配遵循 BCP 47 中指定的查找算法；“最佳命中”匹配器会让运行时至少提供一个语言区域，但合适请求的结果可能会比查找算法的要多。如果应用没有提供一个 locales 参数，或者运行时没有一个匹配请求的语言区域，那么会使用运行时默认的语言区域。匹配器可以使用 `options` 参数的一个属性来进行选择（见下方）。

如果选中的语言标记有一个 Unicode 扩展子字符串，这个扩展会用于自定义构造对象或者方法的行为。每一个构造函数或者方法仅支持 Unicode 扩展定义的 key 的一个子集，和依赖于语言标记的支持的值。例如，`“co”`这个 key（collation）只在 `Collator` 中支持，它的值“phonebk”只在德语中支持。

### `options` 参数

`options` 参数必须是一个对象，其属性值在不同的构造函数和方法中会有所变化。如果 `options` 参数未提供或者为 undefined，所有的属性值则使用默认的。

所有语言敏感的构造函数和方法都支持的一个属性是：`localeMatcher` 属性，它的值必须是字符串“lookup”或者“best fit”，用于选择上边描述的语言区域匹配算法。

规范
--

| Specification |
| --- |
| ECMAScript Internationalization API Specification # intl-object |

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

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

参见
--

* 介绍：The ECMAScript Internationalization API
* 构造函数
    + `Intl.Collator`
    + `Intl.DateTimeFormat`
    + `Intl.ListFormat`
    + `Intl.NumberFormat`
    + `Intl.PluralRules`
    + `Intl.RelativeTimeFormat`
* 方法
    + `String.prototype.localeCompare()`
    + `Number.prototype.toLocaleString()`
    + `Date.prototype.toLocaleString()`
    + `Date.prototype.toLocaleDateString()`
    + `Date.prototype.toLocaleTimeString()`
URIError
========

**`URIError`** 对象用来表示以一种错误的方式使用全局 URI 处理函数而产生的错误。

`URIError` 是 可序列化对象，所以可以使用 `structuredClone()` 克隆它，或者在 Worker 间使用 `postMessage()` 拷贝这个对象。

构造函数
----

`URIError()` (en-US)

创建一个新的 `URIError` 对象。

实例属性
----

`URIError.prototype.message`

错误消息。继承自 `Error`。

`URIError.prototype.name`

错误名称。继承自 `Error`。

`URIError.prototype.cause`

导致错误的原因。继承自 `Error`。

`URIError.prototype.fileName` 
非标准

引发此错误的文件的路径。继承自 `Error`。

`URIError.prototype.lineNumber` 
非标准

引发此错误的代码所在的文件的行号。继承自 `Error`。

`URIError.prototype.columnNumber` 
非标准

引发此错误的代码在文件中所在行的列号。继承自 `Error`。

`URIError.prototype.stack` 
非标准

堆栈跟踪。继承自 `Error`。

示例
--

### 捕获一个 URIError


```js
try {
  decodeURIComponent("%");
} catch (e) {
  console.log(e instanceof URIError); // true
  console.log(e.message); // "malformed URI sequence"
  console.log(e.name); // "URIError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### 创建一个 URIError


```js
try {
  throw new URIError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof URIError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "URIError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-urierror |

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

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

参见
--

* `Error`
* `decodeURI()`
* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()`
GeneratorFunction
=================

**`GeneratorFunction`** 对象为生成器函数提供了方法。在 JavaScript 中，每个生成器函数实际上都是一个 `GeneratorFunction` 对象。

请注意，`GeneratorFunction` *不是*全局对象。可以通过以下代码来获取它：


```js
const GeneratorFunction = function\* () {}.constructor;
```


`GeneratorFunction` 是 `Function` 的子类。

尝试一下
----

构造函数
----

`GeneratorFunction()`

创建一个新的 `GeneratorFunction` 对象。

实例属性
----

*也从其父类 `Function` 继承实例属性*。

这些属性定义于 `GeneratorFunction.prototype` 并由所有 `GeneratorFunction` 实例所共享。

`GeneratorFunction.prototype.constructor`

创建实例对象的构造函数。对于 `GeneratorFunction` 实例，其初始值是 `GeneratorFunction` 构造函数。

`GeneratorFunction.prototype.prototype`

所有生成器函数共享同一个 `prototype` 属性，即 `Generator.prototype`。每个生成器函数实例也有自己的 `prototype` 属性。当生成器函数被调用时，返回的生成器对象从生成器函数继承 `prototype` 属性，而该属性又继承自 `GeneratorFunction.prototype.prototype`。

`GeneratorFunction.prototype[@@toStringTag]`

`@@toStringTag` 属性的初始值是字符串 `"GeneratorFunction"`。该属性被 `Object.prototype.toString()` 使用。

实例方法
----

*从其父类 `Function` 继承实例方法*。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-generatorfunction-objects |

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

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

参见
--

* `function*`
* `function*` 表达式
* `Function`
* `AsyncFunction`
* `AsyncGeneratorFunction`
* 函数