recursal/MDN huggingface dataset:
Promise.reject()
================

**`Promise.reject()`** は静的メソッドで、引数で与えられた理由で拒否された `Promise` オブジェクトを返します。

試してみましょう
--------

構文
--


```js
Promise.reject(reason)
```

### 引数

`reason`

この `Promise` が拒否された理由です。

### 返値

与えられた理由で拒否された `Promise` です。

解説
--

静的な `Promise.reject` 関数は拒否された `Promise` を返します。デバッグのために捕捉するエラーを選別したい場合は、 `reason` を `instanceof` `Error` にかけると良いでしょう。

`Promise.reject()` は汎用的であり、サブクラス化に対応しています。つまり、 `Promise` のサブクラスで呼び出すことができ、その結果はサブクラスの種類のプロミスになります。これを行うには、サブクラスのコンストラクターは `Promise()` コンストラクターと同じ呼び出し定義を実装する必要があります。これは、 `resolve` と `reject` コールバックを引数として呼び出すことができる単一の `executor` 関数を引数に取ります。 `Promise.reject()` は、本質的に `new Promise((resolve, reject) => reject(reason))` の短縮形です。

`Promise.resolve()` とは異なり、 `Promise.reject()` は `reason` がすでに `Promise` であっても、常に新しい `Promise` オブジェクトで `reason` をラップします。

例
-

### 静的な Promise.reject() メソッドの使用


```js
Promise.reject(new Error("fail")).then(
  () => {
    // not called
  },
  (error) => {
    console.error(error); // Stacktrace
  },
);
```

### プロミスの拒否

`Promise.resolve` とは異なり、 `Promise.reject` メソッドは既存の `Promise` インスタンスを再利用することはありません。常に `reason` を包んだ新しい `Promise` インスタンスを返します。


```js
const p = Promise.resolve(1);
const rejected = Promise.reject(p);
console.log(rejected === p); // false
rejected.catch((v) => {
  console.log(v === p); // true
});
```

### Promise 以外のコンストラクターに対する reject() の呼び出し

`Promise.reject()` は汎用的なメソッドです。これは `Promise()` コンストラクターと同じ呼び出し定義を実装した任意のコンストラクターで呼び出すことができます。例えば、 `console.log` を `reject` として渡すコンストラクターで呼び出すことができます。


```js
class NotPromise {
  constructor(executor) {
    // The "resolve" and "reject" functions behave nothing like the
    // native promise's, but Promise.reject() calls them in the same way.
    executor(
      (value) => console.log("Resolved", value),
      (reason) => console.log("Rejected", reason),
    );
  }
}

Promise.reject.call(NotPromise, "foo"); // Logs "Rejected foo"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.reject |

ブラウザーの互換性
---------

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

関連情報
----

* `Promise`
Promise() コンストラクター
==================

**`Promise`** コンストラクターは、主にまだプロミスに対応していない関数をラップするために使用します。

試してみましょう
--------

構文
--


```js
new Promise(executor);
```

### 引数

`executor`

新しい `Promise` オブジェクトを構築する過程でコンストラクターによって呼び出される関数 (`function`) です。 `executor` は結果をプロミスに結びつけるカスタムコードです。プログラマーが `executor` を書きます。この関数の形式は次のようなものであると期待されます。


```js
    function(resolutionFunc, rejectionFunc){
      // 通常は非同期操作です。
    }
```


`resolutionFunc` と `rejectionFunc` も関数で、実際には好きな名前を付けることができます。呼び出し形式は単純で、単一の任意の型の引数を受け付けます。


```js
    resolutionFunc(value) // 解決した時に呼び出し
    rejectionFunc(reason) // 拒否した時に呼び出し
```


`resolutionFunc` の `value` 引数は他のプロミスオブジェクトにすることもでき、そうするとそのプロミスはプロミス連鎖の中に動的に挿入されます。

`executor` については、以下のことを理解することが重要です。

* `executor` の返値は無視されます。
* `executor` の中でエラーが発生した場合、プロミスは拒否されます。

つまり、 `executor` の中のコードが効果を発揮する仕組みは、次のようなものです。

* コンストラクターが新しい `Promise` オブジェクトを生成した時点で、対応する `resolutionFunc` と `rejectionFunc` の一対の関数も生成されます。これらは `Promise` オブジェクトに「結束」されます。
* `executor` 内のコードは、何らかの操作を行う機会を得、その結果を（値が他の Promise オブジェクトでない場合）「解決済み」または「拒否済み」として反映し、それぞれ `resolutionFunc` または `rejectionFunc` を呼び出して終了します。
* つまり、`executor` 内のコードは、 `resolutionFunc` や `rejectionFunc` による副次的影響を介して通信を行います。その副次的影響とは、 `Promise` オブジェクトが「解決済み」または「拒否済み」になることです。

以上のことを踏まえて、典型的な流れをまとめてみました。

1. `executor` の中の操作は非同期であり、コールバックを提供します。
2. コールバックは `executor` コードの中で定義されます。
3. コールバックは `resolutionFunc` を呼び出して終了します。
4. `resolutionFunc` の呼び出しには `value` 引数が含まれます。
5. `value` は繋がっている `Promise` オブジェクトに送り返されます。
6. `Promise` オブジェクトは（非同期に）関連付けられた `.then(handleResolved)` を呼び出します。
7. `.then(handleResolved)` から受け取った `value` は、 `handleResolved` の呼び出しで入力引数として渡されます（プロミスの連鎖を参照してください）。

### 返値

`new` を通じて呼び出された場合、 `Promise` コンストラクターはプロミスオブジェクトを返します。このプロミスオブジェクトは、 `resolutionFunc` 関数または `rejectionFunc` 関数が呼び出されると「解決」になります。なお、 `resolutionFunc` または `rejectionFunc` を別な Promise オブジェクトを引数にして呼び出すと、これが「解決」であると言えますが、「満足」であるとは言えません。

例
-

### 新しい Promise の作成

`Promise` オブジェクトは `new` キーワードとコンストラクターで作成されます。コンストラクターは「executor 関数」と呼ばれる引数を取ります。 これは 2 つの関数を引数として取ります。 1 つ目の関数 (`resolve`) は非同期タスクが成功して完了した場合に呼び出され、タスクの結果を値として返します。2 つ目の関数 (`reject`) はタスクが失敗した場合に呼び出され、失敗した理由（ふつうはエラーオブジェクト）を返します。


```js
const myFirstPromise = new Promise((resolve, reject) => {
  // 次のどちらかを呼び出す非同期処理を行います。
  //
  // resolve(someValue) // 履行
  // または
  // reject("failure reason") // 拒否
});
```

### Promise を返す関数の作成

関数にプロミス機能を提供するには、次のように単にプロミスを返すようにします。


```js
function myAsyncFunction(url) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open("GET", url);
    xhr.onload = () => resolve(xhr.responseText);
    xhr.onerror = () => reject(xhr.statusText);
    xhr.send();
  });
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise-constructor |

ブラウザーの互換性
---------

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

関連情報
----

* `Promise` のポリフィルは `core-js` で利用できます
* プロミスの使用
Int32Array() コンストラクター
=====================

**`Int32Array()`** は型付き配列のコンストラクターで、プラットフォームのバイト順による 2 の補数形式の 32 ビット符号付き整数値の配列を生成します。バイト順の制御が必要な場合は、代わりに `DataView` を使用してください。中身は `0` で初期化されます。生成されると、配列の中の要素はオブジェクトのメソッドを使用するか、配列の標準的な添字の構文を使用するか (すなわち、ブラケット構文を使用するか) して参照することができます。

構文
--
```

new Int32Array(); // new in ES2017
new Int32Array(length);
new Int32Array(typedArray);
new Int32Array(object);
new Int32Array(buffer [, byteOffset [, length]]);
```

### 引数

`length`

`length` 引数付きで呼び出されると、メモリ内に内部的な配列バッファーを作成し、大きさは `length` *を `BYTES_PER_ELEMENT`* で乗じたバイト数になり、ゼロになることもあります。

`typedArray`

`typedArray` 引数付きで呼び出されると、これはあらゆる型付き配列型 (例えば `Int32Array`) にすることができますが、 `typedArray` を新しい型付き配列にコピーします。 `typedArray` の中のそれぞれの値は、新しい配列にコピーされる前にコンストラクターの対応する型に変換されます。新しい型付き配列の長さは `typedArray` 引数の長さと同じになります。

`object`

`object` 引数付きで呼び出されると、あたかも `TypedArray.from()` メソッドであるかのように新しい型付き配列が生成されます。

`buffer`, `byteOffset`, `length`

`buffer` と、オプションで `byteOffset` と `length` 引数を指定して呼び出されると、指定された `ArrayBuffer` を表示する型付き配列ビューが生成されます。 `byteOffset` および `length` 引数は、型付き配列ビューが表示するメモリ範囲を指定する。 両方を省略した場合は `buffer` の全てを表示し、 `length` のみを省略した場合は `buffer` の残りを表示します。

例
-

### 様々な方法による Int32Array の生成


```js
// From a length
var int32 = new Int32Array(2);
int32[0] = 42;
console.log(int32[0]); // 42
console.log(int32.length); // 2
console.log(int32.BYTES\_PER\_ELEMENT); // 4

// From an array
var arr = new Int32Array([21, 31]);
console.log(arr[1]); // 31

// From another TypedArray
var x = new Int32Array([21, 31]);
var y = new Int32Array(x);
console.log(y[0]); // 21

// From an ArrayBuffer
var buffer = new ArrayBuffer(16);
var z = new Int32Array(buffer, 0, 4);

// From an iterable
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var int32 = new Int32Array(iterable);
// Int32Array[1, 2, 3]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray-constructors |

ブラウザーの互換性
---------

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

### 互換性メモ

ECMAScript 2015 から、 `Int32Array` コンストラクターは構築に `new` 演算子が必要になりました。 `Int32Array` コンストラクターを `new` なしで関数として呼び出すと、 `TypeError` が発生するようになりました。


```js
var dv = Int32Array([1, 2, 3]);
// TypeError: calling a builtin Int32Array constructor
// without new is forbidden
```



```js
var dv = new Int32Array([1, 2, 3]);
```

関連情報
----

* JavaScript 型付き配列
* `ArrayBuffer`
* `DataView`
BigInt.asIntN()
===============

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

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

* Learn more
* See full compatibility
* Report feedback
**`BigInt.asIntN`** は静的メソッドで、 BigInt 値を符号付き整数値に丸め、その値を返します。

試してみましょう
--------

構文
--


```js
BigInt.asIntN(bits, bigint);
```

### 引数

`bits`

整数の大きさのために利用できるビットの数です。

`bigint`

指定されたビット数に丸める BigInt 値です。

### 返値

`bigint` を 2^`bits` で割った剰余の値の符号付き整数です。

例
-

### 64 ビットの範囲に収める

`BigInt.asIntN()` メソッドは、 64 ビットの数値の範囲に収めるのに便利です。


```js
const max = 2n \*\* (64n - 1n) - 1n;

BigInt.asIntN(64, max);
// ↪ 9223372036854775807n

BigInt.asIntN(64, max + 1n);
// ↪ -9223372036854775808n
// オーバーフローするので負数になる
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint.asintn |

ブラウザーの互換性
---------

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

関連情報
----

* `BigInt`
* `BigInt.asUintN()`
BigInt.prototype.toString()
===========================

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

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

* Learn more
* See full compatibility
* Report feedback
**`toString()`** メソッドは、指定した `BigInt` オブジェクトを表す文字列を返します。末尾の "n" は文字列の一部にはなりません。

試してみましょう
--------

構文
--


```js
toString();
toString(radix);
```

### 引数

`radix`省略可

オプション。数値を表す底に指定する 2 以上 36 以下の整数（基数）。

### 返値

指定した `BigInt` オブジェクトを表す文字列。

### 例外

`RangeError`

`toString()` に 2 未満または 36 より大きな基数を与えられた場合、`RangeError` が発生します。

解説
--

`BigInt` オブジェクトは `Object` の `toString()` メソッドをオーバーライドします。つまり、 `Object.prototype.toString()` を継承しません。 `BigInt` オブジェクトでは、`toString()` メソッドは指定された基数によるオブジェクトの文字列表現を返します。

`toString()` メソッドは 1 番目の引数を解釈し、指定された基数（底）による文字列表現を返そうとします。10 より大きな基数が指定された場合は、 9 より大きな数値をアルファベットで示します。例えば、16 進数（底が 16）では `a` から `f` が使用されます。

`radix` が指定されなかった場合は、基数として 10 が指定されたとみなします。

`bigIntObj` が負の数だった場合、符号は保持されます。これは、基数が 2 だった場合にも適用されます。つまり、返値の文字列は、`bigIntObj` の正の 2 進数表現の先頭に `-` 符号が付いたものであり、`bigIntObj` の 2 の補数**ではありません。**

例
-

### `toString` の使用


```js
17n.toString(); // '17'
66n.toString(2); // '1000010'
254n.toString(16); // 'fe'
-10n.toString(2); // -1010'
-0xffn.toString(2); // '-11111111'
```

### `BigInt` における負の 0

整数に負の 0 が存在しないのと同様に、`BigInt` には負の 0 がありません。 `-0.0` は JavaScript の `Number` 型にのみ現れる、IEEE 浮動小数点数の概念です。


```js
(-0n).toString(); // '0'
BigInt(-0).toString(); // '0'
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint.prototype.tostring |

ブラウザーの互換性
---------

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

関連情報
----

* `BigInt.prototype.toLocaleString()`
* `BigInt.prototype.valueOf()`
* `Number.prototype.toString()`
BigInt.prototype.valueOf()
==========================

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

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

* Learn more
* See full compatibility
* Report feedback
**`valueOf()`** メソッドは、 `BigInt` オブジェクトにラップされたプリミティブ値を返します。

試してみましょう
--------

構文
--


```js
bigIntObj.valueOf();
```

### 返値

指定された `BigInt` オブジェクトのプリミティブ値を表す BigInt です。

例
-

### `valueOf` の使用


```js
typeof Object(1n); // object
typeof Object(1n).valueOf(); // bigint
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint.prototype.valueof |

ブラウザーの互換性
---------

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

関連情報
----

* `BigInt.prototype.toString()`
BigInt() コンストラクター
=================

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

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

* Learn more
* See full compatibility
* Report feedback
**`BigInt()`** コンストラクターは **bigint** 型の値を返します。

構文
--


```js
BigInt(value);
```

### 引数

`value`

作成しようとしているオブジェクトの数値。文字列または整数にすることができます。


**メモ:** `BigInt()` は `new` 演算子と共には使用されません。

例
-

### 新しい BigInt の生成


```js
BigInt(123);
// 123n
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint-constructor |

ブラウザーの互換性
---------

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

関連情報
----

* `BigInt` クラス
BigInt.asUintN()
================

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

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

* Learn more
* See full compatibility
* Report feedback
**`BigInt.asUintN`** 静的メソッドは、 BigInt 値を符号なし整数に丸め、その値を返します。

試してみましょう
--------

構文
--


```js
BigInt.asUintN(bits, bigint);
```

### 引数

`bits`

整数の大きさのために利用できるビット数。

`bigint`

指定されたビット数に収めるよう丸める整数値。

返値
--

`bigint` を 2^`bits` で割った剰余の値の符号なし整数です。

例
-

### 64ビットの範囲に収める

`BigInt.asUintN()` メソッドは、64ビットの数値の範囲に収めるのに便利です。


```js
const max = 2n \*\* 64n - 1n;

BigInt.asUintN(64, max);
// ↪ 18446744073709551615n

BigInt.asUintN(64, max + 1n);
// ↪ 0n
// オーバーフローするのでゼロになる
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint.asuintn |

ブラウザーの互換性
---------

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

関連情報
----

* `BigInt`
* `BigInt.asIntN()`
BigInt.prototype.toLocaleString()
=================================

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

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

* Learn more
* See full compatibility
* Report feedback
**`toLocaleString()`** メソッドは、この BigInt 値の言語に合わせた表現の文字列を返します。

試してみましょう
--------

構文
--


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

### 引数

`locales` および `options` の引数は、この関数の動作をカスタマイズするためのもので、アプリケーションは整形の慣例を使用する言語を指定することができます。 `locales` や `options` の引数を無視する実装では、使用するロケールや返す文字列の形式はすべて実装に依存します。

これらの引数や使用方法について、詳しくは `Intl.NumberFormat()`
コンストラクター を参照してください。

### 返値

指定された BigInt の言語に合わせた表現の文字列です。

性能
--

大量の数値を整形する場合は、 `Intl.NumberFormat` オブジェクトを生成して `NumberFormat.format` プロパティで提供される関数を使用したほうが有利です。

例
-

### `toLocaleString` の使用

ロケールを使用しない基本的な使用では、既定のロケールと既定のオプションで成形された文字列が返されます。


```js
var bigint = 3500n;

bigint.toLocaleString();
// "3,500" と表示 (U.S. English ロケールの場合)
```

### `locales` の使用

この例ではローカライズされた数値書式の変化形の一部を示しています。アプリケーションのユーザーインターフェイスで使用されている言語の書式を取得するには、必ず `locale` 引きお数でその言語を (場合によっては予備の言語も) 指定してください。


```js
var bigint = 123456789123456789n;

// ドイツ語では千の位の区切りにピリオドを使用
console.log(bigint.toLocaleString("de-DE"));
// → 123.456.789.123.456.789

// 多くのアラビア語を話す国ではアラビア語で東アラビア数字を使用
console.log(bigint.toLocaleString("ar-EG"));
// → ١٢٣٬٤٥٦٬٧٨٩٬١٢٣٬٤٥٦٬٧٨٩

// インドでは千/十万/千万の区切りを使用
console.log(bigint.toLocaleString("en-IN"));
// → 1,23,45,67,89,12,34,56,789

// nu 拡張キーは数値体系を要求。例えば中国語の数字の場合
console.log(bigint.toLocaleString("zh-Hans-CN-u-nu-hanidec"));
// → 一二三,四五六,七八九,一二三,四五六,七八九

// 要求した言語に対応していない場合、例えばバリ語の場合、
// 予備の言語、この場合はインドネシア語を使用
console.log(bigint.toLocaleString(["ban", "id"]));
// → 123.456.789.123.456.789
```

### `options` の使用

`toLocaleString` で提供される結果は `options` 引数でカスタマイズできます。


```js
var bigint = 123456789123456789n;

// 通貨書式を要求
console.log(
  bigint.toLocaleString("de-DE", { style: "currency", currency: "EUR" }),
);
// → 123.456.789.123.456.789,00 €

// 日本円には下位の単位がない
console.log(
  bigint.toLocaleString("ja-JP", { style: "currency", currency: "JPY" }),
);
// → ￥123,456,789,123,456,789

// 有効数字を 3 桁に限定
console.log(bigint.toLocaleString("en-IN", { maximumSignificantDigits: 3 }));
// → 1,23,00,00,00,00,00,00,000
```

仕様書
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sup-bigint.prototype.tolocalestring |

ブラウザーの互換性
---------

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

関連情報
----

* `BigInt.toString()`
ArrayBuffer.isView()
====================

**`ArrayBuffer.isView()`** メソッドは、渡された値が `ArrayBuffer` のビューのうちの一つ、例えば型付き配列オブジェクトや `DataView` であるかどうかを判断します。

試してみましょう
--------

構文
--


```js
ArrayBuffer.isView(value)
```

### 引数

`value`

チェックする値です。

### 返値

渡された引数が `ArrayBuffer` のビューのうちの一つであれば `true` を、そうでなければ `false` を返します。

例
-

### isView の使用


```js
ArrayBuffer.isView(); // false
ArrayBuffer.isView([]); // false
ArrayBuffer.isView({}); // false
ArrayBuffer.isView(null); // false
ArrayBuffer.isView(undefined); // false
ArrayBuffer.isView(new ArrayBuffer(10)); // false

ArrayBuffer.isView(new Uint8Array()); // true
ArrayBuffer.isView(new Float32Array()); // true
ArrayBuffer.isView(new Int8Array(10).subarray(0, 3)); // true

const buffer = new ArrayBuffer(2);
const dv = new DataView(buffer);
ArrayBuffer.isView(dv); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer.isview |

ブラウザーの互換性
---------

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

関連情報
----

* JavaScript の型付き配列
ArrayBuffer() コンストラクター
======================

**`ArrayBuffer()`** コンストラクターは `ArrayBuffer` オブジェクトを生成するために使用されます。

試してみましょう
--------

構文
--


```js
new ArrayBuffer(length)
new ArrayBuffer(length, options)
```


**メモ:** `ArrayBuffer()` は `new` でのみ構築することができます。`new` 無しで呼び出そうとすると、`TypeError` が発生します。

### 引数

`length`

作成する配列バッファーのサイズをバイト単位で指定します。

`options` 省略可 
Experimental

オブジェクトであり、以下のプロパティを持つことができます。

`maxByteLength` 省略可 
Experimental

配列バッファーがサイズ変更可能な最大サイズ（バイト単位）。


### 返値

指定したサイズの新しい `ArrayBuffer` オブジェクト。その `maxByteLength` プロパティには、`maxByteLength` を指定した場合はその値が設定されます。内容は 0 に初期化されます。

### 例外

`RangeError`

以下のいずれかに該当する場合に発生します。

* `length` または `maxByteLength` が `Number.MAX_SAFE_INTEGER` (≥ 253) より大きいか、負の数である。
* `length` が `maxByteLength` より大きい。

例
-

### ArrayBuffer の作成

この例では、バッファーを参照する `Int32Array` ビューを持つ 8 バイトのバッファーを作成しています。


```js
const buffer = new ArrayBuffer(8);
const view = new Int32Array(buffer);
```

### サイズ変更可能な ArrayBuffer の作成

この例では、最大 16 バイトまでリサイズ可能な 8 バイトのバッファーを作成し、`resize()` でそれを 12 バイトにサイズ変更しています。


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

buffer.resize(12);
```


**メモ:** `maxByteLength` は使用する用途に応じて使用可能な最小値に設定することが推奨されます。メモリ不足になる危険を縮小するために、`1073741824` (1GB) を超えないようにする必要があります。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer-constructor |

ブラウザーの互換性
---------

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

関連情報
----

* `ArrayBuffer` のポリフィル (`core-js`)
* JavaScript 型付き配列
* `SharedArrayBuffer`
ArrayBuffer.prototype.byteLength
================================

**`byteLength`** アクセサープロパティは、`ArrayBuffer` の長さをバイト単位で表します。

試してみましょう
--------

解説
--

`byteLength` プロパティはアクセサープロパティで、設定アクセサー関数が `undefined` であるため、このプロパティは読み取ることしかできません。値は配列が構築されるときに設定され、変更することができません。この `ArrayBuffer` が取り外された場合、このプロパティは 0 を返します。

例
-

### byteLength の使用


```js
const buffer = new ArrayBuffer(8);
buffer.byteLength; // 8
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-arraybuffer.prototype.bytelength |

ブラウザーの互換性
---------

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

関連情報
----

* `ArrayBuffer`
ArrayBuffer.prototype.maxByteLength
===================================

**Experimental:** **これは実験的な機能です。**  
本番で使用する前にブラウザー互換性一覧表をチェックしてください。

**`maxByteLength`** は `ArrayBuffer` インスタンスのアクセサープロパティで、`ArrayBuffer` がサイズ変更可能な最大長をバイト数で表します。

試してみましょう
--------

解説
--

`maxByteLength` プロパティはアクセサープロパティであり、その設定アクセサー関数が `undefined` であるため、このプロパティは読み取ることしかできません。この値は配列の構築時に、 `maxByteLength` オプションを `ArrayBuffer()` コンストラクターで設定した際に設定され、変更することができません。

このプロパティは、この `ArrayBuffer` が切り離されている場合は 0 を返し ます。この `ArrayBuffer` が `maxByteLength` の値を指定せずに構築された場合、このプロパティは `ArrayBuffer` の `byteLength` の値と等しい値を返します。

例
-

### maxByteLength の使用

この例では、最大 16 バイトまでサイズ変更可能な 8 バイトのバッファーが作成され、その`maxByteLength`を返しています。


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

buffer.maxByteLength; // 16
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-arraybuffer.prototype.maxbytelength |

ブラウザーの互換性
---------

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

関連情報
----

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

**Experimental:** **これは実験的な機能です。**  
本番で使用する前にブラウザー互換性一覧表をチェックしてください。

**`resizable`** は `ArrayBuffer` インスタンスのアクセサープロパティで、この `ArrayBuffer` がサイズ変更かどうかを表します。

試してみましょう
--------

解説
--

`resizable` プロパティはアクセサープロパティであり、設定アクセサー関数が `undefined` であるためこのプロパティは読み取ることしかできません。この値は、この配列が構築されるときに確定されます。コンストラクターで `maxByteLength` オプションが設定されていれば `resizable` は `true` を返し、そうでなければ `false` を返します。

例
-

### resizable の使用

この例では、最大 16 バイトの長さにサイズ変更可能な 8 バイトのバッファーを作成し、`resizable` プロパティを調べて、`resizable` が true を返す場合にサイズ変更します。


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

if (buffer.resizable) {
  console.log("Buffer is resizable!");
  buffer.resize(12);
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-arraybuffer.prototype.resizable |

ブラウザーの互換性
---------

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

関連情報
----

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

**`slice()`** メソッドは新しい `ArrayBuffer` を返し、その中にこの `ArrayBuffer` の `begin` から `end` の手前までをコピーします。

試してみましょう
--------

構文
--


```js
slice(begin)
slice(begin, end)
```

### 引数

`begin`

スライスの起点を表すゼロ基点のバイトインデックスです。

`end` 省略可

スライスがその前で終了するバイトインデックスです。end を指定しなかった場合、新しい `ArrayBuffer` は、この `ArrayBuffer` の起点から終点まですべてのバイトを含みます。

### 返値

新しい `ArrayBuffer` オブジェクト。

解説
--

`slice()` メソッドは、`end` 引数で指定されたバイトの手前までコピーを行います。`begin` または `end` のどちらかが負の数の場合は、開始位置とは反対に、配列の末尾からのインデックスを参照します。

`begin` および `end` 引数で指定された範囲は、現在の配列で妥当なインデックスの範囲に丸められます。新しい `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`
get ArrayBuffer[@@species]
==========================

**`ArrayBuffer[@@species]`** は静的アクセサープロパティで、配列バッファーメソッドから返値を作成するために使用されるコンストラクタを返します。

**警告:** `@@species` が存在することで、任意のコードを実行することができ、セキュリティ上の脆弱性を⽣じる可能性があります。また、ある種の最適化もとても難しくなります。エンジンの実装者はこの機能を削除するかどうかを調査しています。可能であれば、この機能に頼らないでください。

構文
--


```js
ArrayBuffer[Symbol.species];
```

### 返値

`get @@species` が呼び出されたコンストラクター (`this`) の値です。この返値は、新しい配列バッファーを作成する配列バッファーのメソッドから返値を作成するために使用されます。

解説
--

`@@species` アクセサープロパティは、既定のコンストラクターである `ArrayBuffer` オブジェクトを返します。サブクラスのコンストラクターはコンストラクターに代入することで、これをオーバーライドできます。


```js
// 説明のための仮想の基盤実装
class ArrayBuffer {
  static get [Symbol.species]() {
    return this;
  }
}
```


この 多態的な実装のために、派生したサブクラスの `@@species` も既定値ではコンストラクター自身を返すことになります。


```js
class SubArrayBuffer extends ArrayBuffer {}
SubArrayBuffer[Symbol.species] === SubArrayBuffer; // true
```


既存のオブジェクトを変異させず、新しい配列バッファーのインスタンスを返す配列バッファーのメソッド（例: `slice()`) を呼び出す場合、オブジェクトの `constructor[@species]` にアクセスすることになります。返されたコンストラクターは、配列バッファーメソッドの返値を構成するために使用されます。

例
-

### 通常のオブジェクトの spicies

species プロパティは、`ArrayBuffer` オブジェクトの既定のコンストラクター関数である `ArrayBuffer` コンストラクターを返します。


```js
ArrayBuffer[Symbol.species]; // ArrayBuffer() 関数
```

### 派生オブジェクトの spicies

派生コレクションオブジェクト（たとえば、独自の配列バッファーである `MyArrayBuffer`）では、`MyArrayBuffer` の species は `MyArrayBuffer` コンストラクターです。しかし、派生クラスのメソッドで、親である `ArrayBuffer` オブジェクトを返すためにこれをオーバーライドしたいかもしれません。


```js
class MyArrayBuffer extends ArrayBuffer {
  // MyArrayBuffer species を親である ArrayBuffer コンストラクタにオーバーライド。
  static get [Symbol.species]() {
    return ArrayBuffer;
  }
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-arraybuffer-@@species |

ブラウザーの互換性
---------

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

関連情報
----

* `ArrayBuffer`
* `Symbol.species`