recursal/MDN huggingface dataset:
encodeURI()
===========

**`encodeURI()`** 函数通过将特定字符的每个实例替换为一个、两个、三或四转义序列来对统一资源标识符 (URI) 进行编码 (该字符的 UTF-8 编码仅为四转义序列) 由两个 "代理" 字符组成)。

语法
--
```

encodeURI(URI)
```

### 参数

`URI`

一个完整的 URI。

### 返回值

一个新字符串，表示提供的字符串编码为统一资源标识符 (URI)。

描述
--

假定一个 URI 是完整的 URI，那么无需对那些保留的并且在 URI 中有特殊意思的字符进行编码。
```

http://username:password@www.example.com:80/path/to/file.php?foo=316&bar=this+has+spaces#anchor
```


`encodeURI` 会替换所有的字符，但不包括以下字符，即使它们具有适当的 UTF-8 转义序列：

| 类型 | 包含 |
| --- | --- |
| 保留字符 | `;` `,` `/` `?` `:` `@` `&` `=` `+` `$` |
| 非转义的字符 | 字母 数字 `-` `_` `.` `!` `~` `*` `'` `(` `)` |
| 数字符号 | `#` |

请注意，`encodeURI` 自身*无法*产生能适用于 HTTP GET 或 POST 请求的 URI，例如对于 XMLHTTPRequests，因为 "&", "+", 和 "=" 不会被编码，然而在 GET 和 POST 请求中它们是特殊字符。然而`encodeURIComponent`这个方法会对这些字符编码。

另外，如果试图编码一个非高 - 低位完整的代理字符，将会抛出一个 `URIError` 错误，例如：


```js
// 编码高 - 低位完整字符 ok
console.log(encodeURI("\uD800\uDFFF"));

// 编码单独的高位字符抛出 "Uncaught URIError: URI malformed"
console.log(encodeURI("\uD800"));

// 编码单独的低位字符抛出 "Uncaught URIError: URI malformed"
console.log(encodeURI("\uDFFF"));
```


并且需要注意，如果 URL 需要遵循较新的RFC3986标准，那么方括号是被保留的 (给 IPv6)，因此对于那些没有被编码的 URL 部分 (例如主机)，可以使用下面的代码：


```js
function fixedEncodeURI(str) {
  return encodeURI(str).replace(/%5B/g, "[").replace(/%5D/g, "]");
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-encodeuri-uri |

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

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

参见
--

* `decodeURI`
* `encodeURIComponent`
* `decodeURIComponent`
parseFloat
==========

**`parseFloat()`** 函数解析一个参数（必要时先转换为字符串）并返回一个浮点数。

尝试一下
----

语法
--


```js
parseFloat(string)
```

### 参数

`string`

需要被解析成为浮点数的值。

### 返回值

给定值被解析成浮点数。如果给定值不能被转换成数值，则会返回 `NaN`。

描述
--

`parseFloat` 是个全局函数，不属于任何对象。

* 如果 `parseFloat` 在解析过程中遇到了正号（`+`）、负号（`-` U+002D HYPHEN-MINUS）、数字（`0`-`9`）、小数点（`.`）、或者科学记数法中的指数（e 或 E）以外的字符，则它会忽略该字符以及之后的所有字符，返回当前已经解析到的浮点数。
* 第二个小数点的出现也会使解析停止（在这之前的字符都会被解析）。
* 参数首位和末位的空白符会被忽略。
* 如果参数字符串的第一个字符不能被解析成为数字，则 `parseFloat` 返回 `NaN`。
* `parseFloat` 也可以解析并返回 `Infinity`。
* `parseFloat` 解析 `BigInt` 为 `Numbers`, 丢失精度。因为末位 `n` 字符被丢弃。

考虑使用 `Number(*value*)` 进行更严谨的解析，只要参数带有无效字符就会被转换为 `NaN` 。

`parseFloat` 也可以转换一个已经定义了 `toString` 或者 `valueOf` 方法的对象，它返回的值和在调用该方法的结果上调用 `parseFloat` 值相同。

示例
--

### 示例：`parseFloat`返回正常数字

下面的例子都返回 **3.14**


```js
parseFloat(3.14);
parseFloat("3.14");
parseFloat(" 3.14 ");
parseFloat("314e-2");
parseFloat("0.0314E+2");
parseFloat("3.14some non-digit characters");
parseFloat({
  toString: function () {
    return "3.14";
  },
});
```

### `parseFloat` 返回 NaN

下面的例子将返回`NaN`


```js
parseFloat("FF2");
```

### parseFloat 和 BigInt

以下例子均返回 `900719925474099300`，当整数太大以至于不能被转换时将失去精度。


```js
parseFloat(900719925474099267n);
parseFloat("900719925474099267n");
```

规范
--

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

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

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

参见
--

* `parseInt()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `isNaN()`
decodeURIComponent()
====================

**`decodeURIComponent()`** 方法用于解码由 `encodeURIComponent` 方法或者其他类似方法编码的部分统一资源标识符（URI）。

语法
--
```

decodeURIComponent(encodedURI)
```

### 参数

`encodedURI`

编码后的部分 URI

### 返回值

一个解码后的统一资源标识符（URI）字符串，处理前的 URI 经过了给定格式的编码。

### 异常

当该方法使用不当时，将会抛出一个`URIError`（“格式错误的 URI 序列”）异常。

描述
--

将已编码 URI 中所有能识别的转义序列转换成原字符。

示例
--

### 解码一个西里尔字母的 URL


```js
decodeURIComponent("JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
// "JavaScript\_шеллы"
```

### 捕捉异常


```js
try {
  var a = decodeURIComponent("%E0%A4%A");
} catch (e) {
  console.error(e);
}

// URIError: malformed URI sequence
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-decodeuricomponent-encodeduricomponent |

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

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

参见
--

* `decodeURI`
* `encodeURI`
* `encodeURIComponent`
AsyncFunction
=============

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
**`AsyncFunction`** 对象为异步函数提供方法。在 JavaScript 中，每个异步函数实际上都是一个 `AsyncFunction` 对象。

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


```js
const AsyncFunction = async function () {}.constructor;
```


`AsyncFunction` 是 `Function` 的子类。

构造函数
----

`AsyncFunction()`

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

实例属性
----

*同时也从它的父类 `Function` 继承实例属性*。

这些属性定义在 `AsyncFunction.prototype` 并且由所有 `AsyncFunction` 实例共享。

`AsyncFunction.prototype.constructor`

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

`AsyncFunction.prototype[@@toStringTag]`

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


**备注：** `AsyncFunction` 实例并没有 `prototype` 属性。

实例方法
----

*同时也从它的父类 `Function` 继承方法*。

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-objects |

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

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

参见
--

* `async function` 声明
* `async function` 表达式
* `Function`
* `AsyncGeneratorFunction`
* `GeneratorFunction`
* 函数
AggregateError
==============

**`AggregateError`** 对象代表了包装了多个错误对象的单个错误对象。当一个操作需要报告多个错误时，例如 `Promise.any()`，当传递给它的所有承诺都被拒绝时，就会抛出该错误。

`AggregateError` 是 `Error` 的子类。

构造函数
----

`AggregateError()`

创建一个新的 `AggregateError` 对象

实例属性
----

*从父类 `Error` 中继承实例属性。*

以下属性在 `AggregateError.prototype` 上定义，并由所有 `AggregateError` 实例共享。

`AggregateError.prototype.constructor`

创建实例对象的构造函数。对于 `AggregateError` 实例来说，初始值为 `AggregateError` 构造函数。

`AggregateError.prototype.name`

代表了错误类型的名称，对于 `AggregateError.prototype.name` 来说，初始值为 `"AggregateError"`。

这些属性是每个 `AggregateError` 实例的自有属性。

`errors`

一个数组，基本上反映了 `AggregateError` 实例化时使用的迭代器；例如，如果 `AggregateError` 是用 `AggregateError()` 构造函数创建的，则作为第一个参数传递给构造函数的任何迭代器生成的数组。

实例方法
----

*从父类 `Error` 中继承实例方法。*

示例
--

### 捕获一个 AggregateError


```js
Promise.any([Promise.reject(new Error("some error"))]).catch((e) => {
  console.log(e instanceof AggregateError); // true
  console.log(e.message); // "All Promises rejected"
  console.log(e.name); // "AggregateError"
  console.log(e.errors); // [ Error: "some error" ]
});
```

### 创建一个 AggregateError


```js
try {
  throw new AggregateError([new Error("some error")], "Hello");
} catch (e) {
  console.log(e instanceof AggregateError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "AggregateError"
  console.log(e.errors); // [ Error: "some error" ]
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-aggregate-error-objects |

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

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

参见
--

* `core-js` 中 `AggregateError` 的 polyfill
* `Error`
* `Promise.any`
undefined
=========

全局属性 **`undefined`** 表示原始值 `undefined`。它是一个 JavaScript 的 原始数据类型 。

| `undefined` 的属性特性 |
| --- |
| 可写 | 否 |
| 可枚举 | 否 |
| 可配置 | 否 |

尝试一下
----

语法
--


```js
undefined
```

描述
--

`undefined`是*全局对象*的一个属性。也就是说，它是全局作用域的一个变量。`undefined`的最初值就是原始数据类型`undefined`。

在现代浏览器（JavaScript 1.8.5/Firefox 4+），自 ECMAscript5 标准以来 undefined 是一个不能被配置（non-configurable），不能被重写（non-writable）的属性。即便事实并非如此，也要避免去重写它。

一个没有被赋值的变量的类型是 undefined。如果方法或者是语句中**操作的变量没有被赋值，则会返回 undefined**（对于这句话持疑惑态度，请查看英文原文来理解）。


```js
function test(a) {
  console.log(typeof a); // undefined
  return a;
}

test(); // 返回"undefined"
```


一个函数如果没有使用 return 语句指定`返回`值，就会返回一个 undefined 值。

**警告：** 但是它有可能在非全局作用域中被当作标识符（变量名）来使用（因为 undefined 不是保留字），这样做是一个非常坏的主意，因为这样会使你的代码难以去维护和排错。


```js
// 不要这样做！

(() => {
  const undefined = "foo";
  console.log(undefined, typeof undefined); // foo string
})();

((undefined) => {
  console.log(undefined, typeof undefined); // foo string
})("foo");
```


示例
--

### 严格相等和 undefined

你可以使用 undefined 和严格相等或不相等操作符来决定一个变量是否拥有值。在下面的代码中，变量 x 是未定义的，if 语句的求值结果将是 true


```js
var x;

if (x === undefined) {
  // 执行这些语句
} else {
  // 这些语句不会被执行
}
```


**备注：** 这里是必须使用严格相等操作符（===）而不是标准相等操作符（==），因为 x == undefined 会检查 x 是不是 null，但是严格相等不会检查（有点饶人，其实 === 会严格判断双方的类型、值等是否相等）。null 不等同于 undefined。移步`比较操作符` (en-US)查看详情。

### Typeof 操作符和 undefined

或者，可以使用`typeof`：


```js
var x;
if (typeof x === "undefined") {
  // 执行这些语句
}
```


使用 `typeof`的原因是它不会在一个变量没有被声明的时候抛出一个错误。


```js
// 这里没有声明 y
if (typeof y === "undefined") {
  // 没有错误，执行结果为 true
  console.log("y is " + typeof y); // y is undefined
}

if (y === undefined) {
  // ReferenceError: y is not defined
}
```


但是，技术方面看来这样的使用方法应该被避免。JavaScript 是一个静态作用域语言，所以，一个变量是否被声明可以通过看它是否在一个封闭的上下文中被声明。唯一的例外是全局作用域，但是全局作用域是被绑定在全局对象上的，所以要检查一个变量是否在全局上下文中存在可以通过检查全局对象上是否存在这个属性（比如使用`in`操作符）。


```js
if ("x" in window) {
  // 只有 x 被全局性的定义 才会执行这些语句
}
```

### Void 操作符和 undefined

`void` 操作符是第三种可以替代的方法。


```js
var x;
if (x === void 0) {
  // 执行这些语句
}

// 没有声明 y
if (y === void 0) {
  // 抛出一个 RenferenceError 错误（与 `typeof` 相比）
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-undefined |

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

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

**`AsyncIterator`** 对象是符合异步迭代器协议的对象，其提供了 `next()` 方法用以返回一个兑现为迭代器结果对象的 promise。`AsyncIterator.prototype` 对象是一个隐藏的全局对象，所有内置的异步迭代器都继承自它。其提供了 `@@asyncIterator` 方法，该方法返回异步迭代器对象本身，使异步迭代器也异步可迭代。

注意，`AsyncIterator` *不是*全局对象，尽管将来会出现异步迭代器辅助方法提案。所有内置异步迭代器共享的 `AsyncIterator.prototype` 对象可以通过以下代码获得：


```js
const AsyncIteratorPrototype = Object.getPrototypeOf(
  Object.getPrototypeOf(Object.getPrototypeOf((async function\* () {})())),
);
```

描述
--

目前，唯一内置的 JavaScript 异步迭代器是由异步生成器函数返回的 `AsyncGenerator` 对象。还有一些其他的内置异步迭代器存在于 web API 中，例如 `ReadableStream` 的异步迭代器。

每个异步迭代器都有一个不同的原型对象，它定义了特定异步迭代器使用的 `next()` 方法。所有这些原型对象都继承自 `AsyncIterator.prototype`，它提供了一个 `@@asyncIterator` 方法，该方法返回异步迭代器对象本身，使异步迭代器也可异步迭代。

**备注：** `AsyncIterator.prototype` 并未实现 `@@iterator`，因此默认情况下，异步迭代器不是同步可迭代对象。

实例方法
----

`AsyncIterator.prototype[@@asyncIterator]()`

返回异步迭代器对象本身。这使异步迭代器对象也可以异步迭代。

示例
--

### 使用异步迭代器作为异步可迭代对象

所有内置异步迭代器都可以异步迭代，因此你可以在 `for await...of` 循环中使用它们：


```js
const asyncIterator = (async function\* () {
  yield 1;
  yield 2;
  yield 3;
})();
(async () => {
  for await (const value of asyncIterator) {
    console.log(value);
  }
})();
// 输出：1，2，3
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-asynciteratorprototype |

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

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

参见
--

* `async function*`
* 迭代协议
InternalError
=============

**非标准:** 该特性是非标准的，请尽量不要在生产环境中使用它！

**`InternalError` 对象**表示出现在 JavaScript 引擎内部的错误。通常描述某种数量过多的情况，例如：

* "too many switch cases"（过多 `case` 子句）；
* "too many parentheses in regular expression"（正则表达式中括号过多）；
* "array initializer too large"（数组初始化器过大）；
* "too much recursion"（递归过深）。
构造函数
----

`InternalError()` (en-US) 
非标准

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

实例属性
----

`Error.prototype.message`

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

`Error.prototype.name`

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

`Error.prototype.cause`

表示导致当前错误被抛出的原因。继承自 `Error`。

`Error.prototype.fileName` 
非标准

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

`Error.prototype.lineNumber` 
非标准

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

`Error.prototype.columnNumber` 
非标准

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

`Error.prototype.stack` 
非标准

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

示例
--

### 递归过深

根据退出条件所述，以下递归函数运行 10 次。


```js
function loop(x) {
  // "x >= 10" 是退出条件
  if (x >= 10) return;

  // 做一些事情
  loop(x + 1); // 递归调用
}
loop(0);
```


如果这个条件值太高，可能不会奏效：


```js
function loop(x) {
  if (x >= 1000000000000) return;

  // 做一些事情
  loop(x + 1);
}
loop(0);

// InternalError: too much recursion
```


要获取更多信息，请参阅 InternalError: too much recursion。

规范
--

尚未成为任何规范的一部分。

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

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

参见
--

* `Error`
* InternalError: too much recursion
EvalError
=========

本对象代表了一个关于 `eval()` 全局函数的错误。此异常不再会被 JavaScript 抛出，但是 EvalError 对象仍然存在，以保持兼容性。

`EvalError` 是一个可序列化对象，所以可以使用 `structuredClone()` 对它进行克隆，也可以使用 `postMessage()` 在 Worker 之间拷贝它。

构造函数
----

`EvalError()` (en-US)

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

实例属性
----

`Error.prototype.message`

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

`Error.prototype.name`

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

`Error.prototype.cause`

表示导致当前错误被抛出的原因。继承自 `Error`。

`Error.prototype.fileName` 
非标准

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

`Error.prototype.lineNumber` 
非标准

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

`Error.prototype.columnNumber` 
非标准

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

`Error.prototype.stack` 
非标准

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

示例
--

`EvalError` 不在当前的 ECMAScript 规范中使用，因此不会被运行时抛出。但是对象本身仍然与规范的早期版本向后兼容。

### 创建 EvalError


```js
try {
  throw new EvalError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof EvalError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "EvalError"
  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-evalerror |

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

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

参见
--

* `Error`
* `eval()`
decodeURI()
===========

**`decodeURI()`** 函数能解码由`encodeURI` 创建或其他流程得到的统一资源标识符（URI）。

尝试一下
----

语法
--
```

decodeURI(encodedURI)
```

### 参数

`encodedURI`

一个完整的编码过的 URI

### 返回值

返回一个给定编码统一资源标识符 (URI) 的未编码版本的新字符串。

### 异常

当`encodedURI` 包含无效字符序列时，引发`URIError`（“格式错误的 URI 序列”）异常。

描述
--

将已编码 URI 中所有能识别的转义序列转换成原字符，但不能解码那些不会被 `encodeURI` 编码的内容（例如 "`#`"）。

示例
--

### 解码一个西里尔字母（Cyrillic）URL


```js
decodeURI(
  "https://developer.mozilla.org/ru/docs/JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B",
);
// "https://developer.mozilla.org/ru/docs/JavaScript\_шеллы"
```

### 捕捉异常
```

try {
  var a = decodeURI('%E0%A4%A');
} catch(e) {
  console.error(e);
}

// URIError: malformed URI sequence
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-decodeuri-encodeduri |

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

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

参见
--

* `decodeURIComponent`
* `encodeURI`
* `encodeURIComponent`
Boolean
=======

**`Boolean`** 对象是一个布尔值的对象包装器。

描述
--

如果需要，作为第一个参数传递的值将转换为布尔值。如果省略该参数或参数值为 `0`、`-0`、`null`、`false`、`NaN`、`undefined`，或空字符串（`""`），则该对象具有的初始值为 `false`。所有其他值，包括任何对象，空数组（`[]`）或字符串 `"false"`，都会创建一个初始值为 `true` 的对象。

注意不要将基本类型中的布尔值 `true` 和 `false` 与值为 `true` 和 `false` 的 `Boolean` 对象弄混了。

其值不是 `undefined` 或 `null` 的任何对象（包括其值为 `false` 的布尔对象）在传递给条件语句时都将计算为 `true`。例如，以下 `if` 语句中的条件评估为 `true`：


```js
const x = new Boolean(false);
if (x) {
  // 这里的代码会被执行
}
```


基本类型的布尔值不受此规则影响。例如下面的 `if` 语句的条件为假：


```js
const x = false;
if (x) {
  // 这里的代码不会执行
}
```


不要用创建 `Boolean` 对象的方式将一个非布尔值转化成布尔值，直接将 `Boolean` 当做转换函数来使用即可，或者使用双重非（!!）运算符：


```js
const x = Boolean(expression); // use this...
const x = !!expression; // ...or this
const x = new Boolean(expression); // don't use this!
```


对于任何对象，即使是值为 `false` 的 `Boolean` 对象，当将其传给 `Boolean` 函数时，生成的 `Boolean` 对象的值都是 `true`。


```js
const myFalse = new Boolean(false); // initial value of false
const g = Boolean(myFalse); // initial value of true
const myString = new String("Hello"); // string object
const s = Boolean(myString); // initial value of true
```


最后，不要在应该使用基本类型布尔值的地方使用 `Boolean` 对象。

**备注：** 当将非标准属性 `document.all` 用作此构造函数的参数时，结果是值为 `false` 的布尔对象。此属性是旧的、非标准的属性，不应使用。

当使用非严格相等（`==`）来比较一个对象和布尔原始值时，最重要的是需要弄明白最终比较的是什么。请看一下的示例：


```js
if ([]) {
  console.log("[] is truthy"); // logs "[] is truthy"
}
if ([] == false) {
  console.log("[] == false"); // logs "[] == false"
}
```


`[]` 是真值而 `[] == false` 也同时成立的原因是：非严格比较 `[] == false` 会将 `[]` 的原始值和 `false` 进行比较。而获取 `[]` 的原始值时，JavaScript 引擎会首先调用 `[].toString()`。其结果为 `""`，也是最终和 `false` 一起比较的值。换句话说，`[] == false` 等价于 `"" == false`，而 `""` 是假值——这也解释了为什么会得到这一结果。

构造函数
----

`Boolean()`

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

实例方法
----

`Boolean.prototype.toString()`

根据对象的值返回字符串 `true` 或 `false`。覆盖了 `Object.prototype.toString()` 方法。

`Boolean.prototype.valueOf()`

返回 `Boolean` 对象的原始值。覆盖了 `Object.prototype.valueOf()` 方法。

示例
--

### 以初始值 `false` 创建 `Boolean` 对象


```js
const bNoParam = new Boolean();
const bZero = new Boolean(0);
const bNull = new Boolean(null);
const bEmptyString = new Boolean("");
const bfalse = new Boolean(false);
```

### 以初始值 `true` 创建 `Boolean` 对象


```js
const btrue = new Boolean(true);
const btrueString = new Boolean("true");
const bfalseString = new Boolean("false");
const bSuLin = new Boolean("Su Lin");
const bArrayProto = new Boolean([]);
const bObjProto = new Boolean({});
```

规范
--

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

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

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

参见
--

* Boolean
* 基本类型：布尔类型
* 布尔类型（维基百科）
WeakSet
=======

**`WeakSet`** 是可被垃圾回收的值的集合，包括对象和非全局注册的符号。`WeakSet` 中的值只能出现一次。它在 `WeakSet` 的集合中是唯一的。

描述
--

WeakSet 中的值一定是可被垃圾回收的值。大多数原始数据类型可以被任意地创建，并且没有生命周期，所以它们不能被存储。对象和非全局注册的符号可以被存储，因为它们是可被垃圾回收的值。

它和 `Set` 对象的主要区别有：

* `WeakSet` **只能是对象和符号**的集合，它不能像 `Set` 那样包含任何类型的任意值。
* `WeakSet` 持*弱引用*：`WeakSet` 中对象的引用为*弱*引用。如果没有其他的对 `WeakSet` 中对象的引用存在，那么这些对象会被垃圾回收。

**备注：** 这也意味着集合中没有存储当前值的列表。`WeakSet` 是不可枚举的。
### 用例：检测循环引用

递归调用自身的函数需要一种通过跟踪哪些对象已被处理，来应对循环数据结构的方法。

为此，`WeakSet` 非常适合处理这种情况：


```js
// 对传入的 subject 对象内部存储的所有内容执行回调
function execRecursively(fn, subject, _refs = new WeakSet()) {
  // 避免无限递归
  if (_refs.has(subject)) {
    return;
  }

  fn(subject);
  if (typeof subject === "object") {
    _refs.add(subject);
    for (const key in subject) {
      execRecursively(fn, subject[key], _refs);
    }
  }
}

const foo = {
  foo: "Foo",
  bar: {
    bar: "Bar",
  },
};

foo.bar.baz = foo; // 循环引用！
execRecursively((obj) => console.log(obj), foo);
```


在此，在第一次运行时创建 `WeakSet`，并将其与每个后续函数调用一起传递（使用内部参数 `_refs`）。

对象的数量或它们的遍历顺序无关紧要，因此，`WeakSet` 比 `Set` 更适合（和执行）跟踪对象引用，尤其是在涉及大量对象时。

构造函数
----

`WeakSet()`

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

实例属性
----

这些属性在 `WeakSet.prototype` 上定义，并且由所有 `WeakSet` 实例所共享。

`WeakSet.prototype.constructor`

创建了该实例对象的构造函数。对于 `WeakSet` 实例，初始值是 `WeakSet` 构造函数。

`WeakSet.prototype[@@toStringTag]`

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

实例方法
----

`WeakSet.prototype.add()`

将 `value` 追加到 `WeakSet` 对象。

`WeakSet.prototype.delete()`

从 `WeakSet` 中移除 `value`。此后调用 `WeakSet.prototype.has(value)` 将返回 `false`。

`WeakSet.prototype.has()`

返回一个表示 `value` 是否存在于 `WeakSet` 对象中的布尔值。

示例
--

### 使用 WeakSet 对象


```js
const ws = new WeakSet();
const foo = {};
const bar = {};

ws.add(foo);
ws.add(bar);

ws.has(foo); // true
ws.has(bar); // true

ws.delete(foo); // 从 set 中删除 foo 对象
ws.has(foo); // false，foo 对象已经被删除了
ws.has(bar); // true，bar 依然存在
```


注意，`foo !== bar`。尽管它们是相似的对象，*但是它们不是**同一个对象***。因此，它们都可以被加入到集合中。

规范
--

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

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

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

参见
--

* `core-js` 中 `WeakSet` 的 Polyfill
* `Map`
* `Set`
* `WeakMap`
SyntaxError
===========

**`SyntaxError`**（语法错误）对象代表尝试解析不符合语法的代码的错误。当 Javascript 引擎解析代码时，遇到了不符合语法规范的标记（token）或标记顺序，则会抛出 `SyntaxError`。

`SyntaxError` 是一个可序列化对象，所以可以使用 `structuredClone()` 对它进行克隆，也可以使用 `postMessage()` 在 Worker 之间拷贝它。

构造函数
----

`SyntaxError()` (en-US)

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

实例属性
----

`Error.prototype.message`

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

`Error.prototype.name`

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

`Error.prototype.cause`

表示导致当前错误被抛出的原因。继承自 `Error`。

`Error.prototype.fileName` 
非标准

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

`Error.prototype.lineNumber` 
非标准

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

`Error.prototype.columnNumber` 
非标准

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

`Error.prototype.stack` 
非标准

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

示例
--

### 捕获 SyntaxError


```js
try {
  eval("hoo bar");
} catch (e) {
  console.error(e instanceof SyntaxError);
  console.error(e.message);
  console.error(e.name);
  console.error(e.fileName);
  console.error(e.lineNumber);
  console.error(e.columnNumber);
  console.error(e.stack);
}
```

### 创建 SyntaxError


```js
try {
  throw new SyntaxError("Hello", "someFile.js", 10);
} catch (e) {
  console.error(e instanceof SyntaxError); // true
  console.error(e.message); // Hello
  console.error(e.name); // SyntaxError
  console.error(e.fileName); // someFile.js
  console.error(e.lineNumber); // 10
  console.error(e.columnNumber); // 0
  console.error(e.stack); // @debugger eval code:3:9
}
```

规范
--

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

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

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

参见
--

* `Error`
AsyncGeneratorFunction
======================

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

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


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


`AsyncGeneratorFunction` 是 `Function` 的一个子类。

尝试一下
----

构造函数
----

`AsyncGeneratorFunction()`

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

实例属性
----

*同时也从它的父类 `Function` 继承实例属性*。

这些属性定义在 `AsyncGeneratorFunction.prototype` 并且由所有 `AsyncGeneratorFunction` 实例共享。

`AsyncGeneratorFunction.prototype.constructor`

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

`AsyncGeneratorFunction.prototype.prototype`

所有异步生成器函数共享相同的 `prototype` 属性，即 `AsyncGenerator.prototype`。每个异步生成器函数实例也都有它自己的 `prototype` 属性。当调用异步生成器函数时，返回的异步生成器对象继承自异步生成器函数的 `prototype` 属性，而 property 属性也继承自 `AsyncGeneratorFunction.prototype.prototype`。

`AsyncGeneratorFunction.prototype[@@toStringTag]`

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

实例方法
----

*同时也从它的父类 `Function` 继承方法*。

规范
--

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

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

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

参见
--

* `async function*`
* `async function*` 表达式
* `Function`
* `AsyncFunction`
* `GeneratorFunction`
* 函数