recursal/MDN huggingface dataset:
Reflect
=======

**Reflect** 是一个内置的对象，它提供拦截 JavaScript 操作的方法。这些方法与 proxy handler (en-US) 的方法相同。`Reflect` 不是一个函数对象，因此它是不可构造的。

描述
--

与大多数全局对象不同 `Reflect` 并非一个构造函数，所以不能通过 new 运算符对其进行调用，或者将 `Reflect` 对象作为一个函数来调用。`Reflect` 的所有属性和方法都是静态的（就像 `Math` 对象）。

`Reflect` 对象提供了以下静态方法，这些方法与 proxy handler 方法的命名相同。

静态方法
----

`Reflect.apply(target, thisArgument, argumentsList)`

对一个函数进行调用操作，同时可以传入一个数组作为调用参数。和 `Function.prototype.apply()` 功能类似。

`Reflect.construct(target, argumentsList[, newTarget])`

对构造函数进行 `new` 操作，相当于执行 `new target(...args)`。

`Reflect.defineProperty(target, propertyKey, attributes)`

和 `Object.defineProperty()` 类似。如果设置成功就会返回 `true`

`Reflect.deleteProperty(target, propertyKey)`

作为函数的`delete`操作符，相当于执行 `delete target[name]`。

`Reflect.get(target, propertyKey[, receiver])`

获取对象身上某个属性的值，类似于 `target[name]`。

`Reflect.getOwnPropertyDescriptor(target, propertyKey)`

类似于 `Object.getOwnPropertyDescriptor()`。如果对象中存在该属性，则返回对应的属性描述符，否则返回 `undefined`。

`Reflect.getPrototypeOf(target)`

类似于 `Object.getPrototypeOf()`。

`Reflect.has(target, propertyKey)`

判断一个对象是否存在某个属性，和 `in` 运算符 的功能完全相同。

`Reflect.isExtensible(target)`

类似于 `Object.isExtensible()`.

`Reflect.ownKeys(target)`

返回一个包含所有自身属性（不包含继承属性）的数组。(类似于 `Object.keys()`, 但不会受`enumerable` 影响).

`Reflect.preventExtensions(target)`

类似于 `Object.preventExtensions()`。返回一个`Boolean`。

`Reflect.set(target, propertyKey, value[, receiver])`

将值分配给属性的函数。返回一个`Boolean`，如果更新成功，则返回`true`。

`Reflect.setPrototypeOf(target, prototype)`

设置对象原型的函数。返回一个 `Boolean`，如果更新成功，则返回 `true`。

Examples
--------

### 检测一个对象是否存在特定属性
```

const duck = {
  name: 'Maurice',
  color: 'white',
  greeting: function() {
    console.log(`Quaaaack! My name is ${this.name}`);
  }
}

Reflect.has(duck, 'color');
// true
Reflect.has(duck, 'haircut');
// false
```

### 返回这个对象自身的属性
```

Reflect.ownKeys(duck);
// [ "name", "color", "greeting" ]
```

### 为这个对象添加一个新的属性
```

Reflect.set(duck, 'eyes', 'black');
// returns "true" if successful
// "duck" now contains the property "eyes: 'black'"
```

规范
--

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

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

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

参见
--

* `Proxy`
AsyncGenerator
==============

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

异步生成器方法总是产生 `Promise` 对象。

`AsyncGenerator` 是隐藏类 `AsyncIterator` 的子类。

尝试一下
----

构造函数
----

`AsyncGenerator` 构造函数并非全局可用的。`AsyncGenerator` 的实例必须从异步生成器函数返回。


```js
async function\* createAsyncGenerator() {
  yield await Promise.resolve(1);
  yield await Promise.resolve(2);
  yield await Promise.resolve(3);
}
const asyncGen = createAsyncGenerator();
asyncGen.next().then((res) => console.log(res.value)); // 1
asyncGen.next().then((res) => console.log(res.value)); // 2
asyncGen.next().then((res) => console.log(res.value)); // 3
```


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

实例属性
----

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

`AsyncGenerator.prototype.constructor`

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

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

`AsyncGenerator.prototype[@@toStringTag]`

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

实例方法
----

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

`AsyncGenerator.prototype.next()`

返回 `Promise`，它将通过 `yield` 表达式产生的给定值兑现。

`AsyncGenerator.prototype.return()`

就好像在生成器的暂停位置插入一个 `return` 语句，这将结束生成器并允许生成器执行任何清理任务，尤其是与 `try...finally` 块结合的时候。

`AsyncGenerator.prototype.throw()`

就好像在生成器的暂停位置插入一个 `throw` 语句，这将通知生成器错误的状况并允许去处理错误，或者执行清理操作并关闭它自己。

示例
--

### 迭代异步生成器

以下示例将遍历迭代异步生成器，以递减的时间间隔将值 1-6 打印到控制台。注意，每次产生 Promise 的时候，它会在 `for await...of` 循环中自动地兑现。


```js
// 异步任务。假设它在实践中做了一些更有用的事情。
function delayedValue(time, value) {
  return new Promise((resolve /\*, reject\*/) => {
    setTimeout(() => resolve(value), time);
  });
}

async function\* generate() {
  yield delayedValue(2000, 1);
  yield delayedValue(100, 2);
  yield delayedValue(500, 3);
  yield delayedValue(250, 4);
  yield delayedValue(125, 5);
  yield delayedValue(50, 6);
  console.log("全部完成！");
}

async function main() {
  for await (const value of generate()) {
    console.log("值", value);
  }
}

main().catch((e) => console.error(e));
```

规范
--

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

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

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

参见
--

* function\*
* async function\*
* `function*` 表达式
* 生成器函数
* 异步生成器函数
* 迭代器和生成器指南
Int16Array
==========

**`Int16Array`** 类型化数组表示按平台字节顺序排列的 16 位有符号整数数组。如果需要控制字节顺序，请使用 `DataView` 代替。数组内容初始化为 `0`。建立后，可以使用对象的方法或标准数组索引语法（即使用方括号表示法）引用数组中的元素。

`Int16Array` 是隐藏类 `TypedArray` 的子类。

构造函数
----

`Int16Array()` (en-US)

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

静态属性
----

*从父对象 `TypedArray` 继承静态属性。*

`Int16Array.BYTES_PER_ELEMENT`

返回元素大小的数值。在 `Int16Array` 中该值为 `2`。

静态方法
----

*从父对象 `TypedArray` 继承静态方法。*

实例属性
----

*从父对象 `TypedArray` 继承实例属性。*

这些属性在 `Int16Array.prototype` 中定义，并为所有 `Int16Array` 实例共享。

`Int16Array.prototype.BYTES_PER_ELEMENT`

返回元素大小的数值。在 `Int16Array` 中该值为 `2`。

`Int16Array.prototype.constructor`

创建实例对象的构造函数。对于 `Int16Array` 实例，初始值是 `Int16Array` (en-US) 构造函数。

实例方法
----

*从父对象 `TypedArray` 继承实例方法。*

示例
--

### 创建 Int16Array 的不同方法


```js
// 给定长度
const int16 = new Int16Array(2);
int16[0] = 42;
console.log(int16[0]); // 42
console.log(int16.length); // 2
console.log(int16.BYTES\_PER\_ELEMENT); // 2

// 从一个数组
const x = new Int16Array([21, 31]);
console.log(x[1]); // 31

// 从另外一个 TypedArray
const y = new Int16Array(x);
console.log(y[0]); // 21

// 从一个 ArrayBuffer
const buffer = new ArrayBuffer(16);
const z = new Int16Array(buffer, 2, 4);
console.log(z.byteOffset); // 2

// 从可迭代对象
const iterable = (function\* () {
  yield\* [1, 2, 3];
})();
const int16FromIterable = new Int16Array(iterable);
console.log(int16FromIterable);
// Int16Array [1, 2, 3]
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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

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

参见
--

* `core-js` 中 `Int16Array` 的 polyfill
* JavaScript 类型化数组指南
* `TypedArray`
* `ArrayBuffer`
* `DataView`
unescape()
==========

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

**备注：** `unescape()` 是由浏览器实现的非标准函数，其仅针对跨引擎兼容性而进行了标准化。并不要求所有的 JavaScript 引擎都实现它，并且可能无法在所有地方都正常工作。如果可能的话，请使用 `decodeURIComponent()` 或 `decodeURI()`。

**`unescape()`** 函数计算一个新的字符串，将其中的十六进制转义序列替换为它们所代表的字符。转义序列可能是由 `escape()` 等函数引入的。

语法
--


```js
unescape(str)
```

### 参数

`str`

要解码的字符串。

### 返回值

一个其中的某些字符已被解码的新的字符串。

描述
--

`unescape` 函数是全局对象的函数属性。

`unescape()` 函数将任何转移序列替换为它所代表的字符。具体来说，它将任何形式为 `%XX` 或 `%uXXXX`（其中 `X` 代表一个十六进制数字）的转义序列替换为十六进制值为 `XX`/`XXXX` 的字符。如果转义序列无效（例如，如果 `%` 后面跟着一个或未跟十六进制数字），则保持不变。

**备注：** 该函数主要用于 URL 编码，其部分基于 RFC 1738 中的转义格式。`unescape()` 函数*不会*对字符串字面量中的转义序列进行求值。你可以将 `\xXX` 替换为 `%XX`，将 `\uXXXX` 替换为 `%uXXXX`，以获得一个可以被 `unescape()` 处理的字符串。

示例
--

### 使用 unescape()


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

规范
--

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

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

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

参见
--

* `core-js` 中 `unescape` 的 polyfill
* `decodeURI`
* `decodeURIComponent`
* `escape`
isFinite()
==========

该全局 **`isFinite()`** 函数用来判断被传入的参数值是否为一个有限数值（finite number）。在必要情况下，参数会首先转为一个数值。

尝试一下
----

语法
--


```js
isFinite(testValue)
```

### 参数

`testValue`

用于检测有限性（finiteness）的值。

### 描述

isFinite 是全局的方法，不与任何对象有关系。

你可以用这个方法来判定一个数字是否是有限数字。`isFinite` 方法检测它参数的数值。如果参数是 `NaN`，正无穷大或者负无穷大，会返回`false`，其他返回 `true`。

示例
--


```js
isFinite(Infinity); // false
isFinite(NaN); // false
isFinite(-Infinity); // false

isFinite(0); // true
isFinite(2e64); // true，在更强壮的 Number.isFinite(null) 中将会得到 false

isFinite("0"); // true，在更强壮的 Number.isFinite('0') 中将会得到 false
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-isfinite-number |

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

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

参见
--

* `Number.isFinite()`
* `Number.NaN()`
* `Number.POSITIVE_INFINITY`
* `Number.NEGATIVE_INFINITY`
AsyncGenerator.prototype.throw()
================================

`AsyncGenerator` 实例的 **`throw()`** 方法的作用就好像一个 `throw` 语句被插入到生成器主体的当前暂停位置，这会通知生成器错误的情况并允许其处理错误，或者执行清理和自行关闭。

语法
--


```js
asyncGeneratorInstance.throw(exception)
```

### 参数

`exception`

要抛出的异常。使用 `Error` 实例对调试非常有帮助。

### 返回值

如果抛出的错误没有被捕获，它会返回一个以传入的异常拒绝的 `Promise`。

如果抛出的异常被 `try...catch` 捕获并且生成器恢复生成更多的值，它将返回一个 `Promise`，其兑现为带有两个属性的 `Object`：

`done`

一个布尔值：

* 如果该生成器函数的控制流程已经结束，则为 `true`。
* 如果该生成器函数还能产生更多的值，则为 `false`。

`value`

下一个 `yeild` 表达式生成的值。

示例
--

### 使用 throw()

以下示例展示了一个简单生成器和使用 `throw` 方法抛出的错误。像往常一样，错误可以通过 `try...catch` 块捕获。


```js
// 异步任务。假设它在实践中做了一些更有用的事情。
function sleep(time) {
  return new Promise((resolve, reject) => {
    setTimeout(resolve, time);
  });
}

async function\* createAsyncGenerator() {
  while (true) {
    try {
      await sleep(500);
      yield 42;
    } catch (e) {
      console.error(e);
    }
  }
}

const asyncGen = createAsyncGenerator();
asyncGen.next(1).then((res) => console.log(res)); // { value: 42, done: false }
asyncGen
  .throw(new Error("出了点问题")) // Error: 出了点问题
  .then((res) => console.log(res)); // { value: 42, done: false }
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-asyncgenerator-prototype-throw |

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

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

参见
--

* `async function*`
* 迭代器和生成器指南
AsyncGenerator.prototype.next()
===============================

`AsyncGenerator` 实例的 **`next()`** 方法返回序列中的下一个值。

语法
--


```js
next()
next(value)
```

### 参数

`value` 可选

用于修改生成器内部状态的可选值。传入给 `next()` 方法的值将被 `yield` 接收。

### 返回值

一个 `Promise`，其兑现时将返回一个 `Object`，包含以下两个属性：

`done`

一个布尔值：

* 如果生成器的控制流程已经结束，则为 `true`。在这种情况下，`value` 指定生成器的*返回值*（可能是 undefined）。
* 如果生成器还能产生更多的值，则为 `false`。

`value`

生成器产生或返回的任何 JavaScript 值。

示例
--

### 使用 next()

以下示例展示了一个简单的生成器以及调用 `next` 方法后返回的对象：


```js
// 异步任务。假设它在实践中做了一些更有用的事情。
function delayedValue(time, value) {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve(value), time);
  });
}

async function\* createAsyncGenerator() {
  yield delayedValue(500, 1);
  yield delayedValue(500, 2);
  yield delayedValue(500, 3);
}

const asyncGen = createAsyncGenerator();
asyncGen.next().then((res) => console.log(res)); // { value: 1, done: false }
asyncGen.next().then((res) => console.log(res)); // { value: 2, done: false }
asyncGen.next().then((res) => console.log(res)); // { value: 3, done: false }
asyncGen.next().then((res) => console.log(res)); // { value: undefined, done: true }
```

### 向生成器传值

在此示例中，调用 `next` 时传入了值。

**备注：** 第一次调用不会打印任何内容，因为生成器最初没有产生任何内容。


```js
// 异步任务。假设它在实践中做了一些更有用的事情。
function sleep(time) {
  return new Promise((resolve, reject) => {
    setTimeout(resolve, time);
  });
}

async function\* createAsyncGenerator() {
  while (true) {
    await sleep(500);
    const value = yield;
    console.log(value);
  }
}

async function main() {
  const asyncGen = createAsyncGenerator();
  // 这一步不会有输出：通过 `next` 发送的第一个值会被丢弃
  console.log(await asyncGen.next(1)); // { value: undefined, done: false }
  // 打印通过 `next` 发送的值——2
  console.log(await asyncGen.next(2)); // { value: undefined, done: false }
}

main();
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-asyncgenerator-prototype-next |

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

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

参见
--

* `async function*`
* 迭代器和生成器指南
AsyncGenerator.prototype.return()
=================================

`AsyncGenerator` 实例的 **`return()`** 方法的作用就好像一个 `return` 语句被插入到生成器主体的当前暂停位置，这会结束生成器并允许生成器与 `try...finally` 块结合使用时执行任何清理任务。

语法
--


```js
asyncGeneratorInstance.return()
asyncGeneratorInstance.return(value)
```

### 参数

`value` 可选

要返回的值。

### 返回值

一个 `Promise`，其兑现为一个 `Object`，包含以下两个属性：

`done`

一个布尔值：

* 如果生成器函数的控制流程已经结束，则为 `true`。
* 如果生成器函数的控制流程还未结束并且还能产生更多的值，则为 `false`。只有在 `try...finally` 中捕获 `return` 并且 `finally` 块中还有更多的 `yield` 表达式时才会发生这种情况。

`value`

给定的作为参数的值，或者，如果 `yield` 表达式包含在 `try...finally`，从 `finally` 块产生/返回的值。

描述
--

`return()` 方法在被调用时，可以看作是在生成器主体当前暂停的位置插入了一个 `return value;` 语句，其中 `value` 是传入给 `return()` 方法的值。因此，在典型的流程中，调用 `return(value)` 将返回 `{done: true, value: value }`。然而，如果 `yield` 表达式被包含在 `try...finally` 块中，控制流不会退出函数体，而是进入 `finally` 块。在这种情况下，如果 `finally` 块中有更多 `yield` 表达式，返回的值可能会不同，`done` 甚至可能是 `false`。

示例
--

### 使用 return()

以下例子展示了一个简单的异步生成器和 `return` 方法的使用。


```js
// 异步任务。假设它在实践中做了一些更有用的事情。
function delayedValue(time, value) {
  return new Promise((resolve, reject) => {
    setTimeout(() => resolve(value), time);
  });
}

async function\* createAsyncGenerator() {
  yield delayedValue(500, 1);
  yield delayedValue(500, 2);
  yield delayedValue(500, 3);
}

const asyncGen = createAsyncGenerator();
asyncGen.next().then((res) => console.log(res)); // { value: 1, done: false }
asyncGen.return("foo").then((res) => console.log(res)); // { value: "foo", done: true }
asyncGen.next().then((res) => console.log(res)); // { value: undefined, done: true }
```

### 生成器结束后使用 return()

如果没有给 `return()` 方法传入 `value` 参数，promise 将会像 next() 方法被调用了一样兑现。在本示例中，生成器已经结束，因此返回的值是 `undefined`。

在生成器处于“完成”状态后，仍然可以调用 `return()`，但是生成器将保持此状态。


```js
async function\* createAsyncGenerator() {
  yield await Promise.resolve(1);
  yield await Promise.resolve(2);
  yield await Promise.resolve(3);
}
const asyncGen = createAsyncGenerator();
asyncGen.next().then((res) => console.log(res)); // { value: 1, done: false }
asyncGen.next().then((res) => console.log(res)); // { value: 2, done: false }
asyncGen.next().then((res) => console.log(res)); // { value: 3, done: false }
// 返回的值是 undefined，因为没有传入任何值并且生成器已经 'done'
asyncGen.return().then((res) => console.log(res)); // { value: undefined, done: true }
// 即使生成器完成，我们仍然可以返回一个值
asyncGen.return(1).then((res) => console.log(res)); // { value: 1, done: true }
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-asyncgenerator-prototype-return |

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

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

参见
--

* `async function*`
* 迭代器和生成器指南
AggregateError() 构造函数
=====================

**`AggregateError()`** 构造函数创建了一个包装了多个错误对象的单个错误对象。

语法
--


```js
new AggregateError(errors)
new AggregateError(errors, message)
new AggregateError(errors, message, options)

AggregateError(errors)
AggregateError(errors, message)
AggregateError(errors, message, options)
```


**备注：** 调用 `AggregateError()` 可以使用或不使用 `new`，两种方法都会创建一个新的 `AggregateError` 实例。

### 参数

`errors`

一系列错误对象，实际上可能不是 `Error` 的实例。

`message` 可选

一个可选的对错误集合的可读描述。

`options` 可选

一个具有以下属性的对象：

`cause` 可选

表示错误的具体原因的属性。当捕捉并重新抛出一个带有更具体或有用的错误信息的错误时，这个属性可以用来传递原始错误。


示例
--

### 创建 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-constructor |

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

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

参见
--

* `core-js` 中 `AggregateError` 的 polyfill
* `Promise.any`
ArrayBuffer.prototype.transferToFixedLength()
=============================================

**实验性:** **这是一项实验性技术**  
在将其用于生产之前，请仔细检查浏览器兼容性表格。

`ArrayBuffer` 实例的 **`transferToFixedLength()`** 方法创建一个不可调整大小的新 `ArrayBuffer` 对象，该对象与此缓冲区具有相同的字节内容，然后将此缓冲区分离。

语法
--


```js
transferToFixedLength()
transferToFixedLength(newByteLength)
```

### 参数

`newByteLength`

新的 `ArrayBuffer` 的 `byteLength`。默认为此 `ArrayBuffer` 的 `byteLength`。

* 如果 `newByteLength` 小于此 `ArrayBuffer` 的 `byteLength`，则“溢出的”字节将被丢弃。
* 如果 `newByteLength` 大于此 `ArrayBuffer` 的 `maxByteLength`，则多余的字节用零填充。

### 返回值

一个新的 `ArrayBuffer` 对象。它的内容被初始化为此 `ArrayBuffer` 的内容，如果有多余的字节，则用零填充。新的 `ArrayBuffer` 总是不可调整大小的。原始 `ArrayBuffer` 被分离。

### 异常

`TypeError`

如果此 `ArrayBuffer` 已经分离，则抛出该错误。

描述
--

和 `transfer()` 不同，`transferToFixedLength()` 总是创建一个不可调整大小的 `ArrayBuffer`。这意味着 `newByteLength` 可以比 `maxByteLength` 大，即使此 `ArrayBuffer` 是可调整大小的。有关更多信息，请参阅传输 ArrayBuffer。

示例
--

### 将可调整大小的 ArrayBuffer 转换为固定长度


```js
const buffer = new ArrayBuffer(8, { maxByteLength: 16 });
const view = new Uint8Array(buffer);
view[1] = 2;
view[7] = 4;

const buffer2 = buffer.transferToFixedLength();
console.log(buffer2.byteLength); // 8
console.log(buffer2.resizable); // false
const view2 = new Uint8Array(buffer2);
console.log(view2[1]); // 2
console.log(view2[7]); // 4
```


通过使用 `transferToFixedLength`，`newByteLength` 可以大于原来的 `ArrayBuffer` 的 `maxByteLength`。


```js
const buffer = new ArrayBuffer(8, { maxByteLength: 16 });
const view = new Uint8Array(buffer);
view[1] = 2;
view[7] = 4;

const buffer2 = buffer.transferToFixedLength(20);
console.log(buffer2.byteLength); // 20
console.log(buffer2.resizable); // false
const view2 = new Uint8Array(buffer2);
console.log(view2[1]); // 2
console.log(view2[7]); // 4
```

规范
--

| Specification |
| --- |
| ArrayBuffer transfer # sec-arraybuffer.prototype.transfertofixedlength |

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

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

参见
--

* `ArrayBuffer`
* `ArrayBuffer.prototype.detached`
* `ArrayBuffer.prototype.transfer()`
ArrayBuffer.prototype.slice()
=============================

`ArrayBuffer` 实例的 **`slice()`** 方法返回一个新的 `ArrayBuffer` 实例，其包含原 `ArrayBuffer` 实例中从 `begin` 开始（包含）到 `end` 结束（不含）的所有字节的副本。

尝试一下
----

语法
--


```js
slice()
slice(start)
slice(start, end)
```

### 参数

`start` 可选

要开始提取的位置索引（从 0 开始），将被转换为整数。

* 负数索引将会从缓冲区末尾开始计算——如果 `start < 0`，那么将会使用 `start + buffer.length`。
* 如果 `start < -buffer.length` 或省略了 `start`，则会使用 `0`。
* 如果 `start >= buffer.length`，则不会提取任何内容。

`end` 可选

要结束提取的位置索引（从 0 开始），将被转换为整数。`slice()` 提取到但不包括 `end`。

* 负数索引将会从缓冲区末尾开始计算——如果 `end < 0`，那么将会使用 `end + buffer.length`。
* 如果 `end < -buffer.length`，则会使用 `0`。
* 如果 `end >= buffer.length` 或省略了 `end`，则会使用 `buffer.length`，则会导致直到末尾的所有元素都被提取。
* 如果标准化后的 `end` 位置在 `start` 位置之前，则不会提取任何内容。

### 返回值

一个新的 `ArrayBuffer` 对象。

示例
--

### 复制一个 ArrayBuffer


```js
const buf1 = new ArrayBuffer(8);
const buf2 = buf1.slice(0);
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer.prototype.slice |

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

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

参见
--

* `ArrayBuffer`
ArrayBuffer.prototype.resize()
==============================

`ArrayBuffer` 实例的 **`resize()`** 方法将 `ArrayBuffer` 调整为指定的大小，以字节为单位。

尝试一下
----

语法
--


```js
resize(newLength)
```

### 参数

`newLength`

`ArrayBuffer` 要调整到的新的长度，以字节为单位。

### 返回值

无（`undefined`）。

### 异常

`TypeError`

如果 `ArrayBuffer` 已分离或不可调整大小，则抛出该错误。

`RangeError`

如果 `newLength` 大于该 `ArrayBuffer` 的 `maxByteLength`，则抛出该错误。

描述
--

`resize()` 方法将 `ArrayBuffer` 调整为 `newLength` 参数指定的大小，前提是该 `ArrayBuffer` 是可调整大小的并且新的大小小于或等于该 `ArrayBuffer` 的 `maxByteLength`。新字节被初始化为 0。

请注意，你可以使用 `resize()` 来缩小和增大 `ArrayBuffer`——即使 `newLength` 小于 `ArrayBuffer` 的当前 `byteLength`。

示例
--

### 使用 resize()

在这个示例中，我们创建一个 8 字节缓冲区，该缓冲区可调整大小到的最大长度是 16 字节，然后检查其 `resizable` 属性，如果 `resizable` 返回 `true` 则调整其大小：


```js
const buffer = new ArrayBuffer(8, { maxByteLength: 16 });

if (buffer.resizable) {
  console.log("缓冲区大小是可调整的！");
  buffer.resize(12);
}
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer.prototype.resize |

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

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

参见
--

* `ArrayBuffer`
* `ArrayBuffer.prototype.resizable`
* `ArrayBuffer.prototype.maxByteLength`
ArrayBuffer.prototype.transfer()
================================

**实验性:** **这是一项实验性技术**  
在将其用于生产之前，请仔细检查浏览器兼容性表格。

`ArrayBuffer` 实例的 **`transfer()`** 方法创建一个内容与该缓冲区相同的新 `ArrayBuffer` 实例，然后将当前缓冲区分离。

语法
--


```js
transfer()
transfer(newByteLength)
```

### 参数

`newByteLength` 可选

新的 `ArrayBuffer` 的 `byteLength`。默认为当前 `ArrayBuffer` 的 `byteLength`。

* 如果 `newByteLength` 小于当前 `ArrayBuffer` 的 `byteLength`，“溢出”的字节将被丢弃。
* 如果 `newByteLength` 大于当前 `ArrayBuffer` 的 `byteLength`，剩下的的字节将用零填充。
* 如果当前的 `ArrayBuffer` 是可调整大小的，`newByteLength` 一定不能大于其 `maxByteLength`。

### 返回值

一个新的 `ArrayBuffer` 对象。其内容被初始化为当前 `ArrayBuffer` 的内容，如果有额外的字节。则填充为零。当且仅当当前 `ArrayBuffer` 是可调整大小的，新 `ArrayBuffer` 才是可调整大小的，在这种情况下，其 `maxByteLength` 和当前 `ArrayBuffer` 的相同。当前 `ArrayBuffer` 将被分离。

### 异常

`RangeError`

如果当前 `ArrayBuffer` 是可调整大小的并且 `newByteLength` 大于当前 `ArrayBuffer` 的 `maxByteLength`，则抛出此错误。

`TypeError`

如果当前 `ArrayBuffer` 已经分离，则抛出此错误。

描述
--

`transfer()` 方法执行与结构化克隆算法相同的操作。它将当前 `ArrayBuffer` 的字节复制到一个新的 `ArrayBuffer` 对象中，然后分离当前 `ArrayBuffer` 对象。有关更多信息，请参阅传输 ArrayBuffer。

`transfer()` 保留了当前 `ArrayBuffer` 的大小可调整性。如果你希望新的 `ArrayBuffer` 不可调整大小，请使用 `transferToFixedLength()` 代替。没有办法通过传输使长度固定的缓冲区变为可调整大小的缓冲区。

`transfer()` 是非常高效的，因为（引擎）实现可能以零拷贝移动或 `realloc`——没有实际数据的复制——来实现此方法。

示例
--

### 传输一个 ArrayBuffer


```js
// 创建一个 ArrayBuffer 并写入一些字节
const buffer = new ArrayBuffer(8);
const view = new Uint8Array(buffer);
view[1] = 2;
view[7] = 4;

// 将缓冲区复制到另一个相同大小的缓冲区
const buffer2 = buffer.transfer();
console.log(buffer.detached); // true
console.log(buffer2.byteLength); // 8
const view2 = new Uint8Array(buffer2);
console.log(view2[1]); // 2
console.log(view2[7]); // 4

// 将缓冲区复制到一个更小的缓冲区
const buffer3 = buffer2.transfer(4);
console.log(buffer3.byteLength); // 4
const view3 = new Uint8Array(buffer3);
console.log(view3[1]); // 2
console.log(view3[7]); // undefined

// 将缓冲区复制到一个更大的缓冲区
const buffer4 = buffer3.transfer(8);
console.log(buffer4.byteLength); // 8
const view4 = new Uint8Array(buffer4);
console.log(view4[1]); // 2
console.log(view4[7]); // 0

// 已经分离，抛出 TypeError
buffer.transfer(); // TypeError: Cannot perform ArrayBuffer.prototype.transfer on a detached ArrayBuffer
```

### 传输一个可调整大小的 ArrayBuffer


```js
const buffer = new ArrayBuffer(8, { maxByteLength: 16 });
const view = new Uint8Array(buffer);
view[1] = 2;
view[7] = 4;

// 将缓冲区复制到一个更小的缓冲区
const buffer2 = buffer.transfer(4);
console.log(buffer2.byteLength); // 4
console.log(buffer2.maxByteLength); // 16
const view2 = new Uint8Array(buffer2);
console.log(view2[1]); // 2
console.log(view2[7]); // undefined
buffer2.resize(8);
console.log(view2[7]); // 0

// 将缓冲区复制到一个大小在 maxByteLength 內但更大的缓冲区
const buffer3 = buffer2.transfer(12);
console.log(buffer3.byteLength); // 12

// 将缓冲区复制到一个大小超过 maxByteLength 的更大的缓冲区
buffer3.transfer(20); // RangeError: Invalid array buffer length
```

规范
--

| Specification |
| --- |
| ArrayBuffer transfer # sec-arraybuffer.prototype.transfer |

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

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

参见
--

* `ArrayBuffer`
* `ArrayBuffer.prototype.detached`
* `ArrayBuffer.prototype.transferToFixedLength()`