recursal/MDN huggingface dataset:
Array.prototype.copyWithin()
============================

**`copyWithin()`** は `Array` インスタンスのメソッドで、この配列の一部を配列内の他の場所にシャローコピーし、この配列を長さを変更せずに返します。

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

構文
--


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

### 引数

`target`

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

* 負のインデックスの場合は、配列の末尾から逆に数えます。 `target < 0` の場合は、 `target + array.length` が使用されます。
* `target < -array.length` の場合は、 `0` が使用されます。
* `target >= array.length` の場合は、何もコピーされません。
* `target` が正規化後の `start` の後に位置している場合、コピーは `array.length` の末尾までしか行われません（言い換えれば、 `copyWithin()` は配列を拡張しません）。

`start`

要素のコピー元の始まりを表す 0 から始まるインデックスで、整数に変換されます。

* 負のインデックスの場合は、配列の末尾から逆に数えます。 `start < 0` の場合は、 `start + array.length` が使用されます。
* `start < -array.length` の場合は、 `0` が使用されます。
* `start >= array.length` の場合は、何もコピーされません。

`end` 省略可

要素のコピー元の末尾を表す 0 から始まるインデックスで、整数に変換されます。 `copyWithin()` のコピーは `end` の手前まで行います。

* 負のインデックスの場合は、配列の末尾から逆に数えます。 `end < 0` の場合は、 `end + array.length` が使用されます。
* `end < -array.length` の場合は、 `0` が使用されます。
* `end >= array.length` の場合、または `end` が省略された場合は、 `array.length` が使用され、末尾までのすべての要素がコピーされます。
* 正規化後に `end` が `start` よりも前か同じ位置になったときは、何もコピーされません。

### 返値

変更された配列です。

解説
--

`copyWithin()` メソッドは C や C++ の `memmove` のような動きをし、 `Array` のデータを移動するための高いパフォーマンスのメソッドです。これは特に `TypedArray` の同名メソッドに当てはまります。データの並びがコピーされ貼り付けられる処理が一命令で行われます。コピー元と貼り付け先で領域が重なっていたとしても、貼り付け先の並びはコピーされた値になります。

`undefined` は整数に変換されると `0` になるため、 `start` 引数を省略すると `0` を渡したのと同じ効果があり、配列全体が対象とする位置にコピーされます（右の境界が切り取られ、左の境界が複製される右シフトと同じです）。この動作はコードの読み手を混乱させる可能性があるので、代わりに `start` として `0` を明示的に渡してください。


```js
console.log([1, 2, 3, 4, 5].copyWithin(2));
// [1, 2, 1, 2, 3]; すべての要素を右に 2 つずらす
```


`copyWithin()` は変更を行うメソッドです。 `this` の長さは変更しませんが、 `this` の内容を変更し、必要に応じて新しいプロパティを作成します。

`copyWithin()` メソッドは空のスロットを保持します。コピー元の範囲が疎配列であった場合、空のスロットに対応するインデックスは削除され、空のスロットになります。

`copyWithin()` メソッドは汎用的です。このメソッドは `this` の値に `length` プロパティと整数のキーを持ったプロパティがあることだけを求めます。文字列も配列風オブジェクトですが、文字列は不変なので、このメソッドを適用するのは適していません。

例
-

### copyWithin() の使用


```js
console.log([1, 2, 3, 4, 5].copyWithin(0, 3));
// [4, 5, 3, 4, 5]

console.log([1, 2, 3, 4, 5].copyWithin(0, 3, 4));
// [4, 2, 3, 4, 5]

console.log([1, 2, 3, 4, 5].copyWithin(-2, -3, -1));
// [1, 2, 3, 3, 4]
```

### 疎配列に対する copyWithin() の使用

`copyWithin()` は空のスロットを広めます。


```js
console.log([1, , 3].copyWithin(2, 1, 2)); // [1, empty, empty]
```

### 配列ではないオブジェクトに対する copyWithin() の呼び出し

`copyWithin()` メソッドは `this` の `length` プロパティを読み込んで、関係する整数のインデックスを操作します。


```js
const arrayLike = {
  length: 5,
  3: 1,
};
console.log(Array.prototype.copyWithin.call(arrayLike, 0, 3));
// { '0': 1, '3': 1, length: 5 }
console.log(Array.prototype.copyWithin.call(arrayLike, 3, 1));
// { '0': 1, length: 5 }
// コピー元が空のスロットであるため、 '3' プロパティは削除される
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.copywithin |

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

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

関連情報
----

* `Array.prototype.copyWithin` のポリフィル (`core-js`)
* インデックス付きコレクションガイド
* `Array`
* `TypedArray.prototype.copyWithin()`
Array.prototype.fill()
======================

**`fill()`** は `Array` インスタンスのメソッドで、インデックスの範囲内にある配列のすべての要素を一定の値に変更します。これは変更した配列を返します。

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

構文
--


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

### 引数

`value`

配列を埋める値。もし `value` がオブジェクトであれば、配列のそれぞれの要素はそのオブジェクトを参照します。

`start` 省略可

埋め始める位置のゼロから始まるインデックスで、整数に変換されます。

* インデックスが負の場合、配列の末尾からさかのぼって数えます。 `start < 0` の場合、 `start + array.length` が使用されます。
* `start < -array.length` または `start` が省略された場合は `0` が使用されます。
* `start >= array.length` の場合、埋められるインデックスはありません。

`end` 省略可

埋め終える位置のゼロから始まるインデックスで、整数に変換されます。 `fill()` は `end` を含まず、その直前までを埋めます。

* インデックスが負の場合、配列の末尾からさかのぼって数えます。 `end < 0` の場合、 `end + array.length` が使用されます。
* `end < -array.length` の場合は `0` が使用されます。
* `end >= array.length` または `end` が省略された場合、

### 返値

`value` で埋められて変更された配列です。

解説
--

`fill()` メソッドは変更メソッドです。これは `this` の長さは変更しませんが、 `this` のコンテンツは変更します。

`fill()` メソッドは疎配列の空のスロットを、 `value` で埋めます。

`every()` メソッドは汎用的です。このメソッドは `this` の値に `length` プロパティと整数のキーを持ったプロパティがあることだけを求めます。文字列も配列風のものですが、文字列は不変なので、このメソッドを適用するのは適していません。

**メモ:** `Array.prototype.fill()` を空の配列に対して使用すると、配列に変更するものがないので何も変更されません。
 配列を宣言する際に `Array.prototype.fill()` を使用する場合は、スロットを配列に割り当てるようにしてください。
 例はこちら。


例
-

### fill の使用


```js
console.log([1, 2, 3].fill(4)); // [4, 4, 4]
console.log([1, 2, 3].fill(4, 1)); // [1, 4, 4]
console.log([1, 2, 3].fill(4, 1, 2)); // [1, 4, 3]
console.log([1, 2, 3].fill(4, 1, 1)); // [1, 2, 3]
console.log([1, 2, 3].fill(4, 3, 3)); // [1, 2, 3]
console.log([1, 2, 3].fill(4, -3, -2)); // [4, 2, 3]
console.log([1, 2, 3].fill(4, NaN, NaN)); // [1, 2, 3]
console.log([1, 2, 3].fill(4, 3, 5)); // [1, 2, 3]
console.log(Array(3).fill(4)); // [4, 4, 4]

// 配列の各スロットから参照される、単一のオブジェクト。
const arr = Array(3).fill({}); // [{}, {}, {}]
arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
```

### fill() を使用してすべて 1 の行列を作成

この例では、 Octave や MATLAB の `ones()` 関数のように、すべて 1 の行列を作成する方法を示しています。


```js
const arr = new Array(3);
for (let i = 0; i < arr.length; i++) {
  arr[i] = new Array(4).fill(1); // 大きさが 4、内容が 1 の配列を作成
}
arr[0][0] = 10;
console.log(arr[0][0]); // 10
console.log(arr[1][0]); // 1
console.log(arr[2][0]); // 1
```

### fill() を使用して空の配列を生成

 この例では、配列に値を入力し、すべての要素に詳細な値を設定する方法を示しています。
 `end` 引数を指定する必要はありません。


```js
const tempGirls = Array(5).fill("girl", 0);
```


配列は最初はインデックスが割り当てられていない疎配列であることに注意してください。 `fill()` でこの配列を埋めることができます。

### 配列でないオブジェクトに対する fill() の呼び出し

`fill()` メソッドは `this` の `length` プロパティを読み取り、 `start` から `end` までの各整数キーのプロパティの値を設定します。


```js
const arrayLike = { length: 2 };
console.log(Array.prototype.fill.call(arrayLike, 1));
// { '0': 1, '1': 1, length: 2 }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.fill |

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

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

関連情報
----

* `Array.prototype.fill` のポリフィル (`core-js`)
* インデックス付きコレクションガイド
* `Array`
* `TypedArray.prototype.fill()`
Array.prototype.join()
======================

**`join()`** は `Array` インスタンスのメソッドで、配列の全要素を順に連結した新しい文字列を返します。区切り文字はカンマ、または指定された文字列です。配列にアイテムが一つしかない場合は、区切り文字を使用せずにアイテムが返されます。

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

構文
--


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

### 引数

`separator` 省略可

配列の各要素を区切る文字列です。省略した場合、配列の要素はカンマ (",") で区切られます。

### 返値

配列の全要素が連結された文字列です。 `array.length` が `0` であった場合、空の文字列が返されます。

解説
--

配列のすべての要素を文字列に変換したものが、1 個の文字列に繋がれます。要素が `undefined` または `null` であった場合、 `"null"` や `"undefined"` ではなく空文字列に変換されます。

`join` メソッドは、内部的には `Array.prototype.toString()` によって引数なしでアクセスすることができます。配列インスタンスの `join` をオーバーライドすると、その `toString` の動作もオーバーライドされます。

`Array.prototype.join` は他の配列も含めて、再帰的にそれぞれの要素を文字列に変換します。 `Array.prototype.toString` が返す文字列（これは `join()` を呼び出すのと同じです）には区切り文字がないので、入れ子配列は平坦化されたように見えます。区切り文字を制御できるのは最初のレベルだけで、それ以上のレベルでは常に既定のカンマを使用します。


```js
const matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
];

console.log(matrix.join()); // 1,2,3,4,5,6,7,8,9
console.log(matrix.join(";")); // 1,2,3;4,5,6;7,8,9
```


配列が循環している（コンテナーそのものである要素を格納している）場合、ブラウザーは循環参照を無視することで無限再帰を避けます。


```js
const arr = [];
arr.push(1, [3, arr, 4], 2);
console.log(arr.join(";")); // 1;3,,4;2
```


疎配列で使用した場合、 `join()` メソッドは空のスロットを `undefined` という値があるかのように反復処理します。

`join()` メソッドは汎用的です。これは `this` 値に `length` プロパティと整数キーのプロパティがあることだけを期待します。

例
-

### 3 通りの異なる形で配列をつなぐ

以下の例は、3 個の要素を持つ配列 `a` を作成し、デフォルト引数、カンマとスペース、そして「と」と空文字を使った 4 パターンの結合を行っています。


```js
const a = ["風", "水", "火"];
a.join(); // '風,水,火'
a.join(", "); // '風, 水, 火'
a.join(" + "); // '風 + 水 + 火'
a.join(""); // '風水火'
```

### 疎配列に対する join() の使用

`join()` は空のスロットを `undefined` と同じように扱い、余分な区切り文字を生成します。


```js
console.log([1, , 3].join()); // '1,,3'
console.log([1, undefined, 3].join()); // '1,,3'
```

### 配列以外のオブジェクトに対する join() の呼び出し

`join()` メソッドは `this` の `length` プロパティを読み込み、次にキーが `length` より小さい非負の整数である各プロパティにアクセスします。


```js
const arrayLike = {
  length: 3,
  0: 2,
  1: 3,
  2: 4,
  3: 5, // ignored by join() since length is 3
};
console.log(Array.prototype.join.call(arrayLike));
// 2,3,4
console.log(Array.prototype.join.call(arrayLike, "."));
// 2.3.4
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.join |

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

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

関連情報
----

* `Array.prototype.join` のポリフィル (`core-js`)
* インデックス付きコレクションのガイド
* `Array`
* `Array.prototype.toString()`
* `TypedArray.prototype.join()`
* `String.prototype.split()`
Array.prototype.reverse()
=========================

**`reverse()`** は `Array` のメソッドで、配列の要素をその場 (in-place) で反転させ、その配列への参照を返します。最初の要素が最後の要素に、最後の要素が最初の要素になります。言い換えれば、配列内の要素順序を、先に述べた方向とは逆に向かわせます。

元の配列を変更せずに配列の要素を反転させるには `toReversed()` を使用してください。

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

構文
--


```js
reverse()
```

### 引数

なし。

### 返値

元の配列を反転されたものへの参照です。なお、配列はその場 (in-place) で反転され、コピーは作られません。

解説
--

`reverse()` メソッドは、呼び出した配列オブジェクトの要素を反転し、書き換えられた配列の参照を返します。

`reverse()` メソッドは空のスロットを維持します。元の配列が疎配列である場合、空のスロットに対応する新しいインデックスは削除され、空のスロットになります。

`reverse()` メソッドは汎用的です。これは `this` 値に `length` プロパティと整数キーのプロパティがあることだけを期待します。文字列も配列風ですが、文字列は不変であるため、このメソッドを適用するのは適切ではありません。

例
-

### 配列の要素を反転させる

次の例は、3 つの要素を含む配列 `items` を作成し、その配列を反転させます。`reverse()` の呼び出しは、反転した配列 `items` への参照を返します。


```js
const items = [1, 2, 3];
console.log(items); // [1, 2, 3]

items.reverse();
console.log(items); // [3, 2, 1]
```

### reverse() メソッドは同じ配列への参照を返す

`reverse()` メソッドは元の配列への参照を返すので、返された配列を変更すると、元の配列も変更されます。


```js
const numbers = [3, 2, 4, 1, 5];
const reversed = numbers.reverse();
// numbers and reversed are both in reversed order [5, 1, 4, 2, 3]
reversed[0] = 5;
console.log(numbers[0]); // 5
```


`reverse()` で元の配列を変更せず、他の配列メソッド（`map()` など）が行うようにシャローコピーした配列を返すようにするには、 `toReversed()` メソッドを使用してください。他にも、 `reverse()` を呼び出す前にスプレッド構文か `Array.from()` を使用してシャローコピーを行っておくこともできます。


```js
const numbers = [3, 2, 4, 1, 5];
// [...numbers] はシャローコピーを作成するので、 reverse() は元の配列を変更しない
const reverted = [...numbers].reverse();
reverted[0] = 5;
console.log(numbers[0]); // 3
```

### 疎配列に対する reverse() の使用

疎配列は `reverse()` を呼び出しても疎配列のままです。空のスロットは空のスロットとしてそれぞれの新しいインデックスにコピーされます。


```js
console.log([1, , 3].reverse()); // [3, empty, 1]
console.log([1, , 3, 4].reverse()); // [4, 3, empty, 1]
```

### 配列以外のオブジェクトに対する reverse() の呼び出し

`reverse()` メソッドは `this` の `length` プロパティを読み込みます。そして、 `0` から `length / 2` までの整数のキーを持つ各プロパティを参照し、両端の対応する 2 つのインデックスを入れ替えます。出力先のプロパティで、参照元のプロパティが存在しないものは削除します。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  2: 4,
  3: 33, // length が 3 であるため reverse() 空は無視される
};
console.log(Array.prototype.reverse.call(arrayLike));
// { 0: 4, 3: 33, length: 3, unrelated: 'foo' }
// 元々インデックス 0 が存在しなかったため、インデックス 2 は削除される
// 長さが 3 であるため、インデックス 3 は変更されない
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.reverse |

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

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

関連情報
----

* `Array.prototype.reverse` のポリフィル (`core-js`)
* インデックス付きコレクションのガイド
* `Array`
* `Array.prototype.join()`
* `Array.prototype.sort()`
* `Array.prototype.toReversed()`
* `TypedArray.prototype.reverse()`
Array.prototype.findIndex()
===========================

**`findIndex()`** は `Array` インスタンスのメソッドで、配列内の指定されたテスト関数に合格する最初の要素のインデックスを返します。
 テスト関数に合格する要素がなかった場合は `-1` を返します。

`find()` メソッドも参照してください。こちらのメソッドは、配列内で見つかった要素の位置ではなく、値を返します。

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

構文
--


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

### 引数

`callbackFn`

配列のそれぞれの要素に対して実行する関数です。一致する要素が得られたことを示すには真値を返し、そうでなければ偽値を返してください。この関数は以下の引数で呼び出されます。

`element`

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

`index`

配列内で現在処理されている要素のインデックス（位置）です。

`array`

`findIndex()` を呼び出した元の配列です。


`thisArg` 省略可

`callbackFn` 内で `this` として使われるオブジェクトです。反復処理メソッドを参照してください。

### 返値

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

解説
--

`findIndex()` メソッドは反復処理メソッドです。配列の要素のそれぞれに対して、インデックスの昇順に一度ずつ `callbackFn` 関数を実行し、`callbackFn` 関数が真値を返すまで繰り返します。 `findIndex()` はその要素を返し、配列の反復処理を停止します。もし `callbackFn` が真値を返さない場合、 `findIndex()` は `-1` を返します。

`callbackFn` は、値が割り当てられているものに限らず、配列中の*すべて*のインデックスに対して呼び出されます。疎配列では、空のスロットは `undefined` と同じ動作をします。

`findIndex()` は、呼び出した配列を変更 (mutate) しませんが、`callbackFn` で提供された関数は変更する可能性があります。しかし、配列の長さは最初に `callbackFn` が呼び出される*前に*設定されます。したがって、

* `callbackFn` は `findIndex()` の呼び出しを始めたときの配列の長さを超えて追加された要素にはアクセスしません。
* 既に訪問した位置を変更しても、 `callbackFn` が再度呼び出されることはありません。
* まだ訪問していない既存の配列要素が `callbackFn` によって変更された場合、 `callbackFn` に渡される値はその要素が取得される時点の値になります。削除された 要素は `undefined` であるかのように処理されます。

**警告:** 上で説明したような同時進行の変更は、理解しにくいコードになることが多いので、（特別な場合を除いて）避けるのが一般的です。

`findIndex()` メソッドは汎用的です。これは `this` 値に `length` プロパティと整数キーのプロパティがあることだけを期待します。

例
-

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

次の例では、配列の中で素数の入った最初の要素の位置を返し、素数が見つからなかった場合は `-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;
}

console.log([4, 6, 8, 9, 12].findIndex(isPrime)); // -1, not found
console.log([4, 6, 7, 9, 12].findIndex(isPrime)); // 2 (array[2] is 7)
```

### 疎配列における find() の使用

疎配列で `undefined` を検索することで、空スロットのインデックスを取得することができます。


```js
console.log([1, , 3].findIndex((x) => x === undefined)); // 1
```

### 配列でないオブジェクトに対する find() の呼び出し

`findIndex()` メソッドは `this` の `length` プロパティを読み込み、そのキーが `length` よりも小さい非負の整数である各プロパティにアクセスします。


```js
const arrayLike = {
  length: 3,
  "-1": 0.1, // -1 < 0 なので findIndex() 空は無視される
  0: 2,
  1: 7.3,
  2: 4,
};
console.log(
  Array.prototype.findIndex.call(arrayLike, (x) => !Number.isInteger(x)),
); // 1
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.findindex |

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

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

関連情報
----

* `Array.prototype.findIndex` のポリフィル (`core-js`)
* インデックス付きコレクションのガイド
* `Array`
* `Array.prototype.find()`
* `Array.prototype.findLast()`
* `Array.prototype.findLastIndex()`
* `Array.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`
* `TypedArray.prototype.findIndex()`
Array.prototype.toLocaleString()
================================

**`toLocaleString()`** メソッドは、配列の要素を表す文字列を返します。配列の要素は、それぞれの `toLocaleString` メソッドを使い、ロケール固有の文字列に変換されます（例えばカンマ "," など）。

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

構文
--


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

### 引数

`locales` 省略可

BCP 47 言語タグの文字列か、その配列です。`locales` 引数の一般的な形式と解釈については、ロケールの識別とネゴシエーションを参照してください。

`options` 省略可

設定プロパティのオブジェクトです。数値に関しては `Number.prototype.toLocaleString()` を、日付に関しては `Date.prototype.toLocaleString()` を見てください。

### 返値

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

解説
--

`Array.prototype.toLocaleString` メソッドは、その内容を走査し、すべての要素に対して `toLocaleString` メソッドを、引数 `locales` と `options` を指定して呼び出し、実装で定義された区切り文字 (",") でその結果を連結したものを返します。このメソッド自身は、この 2 つの引数を使用せず、各要素に対する `toLocaleString()` の呼び出しで渡すだけであることに注意してください。区切り文字列の選択はホストの現在のロケールに依存し、 `locales` 引数は使用しません。

例
-

### locales と options の使用

配列の要素は、その `toLocaleString` メソッドを使用して文字列に変換されます。

* `Object`: `Object.prototype.toLocaleString()`
* `Number`: `Number.prototype.toLocaleString()`
* `Date`: `Date.prototype.toLocaleString()`

`prices` 配列内の文字列と数値の通貨を常に表示します。


```js
const prices = ["￥7", 500, 8123, 12];
prices.toLocaleString("ja-JP", { style: "currency", currency: "JPY" });

// "￥7,￥500,￥8,123,￥12"
```


それ以外の例については、 `Intl.NumberFormat` や `Intl.DateTimeFormat` のページを参照してください。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.tolocalestring |
| ECMAScript Internationalization API Specification # sup-array.prototype.tolocalestring |

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

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

関連情報
----

* `Array.prototype.toString()`
* `Intl`
* `Object.prototype.toLocaleString()`
* `Number.prototype.toLocaleString()`
* `Date.prototype.toLocaleString()`
Array.prototype.toSpliced()
===========================

**`toSpliced()`** は `Array` インスタンスのメソッドで、 `splice()` メソッドに対応するコピーメソッドです。これは、指定された位置の要素を除去したり置き換えたりした新しい配列を返します。

構文
--


```js
toSpliced(start)
toSpliced(start, deleteCount)
toSpliced(start, deleteCount, item1)
toSpliced(start, deleteCount, item1, item2)
toSpliced(start, deleteCount, item1, item2, /\* …, \*/ itemN)
```

### 引数

`start`

配列の変更を始める位置のゼロから始まるインデックスで、整数に変換されます。

* 負のインデックスは配列の末尾から数えます。 `start < 0` の場合は `start + array.length` を使用します。
* `start < -array.length` または `start` が省略された場合は `0` が使用されます。
* `start >= array.length` である場合、削除される要素はありませんが、このメソッドは追加関数として動作し、提供されただけの要素を追加します。

`deleteCount` 省略可

整数で、配列内で `start` から削除する要素の数を示します。

`deleteCount` を省略した場合、またはその値が `start` で指定した位置以降の要素数以上の場合、 `start` から配列の末尾までのすべての要素が削除されます。ただし、もし `itemN` 引数を渡したい場合は、 `Infinity` を `deleteCount` に渡して `start` 以降の要素をすべて削除してください。明示的に `undefined` を指定すると `0` に変換されてしまうからです。

`deleteCount` が `0` または負の場合、要素は除去されません。
 この場合、少なくとも 1 つの新しい要素を指定する必要があります（下記参照）。


`item1`, …, `itemN` 省略可

配列に追加する要素を `start` から始めます。

要素を指定しない場合、 `toSpliced()` は配列から要素を取り除くだけです。

### 返値

`start`, `item1`, `item2`, …, `itemN` より前のすべての要素と、 `start + deleteCount` より後のすべての要素からなる新しい配列です。

解説
--

`toSpliced()` メソッドは `splice()` と同様に、一度に複数のことを行います。指定されたインデックスの位置から、指定された数の要素を配列から除去し、同じインデックスの位置に指定された要素を挿入します。しかし、元の配列を変更するのではなく、新しい配列を返します。したがって、削除された要素はこのメソッドからは返されません。

`toSpliced()` メソッドは決して疎配列を生成しません。疎配列の場合、空のスロットは新しい配列の `undefined` に置き換わります。

`toSpliced()` メソッドは汎用です。 `this` の値が `length` プロパティを持っており、整数のキーのプロパティがあることのみを期待します。

例
-

### 要素の削除、追加、置き換え

`toSpliced()` を使用すると、配列の要素を削除、追加、置き換えることができ、`slice()` や `concat()` を使用するよりも効率的に新しい配列を作成することができます。


```js
const months = ["Jan", "Mar", "Apr", "May"];

// インデックス 1 の要素の挿入
const months2 = months.toSpliced(1, 0, "Feb");
console.log(months2); // ["Jan", "Feb", "Mar", "Apr", "May"]

// インデックス 2 から始まる 2 つの要素を削除
const months3 = months2.toSpliced(2, 2);
console.log(months3); // ["Jan", "Feb", "May"]

// インデックス 1 の要素を 2 つの新しい要素で置き換え
const months4 = months3.toSpliced(1, 1, "Feb", "Mar");
console.log(months4); // ["Jan", "Feb", "Mar", "May"]

// 元配列は変更しない
console.log(months); // ["Jan", "Mar", "Apr", "May"]
```

### 疎配列に対する toSpliced() の使用

`toSpliced()` メソッドは常に密な配列を作成します。


```js
const arr = [1, , 3, 4, , 6];
console.log(arr.toSpliced(1, 2)); // [1, 4, undefined, 6]
```

### 配列以外のオブジェクトに対する toSpliced() の呼び出し

`toSpliced()` メソッドは `this` の `length` プロパティを読み取ります。そして、必要な整数キーのプロパティを読み込み、新しい配列に書き込みます。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  0: 5,
  2: 4,
};
console.log(Array.prototype.toSpliced.call(arrayLike, 0, 1, 2, 3));
// [2, 3, undefined, 4]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.tospliced |

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

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

関連情報
----

* `Array.prototype.toSpliced` のポリフィル (`core-js`)
* `Array.prototype.splice()`
* `Array.prototype.toReversed()`
* `Array.prototype.toSorted()`
* `Array.prototype.with()`
Array.prototype.flat()
======================

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

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

* Learn more
* See full compatibility
* Report feedback
**`flat()`** は `Array` インスタンスのメソッドで、すべてのサブ配列の要素を指定した深さで再帰的に結合した新しい配列を生成します。

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

構文
--


```js
flat()
flat(depth)
```

### 引数

`depth` 省略可

 ネストされた配列構造で、どの程度の深さをフラット化するか指定する深さレベルです。
 既定値は 1 です。


### 返値

サブ配列の要素を結合した新しい配列。

解説
--

`flat()` メソッドはコピーメソッドです。これは `this` を変更するのではなく、元の配列と同じ要素を格納したシャローコピーを返します。

`flat()` メソッドは、フラット化される配列が疎配列の場合、空のスロットを無視します。例えば、 `depth` が 1 の場合、ルート配列と最初の入れ子配列の空のスロットは無視されますが、それ以上の入れ子配列の空のスロットは配列自体に保持されます。

`flat()` メソッドは汎用的です。これは `this` 値に `length` プロパティと整数キーのプロパティがあることだけを期待します。しかし、その要素を平坦化するには配列でなければなりません。

例
-

### ネストされた配列の平坦化


```js
const arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]

const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

### 平坦化と配列の穴

`flat()` メソッドは配列内の空要素を削除します。


```js
const arr5 = [1, 2, , 4, 5];
console.log(arr5.flat()); // [1, 2, 4, 5]

const array = [1, , 3, ["a", , "c"]];
console.log(array.flat()); // [ 1, 3, "a", "c" ]

const array2 = [1, , 3, ["a", , ["d", , "e"]]];
console.log(array2.flat()); // [ 1, 3, "a", ["d", empty, "e"] ]
console.log(array2.flat(2)); // [ 1, 3, "a", "d", "e"]
```

### 配列でないオブジェクトに対する flat() の呼び出し

`flat()` メソッドは `this` の `length` プロパティを読み込み、キーが `length` より小さい非負の整数である各プロパティにアクセスします。要素が配列でない場合は、結果に直接追加されます。要素が配列の場合は、引数 `depth` に従って平坦化されます。


```js
const arrayLike = {
  length: 3,
  0: [1, 2],
  // 配列風オブジェクトは平坦化されない
  1: { length: 2, 0: 3, 1: 4 },
  2: 5,
  3: 3, // length が 3 なので flat() から無視される
};
console.log(Array.prototype.flat.call(arrayLike));
// [ 1, 2, { '0': 3, '1': 4, length: 2 }, 5 ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.flat |

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

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

関連情報
----

* `Array.prototype.flat` のポリフィル (`core-js`)
* インデックス付きコレクションのガイド
* `Array`
* `Array.prototype.concat()`
* `Array.prototype.flatMap()`
* `Array.prototype.map()`
* `Array.prototype.reduce()`
Array: length
=============

**`length`** は `Array` インスタンスのデータプロパティで、配列の要素の数を表します。値は符号なし 32 ビット整数で、常に配列の最も大きなインデックスよりも数値的に大きくなります。

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

値
-

非負の整数で、 232 未満です。

| `Array: length` のプロパティ属性 |
| --- |
| 書込可能 | 可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

解説
--

`length` プロパティの値は非負の整数で、 232 未満の値です。


```js
const listA = [1, 2, 3];
const listB = new Array(6);

console.log(listA.length);
// 3

console.log(listB.length);
// 6

listB.length = 2 \*\* 32; // 4294967296
// RangeError: Invalid array length

const listC = new Array(-100); // 負の数は許されない
// RangeError: Invalid array length
```


配列オブジェクトは `length` プロパティを監視し、自動的に `length` 値を配列のコンテンツと同期させます。これは、次のことを意味します。

* 新しい `length` を超えた要素は削除されます。
* 配列のインデックス（232 より小さい非負の整数）を現在の `length` よりも大きい値に設定するには、配列を拡張します。 `length` プロパティは新しい最も大きいインデックスを反映するように増加します。
* `length` に無効な値（例えば、負の数や非整数）を設定すると、 `RangeError` 例外が発生します。

`length` に現在の長さよりも大きな値を設定すると、配列は実際の値が `undefined` ではなく、空のスロットを追加することで拡張されます。空のスロットは配列メソッドと特別な対話をします。配列メソッドと空のスロットを参照してください。


```js
const arr = [1, 2];
console.log(arr);
// [ 1, 2 ]

arr.length = 5; // 現在 2 の配列の長さを 5 に設定
console.log(arr);
// [ 1, 2, <3 つの空アイテム> ]

arr.forEach((element) => console.log(element));
// 1
// 2
```


詳細は `length` と数値プロパティとの関係をご覧ください。

例
-

### 配列を反復処理する

以下の例では、配列 `numbers` がいくつの要素を持っているかを知るために `length` プロパティを見ることで、配列を反復処理します。その際それぞれの値は 2 倍されます。


```js
const numbers = [1, 2, 3, 4, 5];
const length = numbers.length;
for (let i = 0; i < length; i++) {
  numbers[i] \*= 2;
}
// numbers は [2, 4, 6, 8, 10] となった
```

### 配列の短縮

以下の例は配列 `numbers` の要素数が 3 より大きいかどうかを調べて、大きいならその `length` を 3 としています。


```js
const numbers = [1, 2, 3, 4, 5];

if (numbers.length > 3) {
  numbers.length = 3;
}

console.log(numbers); // [1, 2, 3]
console.log(numbers.length); // 3
console.log(numbers[3]); // undefined; the extra elements are deleted
```

### 固定長の空の配列を作成

`length` に現在の長さ以上の値を設定すると、疎配列を作成します。


```js
const numbers = [];
numbers.length = 3;
console.log(numbers); // [empty x 3]
```

### length の書き込み不可の配列

`length` プロパティは、現在の長さを超えて要素が追加されると、配列によって自動的に更新されます。もし `length` プロパティを書き込み不可にすると、配列はそれを更新できなくなります。これは厳格モードではエラーが発生します。


```js
"use strict";

const numbers = [1, 2, 3, 4, 5];
Object.defineProperty(numbers, "length", { writable: false });
numbers[5] = 6; // TypeError: Cannot assign to read only property 'length' of object '[object Array]'
numbers.push(5); // // TypeError: Cannot assign to read only property 'length' of object '[object Array]'
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-array-instances-length |

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

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

関連情報
----

* インデックス付きコレクションガイド
* `Array`
* `TypedArray.prototype.length`
* `String`: `length`
* RangeError: invalid array length