recursal/MDN huggingface dataset:
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()
===============================

**`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()
==============================

**`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()
==================================

**`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()
===============================

**`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()
==============================

**`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()
================================

**`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
===========================

**`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]()
==================================

**`[@@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()
===============================

**`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()
===========================

**`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()
=================

**`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()
====================================

**`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()
=============================

**`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()`