SharedArrayBuffer.prototype.slice() - JavaScript

SharedArrayBuffer.prototype.slice()
===================================

**`SharedArrayBuffer.prototype.slice()`** メソッドは、新しい `SharedArrayBuffer` を生成し、その内容にこの `SharedArrayBuffer` のバイトを先頭位置 (含む) から末尾位置 (含まない) までをコピーして返します。先頭または末尾が負の値であった場合は、配列の先頭からではなく、末尾からの位置になります。このメソッドは `Array.prototype.slice()` と同じアルゴリズムです。

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

構文
--

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

### 引数

`begin` 省略可

取り出す先頭位置を表す 0 から始まるインデックスです。

 負のインデックスを使用して、配列の末尾からのオフセットを示すことが可能です。
 `slice(-2)` は並びの最後の2つの要素を取り出します。

`begin` が undefined であった場合は、 `slice` は `0` の位置から取り出し始めます。

`end` 省略可

0 から始まるインデックスで、取り出す範囲の末尾の*前*を示します。 `slice` はここまでを取り出しますが、 `end` は含めません。

例えば、 `slice(1,4)` は2番目から4番目までの要素を取り出します（インデックスが 1, 2, 3 の要素）。

負のインデックスを使用して、配列の末尾からのオフセットを示すことが可能です。 `slice(2,-1)` は 3 番目から、並びの最後から 2 番目までの要素を取り出します。

`end` が省略されると、 `slice` は並びの最後 (`sab.byteLength`) までの範囲を取り出します。

### 返値

取り出した要素をが入った新しい `SharedArrayBuffer` です。

例
-

### slice() の使用

```js
const sab = new SharedArrayBuffer(1024);
sab.slice(); // SharedArrayBuffer { byteLength: 1024 }
sab.slice(2); // SharedArrayBuffer { byteLength: 1022 }
sab.slice(-2); // SharedArrayBuffer { byteLength: 2 }
sab.slice(0, 1); // SharedArrayBuffer { byteLength: 1 }
```

仕様書
---

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

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

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

関連情報
----

* `SharedArrayBuffer`
* `Array.prototype.slice()`


SharedArrayBuffer.prototype.byteLength - JavaScript

SharedArrayBuffer.prototype.byteLength
======================================

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

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

解説
--

`byteLength` プロパティは、 set アクセサー関数が `undefined` であるアクセサープロパティです。つまり、このプロパティは読み取り専用です。値は共有配列が生成されたときに決定され、変更できません。

例
-

### byteLength の使用

```js
const sab = new SharedArrayBuffer(1024);
sab.byteLength; // 1024
```

仕様書
---

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

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

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

関連情報
----

* `SharedArrayBuffer`


Float32Array() コンストラクター - JavaScript

Float32Array() コンストラクター
=======================

**`Float32Array()`** は型付き配列のコンストラクターで、新しい `Float32Array` オブジェクト、すなわち 32 ビット浮動小数点数 (C 言語の `float` データ型に相当) の配列をプラットフォームのバイトオーダーで生成します。バイトオーダーを制御する必要がある場合は、代わりに `DataView` を使用してください。生成後は、オブジェクトのメソッドや、標準の配列の添字構文 (すなわち角括弧表記) を用いて配列の要素を参照することができます。

構文
--
```

new Float32Array(); // new in ES2017
new Float32Array(length);
new Float32Array(typedArray);
new Float32Array(object);
new Float32Array(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` の残りがビューとなります。

例
-

### Float32Array を生成するための様々な方法

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

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

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

// From an ArrayBuffer
var buffer = new ArrayBuffer(32);
var z = new Float32Array(buffer, 0, 4);

// From an iterable
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var float32 = new Float32Array(iterable);
// Float32Array[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 から、 `Float32Array` コンストラクターは `new` 演算子を使用して構築する必要があります。 `new` 演算子を使用せずに `Float32Array` コンストラクターを呼び出した場合、 `TypeError` が発生するようになりました。

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

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

関連情報
----

* JavaScript typed arrays
* `ArrayBuffer`
* `DataView`


Uint32Array() コンストラクター - JavaScript

Uint32Array() コンストラクター
======================

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

構文
--
```

new Uint32Array(); // new in ES2017
new Uint32Array(length);
new Uint32Array(typedArray);
new Uint32Array(object);
new Uint32Array(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` の残りを表示します。

例
-

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

```js
// 長さを指定
var uint32 = new Uint32Array(2);
uint32[0] = 42;
console.log(uint32[0]); // 42
console.log(uint32.length); // 2
console.log(uint32.BYTES\_PER\_ELEMENT); // 4

// 配列から
var arr = new Uint32Array([21, 31]);
console.log(arr[1]); // 31

// 他の型付き配列から
var x = new Uint32Array([21, 31]);
var y = new Uint32Array(x);
console.log(y[0]); // 21

// ArrayBuffer から
var buffer = new ArrayBuffer(16);
var z = new Uint32Array(buffer, 0, 4);

// 反復可能オブジェクトから
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var uint32 = new Uint32Array(iterable);
// Uint32Array[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 から、 `Uint32Array` コンストラクターは構築に `new` 演算子が必要になりました。 `Uint32Array` コンストラクターを `new` なしで関数として呼び出すと、 `TypeError` が発生するようになりました。

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

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

関連情報
----

* JavaScript 型付き配列
* `ArrayBuffer`
* `DataView`


TypedArray.prototype.includes() - JavaScript

TypedArray.prototype.includes()
===============================

**`includes()`** は `TypedArray` インスタンスのメソッドで、型付き配列の項目内に特定の値が含まれているかどうかを判断し、その結果に応じて `true` か `false` を返します。このメソッドは `Array.prototype.includes()` と同じアルゴリズムです。

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

構文
--

```js
includes(searchElement)
includes(searchElement, fromIndex)
```

### 引数

`searchElement`

探す対象の要素

`fromIndex` 省略可

検索を始める位置を示すゼロ基点のインデックスで、整数に変換されます。

### 返値

論理値で、型付き配列（指定する場合はインデックス `fromIndex` で示される型付き配列の一部）内で値 `searchElement` が見つかった場合に `true` なります。

解説
--

詳細については、 `Array.prototype.includes()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### includes の使用

```js
const uint8 = new Uint8Array([1, 2, 3]);
uint8.includes(2); // true
uint8.includes(4); // false
uint8.includes(3, 3); // false

// NaN の扱い (Float32 および Float64 に限り true)
new Uint8Array([NaN]).includes(NaN); // false (コンストラクターに渡した NaN は 0 に変換されるため)
new Float32Array([NaN]).includes(NaN); // true;
new Float64Array([NaN]).includes(NaN); // true;
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.includes |

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

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

関連情報
----

* `TypedArray.prototype.includes` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.indexOf()`
* `TypedArray.prototype.find()`
* `TypedArray.prototype.findIndex()`
* `Array.prototype.includes()`
* `String.prototype.includes()`


TypedArray.prototype.forEach() - JavaScript

TypedArray.prototype.forEach()
==============================

**`forEach()`** は `TypedArray` インスタンスのメソッドで、型付き配列の要素ごとに一度与えられた関数を実行します。このメソッドのアルゴリズムは `Array.prototype.forEach()` と同じです。

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

構文
--

```js
forEach(callbackFn)
forEach(callbackFn, thisArg)
```

### 引数

`callbackFn`

型付き配列のそれぞれの要素に対して実行する関数です。返値は破棄されます。この関数は以下の引数で呼び出されます。

`element`

現在処理されている型付き配列の要素です。

`index`

現在処理されている型付き配列の要素のインデックスです。

`array`

`forEach()` が呼び出されている型付き配列です。

`thisArg` 省略可

`callbackFn` を実行する際に `this` として使用する値。反復処理メソッドを参照してください。

### 返値

なし (`undefined`)。

解説
--

詳細については、 `Array.prototype.forEach()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 型付き配列の内容をログに出力する

以下のコードは型付き配列内の各要素を 1 行ずつ出力します。

```js
function logArrayElements(element, index, array) {
  console.log(`a[${index}] = ${element}`);
}

new Uint8Array([0, 1, 2, 3]).forEach(logArrayElements);
// 出力:
// a[0] = 0
// a[1] = 1
// a[2] = 2
// a[3] = 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.foreach |

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

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

関連情報
----

* `TypedArray.prototype.forEach` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.find()`
* `TypedArray.prototype.map()`
* `TypedArray.prototype.filter()`
* `TypedArray.prototype.every()`
* `TypedArray.prototype.some()`
* `Array.prototype.forEach()`
* `Map.prototype.forEach()`
* `Set.prototype.forEach()`


TypedArray.prototype.reduceRight() - JavaScript

TypedArray.prototype.reduceRight()
==================================

**`reduceRight()`** は `TypedArray` インスタンスのメソッドで、アキュームレーターと型付き配列のそれぞれの値に対して（右から左へ）関数を適用していき、単一の値にまとめます。このメソッドは、`Array.prototype.reduceRight()`と同じアルゴリズムです。

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

構文
--

```js
reduceRight(callbackFn)
reduceRight(callbackFn, initialValue)
```

### 引数

`callbackFn`

型付き配列の各要素に対して実行される関数です。その返値は、次に `callbackFn` を呼び出す際の `accumulator` 引数の値になります。最後の呼び出しでは、返値は `reduce()` の返値となります。この関数は以下の引数で呼び出されます。

`accumulator`

前回 `callbackFn` を呼び出した結果の値。最初の呼び出しでは、後で `initialValue` を指定した場合はその値になり、指定されなかった場合は型付き配列の最後の要素になります。

`currentValue`

現在の要素の値。最初の呼び出しでは、 `initialValue` を指定した場合は最後の要素となり、指定しなかった場合は最後から 2 番目の要素となります。

`currentIndex`

型付き配列の `currentValue` を入力するインデックスの位置。最初の呼び出しで `initialValue` を指定した場合は `array.length - 1`、そうでない場合は `array.length - 2` となります。

`array`

`reduceRight()` が呼び出された型付き配列。

`initialValue` 省略可

`callbackFn` を最初に呼び出す際の `accumulator` として使用される値。初期値が与えられなかった場合は、型付き配列の最後の要素が使用され、その値はスキップされます。初期値のない空の型付き配列に対して `reduceRight()` を呼び出すと `TypeError` が発生します。

### 返値

畳み込みによって得られた 1 つの値です。

解説
--

詳細については、 `Array.prototype.reduceRight()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 配列内のすべての値を合計する

```js
const total = new Uint8Array([0, 1, 2, 3]).reduceRight((a, b) => a + b);
// total === 6
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.reduceright |

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

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

関連情報
----

* `TypedArray.prototype.reduceRight` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.map()`
* `TypedArray.prototype.reduce()`
* `Array.prototype.reduceRight()`
* `Object.groupBy()`
* `Map.groupBy()`


TypedArray.prototype.subarray() - JavaScript

TypedArray.prototype.subarray()
===============================

**`subarray()`** は `TypedArray` インスタンスのメソッドで、同じ `ArrayBuffer` ストアにおいて、この型付き配列オブジェクトと同じ要素の型をもつ新しい型付き配列を返します。先頭のオフセットは**含み**、末尾のオフセットは**含みません**。

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

構文
--

```js
subarray()
subarray(begin)
subarray(begin, end)
```

### 引数

`begin` 省略可

先頭の要素です。この位置は含まれます。この値が指定されていない場合、配列全体が新しいビューに含まれます。

`end` 省略可

末尾の要素です。この位置は含まれません。この値が指定されていない場合、 `begin` によって指定された要素から配列の最後まですべての要素が新しいビューに含まれます。

### 返値

新しい `TypedArray` オブジェクトです。

解説
--

`begin` と `end` によって指定される範囲は、現在の配列に対して有効なインデックスの範囲に丸められます。すなわち、新しい範囲の計算された長さがマイナスなら、ゼロになります。 `begin` か `end` のどちらかがマイナスなら、配列の最初からではなく、最後からインデックスを参照します。

既存のバッファー上に新しいビューを作っていることにも注意して下さい。すなわち、新しいオブジェクトの内容への変更は、元のオブジェクトに強い影響を与えます。逆もまた同様です。

例
-

### subarray() メソッドの使用

```js
const buffer = new ArrayBuffer(8);
const uint8 = new Uint8Array(buffer);
uint8.set([1, 2, 3]);

console.log(uint8); // Uint8Array [ 1, 2, 3, 0, 0, 0, 0, 0 ]

const sub = uint8.subarray(0, 4);

console.log(sub); // Uint8Array [ 1, 2, 3, 0 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.subarray |

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

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

関連情報
----

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


TypedArray.prototype.indexOf() - JavaScript

TypedArray.prototype.indexOf()
==============================

**`indexOf()`** は `TypedArray` インスタンスのメソッドで、指定された要素が型付き配列内で見つかった最初のインデックスを返し、存在しなければ -1 を返します。このメソッドは `Array.prototype.indexOf()` と同じアルゴリズムです。

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

構文
--

```js
indexOf(searchElement)
indexOf(searchElement, fromIndex)
```

### 引数

`searchElement`

型付き配列内を検索する要素。

`fromIndex` 省略可

検索を始める位置を示すゼロ基点のインデックスで、整数に変換されます。

### 返値

型付き配列内の最初の `searchElement` のインデックスです。見つからなかったら `-1` になります。

解説
--

詳細については、 `Array.prototype.indexOf()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### indexOf() の使用

```js
const uint8 = new Uint8Array([2, 5, 9]);
uint8.indexOf(2); // 0
uint8.indexOf(7); // -1
uint8.indexOf(9, 2); // 2
uint8.indexOf(2, -1); // -1
uint8.indexOf(2, -3); // 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.indexof |

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

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

関連情報
----

* `TypedArray.prototype.indexOf` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.findIndex()`
* `TypedArray.prototype.findLastIndex()`
* `TypedArray.prototype.lastIndexOf()`
* `Array.prototype.indexOf()`
* `String.prototype.indexOf()`


TypedArray.prototype.findIndex() - JavaScript

TypedArray.prototype.findIndex()
================================

**`findIndex()`** は `TypedArray` インスタンスのメソッドで、指定されたテスト関数を満たす型付き配列の最初の要素のインデックスを返します。テスト関数を満たす要素がない場合、 -1 を返します。このメソッドのアルゴリズムは `Array.prototype.findIndex()` と同じです。

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

構文
--

```js
findIndex(callbackFn)
findIndex(callbackFn, thisArg)
```

### 引数

`callbackFn`

配列のそれぞれの要素に対して実行する関数です。要素がテストに合格した場合は真値を返し、そうでなければ偽値を返す必要があります。この関数は以下の引数で呼び出されます。

`element`

現在処理されている型付き配列の要素です。

`index`

現在処理されている型付き配列の要素のインデックスです。

`array`

`findIndex()` が実行されている型付き配列です。

`thisArg` 省略可

`callbackFn` を実行する際に `this` として使用する値。反復処理メソッドを参照してください。

### 返値

テストを通った配列の要素の位置を返します。それ以外の場合は、 `-1` を返します。

解説
--

詳細については、 `Array.prototype.findIndex()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 型付き配列内の素数の位置を検索する

次の例では、型付き配列の中で素数の入った最初の要素の位置を返し、素数が見つからなかった場合は `-1` を返します。

```js
function isPrime(element, index, array) {
  let start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

const uint8 = new Uint8Array([4, 6, 8, 12]);
const uint16 = new Uint16Array([4, 6, 7, 12]);

console.log(uint8.findIndex(isPrime)); // -1, not found
console.log(uint16.findIndex(isPrime)); // 2
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.findindex |

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

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

関連情報
----

* `TypedArray.prototype.findIndex` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.find()`
* `TypedArray.prototype.findLast()`
* `TypedArray.prototype.findLastIndex()`
* `TypedArray.prototype.indexOf()`
* `TypedArray.prototype.lastIndexOf()`
* `Array.prototype.findIndex()`


TypedArray.prototype.buffer - JavaScript

TypedArray.prototype.buffer
===========================

**`buffer`** は `TypedArray` インスタンスのアクセサープロパティで、構築時点にこの型付き配列が参照する `ArrayBuffer` または `SharedArrayBuffer` を返します。

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

解説
--

`byteLength` プロパティは設定アクセサープロパティが `undefined` である、読み取り専用のアクセサープロパティです。値は *TypedArray* が構築されたときに確立し、変更することができません。 *TypedArray* は型付き配列オブジェクトのうちの一つです。

型付き配列はバッファーのビューであるため、基盤となるバッファーは型付き配列自体よりも長い場合があります。

例
-

### buffer プロパティの使用

```js
const buffer = new ArrayBuffer(8);
const uint16 = new Uint16Array(buffer);
uint16.buffer; // ArrayBuffer { byteLength: 8 }
```

### 配列の断片のビューから、基盤のバッファーにアクセス

```js
const buffer = new ArrayBuffer(1024);
const arr = new Uint8Array(buffer, 64, 128);
console.log(arr.byteLength); // 128
console.log(arr.buffer.byteLength); // 1024
console.log(arr.buffer === buffer); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%.prototype.buffer |

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

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

関連情報
----

* JavaScript の型付き配列
* `TypedArray`


TypedArray.prototype[@@iterator]() - JavaScript

TypedArray.prototype[@@iterator]()
==================================

**`[@@iterator]()`** は `TypedArray` インスタンスのプロパティで、反復可能プロトコルを実装し、型付き配列をスプレッド構文や `for...of` ループのような反復可能オブジェクトを想定するほとんどの構文で利用できるようにするためのものです。この型付き配列の各要素の値を返す配列イテレーターオブジェクトを返します。

このプロパティの初期値は `TypedArray.prototype.values` プロパティの初期値と同じ関数オブジェクトです。

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

構文
--

```js
typedArray[Symbol.iterator]()
```

### 引数

なし。

### 返値

`TypedArray.prototype.values()` と同じ返値で、この型付き配列のすべての要素の値を返す、新しい反復可能イテレーターオブジェクトを返します。

例
-

### for...of ループを使用した反復処理

このメソッドを直接呼び出す必要はめったにないことに注意してください。`@@iterator` メソッドの存在により、型付き配列は反復可能となり、 `for...of` ループのような反復処理構文は、ループするために自動的にこのメソッドを呼び出し、イテレータを取得します。

```js
const arr = new Uint8Array([10, 20, 30, 40, 50]);
for (const n of arr) {
  console.log(n);
}
```

### 手動でイテレーターを手繰る

反復処理を最大限に制御するために、返すイテレーターオブジェクトの `next()` メソッドを手動で呼び出すことができます。

```js
const arr = new Uint8Array([10, 20, 30, 40, 50]);
const arrIter = arr[Symbol.iterator]();
console.log(arrIter.next().value); // 10
console.log(arrIter.next().value); // 20
console.log(arrIter.next().value); // 30
console.log(arrIter.next().value); // 40
console.log(arrIter.next().value); // 50
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype-@@iterator |

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

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

関連情報
----

* `TypedArray.prototype[@@iterator]` のポリフィル (`core-js`)
* JavaScript の型付き配列
* `TypedArray`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.keys()`
* `TypedArray.prototype.values()`
* `Symbol.iterator`
* 反復処理プロトコル


TypedArray.prototype.toSorted() - JavaScript

TypedArray.prototype.toSorted()
===============================

**`toSorted()`** は `TypedArray` インスタンスのメソッドで、 `sort()` メソッドのコピーメソッド版です。これは、要素を昇順にソートした新しい型付き配列を返します。このメソッドは `Array.prototype.toSorted()` と同じアルゴリズムですが、既定で文字列としてではなく数値として値をソートする点が異なります。

構文
--

```js
toSorted()
toSorted(compareFn)
```

### 引数

`compareFn` 省略可

ソート順を定義する関数です。返値は、 2 つの要素の相対順序を示す符号を持つ数値でなければなりません。

`a`

比較のための最初の要素です。

`b`

比較のための 2 つ目の要素です。

### 返値

要素を昇順にソートした新しい型付き配列です。

解説
--

詳細については、 `Array.prototype.toSorted()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 配列のソート

その他の例については、 `Array.prototype.sort()` メソッドもご覧ください。

```js
const numbers = new Uint8Array([40, 1, 5, 200]);
const numberSorted = numbers.toSorted();
console.log(numberSorted); // Uint8Array [ 1, 5, 40, 200 ]
// 通常の配列とは異なり、数値の並べ替えでは比較関数が
// 要求されません。
console.log(numbers); // Uint8Array [ 40, 1, 5, 200 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.tosorted |

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

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

関連情報
----

* `TypedArray.prototype.toSorted` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray.prototype.sort()`
* `TypedArray.prototype.toReversed()`
* `TypedArray.prototype.with()`
* `Array.prototype.toSorted()`


TypedArray.prototype.sort() - JavaScript

TypedArray.prototype.sort()
===========================

**`sort()`** は `TypedArray` インスタンスのメソッドで、型付き配列の要素をその場 (in-place) でソートし、その型付き配列を返します。このメソッドは `Array.prototype.sort()` と同じアルゴリズムですが、既定で文字列としてではなく数値として値をソートする点が異なります。

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

構文
--

```js
sort()
sort(compareFn)
```

### 引数

`compareFn` 省略可

ソート順を定義する関数です。返値は、 2 つの要素の相対順序を示す符号を持つ数値でなければなりません。 `a` が `b` より小さい場合は負の値、`a` が `b` より大きい場合は正の値、等しい場合は 0 です。 `NaN` は `0` として扱われます。この関数は以下の引数で呼び出されます。

`a`

比較のための最初の要素。決して `undefined` にはなりません。

`b`

比較のための2つ目の要素。決して `undefined` にはなりません。

省略した場合、型付き配列の要素は数値順にソートされます。

### 返値

ソートされた型付き配列の元配列への参照です。型付き配列はその場 (in-place) でソートされ，コピーは行われないことに注意してください。

解説
--

詳細については、 `Array.prototype.sort()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### sort() の使用

他の例は、 `Array.prototype.sort()` メソッドです。

```js
let numbers = new Uint8Array([40, 1, 5, 200]);
numbers.sort();
// Uint8Array [ 1, 5, 40, 200 ]
// ふつうの配列とは異なり、数値的に数値を並べ替えるためには
// 比較関数は必要ありません。

// ふつうの配列は数値で並べ替えるために比較関数を必要とします。
numbers = [40, 1, 5, 200];
numbers.sort();
// [1, 200, 40, 5]

numbers.sort((a, b) => a - b); // 数値を比較
// [ 1, 5, 40, 200 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.sort |

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

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

関連情報
----

* `TypedArray.prototype.sort` の現代の動作の安定したソートのポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.reverse()`
* `TypedArray.prototype.toSorted()`
* `Array.prototype.sort()`


TypedArray.from() - JavaScript

TypedArray.from()
=================

**`TypedArray.from()`** メソッドは、配列風オブジェクトや反復可能オブジェクトから新しい型付き配列を生成します。このメソッドは `Array.from()` とほぼ同じです。

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

構文
--

```js
TypedArray.from(arrayLike, mapFn)
TypedArray.from(arrayLike, mapFn, thisArg)
```

ここで `TypedArray` は次のいずれかです。

* `Int8Array`
* `Uint8Array`
* `Uint8ClampedArray`
* `Int16Array`
* `Uint16Array`
* `Int32Array`
* `Uint32Array`
* `Float32Array`
* `Float64Array`
* `BigInt64Array`
* `BigUint64Array`
### 引数

`arrayLike`

型付き配列に変換する反復可能または配列風オブジェクトです。

`mapFn` 省略可

型付き配列の各要素に対して呼び出す関数です。指定された場合、配列に追加するすべての値は最初にこの関数に渡され、代わりに `mapFn` の返値が型付き配列に追加されます。この関数は以下の引数で呼び出されます。

`element`

現在処理されている型付き配列の要素です。

`index`

現在処理されている型付き配列の要素のインデックスです。

`thisArg` 省略可

`mapFn` を実行するときに `this` として使う値です。

### 返値

新しい `TypedArray` インスタンスです。

解説
--

詳しくは `Array.from()` を娯楽んだ歳。

`Array.from()` と `TypedArray.from()` の間には微妙な違いがあります（メモ: 下記で言及する `this` 値は `TypedArray.from()` が呼び出された `this` 値であり、 `mapFn` を呼び出すために用いた `thisArg` 引数ではありません）。

* `TypedArray.from()` に渡された `this` の値がコンストラクターではなかった場合、 `TypedArray.from()` で `TypeError` が発生します。それに対して `Array.from()` が既定で新しい `Array` を生成します。
* `this` で構築されるオブジェクトは `TypedArray` インスタンスでなければなりませんが、 `Array.from()` は `this` の値を任意のオブジェクトに構築することができます。
* 引数 `source` がイテレーターの場合、 `TypedArray.from()` は最初にイテレーターからすべての値を収集し、次にそのカウントを使用して `this` のインスタンスを作成し、最後にそのインスタンスに値を設定します。 `Array.from()` はイテレーターから値を受け取るとそれぞれの値を設定し、最後に `length` を設定します。
* `TypedArray.from()` は `[[Set]]` を使用します。 `Array.from()` は `[[DefineOwnProperty]]` を使用します。 従って `Proxy` オブジェクトを使っている場合は、新しい要素を追加するときに `handler.set()` が `handler.defineProperty()` の代わりに呼び出されます。
* `Array.from()` がイテレーターではない配列風オブジェクトを受け取ったときは、穴をそのまま残します。 `TypedArray.from()` は必ず密配列 (dense array) を生成します。
例
-

### 反復可能オブジェクトから (Set)

```js
const s = new Set([1, 2, 3]);
Uint8Array.from(s);
// Uint8Array [ 1, 2, 3 ]
```

### 文字列から

```js
Int16Array.from("123");
// Int16Array [ 1, 2, 3 ]
```

### アロー関数と map の使用

アロー関数をマップ関数として使用して要素を操作します。

```js
Float32Array.from([1, 2, 3], (x) => x + x);
// Float32Array [ 2, 4, 6 ]
```

### 数列を生成する

```js
Uint8Array.from({ length: 5 }, (v, k) => k);
// Uint8Array [ 0, 1, 2, 3, 4 ]
```

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

`from()` の `this` 値は `TypedArray` インスタンスを返すコンストラクターでなければなりません。

```js
function NotArray(len) {
  console.log("NotArray called with length", len);
}

Int8Array.from.call({}, []); // TypeError: #<Object> is not a constructor
Int8Array.from.call(NotArray, []);
// NotArray called with length 0
// TypeError: Method %TypedArray%.from called on incompatible receiver #<NotArray>
```

```js
function NotArray2(len) {
  console.log("NotArray2 called with length", len);
  return new Uint8Array(len);
}
console.log(Int8Array.from.call(NotArray2, [1, 2, 3]));
// NotArray2 called with length 3
// Uint8Array(3) [ 1, 2, 3 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.from |

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

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

関連情報
----

* `TypedArray.from` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.of()`
* `TypedArray.prototype.map()`
* `Array.from()`


TypedArray.prototype.findLastIndex() - JavaScript

TypedArray.prototype.findLastIndex()
====================================

**`findLastIndex()`** は `TypedArray` インスタンスのメソッドで、型付き配列を逆順で反復処理し、指定したテスト関数を満たす最初の要素のインデックスを返します。テスト関数を満たす値がなかった場合は、-1 を返します。このメソッドのアルゴリズムは `Array.prototype.findLastIndex()` と同じです。

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

構文
--

```js
findLastIndex(callbackFn)
findLastIndex(callbackFn, thisArg)
```

### 引数

`callbackFn`

配列のそれぞれの要素に対して実行する関数です。要素がテストに合格した場合は真値を返し、そうでなければ偽値を返す必要があります。この関数は以下の引数で呼び出されます。

`element`

現在処理されている型付き配列の要素です。

`index`

現在処理されている型付き配列の要素のインデックスです。

`array`

`findLastIndex()` が実行されている型付き配列です。

`thisArg` 省略可

`callbackFn` を実行する際に `this` として使用する値。反復処理メソッドを参照してください。

### 返値

 テストに合格した要素のうち、配列の最後（最も大きなインデックス）の要素のインデックス。
 一致する要素が見つからなかった場合に -1 を返します。

解説
--

詳細については、 `Array.prototype.findLastIndex()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 型付き配列から素数のインデックスを探す

以下の例では、配列の中で素数である最後の要素のインデックスを探します。素数がない場合は `-1` を返します。

```js
function isPrime(element) {
  if (element % 2 === 0 || element < 2) {
    return false;
  }
  for (let factor = 3; factor <= Math.sqrt(element); factor += 2) {
    if (element % factor === 0) {
      return false;
    }
  }
  return true;
}

let uint8 = new Uint8Array([4, 6, 8, 12]);
console.log(uint8.findLastIndex(isPrime));
// -1 （配列に素数がない）
uint8 = new Uint8Array([4, 5, 7, 8, 9, 11, 12]);
console.log(uint8.findLastIndex(isPrime));
// 5
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.findlastindex |

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

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

関連情報
----

* `TypedArray.prototype.findLastIndex` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.find()`
* `TypedArray.prototype.findIndex()`
* `TypedArray.prototype.findLast()`
* `TypedArray.prototype.indexOf()`
* `TypedArray.prototype.lastIndexOf()`
* `Array.prototype.findLastIndex()`


TypedArray.prototype.reduce() - JavaScript

TypedArray.prototype.reduce()
=============================

**`reduce()`** は `TypedArray` インスタンスのメソッドで、型付き配列のそれぞれの要素に対して、ユーザーが提供した「縮小」コールバック関数を呼び出します。その際、直前の要素における計算結果の返値を渡します。型付き配列のすべての要素に対して縮小関数を実行した結果が単一の値が最終結果になります。このメソッドは、`Array.prototype.reduce()`と同じアルゴリズムです。

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

構文
--

```js
reduce(callbackFn)
reduce(callbackFn, initialValue)
```

### 引数

`callbackFn`

型付き配列の各要素に対して実行される関数です。その返値は、次に `callbackFn` を呼び出す際の `accumulator` 引数の値になります。最後の呼び出しでは、返値は `reduce()` の返値となります。この関数は以下の引数で呼び出されます。

`accumulator`

前回 `callbackFn` を呼び出した結果の値。最初の呼び出しでは、後で `initialValue` を指定した場合はその値になり、指定されなかった場合は `array[0]` になります。

`currentValue`

現在の要素の値。最初の呼び出しでは、 `initialValue` を指定した場合は `array[0]` となり、指定しなかった場合は `array[1]` となります。

`currentIndex`

型付き配列の `currentValue` を入力するインデックスの位置。最初の呼び出しで `initialValue` を指定した場合は `0`、そうでない場合は `1` となります。

`array`

`reduce()` が呼び出された型付き配列。

`initialValue` 省略可

 コールバックが最初に呼び出された時に `accumulator` が初期化される値です。
 `initialValue` が指定された場合、`callbackFn` は配列の最初の値を `currentValue` として実行を開始します。
 もし `initialValue` が指定されなかった場合、`accumulator` は配列の最初の値に初期化され、`callbackFn` は配列の 2 つ目の値を `currentValue` として実行を開始します。この場合、配列が空であれば（`accumulator`として返す最初の値がなければ）エラーが発生します。

### 返値

型付き配列全体にわたって「縮小」コールバック関数を実行した結果の値です。

### 例外

`TypeError`

型付き配列に要素がなく、かつ `initialValue` が提供されなかった場合に発生します。

解説
--

詳細については、 `Array.prototype.reduce()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 配列内のすべての値を合計する

```js
const total = new Uint8Array([0, 1, 2, 3]).reduce((a, b) => a + b);
// total === 6
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.reduce |

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

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

関連情報
----

* `TypedArray.prototype.reduce` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.map()`
* `TypedArray.prototype.reduceRight()`
* `Array.prototype.reduce()`
* `Object.groupBy()`
* `Map.groupBy()`


TypedArray.prototype.toString() - JavaScript

TypedArray.prototype.toString()
===============================

**`toString()`** は `TypedArray` インスタンスのメソッドで、指定された配列とその要素を表す文字列を返します。このメソッドは `Array.prototype.toString()` と同じアルゴリズムです。

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

構文
--

```js
toString()
```

### 引数

なし。

### 返値

型付き配列の要素を表す文字列です。

解説
--

詳細については、 `Array.prototype.toString()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 型付き配列を文字列へ変換

```js
const uint8 = new Uint8Array([1, 2, 3]);
// 明示的な変換
console.log(uint8.toString()); // 1,2,3
// 暗黙の変換
console.log(`${uint8}`); // 1,2,3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.tostring |

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

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

関連情報
----

* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.join()`
* `TypedArray.prototype.toLocaleString()`
* `Array.prototype.toString()`
* `String.prototype.toString()`


TypedArray.prototype.copyWithin() - JavaScript

TypedArray.prototype.copyWithin()
=================================

**`copyWithin()`** は `TypedArray` インスタンスのメソッドで、この型付き配列の一部を同じ型付き配列の別の場所にシャローコピーし、この型付き配列の長さを変更せずに返します。このメソッドは `Array.prototype.copyWithin()` と同じアルゴリズムです。

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

構文
--

```js
copyWithin(target, start)
copyWithin(target, start, end)
```

### 引数

`target`

並びのコピー先となるゼロ基点のインデックスで、整数に変換されます。これは `start` にある要素がコピーされる場所に対応し、`start` から `end` までのすべての要素が後続のインデックスにコピーされます。

`start`

コピー元でコピーを始める位置のゼロ基点のインデックスで、整数に変換されます。

`end` 省略可

コピー元でコピーを終える位置のゼロ基点のインデックスで、整数に変換されます。 `copyWithin()` はここまでをコピーしますが、 `end` は含みません。

### 返値

変更された型付き配列です。

解説
--

詳細については、 `Array.prototype.copyWithin()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### copyWithin() の使用

```js
const buffer = new ArrayBuffer(8);
const uint8 = new Uint8Array(buffer);
uint8.set([1, 2, 3]);
console.log(uint8); // Uint8Array [ 1, 2, 3, 0, 0, 0, 0, 0 ]
uint8.copyWithin(3, 0, 3);
console.log(uint8); // Uint8Array [ 1, 2, 3, 1, 2, 3, 0, 0 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.copywithin |

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

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

関連情報
----

* `TypedArray.prototype.copyWithin` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `Array.prototype.copyWithin()`


TypedArray.prototype.at() - JavaScript

TypedArray.prototype.at()
=========================

**`at()`** は `TypedArray` インスタンスのメソッドで整数値を受け取り、そのインデックスにある項目を返します。整数値には正の整数と負の整数が使用できます。負の整数の場合は、この型付き配列の末尾の項目から前に数えます。このメソッドは `Array.prototype.at()` と同じアルゴリズムです。

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

構文
--

```js
at(index)
```

### 引数

`index`

返される配列要素のゼロ基点のインデックスで、整数に変換されます。負の添字を使用した場合は、配列の末尾から逆に数えた位置です。 `index < 0` であれば、 `index + array.length` がアクセスされます。

### 返値

指定されたインデックスに一致する型付き配列の要素です。 `index < -array.length` または `index >= array.length` の場合は、対応するプロパティにアクセスしようとせずに常に `undefined` を返します。

解説
--

詳細は `Array.prototype.at()` を参照してください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 型付き配列の最後の値を返す

次の例は、指定した配列の中で最後に見つかった要素を返す関数を提供する例です。

```js
const uint8 = new Uint8Array([1, 2, 4, 7, 11, 18]);

// 指定された配列の最後の項目を返す関数です。
function returnLast(arr) {
  return arr.at(-1);
}

const lastItem = returnLast(uint8);
console.log(lastItem); // 18
```

### メソッドの比較

ここでは、 `TypedArray` の最後から 2 番目の項目を選択するさまざまな方法を比較しています。以下に示すどの方法も有効ですが、`at()` メソッドの簡潔さと読みやすさが際立っています。

```js
// Our typed array with values
const uint8 = new Uint8Array([1, 2, 4, 7, 11, 18]);

// Using length property
const lengthWay = uint8[uint8.length - 2];
console.log(lengthWay); // 11

// Using slice() method. Note an array is returned
const sliceWay = uint8.slice(-2, -1);
console.log(sliceWay[0]); // 11

// Using at() method
const atWay = uint8.at(-2);
console.log(atWay); // 11
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.at |

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

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

関連情報
----

* `TypedArray.prototype.at` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.findIndex()`
* `TypedArray.prototype.indexOf()`
* `TypedArray.prototype.with()`
* `Array.prototype.at()`
* `String.prototype.at()`


TypedArray[@@species] - JavaScript

TypedArray[@@species]
=====================

**`TypedArray[@@species]`** は静的アクセサープロパティで、型付き配列のメソッドの返値を構築するのに使われるコンストラクターを返します。

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

構文
--

```js
TypedArray[Symbol.species]
```

### 返値

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

解説
--

`@@species` アクセサープロパティは、型付き配列オブジェクトの既定のコンストラクターを返します。サブクラスのコンストラクターは、コンストラクターの割り当てを変更するために、これをオーバーライドできます。

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

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

```js
class SubTypedArray extends Int8Array {}
SubTypedArray[Symbol.species] === SubTypedArray; // true
```

既存の配列を変更せず、新しい配列のインスタンスを返す型付き配列のメソッド（例えば、 `filter()` や `map()`）を呼び出した場合、配列の `constructor[@@species]` にアクセスすることになります。返されたコンストラクターは、配列の型付き配列メソッドの返値を構築するために使用されます。

しかし、`Array[@@species]` とは異なり、`@@species` を使って型付き配列を新しく作成する場合、言語が新しく作成する配列が正しい型付き配列であり、元の配列と同じ種類の内容を持つことを確認するようになっています。例えば、`BigInt64Array` から `Float64Array` を作成したり、BigInt の配列から BigInt ではない配列を作成することはできません。この場合、`TypeError` が発生します。

```js
class BadArray extends Int8Array {
  static get [Symbol.species]() {
    return Array;
  }
}
new BadArray(1).map(() => 0); // TypeError: Method %TypedArray%.prototype.map called on incompatible receiver [object Array]

class BadArray2 extends Int8Array {
  static get [Symbol.species]() {
    return BigInt64Array;
  }
}
new BadArray2(1).map(() => 0n); // TypeError: TypedArray.prototype.map constructed typed array of different content type from |this|
```

**メモ:** SpiderMonkey と V8 の両方にバグがあり、内容物の型が一致するかどうかが調べられません。2 つ目の例では Safari のみで `TypeError` が発生します。

例
-

### 普通のオブジェクト

`species` プロパティは、指定した型付き配列オブジェクトの型付き配列のコンストラクターを、既定のコンストラクター関数として返します。

```js
Int8Array[Symbol.species]; // function Int8Array()
Uint8Array[Symbol.species]; // function Uint8Array()
Float32Array[Symbol.species]; // function Float32Array()
```

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

独自の `TypedArray` のサブクラス（例えば `MyTypedArray`）のインスタンスでは、`MyTypedArray` の species は `MyTypedArray` コンストラクターとなります。しかし、派生クラスのメソッドで親の型付き配列オブジェクトを返すために、これを上書きしたい場合があります。

```js
class MyTypedArray extends Uint8Array {
  // MyTypedArray の species を親である Uint8Array コンストラクターに上書き
  static get [Symbol.species]() {
    return Uint8Array;
  }
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%-@@species |

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

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

関連情報
----

* `TypedArray`
* `Symbol.species`


TypedArray.prototype.byteLength - JavaScript

TypedArray.prototype.byteLength
===============================

**`byteLength`** は `TypedArray` のアクセサープロパティで、この型付き配列の長さを（バイト単位で）返します。

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

解説
--

`byteLength` プロパティは設定アクセサープロパティが `undefined` である、読み取り専用のアクセサープロパティです。値は *TypedArray* が構築されたときに確立し、変更することができません。 *TypedArray* が `byteOffset` や `length` を指定していないなら、参照されている `ArrayBuffer` の `length` が返されます。 *TypedArray* は型付き配列オブジェクトのうちの一つです。

例
-

### byteLength プロパティの使用

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

const uint8 = new Uint8Array(buffer);
uint8.byteLength; // 8 (matches the byteLength of the buffer)

const uint8newLength = new Uint8Array(buffer, 1, 5);
uint8newLength.byteLength; // 5 (as specified when constructing the Uint8Array)

const uint8offSet = new Uint8Array(buffer, 2);
uint8offSet.byteLength; // 6 (due to the offset of the constructed Uint8Array)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%.prototype.bytelength |

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

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

関連情報
----

* JavaScript の型付き配列
* `TypedArray`


TypedArray.prototype.slice() - JavaScript

TypedArray.prototype.slice()
============================

**`slice()`** は `TypedArray` インスタンスのメソッドで、型付き配列の一部を `start` から `end` （`end` は含まれない）まで選択された新しい型付き配列オブジェクトにコピーして返します。元の型付き配列は変更されません。このメソッドは `Array.prototype.reverse()` と同じアルゴリズムです。

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

構文
--

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

### 引数

`start` 省略可

抽出を始める位置を示すゼロ基点のインデックスで、整数に変換されます。

`end` 省略可

抽出を終了する位置を示すゼロ基点のインデックスで、整数に変換されます。 `slice()` はここまでを抽出しますが、 `end` は含みません。

### 返値

抽出された要素が入った新しい型付き配列です。

解説
--

詳細については、 `Array.prototype.slice()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 例: 既存の配列の一部を返す

```js
const uint8 = new Uint8Array([1, 2, 3]);
uint8.slice(1); // Uint8Array [ 2, 3 ]
uint8.slice(2); // Uint8Array [ 3 ]
uint8.slice(-2); // Uint8Array [ 2, 3 ]
uint8.slice(0, 1); // Uint8Array [ 1 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.slice |

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

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

関連情報
----

* `TypedArray.prototype.slice` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `Array.prototype.slice()`
* `String.prototype.slice()`


TypedArray.prototype.findLast() - JavaScript

TypedArray.prototype.findLast()
===============================

**`findLast()`** は `TypedArray` インスタンスのメソッドで、型付き配列を逆順に反復処理し、指定されたテスト関数を満たす最初の要素の値を返します。テスト関数を満たす要素がない場合は `undefined` を返します。このメソッドのアルゴリズムは `Array.prototype.findLast()` と同じです。

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

構文
--

```js
findLast(callbackFn)
findLast(callbackFn, thisArg)
```

### 引数

`callbackFn`

配列のそれぞれの要素に対して実行する関数です。要素がテストに合格した場合は真値を返し、そうでなければ偽値を返す必要があります。この関数は以下の引数で呼び出されます。

`element`

現在処理されている型付き配列の要素です。

`index`

現在処理されている型付き配列の要素のインデックスです。

`array`

`findLast()` が実行されている型付き配列です。

`thisArg` 省略可

`callbackFn` を実行する際に `this` として使用する値。反復処理メソッドを参照してください。

### 返値

指定されたテスト関数を満たす、最後の（最も大きなインデックスを持つ）型付き配列の要素です。一致する値が見つからない場合は `undefined` です。

解説
--

詳細については、 `Array.prototype.findLast()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 型付き配列から素数のインデックスを探す

以下の例では、型付き配列から素数である値のうち、最後の値を返します（素数がない場合は `undefined` を返します）。

```js
function isPrime(element) {
  if (element % 2 === 0 || element < 2) {
    return false;
  }
  for (let factor = 3; factor <= Math.sqrt(element); factor += 2) {
    if (element % factor === 0) {
      return false;
    }
  }
  return true;
}

let uint8 = new Uint8Array([4, 6, 8, 12]);
console.log(uint8.findLast(isPrime)); // undefined （配列に素数がない）
uint8 = new Uint8Array([4, 5, 7, 8, 9, 11, 12]);
console.log(uint8.findLast(isPrime)); // 11
```

### すべての要素が処理され、コールバックによって変更することがある場合

以下は、すべての要素が処理され、コールバック値に渡された値が処理時の値であることを示す例です。

```js
// インデックス 2, 3, 4 に要素のない配列を宣言。
// 欠落した要素はゼロに初期化されます。
const uint8 = new Uint8Array([0, 1, , , , 5, 6]);

// 要素を逆順に反復処理します。
// なお、すべての要素が処理されます。
uint8.findLast((value, index) => {
  console.log(`Visited index ${index} with value ${value}`);
});

// 削除されたものも含めて、すべての要素が表示されます。
uint8.findLast((value, index) => {
  // 最初の反復処理で要素 3 を変更します。
  if (index === 6) {
    console.log("Set uint8[3] to 44");
    uint8[3] = 44;
  }
  // 要素 3 はまだ処理されますが、新しい値が示されます。
  console.log(`Visited index ${index} with value ${value}`);
});
// Visited index 6 with value 6
// Visited index 5 with value 5
// Visited index 4 with value 0
// Visited index 3 with value 0
// Visited index 2 with value 0
// Visited index 1 with value 1
// Visited index 0 with value 0
// Set uint8[3] to 44
// Visited index 6 with value 6
// Visited index 5 with value 5
// Visited index 4 with value 0
// Visited index 3 with value 44
// Visited index 2 with value 0
// Visited index 1 with value 1
// Visited index 0 with value 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.findlast |

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

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

関連情報
----

* `TypedArray.prototype.findLast` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.find()`
* `TypedArray.prototype.findIndex()`
* `TypedArray.prototype.findLastIndex()`
* `TypedArray.prototype.includes()`
* `TypedArray.prototype.filter()`
* `TypedArray.prototype.every()`
* `TypedArray.prototype.some()`
* `Array.prototype.findLast()`


TypedArray.prototype.reverse() - JavaScript

TypedArray.prototype.reverse()
==============================

**`reverse()`** は `TypedArray` インスタンスのメソッドで、型付き配列をその場 (in-place) で反転し、同じ型付き配列への参照を返します。型付き配列の最初の要素は最後になり、型付き配列の最後の要素は最初になります。言い換えれば，型付き配列の他の要素の順序は，以前とは逆の順序になります。このメソッドは `Array.prototype.reverse()` と同じアルゴリズムです。

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

構文
--

```js
reverse()
```

### 引数

なし。

### 返値

反転された元の型付き配列への参照です。型付き配列はその場 (in-place) で反転され，コピーは行われないことに注意してください。

解説
--

詳細については、 `Array.prototype.reverse()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### reverse() の使用

```js
const uint8 = new Uint8Array([1, 2, 3]);
uint8.reverse();

console.log(uint8); // Uint8Array [3, 2, 1]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.reverse |

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

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

関連情報
----

* `TypedArray.prototype.reverse` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.join()`
* `TypedArray.prototype.sort()`
* `TypedArray.prototype.toReversed()`
* `Array.prototype.reverse()`


TypedArray.prototype.map() - JavaScript

TypedArray.prototype.map()
==========================

**`map()`** は `TypedArray` インスタンスのメソッドで、与えられた関数を呼び出された型付き配列のすべての要素に対して呼び出し、その結果からなる新しい型付き配列を生成します。このメソッドは、 `Array.prototype.map()` と同じアルゴリズムです。

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

構文
--

```js
map(callbackFn)
map(callbackFn, thisArg)
```

### 引数

`callbackFn`

型付き配列のそれぞれの要素に対して実行する関数。その返値は、新しい型付き配列の単一の要素として追加されます。この関数は以下の引数で呼び出されます。

`element`

型付き配列で現在処理されている要素です。

`index`

現在処理中の要素の型付き配列内におけるインデックスです。

`array`

`map()` が呼び出されてた型付き配列です。

`thisArg` 省略可

`callbackFn` を実行する際に `this` として使用する値。反復処理メソッドを参照してください。

### 返値

各要素がコールバック関数の結果である新しい型付き配列です。

解説
--

詳細については、 `Array.prototype.map()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 型付き配列を平方根の型付き配列にマッピング

次のコードは型付き配列を取り、最初の型付き配列にある数値の平方根からなる新しい型付き配列を生成します。

```js
const numbers = new Uint8Array([1, 4, 9]);
const roots = numbers.map(Math.sqrt);
// roots の内容は [1, 2, 3] となる
// numbers の内容は [1, 4, 9] のまま
```

### 引数を含む関数を使用して型付き配列をマッピングする

次のコードは、1 つの引数を必要とする関数を使用するときに `map()` がどのように動作するかを示しています。引数は元の配列を通した `map()` ループとして、配列の各要素に自動的に割り当てられます。

```js
const numbers = new Uint8Array([1, 4, 9]);
const doubles = numbers.map((num) => num \* 2);
// doubles は Uint8Array [2, 8, 18] となる
// numbers は Uint8Array [1, 4, 9] のまま
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.map |

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

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

関連情報
----

* `TypedArray.prototype.map` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.forEach()`
* `TypedArray.from()`
* `Array.prototype.map()`
* `Map`


TypedArray.prototype.fill() - JavaScript

TypedArray.prototype.fill()
===========================

**`fill()`** は `TypedArray` インスタンスのメソッドで、型付き配列のある範囲のインデックスにあるすべての要素を固定値で埋めます。これは変更された型付き配列を返します。このメソッドのアルゴリズムは `Array.prototype.fill()` と同じです。

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

構文
--

```js
fill(value)
fill(value, start)
fill(value, start, end)
```

### 引数

`value`

型付き配列を埋める値です。

`start` 省略可

埋まる範囲の開始点を表すゼロ基点のインデックスで、整数に変換されます。

`end` 省略可

埋まる範囲の終了点を表すゼロ基点のインデックスで、整数に変換されます。 `fill()` は `end` の手前までを埋めます。

### 返値

変更された配列です。

解説
--

詳細については、 `Array.prototype.fill()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### fill() の使用

```js
new Uint8Array([1, 2, 3]).fill(4); // Uint8Array [4, 4, 4]
new Uint8Array([1, 2, 3]).fill(4, 1); // Uint8Array [1, 4, 4]
new Uint8Array([1, 2, 3]).fill(4, 1, 2); // Uint8Array [1, 4, 3]
new Uint8Array([1, 2, 3]).fill(4, 1, 1); // Uint8Array [1, 2, 3]
new Uint8Array([1, 2, 3]).fill(4, -3, -2); // Uint8Array [4, 2, 3]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.fill |

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

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

関連情報
----

* `TypedArray.prototype.fill` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `Array.prototype.fill()`


TypedArray.prototype.every() - JavaScript

TypedArray.prototype.every()
============================

**`every()`** は `TypedArray` インスタンスのメソッドで、提供された関数で実装されたテストに、型付き配列内のすべての要素が合格するかどうかをテストします。これは論理値を返します。このメソッドのアルゴリズムは `Array.prototype.every()` と同じです。

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

構文
--

```js
every(callbackFn)
every(callbackFn, thisArg)
```

### 引数

`callbackFn`

配列のそれぞれの要素に対して実行する関数です。要素がテストに合格した場合は真値を返し、そうでなければ偽値を返す必要があります。この関数は以下の引数で呼び出されます。

`element`

現在処理されている型付き配列の要素です。

`index`

現在処理されている型付き配列の要素の添字です。

`array`

`every()` が実行されている型付き配列です。

`thisArg` 省略可

`callbackFn` を実行する際に `this` として使用する値。反復処理メソッドを参照してください。

### 返値

`callbackFn` 関数がいずれかの要素で偽値を返した場合は、すぐに `false` を返します。それ以外は `true` です。

解説
--

詳細については、 `Array.prototype.every()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### すべての型付き配列の要素の大きさをテストする

次の例は、型付き配列内のすべての要素が 10 以上であるかどうかテストします。

```js
function isBigEnough(element, index, array) {
  return element >= 10;
}
new Uint8Array([12, 5, 8, 130, 44]).every(isBigEnough); // false
new Uint8Array([12, 54, 18, 130, 44]).every(isBigEnough); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.every |

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

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

関連情報
----

* `TypedArray.prototype.every` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.forEach()`
* `TypedArray.prototype.some()`
* `TypedArray.prototype.find()`
* `Array.prototype.every()`


TypedArray.prototype.join() - JavaScript

TypedArray.prototype.join()
===========================

**`join()`** は `TypedArray` インスタンスのメソッドで、この型付き配列のすべての要素を、カンマまたは指定する区切り文字で連結して新しい文字列を作成して返します。型付き配列に 1 つの項目しかない場合、その項目は区切り文字を使用せずに返します。このメソッドのアルゴリズムは `Array.prototype.join()` と同じです。

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

構文
--

```js
join()
join(separator)
```

### 引数

`separator` 省略可

配列の各要素を区切る文字列を指定します。 `separator` は、必要であれば文字列に変換されます。省略した場合、配列の要素はカンマ (",") で区切られます。

### 返値

型付き配列の要素をすべて連結した文字列です。 `array.length` が `0` の場合は空文字列を返します。

解説
--

詳細については、 `Array.prototype.join()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### join() の使用

```js
const uint8 = new Uint8Array([1, 2, 3]);
uint8.join(); // '1,2,3'
uint8.join(" / "); // '1 / 2 / 3'
uint8.join(""); // '123'
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.join |

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

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

関連情報
----

* `TypedArray.prototype.join` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.toString()`
* `Array.prototype.join()`
* `String.prototype.split()`


TypedArray.prototype.byteOffset - JavaScript

TypedArray.prototype.byteOffset
===============================

**`byteOffset`** は `TypedArray` インスタンスのアクセサープロパティで、この型付き配列の `ArrayBuffer` または `SharedArrayBuffer` の開始位置からの（バイト単位の）オフセットを返します。

解説
--

`byteOffset` プロパティは set アクセサープロパティが `undefined` であるアクセサープロパティです。これは、このプロパティが読み取り専用であることを意味します。値は *TypedArray* が構築されたときに確立し、変更することができません。 *TypedArray* は型付き配列オブジェクトのうちの一つです。

例
-

### byteOffset プロパティの使用

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

const uint8array1 = new Uint8Array(buffer);
uint8array1.byteOffset; // 0 (no offset specified)

const uint8array2 = new Uint8Array(buffer, 3);
uint8array2.byteOffset; // 3 (as specified when constructing Uint8Array)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%.prototype.byteoffset |

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

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

関連情報
----

* JavaScript の型付き配列
* `TypedArray`


TypedArray.prototype.set() - JavaScript

TypedArray.prototype.set()
==========================

**`set()`** は `TypedArray` インスタンスのメソッドで、複数の値を指定した配列から入力値を読み込み、型付き配列に格納します。

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

構文
--

```js
set(array)
set(array, targetOffset)

set(typedarray)
set(typedarray, targetOffset)
```

### 引数

`array`

値のコピーする配列です。コピー元の配列からのすべての値がコピー先の配列にコピーされます。ただし、コピー元の配列の長さにオフセットを加えた長さがコピー先の配列の長さを超えた場合は、例外が発生します。

`typedarray`

コピー元の配列が型付き配列の場合、2 つの配列は同じ `ArrayBuffer` を共有することができます。 JavaScript エンジンは、バッファーのコピー元の範囲をコピー先の範囲にインテリジェントに **copy** します。

`targetOffset` 省略可

コピー先の配列へのオフセットで、コピー元の配列からの値の書き込みを開始する位置です。この値を省略した場合は 0 と見なされます（つまり、コピー元の配列はインデックス 0 から始まるコピー先配列の値を上書きします）。

### 返値

なし (`undefined`)。

### 例外

`RangeError`

以下の条件のいずれかで発生します。

* `targetOffset` が大きすぎるか、`array` または `typedarray` が大きすぎるために、要素が配列の末尾を越えて格納されることになる。
* `targetOffset` が負の数である。

例
-

### set() の使用

```js
const buffer = new ArrayBuffer(8);
const uint8 = new Uint8Array(buffer);

uint8.set([1, 2, 3], 3);

console.log(uint8); // Uint8Array [ 0, 0, 0, 1, 2, 3, 0, 0 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.set |

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

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

関連情報
----

* `TypedArray.prototype.set` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `ArrayBuffer`


TypedArray.of() - JavaScript

TypedArray.of()
===============

**`TypedArray.of()`** メソッドは、引数の変数番号から新しい型付き配列を生成します。このメソッドは `Array.of()` とほぼ同じです。

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

構文
--

```js
TypedArray.of()
TypedArray.of(element1)
TypedArray.of(element1, element2)
TypedArray.of(element1, element2, /\* …, \*/ elementN)
```

ここで `TypedArray` は次のいずれかです。

* `Int8Array`
* `Uint8Array`
* `Uint8ClampedArray`
* `Int16Array`
* `Uint16Array`
* `Int32Array`
* `Uint32Array`
* `Float32Array`
* `Float64Array`
* `BigInt64Array`
* `BigUint64Array`
### 引数

`element1`, …, `elementN`

型付き配列を作成するのに使われる要素です。

### 返値

新しい `TypedArray` のインスタンスです。

解説
--

詳細については、 `Array.of()` をご覧ください。 `Array.of()` と `TypedArray.of()` との間にはいくつか微妙な違いがあります。

* `TypedArray.of()` に渡された `this` の値がコンストラクターではなかった場合、 `TypedArray.of()` では `TypeError` が発生します。一方、 `Array.of()` は既定で新しい `Array` を生成します。
* `TypedArray.of()` は `[[Set]]` を使用するのに対し、 `Array.of()` は `[[DefineProperty]]` を使用します。従って `Proxy` オブジェクトを使っている場合は、新しい要素を追加するときに `handler.set()` が `handler.defineProperty()` の代わりに呼び出されます。
例
-

### of() の使用

```js
Uint8Array.of(1); // Uint8Array [ 1 ]
Int8Array.of("1", "2", "3"); // Int8Array [ 1, 2, 3 ]
Float32Array.of(1, 2, 3); // Float32Array [ 1, 2, 3 ]
Int16Array.of(undefined); // Int16Array [ 0 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.of |

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

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

関連情報
----

* `TypedArray.of` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.from()`
* `Array.of()`


TypedArray.prototype.length - JavaScript

TypedArray.prototype.length
===========================

**`length`** は `TypedArray` インスタンスのアクセサープロパティで、型付き配列の長さを（要素数で）返します。

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

解説
--

`length` プロパティは set アクセサープロパティが `undefined` であるアクセサープロパティです。これは、このプロパティが読み取り専用であることを意味します。値は *TypedArray* が構築されたときに確立し、変更することができません。 *TypedArray* に `byteOffset` または `length` が指定されていない場合、参照される `ArrayBuffer` の長さが返されます。 *TypedArray* は型付き配列オブジェクトのうちの一つです。

例
-

### length プロパティの使用

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

let uint8 = new Uint8Array(buffer);
uint8.length; // 8 （バッファーの長さと一致）

uint8 = new Uint8Array(buffer, 1, 5);
uint8.length; // 5 （Uint8Array の構築の際に指定された通り）

uint8 = new Uint8Array(buffer, 2);
uint8.length; // 6 （構築された Uint8Array のオフセットによる）
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%.prototype.length |

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

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

関連情報
----

* JavaScript の型付き配列
* `TypedArray`


TypedArray.prototype.keys() - JavaScript

TypedArray.prototype.keys()
===========================

**`keys()`** は `TypedArray` インスタンスのメソッドで、配列内の各インデックスに対するキーを含む新しい配列イテレーターオブジェクトを返します。このメソッドのアルゴリズムは `Array.prototype.keys()` と同じです。

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

構文
--

```js
keys()
```

### 引数

なし。

### 返値

新しい配列イテレーターオブジェクトです。

解説
--

詳細については、 `Array.prototype.keys()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### for...of を使用した反復処理

```js
const arr = new Uint8Array([10, 20, 30, 40, 50]);
const arrKeys = arr.keys();
for (const n of arrKeys) {
  console.log(n);
}
```

### 他の繰り返し処理

```js
const arr = new Uint8Array([10, 20, 30, 40, 50]);
const arrKeys = arr.keys();
console.log(arrKeys.next().value); // 0
console.log(arrKeys.next().value); // 1
console.log(arrKeys.next().value); // 2
console.log(arrKeys.next().value); // 3
console.log(arrKeys.next().value); // 4
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.keys |

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

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

関連情報
----

* `TypedArray.prototype.keys` のポリフィル (`core-js`)
* JavaScript の型付き配列
* `TypedArray`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.values()`
* `TypedArray.prototype[@@iterator]()`
* `Array.prototype.keys()`
* 反復処理プロトコル


TypedArray.prototype.filter() - JavaScript

TypedArray.prototype.filter()
=============================

**`filter()`** は `TypedArray` インスタンスのメソッドで、指定された関数で実装されているテストに合格した要素だけにフィルタリングされた、指定された型付き配列の一部のコピーを作成します。このメソッドのアルゴリズムは `Array.prototype.filter()` と同じです。

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

構文
--

```js
filter(callbackFn)
filter(callbackFn, thisArg)
```

### 引数

`callbackFn`

配列のそれぞれの要素に対して実行する関数です。要素がテストに合格した場合は真値を返し、そうでなければ偽値を返す必要があります。この関数は以下の引数で呼び出されます。

`element`

現在処理されている型付き配列の要素です。

`index`

現在処理されている型付き配列の要素のインデックスです。

`array`

`filter()` が実行されている型付き配列です。

`thisArg` 省略可

`callbackFn` を実行する際に `this` として使用する値。反復処理メソッドを参照してください。

### 返値

テストに合格した要素だけを格納した、指定された型付き配列のコピー。テストに合格する要素がない場合は、空の型付き配列を返します。

解説
--

詳細については、 `Array.prototype.filter()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 小さな値をすべて取り除く

次の例では、`filter()` を使って `10` 未満の値を持つ要素をすべて取り除いた型付き配列を生成します。

```js
function isBigEnough(element, index, array) {
  return element >= 10;
}
new Uint8Array([12, 5, 8, 130, 44]).filter(isBigEnough);
// Uint8Array [ 12, 130, 44 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.filter |

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

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

関連情報
----

* `TypedArray.prototype.filter` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.forEach()`
* `TypedArray.prototype.every()`
* `TypedArray.prototype.map()`
* `TypedArray.prototype.some()`
* `TypedArray.prototype.reduce()`
* `Array.prototype.filter()`


TypedArray.prototype.lastIndexOf() - JavaScript

TypedArray.prototype.lastIndexOf()
==================================

**`lastIndexOf()`** は `TypedArray` インスタンスのメソッドで、指定された要素が型付き配列内で見つかった最後の位置のインデックスを返し、存在しなければ -1 を返します。型付き配列は `fromIndex` で始まる位置から逆方向に検索されます。 このメソッドは `Array.prototype.lastIndexOf()` と同じアルゴリズムです。

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

構文
--

```js
lastIndexOf(searchElement)
lastIndexOf(searchElement, fromIndex)
```

### 引数

`searchElement`

型付き配列内で検索する要素。

`fromIndex` 省略可

検索を始める位置を示すゼロ基点のインデックスで、整数に変換されます。

### 返値

型付き配列内における最後の `searchElement` のインデックスです。見つからなかったら `-1` になります。

解説
--

詳細については、 `Array.prototype.lastIndexOf()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### lastIndexOf() の使用

```js
const uint8 = new Uint8Array([2, 5, 9, 2]);
uint8.lastIndexOf(2); // 3
uint8.lastIndexOf(7); // -1
uint8.lastIndexOf(2, 3); // 3
uint8.lastIndexOf(2, 2); // 0
uint8.lastIndexOf(2, -2); // 0
uint8.lastIndexOf(2, -1); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.lastindexof |

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

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

関連情報
----

* `TypedArray.prototype.lastIndexOf` のポリフィル (`core-js`)
* JavaScript の型付き配列
* `TypedArray`
* `TypedArray.prototype.findIndex()`
* `TypedArray.prototype.findLastIndex()`
* `TypedArray.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`
* `String.prototype.lastIndexOf()`


TypedArray.prototype.entries() - JavaScript

TypedArray.prototype.entries()
==============================

**`entries()`** は `TypedArray` インスタンスのメソッドで、型付き配列の各インデックスのキーと値を含む新しい配列のイテレーターオブジェクトを返します。このメソッドは `Array.prototype.entries()` と同じアルゴリズムです。

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

構文
--

```js
entries()
```

### 引数

なし。

### 返値

新しい配列イテレーターオブジェクトです。

解説
--

詳細については、 `Array.prototype.entries()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### for...of ループを使用した反復処理

```js
const array = new Uint8Array([10, 20, 30, 40, 50]);
const arrayEntries = arr.entries();
for (const element of arrayEntries) {
  console.log(element);
}
```

### 他の反復処理

```js
const array = new Uint8Array([10, 20, 30, 40, 50]);
const arrayEntries = arr.entries();

console.log(arrayEntries.next().value); // [0, 10]
console.log(arrayEntries.next().value); // [1, 20]
console.log(arrayEntries.next().value); // [2, 30]
console.log(arrayEntries.next().value); // [3, 40]
console.log(arrayEntries.next().value); // [4, 50]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.entries |

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

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

関連情報
----

* `TypedArray.prototype.entries` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.keys()`
* `TypedArray.prototype.values()`
* `TypedArray.prototype[@@iterator]()`
* `Array.prototype.entries()`
* Iteration protocols


TypedArray.prototype.values() - JavaScript

TypedArray.prototype.values()
=============================

**`values()`** は `TypedArray` インスタンスのメソッドで、配列内の各インデックスに対する値を持つ新しい配列イテレーターオブジェクトを返します。このメソッドのアルゴリズムは `Array.prototype.values()` と同じです。

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

構文
--

```js
values()
```

### 引数

なし。

### 返値

新しい配列イテレーターオブジェクトです。

解説
--

詳細については、 `Array.prototype.values()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### for...of ループを用いた反復処理

```js
const arr = new Uint8Array([10, 20, 30, 40, 50]);
const values = arr.values();
for (const n of values) {
  console.log(n);
}
```

### 他の反復処理

```js
const arr = new Uint8Array([10, 20, 30, 40, 50]);
const values = arr.values();
console.log(values.next().value); // 10
console.log(values.next().value); // 20
console.log(values.next().value); // 30
console.log(values.next().value); // 40
console.log(values.next().value); // 50
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.values |

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

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

関連情報
----

* `TypedArray.prototype.values` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.keys()`
* `TypedArray.prototype[@@iterator]()`
* `Array.prototype.values()`
* 反復処理プロトコル


TypedArray.prototype.toLocaleString() - JavaScript

TypedArray.prototype.toLocaleString()
=====================================

**`toLocaleString()`** は `TypedArray` インスタンスのメソッドで、型付き配列の要素を表す文字列を返します。要素は `toLocaleString` メソッドを使用して文字列に変換され、これらの文字列はロケール依存の文字列（カンマ "," など）で区切られます。このメソッドは `Array.prototype.toLocaleString()` と同じアルゴリズムです。

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

構文
--

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

### 引数

`locales` 省略可

BCP 47 言語タグの文字列か、その配列です。 `locales` 引数の一般的な形式と解釈については、 `Intl` メインページの引数の説明を参照してください。

`options` 省略可

構成プロパティを持つオブジェクトです。 `Number.prototype.toLocaleString()` を参照してください。

### 返値

型付き配列の要素を表す文字列です。

解説
--

詳細については、 `Array.prototype.toLocaleString()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### toLocaleString() の使用

```js
const uint = new Uint32Array([2000, 500, 8123, 12, 4212]);

uint.toLocaleString();
// de-DE ロケールで実行している場合
// "2.000,500,8.123,12,4.212"

uint.toLocaleString("en-US");
// "2,000,500,8,123,12,4,212"

uint.toLocaleString("ja-JP", { style: "currency", currency: "JPY" });
// "￥2,000,￥500,￥8,123,￥12,￥4,212"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.tolocalestring |

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

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

関連情報
----

* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.toString()`
* `Array.prototype.toLocaleString()`
* `Intl`
* `Intl.ListFormat`
* `Number.prototype.toLocaleString()`


TypedArray.prototype.with() - JavaScript

TypedArray.prototype.with()
===========================

**`with()`** は `TypedArray` インスタンスのメソッドで、ブラケット記法を使用して指定された位置の値を変更することのコピーメソッド版です。これは指定されたインデックスの要素を指定された値で置き換えた新しい配列の添字を返します。このメソッドのアルゴリズムは `Array.prototype.with()` と同じです。

構文
--

```js
arrayInstance.with(index, value)
```

### 引数

`index`

型付き配列を変更する場所を示すゼロ基点のインデックスで、整数に変換されます。

`value`

指定された位置に割り当てる値です。

### 返値

`index` の要素を `value` に置き換えた新しい型付き配列。

### 例外

`RangeError`

`index >= array.length` または `index < -array.length` の場合に発生します。

解説
--

詳細については、 `Array.prototype.with()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### with() の使用

```js
const arr = new Uint8Array([1, 2, 3, 4, 5]);
console.log(arr.with(2, 6)); // Uint8Array [1, 2, 6, 4, 5]
console.log(arr); // Uint8Array [1, 2, 3, 4, 5]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.with |

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

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

関連情報
----

* `TypedArray.prototype.with` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray.prototype.toReversed()`
* `TypedArray.prototype.toSorted()`
* `TypedArray.prototype.at()`
* `Array.prototype.with()`


TypedArray.prototype.some() - JavaScript

TypedArray.prototype.some()
===========================

**`some()`** は `TypedArray` インスタンスのメソッドで、型付き配列の中に指定された関数で実装されているテストに合格する要素が 1 つでもあるかどうかをテストします。型付き配列の中に指定された関数が true を返す要素があれば true を返し、なければ false を返します。型付き配列を変更することはありません。このメソッドは `Array.prototype.some()` と同じアルゴリズムです。

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

構文
--

```js
some(callbackFn)
some(callbackFn, thisArg)
```

### 引数

`callbackFn`

配列のそれぞれの要素に対して実行する関数です。要素がテストに合格した場合は真値を返し、そうでなければ偽値を返す必要があります。この関数は以下の引数で呼び出されます。

`element`

現在処理されている型付き配列の要素です。

`index`

現在処理されている型付き配列の要素のインデックスです。

`array`

`some()` が実行されている型付き配列です。

`thisArg` 省略可

`callbackFn` を実行する際に `this` として使用する値。反復処理メソッドを参照してください。

### 返値

型付き配列の要素に対して `callbackFn` が真値を返した場合は `true` を即座に返します。それ以外は `false` を返します。

解説
--

詳細については、 `Array.prototype.some()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 型付き配列のすべての要素の大きさをテストする

次の例では、型付き配列の中に 10 よりも大きい要素があるかどうかをテストします。

```js
function isBiggerThan10(element, index, array) {
  return element > 10;
}
new Uint8Array([2, 5, 8, 1, 4]).some(isBiggerThan10); // false
new Uint8Array([12, 5, 8, 1, 4]).some(isBiggerThan10); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.some |

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

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

関連情報
----

* `TypedArray.prototype.some` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.every()`
* `TypedArray.prototype.forEach()`
* `TypedArray.prototype.find()`
* `TypedArray.prototype.includes()`
* `Array.prototype.some()`


TypedArray.BYTES_PER_ELEMENT - JavaScript

TypedArray.BYTES\_PER\_ELEMENT
==============================

**`TypedArray.BYTES_PER_ELEMENT`** プロパティは、型付き配列内の各要素の大きさをバイト単位で表します。

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

値
-

`TypedArray` の方に応じた値を持つ数値です。

| `TypedArray.BYTES_PER_ELEMENT` のプロパティ属性 |
| --- |
| 書込可能 | 不可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

解説
--

`TypedArray`オブジェクトは、要素ごとのバイト数とバイトの解釈の仕方がそれぞれ異なります。`BYTES_PER_ELEMENT` 定数は、指定された `TypedArray` の各要素のバイト数を格納します。

`BYTES_PER_ELEMENT` プロパティはインスタンスプロパティでも静的プロパティでもあります。これは `TypedArray` サブクラスのコンストラクターとコンストラクターのインスタンスの両方で利用することができます。

インスタンスプロパティとして、`BYTES_PER_ELEMENT` はコンストラクターの `prototype` で定義されます。

```js
console.log(Object.hasOwn(Int8Array.prototype, "BYTES\_PER\_ELEMENT")); // true
```

例
-

### BYTES\_PER\_ELEMENT の使用

静的プロパティとして

```js
Int8Array.BYTES\_PER\_ELEMENT; // 1
Uint8Array.BYTES\_PER\_ELEMENT; // 1
Uint8ClampedArray.BYTES\_PER\_ELEMENT; // 1
Int16Array.BYTES\_PER\_ELEMENT; // 2
Uint16Array.BYTES\_PER\_ELEMENT; // 2
Int32Array.BYTES\_PER\_ELEMENT; // 4
Uint32Array.BYTES\_PER\_ELEMENT; // 4
Float32Array.BYTES\_PER\_ELEMENT; // 4
Float64Array.BYTES\_PER\_ELEMENT; // 8
BigInt64Array.BYTES\_PER\_ELEMENT; // 8
BigUint64Array.BYTES\_PER\_ELEMENT; // 8
```

インスタンスプロパティとして

```js
new Int8Array([]).BYTES\_PER\_ELEMENT; // 1
new Uint8Array([]).BYTES\_PER\_ELEMENT; // 1
new Uint8ClampedArray([]).BYTES\_PER\_ELEMENT; // 1
new Int16Array([]).BYTES\_PER\_ELEMENT; // 2
new Uint16Array([]).BYTES\_PER\_ELEMENT; // 2
new Int32Array([]).BYTES\_PER\_ELEMENT; // 4
new Uint32Array([]).BYTES\_PER\_ELEMENT; // 4
new Float32Array([]).BYTES\_PER\_ELEMENT; // 4
new Float64Array([]).BYTES\_PER\_ELEMENT; // 8
new BigInt64Array([]).BYTES\_PER\_ELEMENT; // 8
new BigUint64Array([]).BYTES\_PER\_ELEMENT; // 8
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray.bytes\_per\_element |

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

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

関連情報
----

* JavaScript の型付き配列
* `TypedArray`


TypedArray.prototype.find() - JavaScript

TypedArray.prototype.find()
===========================

**`find()`** は `TypedArray` インスタンスのメソッドで、型付き配列のある要素の値が与えられたテスト関数を満たした場合、その値を返します。そうでなければ `undefined` を返します。このメソッドのアルゴリズムは `Array.prototype.find()` と同じです。

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

構文
--

```js
find(callbackFn)
find(callbackFn, thisArg)
```

### 引数

`callbackFn`

配列のそれぞれの要素に対して実行する関数です。要素がテストに合格した場合は真値を返し、そうでなければ偽値を返す必要があります。この関数は以下の引数で呼び出されます。

`element`

現在処理されている型付き配列の要素です。

`index`

現在処理されている型付き配列の要素のインデックスです。

`array`

`find()` が実行されている型付き配列です。

`thisArg` 省略可

`callbackFn` を実行する際に `this` として使用する値。反復処理メソッドを参照してください。

### 返値

テストを満たした配列の要素の位置を返します。それ以外の場合は、 `undefined` を返します。

解説
--

詳細については、 `Array.prototype.find()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### 型付き配列内の素数を探す

次の例では、型付き配列内で素数である要素を探します（または、素数がない場合は `undefined` を返します）。

```js
function isPrime(element, index, array) {
  let start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

const uint8 = new Uint8Array([4, 5, 8, 12]);
console.log(uint8.find(isPrime)); // 5
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.find |

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

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

関連情報
----

* `TypedArray.prototype.find` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray`
* `TypedArray.prototype.findIndex()`
* `TypedArray.prototype.findLast()`
* `TypedArray.prototype.findLastIndex()`
* `TypedArray.prototype.includes()`
* `TypedArray.prototype.filter()`
* `TypedArray.prototype.every()`
* `TypedArray.prototype.some()`
* `Array.prototype.find()`


TypedArray.prototype.toReversed() - JavaScript

TypedArray.prototype.toReversed()
=================================

**`toReversed()`** は `TypedArray` インスタンスのメソッドで、 `reverse()` メソッドに対応するコピーメソッドです。このメソッドは、要素を逆順にした新しい型付き配列を返します。このメソッドは `Array.prototype.toReversed()` と同じアルゴリズムです。

構文
--

```js
toReversed()
```

### 引数

なし。

### 返値

要素を逆順に格納した新しい型付き配列です。

解説
--

詳細については、 `Array.prototype.toReversed()` をご覧ください。このメソッドは汎用的ではなく、型付き配列インスタンスに対してのみ呼び出すことができます。

例
-

### toReversed() の使用

```js
const uint8 = new Uint8Array([1, 2, 3]);
const reversedUint8 = uint8.toReversed();
console.log(reversedUint8); // Uint8Array [3, 2, 1]
console.log(uint8); // Uint8Array [1, 2, 3]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.toreversed |

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

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

関連情報
----

* `TypedArray.prototype.toReversed` のポリフィル (`core-js`)
* JavaScript の型付き配列ガイド
* `TypedArray.prototype.reverse()`
* `TypedArray.prototype.toSorted()`
* `TypedArray.prototype.with()`
* `Array.prototype.toReversed()`


Reflect.preventExtensions() - JavaScript

Reflect.preventExtensions()
===========================

静的な **`Reflect.preventExtensions()`** メソッドは、すでにプロパティが追加されたオブジェクトに、新しいプロパティを抑制します (つまり、オブジェクトのさらなる拡張を抑制します)。 `Object.preventExtensions()` に似ていますが、違いがあります。

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

構文
--
```

Reflect.preventExtensions(target)
```

### 引数

`target`

拡張を抑止する対象のオブジェクト。

### 返値

`Boolean` で、対象が拡張の抑止の設定に成功したかどうかを表します。

### 例外

`TypeError`: `target` が `Object` ではない場合

解説
--

`Reflect.preventExtensions` メソッドは、すでにプロパティが追加されたオブジェクトに、新しいプロパティを抑制します (つまり、オブジェクトのさらなる拡張を抑制します)。これは `Object.preventExtensions()` と同様のメソッドです。

例
-

### Reflect.preventExtensions() の使用

`Object.preventExtensions()` も参照してください。

```js
// オブジェクトは既定で拡張可能。
let empty = {};
Reflect.isExtensible(empty); // === true

// ...しかし、変更できる。
Reflect.preventExtensions(empty);
Reflect.isExtensible(empty); // === false
```

### Object.preventExtensions() との違い

このメソッドへの最初の引数がオブジェクトではない (プリミティブである) 場合、 `TypeError` が発生します。 `Object.preventExtensions()` では、 `target` がオブジェクトではない場合はオブジェクトに強制的に変換されます。

```js
Reflect.preventExtensions(1);
// TypeError: 1 is not an object

Object.preventExtensions(1);
// 1
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.preventextensions |

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

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

関連情報
----

* `Reflect`
* `Object.isExtensible()`


Reflect.getOwnPropertyDescriptor() - JavaScript

Reflect.getOwnPropertyDescriptor()
==================================

静的な **`Reflect.getOwnPropertyDescriptor()`** メソッドは `Object.getOwnPropertyDescriptor()` と似ています。オブジェクトにプロパティが存在する場合は、指定されたプロパティのプロパティ記述子を返します。一方、プロパティが存在しない場合は `undefined` を返します。

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

構文
--
```

Reflect.getOwnPropertyDescriptor(target, propertyKey)
```

### 引数

`target`

プロパティを探す対象のオブジェクト。

`propertyKey`

所有しているプロパティ記述子を取得するためのプロパティ名。

### 返値

`target` オブジェクト内にプロパティが存在する場合は、プロパティ記述子オブジェクト、または `undefined`。

### 例外

`TypeError`: `target` が `Object` ではない場合

解説
--

`Reflect.getOwnPropertyDescriptor` オブジェクトにプロパティが存在する場合、与えられたプロパティのプロパティディスクリプタを返します。一方、プロパティが存在しない場合は、`undefined` を返します。`Object.getOwnPropertyDescriptor()` との唯一の違いは、非オブジェクトの対象がどのようにバンドルされるかだけです。

例
-

### Reflect.getOwnPropertyDescriptor() の使用

```js
Reflect.getOwnPropertyDescriptor({ x: "hello" }, "x");
// {value: "hello", writable: true, enumerable: true, configurable: true}

Reflect.getOwnPropertyDescriptor({ x: "hello" }, "y");
// undefined

Reflect.getOwnPropertyDescriptor([], "length");
// {value: 0, writable: true, enumerable: false, configurable: false}
```

### Object.getOwnPropertyDescriptor() との違い

このメソッドへの最初の引数がオブジェクトではない (プリミティブであった) 場合、 `TypeError` が発生します。 `Object.getOwnPropertyDescriptor` だと、非オブジェクトである最初の引数は強制的にオブジェクトに変換されます。

```js
Reflect.getOwnPropertyDescriptor("foo", 0);
// TypeError: "foo" is not non-null object

Object.getOwnPropertyDescriptor("foo", 0);
// { value: "f", writable: false, enumerable: true, configurable: false }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.getownpropertydescriptor |

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

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

関連情報
----

* `Reflect`
* `Object.getOwnPropertyDescriptor()`


Reflect.isExtensible() - JavaScript

Reflect.isExtensible()
======================

静的な **`Reflect.isExtensible()`** メソッドは 、オブジェクトを拡張できるかを測定します (オブジェクトに追加された新しいプロパティを持てるかどうか)。これは `Object.isExtensible()` に似ていますが、いくつかの違いがあります。

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

構文
--
```

Reflect.isExtensible(target)
```

### 引数

`target`

拡張できるかどうかをチェックする対象のオブジェクト。

### 返値

対象が拡張可能かどうかを示す `Boolean` 値。

### 例外

`TypeError`: `target` が `Object` ではなかった場合。

解説
--

`Reflect.isExtensible` メソッドは 、オブジェクトを拡張できるかを測定します（オブジェクトに追加された新しいプロパティを持てるかどうか）。これは `Object.isExtensible()` と同じメソッドです。

例
-

### Reflect.isExtensible() の使用

`Object.isExtensible()` も見てください。

```js
// 今オブジェクトは拡張可能。
let empty = {};
Reflect.isExtensible(empty); // === true

// ...しかし、変更できます
Reflect.preventExtensions(empty);
Reflect.isExtensible(empty); // === false

// シールドオブジェクトは拡張できないように定義される。
let sealed = Object.seal({});
Reflect.isExtensible(sealed); // === false

// フローズンオブジェクトも拡張できないように定義される。
let frozen = Object.freeze({});
Reflect.isExtensible(frozen); // === false
```

### Object.isExtensible() との違い

このメソッドへの最初の引数がオブジェクトではなかった (プリミティブであった) 場合、これは `TypeError` を引き起こします。`Object.isExtensible()` だと、オブジェクトではない最初の引数はオブジェクトに強制的に変換されます。

```js
Reflect.isExtensible(1);
// TypeError: 1 はオブジェクトではない

Object.isExtensible(1);
// false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.isextensible |

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

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

関連情報
----

* `Reflect`
* `Object.isExtensible()`


Reflect.ownKeys() - JavaScript

Reflect.ownKeys()
=================

静的な **`Reflect.ownKeys()`** メソッドは、 `target` オブジェクトが持つプロパティキーの配列を返します。

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

構文
--
```

Reflect.ownKeys(target)
```

### 引数

`target`

キーを取得する対象のオブジェクト

### 返値

`target` オブジェクトが持つプロパティキーの `Array` 。

### 例外

`TypeError`: `target` が `Object` ではない場合

解説
--

`Reflect.ownKeys` メソッドは、対象のオブジェクトが持つプロパティキーの配列を返します。この返値は、`Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))` と同じです。

例
-

### Reflect.ownKeys() の使用

```js
Reflect.ownKeys({ z: 3, y: 2, x: 1 }); // [ "z", "y", "x" ]
Reflect.ownKeys([]); // ["length"]

let sym = Symbol.for("comet");
let sym2 = Symbol.for("meteor");
let obj = {
  [sym]: 0,
  str: 0,
  773: 0,
  0: 0,
  [sym2]: 0,
  "-1": 0,
  8: 0,
  "second str": 0,
};
Reflect.ownKeys(obj);
// [ "0", "8", "773", "str", "-1", "second str", Symbol(comet), Symbol(meteor) ]
// 数字順のインデックス、
// 挿入順の文字列、
// 挿入順のシンボル
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.ownkeys |

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

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

関連情報
----

* `Reflect`
* `Object.getOwnPropertyNames()`


Reflect.set() - JavaScript

Reflect.set()
=============

静的な **`Reflect.set()`** メソッドは、オブジェクトにプロパティを設定するかのように動作します。

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

構文
--
```

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

### 引数

`target`

プロパティを設定する対象のオブジェクト。

`propertyKey`

設定するプロパティ名。

`value`

設定する値。

`receiver` 省略可

セッターによって `target` が呼び出されたときの `this` 値を提供する。

### 返値

プロパティが成功裏に設定できたかどうかを示す `Boolean` 値。

### 例外

`TypeError`: `target` が `Object` ではなかった場合。

解説
--

`Reflect.set` メソッドは、オブジェクトにプロパティを設定します。これはプロパティの割り当てを行い、機能としては プロパティアクセサー 構文のようなものです。

例
-

### Reflect.set() の使用

```js
// オブジェクト
let obj = {};
Reflect.set(obj, "prop", "value"); // true
obj.prop; // "value"

// 配列
let arr = ["duck", "duck", "duck"];
Reflect.set(arr, 2, "goose"); // true
arr[2]; // "goose"

// 配列を切り詰められる。
Reflect.set(arr, "length", 1); // true
arr; // ["duck"]

// 引数が1つだけだと、プロパティキーと値は "undefined" になる。
let obj = {};
Reflect.set(obj); // true
Reflect.getOwnPropertyDescriptor(obj, "undefined");
// { value: undefined, writable: true, enumerable: true, configurable: true }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.set |

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

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

関連情報
----

* `Reflect`
* プロパティアクセサー


Reflect.setPrototypeOf() - JavaScript

Reflect.setPrototypeOf()
========================

静的な **`Reflect.setPrototypeOf()`** メソッドは、返値を除いて、 `Object.setPrototypeOf()` と同じメソッドです。これは指定されたオブジェクトのプロトタイプ (つまり、内部の `[[Prototype]]` プロパティ) にほかのオブジェクト、または `null` を設定し、操作が成功したなら `true` を、そうでないなら `false` を返します。

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

構文
--
```

Reflect.setPrototypeOf(target, prototype)
```

### 引数

`target`

プロトタイプを設定する対象のオブジェクトです。

`prototype`

オブジェクトの新しいプロトタイプ (オブジェクトまたは `null`) です。

### 返値

プロトタイプが正常に設定されたかどうかを示す `Boolean` 値です。

### 例外

`TypeError`: `target` が `Object` ではない場合、または `prototype` がオブジェクトでも `null` でもない場合。

解説
--

`Reflect.setPrototypeOf` メソッドは、指定されたオブジェクトのプロトタイプ (つまり、内部の `[[Prototype]]` プロパティ) を変更します。

例
-

### Reflect.setPrototypeOf() の使用

```js
Reflect.setPrototypeOf({}, Object.prototype); // true

// オブジェクトの [[Prototype]] は null に変更できる。
Reflect.setPrototypeOf({}, null); // true

// 対象が拡張できない場合、false を返す。
Reflect.setPrototypeOf(Object.freeze({}), null); // false

// プロトタイプチェーンが循環する場合、false を返す。
let target = {};
let proto = Object.create(target);
Reflect.setPrototypeOf(target, proto); // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.setprototypeof |

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

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

関連情報
----

* `Reflect`
* `Object.setPrototypeOf()`


Reflect.get() - JavaScript

Reflect.get()
=============

静的な **`Reflect.get()`** メソッドは、オブジェクト (`target[propertyKey]`) からプロパティを関数として取得するように動作します。

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

構文
--

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

### 引数

`target`

プロパティを取得する対象のオブジェクト。

`propertyKey`

設定するプロパティ名。

`receiver` 省略可

ゲッターがあった場合、 `target` への呼び出しで使用する `this` の値を提供します。 `Proxy` とともに使用すると、 `target` から継承しているオブジェクトにすることができます。

### 返値

プロパティの値です。

### 例外

`target` が `Object` でなかった場合、 `TypeError` が発生します。

解説
--

`Reflect.get` メソッドはオブジェクトのプロパティを取得します。機能としてはプロパティアクセサー構文と似ています。

例
-

### `Reflect.get()` の使用

```js
// オブジェクト
let obj = { x: 1, y: 2 };
Reflect.get(obj, "x"); // 1

// 配列
Reflect.get(["zero", "one"], 1); // "one"

// Proxy with a get handler
let x = { p: 1 };

let obj = new Proxy(x, {
  get(t, k, r) {
    return k + "bar";
  },
});
Reflect.get(obj, "foo"); // "foobar"

//Proxy with get handler and receiver
let x = { p: 1, foo: 2 };
let y = { foo: 3 };

let obj = new Proxy(x, {
  get(t, prop, receiver) {
    return receiver[prop] + "bar";
  },
});
Reflect.get(obj, "foo", y); // "3bar"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.get |

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

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

関連情報
----

* `Reflect`
* プロパティアクセサー


Reflect.has() - JavaScript

Reflect.has()
=============

静的な **`Reflect.has()`** メソッドは、機能としては `in` 演算子のように動作します。

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

構文
--
```

Reflect.has(target, propertyKey)
```

### 引数

`target`

プロパティを探す対象のオブジェクト。

`propertyKey`

チェックするプロパティ名。

### 返値

対象がプロパティを持つかどうかを示す `Boolean` 値。

### 例外

`target` が `Object` でなかった場合、 `TypeError` が発生します。

解説
--

`Reflect.has` メソッドは、オブジェクトプロパティがあるかをチェックします。機能としては `in` 演算子のように動作します。

例
-

### Reflect.has() の使用

```js
Reflect.has({ x: 0 }, "x"); // true
Reflect.has({ x: 0 }, "y"); // false

// プロトタイプチェーンのプロパティがあるため、true が返る
Reflect.has({ x: 0 }, "toString");

// Proxy with .has() handler method
obj = new Proxy(
  {},
  {
    has(t, k) {
      return k.startsWith("door");
    },
  },
);
Reflect.has(obj, "doorbell"); // true
Reflect.has(obj, "dormitory"); // false
```

`Reflect.has` は継承されたプロパティについて `true` を返し、これは `in` 演算子と同様です。

```js
const a = { foo: 123 };
const b = { \_\_proto\_\_: a };
const c = { \_\_proto\_\_: b };
// The prototype chain is: c -> b -> a
Reflect.has(c, "foo"); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.has |

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

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

関連情報
----

* `Reflect`
* `in` 演算子


Reflect.apply() - JavaScript

Reflect.apply()
===============

静的な **`Reflect.apply()`** メソッドは、指定された引数とともに対象となる関数を呼び出します。

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

構文
--
```

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

### 引数

`target`

呼び出し対象の関数。

`thisArgument`

`target` の呼び出す際の `this` 値を提供する。

`argumentsList`

`target` と一緒に呼び出す引数を指定する配列風オブジェクト。

### 返値

指定された `target` 値と引数の条件で対象の関数を呼び出したときの結果です。

### 例外

`TypeError`: `target` が呼び出せない場合。

解説
--

ES5 では、ふつう `Function.prototype.apply()` メソッドを使用することで、指定された `this` の値と `arguments` で配列 (または 配列風オブジェクト) により引数を指定することで、関数を呼び出すことができます。

```js
Function.prototype.apply.call(Math.floor, undefined, [1.75]);
```

`Reflect.apply()` を使うと、それほど冗長ではなく理解しやすくなります。

例
-

### Reflect.apply() の使用

```js
Reflect.apply(Math.floor, undefined, [1.75]);
// 1;

Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
// "hello"

Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index;
// 4

Reflect.apply("".charAt, "ponies", [3]);
// "i"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.apply |

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

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

関連情報
----

* `Reflect`
* `Function.prototype.apply()`


Reflect.defineProperty() - JavaScript

Reflect.defineProperty()
========================

静的な **`Reflect.defineProperty()`** メソッドは、`Object.defineProperty()` と似ていますが、 `Boolean` を返します。

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

構文
--
```

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

### 引数

`target`

プロパティを定義する対象のオブジェクトです。

`propertyKey`

定義または修正をするプロパティ名です。

`attributes`

定義または修正されているプロパティのための属性です。

### 返値

プロパティの定義に成功したかどうかを示す `Boolean` です。

### 例外

`TypeError`: `target` が `Object` ではなかった場合。

解説
--

`Reflect.defineProperty` メソッドは、オブジェクトのプロパティの正確な追加や修正を行います。詳細は、類似メソッドの `Object.defineProperty` を参照してください。

**メモ:** `Object.defineProperty` はプロパティの定義が成功しなかった場合、オブジェクトを返すか `TypeError` を発生させます。しかし、`Reflect.defineProperty` は単純に、プロパティの定義が成功したかどうかを示す `Boolean` を返します。

例
-

### Reflect.defineProperty() の使用

```js
let obj = {};
Reflect.defineProperty(obj, "x", { value: 7 }); // true
obj.x; // 7
```

### プロパティ定義が成功したかチェックする

成功してオブジェクトを返すか、失敗して `TypeError` をスローする `Object.defineProperty` を使う場合、プロパティの定義中に発生する何らかの例外をキャッチするには、`try...catch` ブロックを使用します。

`Reflect.defineProperty` は真偽値の成功ステータスを返すので、`if...else` ブロックを使用することができます。

```js
if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.defineproperty |

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

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

関連情報
----

* `Reflect`
* `Object.defineProperty()`


Reflect.construct() - JavaScript

Reflect.construct()
===================

静的な **`Reflect.construct()`** メソッドは `new` 演算子のように、ただし関数として動作します。これは `new target(...args)` の呼び出しと同等です。このメソッドはオプションを追加することで、別なプロトタイプを指定することができます。

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

構文
--

```js
Reflect.construct(target, argumentsList);
Reflect.construct(target, argumentsList, newTarget);
```

### 引数

`target`

呼び出し対象の関数。

`argumentsList`

配列風オブジェクトで、 `target` の呼び出しの引数を指定する。

`newTarget` 省略可

プロトタイプを使用するコンストラクター。 `new.target` も参照してください。 `newTarget` が存在しない場合は、既定値は `target` になります。

### 返値

`target` (または、もしあれば `newTarget`) の新しいインスタンスで、 `target` に `argumentsList` を渡してコンストラクターとして呼び出すことで初期化します。

### 例外

`TypeError`: `target` または `newTarget` がコンストラクターではない場合。

解説
--

`Reflect.construct()` によって、可変長引数を指定してコンストラクターを呼び出すことができます。 (これはスプレッド構文と`new` 演算子を組み合わせて使用することでも可能です。)

```js
let obj = new Foo(...args);
let obj = Reflect.construct(Foo, args);
```

### `Reflect.construct()` と `Object.create()`

`Reflect` が導入される前は、オブジェクトを構築するのにコンストラクターとプロトタイプの任意の組み合わせで `Object.create()` を使用して構築することができました。

```js
function OneClass() {
  this.name = "one";
}

function OtherClass() {
  this.name = "other";
}

// Calling this:
let obj1 = Reflect.construct(OneClass, args, OtherClass);

// ...has the same result as this:
let obj2 = Object.create(OtherClass.prototype);
OneClass.apply(obj2, args);

console.log(obj1.name); // 'one'
console.log(obj2.name); // 'one'

console.log(obj1 instanceof OneClass); // false
console.log(obj2 instanceof OneClass); // false

console.log(obj1 instanceof OtherClass); // true
console.log(obj2 instanceof OtherClass); // true

//Another example to demonstrate below:

function func1(a, b, c, d) {
  console.log(arguments[3]);
}

function func2(d, e, f, g) {
  console.log(arguments[3]);
}

let obj1 = Reflect.construct(func1, ["I", "Love", "my", "India"]);
obj1;
```

この 2 つの手法の最終結果は同じですが、その過程に重要な違いがあります。 `Object.create()` と `Function.prototype.apply()` を使用する場合、 `new.target` 演算子はコンストラクター内で `undefined` を返します。これは、 `new` 演算子を用いないためです。

一方、 `Reflect.construct()` を呼び出す場合は、 `new.target` 演算子は、提供されていれば `newTarget` を指し、そうでなければ `target` を指します。

```js
function OneClass() {
  console.log("OneClass");
  console.log(new.target);
}
function OtherClass() {
  console.log("OtherClass");
  console.log(new.target);
}

let obj1 = Reflect.construct(OneClass, args);
// Output:
// OneClass
// function OneClass { ... }

let obj2 = Reflect.construct(OneClass, args, OtherClass);
// Output:
// OneClass
// function OtherClass { ... }

let obj3 = Object.create(OtherClass.prototype);
OneClass.apply(obj3, args);
// Output:
// OneClass
// undefined
```

例
-

### `Reflect.construct()` の使用

```js
let d = Reflect.construct(Date, [1776, 6, 4]);
d instanceof Date; // true
d.getFullYear(); // 1776
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.construct |

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

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

関連情報
----

* `Reflect.construct` のポリフィルが `core-js` にあります
* `Reflect`
* `new`
* `new.target`


Reflect.getPrototypeOf() - JavaScript

Reflect.getPrototypeOf()
========================

静的な **`Reflect.getPrototypeOf()`** メソッドは、`Object.getPrototypeOf()` とほぼ同じメソッドです。これは指定したオブジェクトのプロトタイプ (つまり、内部の `[[Prototype]]` プロパティの値) を返します。

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

構文
--
```

Reflect.getPrototypeOf(target)
```

### 引数

`target`

プロトタイプを取得する対象のオブジェクトです。

### 返値

与えられたオブジェクトのプロトタイプです。継承されたプロパティがない場合、`null` を返します。

### 例外

`target` が `Object` でない場合に `TypeError` がスローされます。

解説
--

`Reflect.getPrototypeOf` メソッドは、指定したオブジェクトのプロトタイプ (つまり、内部の `[[Prototype]]` プロパティの値) を返します。

例
-

### Reflect.getPrototypeOf() の使用

```js
Reflect.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf(Object.prototype); // null
Reflect.getPrototypeOf(Object.create(null)); // null
```

### Object.getPrototypeOf() との比較

```js
// Object の結果は同じです
Object.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf({}); // Object.prototype

// ES5 上では非Objectの結果は両方とも例外です
Object.getPrototypeOf("foo"); // Throws TypeError
Reflect.getPrototypeOf("foo"); // Throws TypeError

// ES2015 上では Reflect のみ例外で、Object は 非Object を Object として扱います
Object.getPrototypeOf("foo"); // String.prototype
Reflect.getPrototypeOf("foo"); // Throws TypeError

// To mimic the Object ES2015 behavior you need to coerce
Reflect.getPrototypeOf(Object("foo")); // String.prototype
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.getprototypeof |

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

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

関連情報
----

* `Reflect`
* `Object.getPrototypeOf()`


Reflect.deleteProperty() - JavaScript

Reflect.deleteProperty()
========================

静的な **`Reflect.defineProperty()`** メソッドは、`Object.defineProperty()` と似ていますが、 `Boolean` を返します。

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

構文
--
```

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

### 引数

`target`

プロパティを定義する対象のオブジェクトです。

`propertyKey`

定義または修正をするプロパティ名です。

`attributes`

定義または修正されているプロパティのための属性です。

### 返値

プロパティの定義に成功したかどうかを示す `Boolean` です。

### 例外

`TypeError`: `target` が `Object` ではなかった場合。

解説
--

`Reflect.defineProperty` メソッドは、オブジェクトのプロパティの正確な追加や修正を行います。詳細は、類似メソッドの `Object.defineProperty` を参照してください。

**メモ:** `Object.defineProperty` はプロパティの定義が成功しなかった場合、オブジェクトを返すか `TypeError` を発生させます。しかし、`Reflect.defineProperty` は単純に、プロパティの定義が成功したかどうかを示す `Boolean` を返します。

例
-

### Reflect.defineProperty() の使用

```js
let obj = {};
Reflect.defineProperty(obj, "x", { value: 7 }); // true
obj.x; // 7
```

### プロパティ定義が成功したかチェックする

成功してオブジェクトを返すか、失敗して `TypeError` をスローする `Object.defineProperty` を使う場合、プロパティの定義中に発生する何らかの例外をキャッチするには、`try...catch` ブロックを使用します。

`Reflect.defineProperty` は真偽値の成功ステータスを返すので、`if...else` ブロックを使用することができます。

```js
if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.deleteproperty |

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

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

関連情報
----

* `Reflect`
* `Object.defineProperty()`


BigUint64Array() コンストラクター - JavaScript

BigUint64Array() コンストラクター
=========================

**`BigUint64Array()`** は型付き配列のコンストラクターで、新しい `BigUint64Array` オブジェクト、すなわち 64 ビット符号なし整数の配列をプラットフォームのバイトオーダーで生成します。バイトオーダーを制御する必要がある場合は、代わりに `DataView` を使用してください。中身は `0n` で初期化されます。生成後は、オブジェクトのメソッドや、標準の配列の添字構文 (すなわち角括弧表記) を用いて配列の要素を参照することができます。

構文
--
```

new BigUint64Array();
new BigUint64Array(length);
new BigUint64Array(typedArray);
new BigUint64Array(object);
new BigUint64Array(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` の残りがビューとなります。

例
-

### BigUint64Array を生成するための様々な方法

```js
// From a length
var biguint64 = new BigUint64Array(2);
biguint64[0] = 42n;
console.log(biguint64[0]); // 42n
console.log(biguint64.length); // 2
console.log(biguint64.BYTES\_PER\_ELEMENT); // 8

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

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

// From an ArrayBuffer
var buffer = new ArrayBuffer(32);
var z = new BigUint64Array(buffer, 0, 4);

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

仕様書
---

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

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

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

関連情報
----

* JavaScript typed arrays
* `BigInt64Array`
* `DataView`


Generator.prototype.return() - JavaScript

Generator.prototype.return()
============================

**`return()`** メソッドは、指定された値を返してジェネレーターを終了します。

構文
--
```

gen.return(value)
```

### 引数

`value`

返却する値です。

### 返値

この関数に引数として与えられている値を返します。

例
-

### return() の使用

次の例では簡単なジェネレーターと `return` メソッドを示します。

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

const g = gen();

g.next(); // { value: 1, done: false }
g.return("foo"); // { value: "foo", done: true }
g.next(); // { value: undefined, done: true }
```

`return(value)` がすでに "完了" の状態のジェネレーターで呼び出されると、ジェネレーターは "完了" の状態のままになります。

引数が提供されなかった場合、返却されるオブジェクトの `value` プロパティは `.next()` の場合と同じになります。引数が提供された場合は、返却されるオブジェクトの `value` プロパティの値に設定されます。

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

const g = gen();
g.next(); // { value: 1, done: false }
g.next(); // { value: 2, done: false }
g.next(); // { value: 3, done: false }
g.next(); // { value: undefined, done: true }
g.return(); // { value: undefined, done: true }
g.return(1); // { value: 1, done: true }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.return |

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

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

関連情報
----

* `function*`


Generator.prototype.next() - JavaScript

Generator.prototype.next()
==========================

**`next()`** メソッドは、2 つのプロパティ `done` と `value` を持つオブジェクトを返します。 `next` メソッドに引数を提供して、ジェネレーターへ値を送ることもできます。

構文
--

```js
generatorObject.next(value)
```

### 引数

`value`

ジェネレーターへ送る値です。

この値は `yield` 式の結果として代入されます。例えば `variable = yield expression` の場合、 `.next()` 関数に渡された値は `variable` に代入されます。

### 返値

以下の 2 つのプロパティを持った `Object` です。

`done` (boolean)

イテレーターが反復処理の末尾を過ぎている場合、値は `true` になります。この場合、 `value` はオプションでそのイテレーターの *返値* を指定します。

イテレーターが反復処理の次の値を生成することができた場合、値は `false` になります。これは `done` プロパティを指定しない場合も同等です。

`value`

イテレーターが yield または return した、何らかの JavaScript の値です。

例
-

### next() の使用

次の例では、 `next` メソッドが返す簡単なジェネレーターとオブジェクトを示します。

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

const g = gen(); // "Generator { }"
g.next(); // "Object { value: 1, done: false }"
g.next(); // "Object { value: 2, done: false }"
g.next(); // "Object { value: 3, done: false }"
g.next(); // "Object { value: undefined, done: true }"
```

### リストでの next() の使用

この例では、 `getPage` はリストを受け取り `pageSize` 件ごとにページ分割します。それぞれの `next` 呼び出しは個々のページを返します。

```js
function\* getPage(list, pageSize = 1) {
  for (let index = 0; index < list.length; index += pageSize) {
    yield list.slice(index, index + pageSize);
  }
}
const list = [1, 2, 3, 4, 5, 6, 7, 8];
const page = getPage(list, 3); // Generator { }
page.next(); // { value: [1, 2, 3], done: false }
page.next(); // { value: [4, 5, 6], done: false }
page.next(); // { value: [7, 8], done: false }
page.next(); // { value: undefined, done: true }
```

### ジェネレーターへ値を送る

この例では `next` を値付きで呼び出しています。

**メモ:** 最初の呼び出しではジェネレーターが何も生成していないため、何もログを記録しません。

```js
function\* gen() {
  while (true) {
    let value = yield null;
    console.log(value);
  }
}

const g = gen();
g.next(1);
// "{ value: null, done: false }"
g.next(2);
// 2
// "{ value: null, done: false }"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.next |

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

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

関連情報
----

* `function*`
* イテレーターとジェネレーター


Generator.prototype.throw() - JavaScript

Generator.prototype.throw()
===========================

**`throw()`** メソッドは、ジェネレーターの例外を、エラーを発生させることで再開し、 `done` と `value` の 2 つのプロパティを持ったオブジェクトを返します。

構文
--
```

gen.throw(exception)
```

### 引数

`exception`

発生させる例外。デバッグ時には `instanceof` `Error` を行うと便利です。

### 返値

2 つのプロパティを持つ `Object` です。

`done` (boolean)

* イテレーターが反復処理の末尾を過ぎている場合、値は `true` になります。この場合、 `value` はオプションでそのイテレーターの*返値*を指定します。
* イテレーターが反復処理の次の値を生成することができた場合、値は `false` になります。これは `done` プロパティを指定しない場合も同等です。

`value`

イテレーターが返す何らかの JavaScript の値です。 `done` が `true` の場合は省略可能です。

例
-

### throw() の使用

次の例では、簡単なジェネレーターと、 `throw`メソッドを用いて発生させるエラーを示します。エラーは通常 `try...catch` ブロックによって受け取られます。

```js
function\* gen() {
  while (true) {
    try {
      yield 42;
    } catch (e) {
      console.log("Error caught!");
    }
  }
}

const g = gen();
g.next();
// { value: 42, done: false }
g.throw(new Error("Something went wrong"));
// "Error caught!"
// { value: 42, done: false }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.throw |

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

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

関連情報
----

* `function*`


Proxy.revocable() - JavaScript

Proxy.revocable()
=================

**`Proxy.revocable()`** メソッドは、取り消し可能な `Proxy` オブジェクトを作成するために使用します。

構文
--

```js
Proxy.revocable(target, handler)
```

### 引数

`target`

`Proxy` でラップする対象のオブジェクトです。これは一連のオブジェクト、例えばネイティブの配列、関数、他のプロキシーなどを取ることもできます。

`handler`

プロキシー `p` に対して操作が行われたときの動作を定義する関数をプロパティとするオブジェクトです。

### 返値

以下の 2 つのプロパティを持つプレーンなオブジェクトです。

`proxy`

`new Proxy(target, handler)` 呼び出しで生成したプロキシーオブジェクトです。

`revoke`

`proxy` を無効にするための引数を持たない関数です。

解説
--

`Proxy.revocable()` はファクトリー関数で、`Proxy()` コンストラクターと同じですが、プロキシーオブジェクトを作成するだけでなく、プロキシーを無効にするために求められる `revoke` 関数を作成します。プロキシーオブジェクトと `revoke` 関数はプレーンオブジェクトにラップされています。

`revoke` 関数は引数を取らず、`this` 値にも頼りません。作成された `proxy` オブジェクトは `revoke` 関数にプライベートプロパティとして結び付けられ、`revoke` 関数が呼び出されたときに自分自身でアクセスします（プライベートプロパティの存在は外からは観測できませんが、ガーベジコレクションが発生する方法については影響があります）。`proxy` オブジェクトは `revoke` 関数のクロージャ内には収容されません（`revoke` がまだ生きている場合、`proxy` のガベージコレクションは不可能になります）。

`revoke()` 関数が呼び出された後、プロキシーは使用できなくなります。ハンドラーのトラップが発生すると `TypeError` が発生します。一度プロキシーが取り消されると、取り消されたままになり、再び `revoke()` を呼び出しても何の効果もありません。実際、`revoke()` を呼び出すと `proxy` オブジェクトを `revoke` 関数から切り離すので、`revoke` 関数が再びプロキシーにアクセスできることは全くありません。プロキシーが他の場所で参照されていない場合、ガベージコレクションの対象となります。`revoke` 関数は `target` と `handler` も `proxy` から切り離すので、`target` が他の場所で参照されていない場合、プロキシーがまだ生きていても、対象のオブジェクトと意味のあるやりとりをする方法がなくなったので、それもガベージコレクションの対象となります。

ユーザーが取り消し可能なプロキシーを通してオブジェクトと対話することで、ユーザーに公開されるオブジェクトのライフタイムを制御できます。ユーザーがまだそのプロキシーを参照しているときでも、オブジェクトをガベージコレクション可能にすることができます。

例
-

### Proxy.revocable() の使用

```js
const revocable = Proxy.revocable(
  {},
  {
    get(target, name) {
      return `[[${name}]]`;
    },
  },
);
const proxy = revocable.proxy;
console.log(proxy.foo); // "[[foo]]"

revocable.revoke();

console.log(proxy.foo); // TypeError が発生
proxy.foo = 1; // TypeError が発生
delete proxy.foo; // これも TypeError
typeof proxy; // "object" と表示。 typeof でトラップは発生しない
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy.revocable |

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

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

関連情報
----

* `Proxy`