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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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