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

**`findLastIndex()`** は `Array` のメソッドで、この配列を逆順に反復処理し、指定されたテスト関数を満たす配列の最後の要素のインデックスを返します。
 テスト関数を満たす要素がなかった場合は、 -1 を返します。

`findLast()` メソッドも参照してください。こちらはテスト関数を満たす最後の要素の（位置ではなく）値を返します。

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

構文
--


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

### 引数

`callbackFn`

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

`element`

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

`index`

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

`array`

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


`thisArg` 省略可

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

### 返値

 配列内で、テストを満たした最後の（最も大きな）要素のインデックス。
 それ以外の場合は，一致する要素が見つからなければ `-1` となります。

解説
--

`findLastIndex()` メソッドは反復処理メソッドです。配列のそれぞれの要素に対して、インデックスの降順に一度ずつ指定された `callbackFn` 関数を実行し、 `callbackFn` が真値を返すまで続けます。そして、 `findLastIndex()` がその要素のインデックスを返し、配列のイテレーターを停止します。もし `callbackFn` が真値を返さなかった場合、 `findLastIndex()` は `-1` を返します。

`callbackFn` は値が割り当てられている要素だけではなく、配列の「すべての」インデックスに対して呼び出されます。疎配列で空のスロットは `undefined` と同じ動作をします。

`findLastIndex()` メソッドは呼び出し元の配列を変更しませんが、 `callbackFn` に指定された関数は変更することがあります。ただし、配列の長さは `callbackFn` を最初に呼び出す前に保存されることに注意してください。したがって、

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

**警告:** 前項で説明したような、参照中の配列の同時進行での変更は（特殊な場合を除いて）普通は避けるべきです。多くの場合、理解しにくいコードになります。

`findLastIndex()` メソッドは汎用的です。これは `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, 12].findLastIndex(isPrime)); // -1, not found
console.log([4, 5, 7, 8, 9, 11, 12].findLastIndex(isPrime)); // 5
```

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

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


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

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

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


```js
const arrayLike = {
  length: 3,
  0: 2,
  1: 7.3,
  2: 4,
  3: 3, // length が 3 であるため findLastIndex() から無視される
};
console.log(
  Array.prototype.findLastIndex.call(arrayLike, (x) => Number.isInteger(x)),
); // 2
```

仕様書
---

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

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

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

関連情報
----

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

**`includes()`** は `Array` インスタンスのメソッドで、特定の要素が配列に含まれているかどうかを `true` または `false` で返します。

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

構文
--


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

### 引数

`searchElement`

検索する値です。

`fromIndex` 省略可

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

* インデックスが負の場合、配列の末尾からさかのぼって数えます。 `fromIndex < 0` の場合、 `fromIndex + array.length` が使用されます。ただし、この場合でも配列は前から後ろに向けて検索されます。
* `fromIndex < -array.length` または `fromIndex` が省略された場合は `0` が使用され、配列全体に対して検索が行われます。
* `fromIndex >= array.length` の場合、配列の検索は行われず、 `false` が返されます。

### 返値

論理値で、`searchElement` の値が配列内（`fromIndex` が指定されていた場合は、配列のその位置以降の部分）にあった場合は `true` を返します。

解説
--

`includes()` は `searchElement` を SameValueZero アルゴリズムを使用して比較します。ゼロの値は符号に関わらず、すべて等しい（すなわち、`-0` は `0` と等しい）とみなされますが、`false` は `0` と同じとはみなされ*ません*。 `NaN` は正しく検索することができます。

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

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

例
-

### includes() の使用


```js
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
["1", "2", "3"].includes(3); // false
```

### fromIndex が配列の長さと同じか大きい場合

`fromIndex` が配列の長さと同じか大きい場合は、配列を検索せずに `false` を返します。


```js
const arr = ["a", "b", "c"];

arr.includes("c", 3); // false
arr.includes("c", 100); // false
```

### 計算された位置が 0 より小さい場合

`fromIndex` が負の値である場合、`searchElement` の検索を開始するための配列内の位置として、計算により位置が算出されます。計算された位置が `0` 以下の場合は、配列全体が検索されます。


```js
// 配列の長さは 3
// fromIndex は -100
// 補正されたインデックスは 3 + (-100) = -97

const arr = ["a", "b", "c"];

arr.includes("a", -100); // true
arr.includes("b", -100); // true
arr.includes("c", -100); // true
arr.includes("a", -2); // false
```

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

疎配列で `undefined` を検索して `true` を取得することができます。


```js
console.log([1, , 3].includes(undefined)); // true
```

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

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


```js
const arrayLike = {
  length: 3,
  0: 2,
  1: 3,
  2: 4,
  3: 1, // length が 3 なので includes() からは無視される
};
console.log(Array.prototype.includes.call(arrayLike, 2));
// true
console.log(Array.prototype.includes.call(arrayLike, 1));
// false
```

仕様書
---

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

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

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

関連情報
----

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

**`Array.isArray()`** 静的メソッドは、渡された値が `Array` かどうかを判断します。

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

構文
--


```js
Array.isArray(value)
```

### 引数

`value`

チェックするオブジェクト。

### 返値

`value` が `Array` の場合は `true` です。そうでなければ `false` を返します。 `value` が `TypedArray` インスタンスであった場合は常に `false` を返します。

解説
--

`Array.isArray()` は、渡された値が `Array` であるかどうかを調べます。値のプロトタイプチェーンを調べたり、 `Array` コンストラクターに頼っているわけではありません。配列リテラル構文または `Array` コンストラクターを使用して作成した値に対しては `true` を返します。このため、 `Array` コンストラクターの ID が異なり、`instanceof Array` が失敗してしまうような領域を超えるオブジェクトでも安全に使用することができます。

詳しくは、 "Determining with absolute accuracy whether or not a JavaScript object is an array" を参照してください。

また、 `Array.isArray()` は `Array.prototype` をプロトタイプチェーンに持つオブジェクトも拒否しますが、 `instanceof Array` が受け入れる実際の配列ではありません。

例
-

### Array.isArray() の使用


```js
// 以下の呼び出しはすべて true を返します
Array.isArray([]);
Array.isArray([1]);
Array.isArray(new Array());
Array.isArray(new Array("a", "b", "c", "d"));
Array.isArray(new Array(3));
// あまり知られていないものの Array.prototype は配列です
Array.isArray(Array.prototype);

// 以下の呼び出しはすべて false を返します
Array.isArray();
Array.isArray({});
Array.isArray(null);
Array.isArray(undefined);
Array.isArray(17);
Array.isArray("Array");
Array.isArray(true);
Array.isArray(false);
Array.isArray(new Uint8Array(32));
// これは配列ではありません。配列リテラルを使用した構文でも、
// Array コンストラクターでもないからです。
Array.isArray({ \_\_proto\_\_: Array.prototype });
```

### instanceof と Array.isArray()

`Array` のインスタンスをチェックする際、 `Array.isArray` は領域を超えても動作するので、 `instanceof` よりも推奨されます。


```js
const iframe = document.createElement("iframe");
document.body.appendChild(iframe);
const xArray = window.frames[window.frames.length - 1].Array;
const arr = new xArray(1, 2, 3); // [1, 2, 3]

// 配列を正しくチェックできます
Array.isArray(arr); // true
// arr のプロトタイプは xArray.prototype であり、
// Array.prototype とは異なるオブジェクトです。
arr instanceof Array; // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.isarray |

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

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

関連情報
----

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

**`entries()`** は `Array` インスタンスのメソッドで、配列内の各要素に対するキー/値のペアを含む新しい配列イテレーターオブジェクトを返します。

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

構文
--


```js
entries()
```

### 引数

なし。

### 返値

新しい反復可能イテレーターオブジェクトです。

解説
--

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

`entries()` メソッドは汎用的です。このメソッドは `this` の値に `length` プロパティと整数のキーを持ったプロパティがあることだけを求めます。

例
-

### インデックスと要素の反復処理


```js
const a = ["a", "b", "c"];

for (const [index, element] of a.entries()) {
  console.log(index, element);
}

// 0 'a'
// 1 'b'
// 2 'c'
```

### for...of ループの使用


```js
const array = ["a", "b", "c"];
const arrayEntries = array.entries();

for (const element of arrayEntries) {
  console.log(element);
}

// [0, 'a']
// [1, 'b']
// [2, 'c']
```

### 疎配列を反復処理

`entries()` は空のスロットを `undefined` であるかのように処理します。


```js
for (const element of [, "a"].entries()) {
  console.log(element);
}
// [0, undefined]
// [1, 'a']
```

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

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


```js
const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
  3: "d", // length が 3 なので entries() からは無視される
};
for (const entry of Array.prototype.entries.call(arrayLike)) {
  console.log(entry);
}
// [ 0, 'a' ]
// [ 1, 'b' ]
// [ 2, 'c' ]
```

仕様書
---

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

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

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

関連情報
----

* `Array.prototype.entries` のポリフィル (`core-js`)
* インデックス付きコレクションガイド
* `Array`
* `Array.prototype.keys()`
* `Array.prototype.values()`
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype.entries()`
* 反復処理プロトコル
Array.prototype.toSorted()
==========================

**`toSorted()`** は `Array` インスタンスのメソッドで、 `sort()` メソッドに対応するコピーメソッドです。これは、要素を昇順にソートした新しい配列を返します。

構文
--


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

### 引数

`compareFn` 省略可

ソート順を定義する関数を指定します。省略した場合は、配列の要素を文字列に変換し、 Unicode コードポイントの値に従って並べ替えます。

`a`

比較する最初の要素です。

`b`

比較する 2 番目の要素です。


### 返値

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

解説
--

`compareFn` 引数の情報については `sort()` を参照してください。

疎配列が使用された場合、 `toSorted()` メソッドは空のスロットを `undefined` という値があるものとして反復処理します。

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

例
-

### 配列のソート


```js
const months = ["Mar", "Jan", "Feb", "Dec"];
const sortedMonths = months.toSorted();
console.log(sortedMonths); // ['Dec', 'Feb', 'Jan', 'Mar']
console.log(months); // ['Mar', 'Jan', 'Feb', 'Dec']

const values = [1, 10, 21, 2];
const sortedValues = values.toSorted((a, b) => a - b);
console.log(sortedValues); // [1, 2, 10, 21]
console.log(values); // [1, 10, 21, 2]
```


他の利用例は、 `sort()` を参照してください。

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

空のスロットは値が `undefined` であるかのようにソートされます。これらは常に配列の末尾にソートされ、 `compareFn` は呼び出されません。


```js
console.log(["a", "c", , "b"].toSorted()); // ['a', 'b', 'c', undefined]
console.log([, undefined, "a", "b"].toSorted()); // ["a", "b", undefined, undefined]
```

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

`toSorted()` メソッドは `this` の `length` プロパティを読み取ります。そして、`length - 1` から `0` までの整数のキーを持つ各プロパティを降順に訪れ、現在のプロパティの値を配列の末尾に追加して返します。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  0: 5,
  2: 4,
  3: 3, // length が 3 なので toSorted() からは無視される
};
console.log(Array.prototype.toSorted.call(arrayLike));
// [4, 5, undefined]
```

仕様書
---

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

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

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

関連情報
----

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

**`keys()`** は `Array` インスタンスのメソッドで、配列内の各インデックスのキーを含む、新しい配列イテレーターオブジェクトを返します。

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

構文
--


```js
keys()
```

### 引数

なし。

### 返値

新しい反復可能なイテレーターオブジェクトです。

解説
--

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

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

例
-

### 疎配列に対する keys() の呼び出し

配列に実際に存在するキーだけを処理する `Object.keys()` とは異なり、 `keys()` イテレーターは見つからないプロパティを表す穴を無視しません。


```js
const arr = ["a", , "c"];
const sparseKeys = Object.keys(arr);
const denseKeys = [...arr.keys()];
console.log(sparseKeys); // ['0', '2']
console.log(denseKeys); // [0, 1, 2]
```

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

`keys()`メソッドは `this` の `length` プロパティを読み込み、 0 から `length - 1` までのすべての整数インデックスを返します。実際にはインデックスアクセスは行われません。


```js
const arrayLike = {
  length: 3,
};
for (const entry of Array.prototype.keys.call(arrayLike)) {
  console.log(entry);
}
// 0
// 1
// 2
```

仕様書
---

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

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

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

関連情報
----

* `Array.prototype.keys` のポリフィル (`core-js`)
* インデックス付きコレクションのガイド
* `Array`
* `Array.prototype.entries()`
* `Array.prototype.values()`
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype.keys()`
* Iteration protocols
Array.prototype.shift()
=======================

**`shift()`** は `Array` インスタンスのメソッドで、配列から**最初**の要素を取り除き、その要素を返します。このメソッドは配列の長さを変えます。

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

構文
--


```js
shift()
```

### 引数

なし。

### 返値

配列から取り除かれた要素を返します。配列が空の場合は、`undefined` を返します。

解説
--

`shift()` メソッドは 0 番目の位置の要素を取り除き、続く位置の値を小さい方向にずらします。
 そして、削除された値を返します。`length` プロパティが 0 の場合、`undefined` を返します。

`pop()` メソッドは `shift()` と似た動作をしますが、こちらは配列の末尾の要素に適用されます。

`shift()` メソッドは変更メソッドです。長さと `this` の内容を変更します。 `this` の値を変化させず、最初の要素を取り除いた新しい配列を返したい場合は、代わりに `arr.slice(1)` を使用することができます。

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

例
-

### 配列から要素を除去

以下のコードは `myFish` 配列を、その最初の要素を取り除く前後で表示します。また、取り除いた要素も表示します。


```js
const myFish = ["angel", "clown", "mandarin", "surgeon"];

console.log("myFish 処理前:", myFish);
// myFish 処理前: ['angel', 'clown', 'mandarin', 'surgeon']

const shifted = myFish.shift();

console.log("myFish 処理後:", myFish);
// myFish 処理後: ['clown', 'mandarin', 'surgeon']

console.log("取り除いた要素:", shifted);
// 取り除いた要素: angel
```

### shift() メソッドの while ループ内での使用

shift() メソッドは時に、 while 文の条件内において用いられます。以下のコードでは、要素がすべて無くなるまで、反復処理のたびにその配列内の次の要素を取り除きます。


```js
const names = ["Andrew", "Tyrone", "Paul", "Maria", "Gayatri"];

while (typeof (i = names.shift()) !== "undefined") {
  console.log(i);
}
// Andrew, Tyrone, Paul, Maria, Gayatri
```

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

`shift()` メソッドは `this` の `length` プロパティを読み込みます。正規化された長さが 0 の場合、`length` は再び `0` に設定されます（以前は負の値または `undefined` であった可能性があります）。そうでない場合は、 `0` のプロパティを返し、残りのプロパティは左に 1 つシフトされます。 `length` プロパティは 1 つデクリメントされます。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  2: 4,
};
console.log(Array.prototype.shift.call(arrayLike));
// undefined。空のスロットであるため
console.log(arrayLike);
// { '1': 4, length: 2, unrelated: 'foo' }

const plainObj = {};
// length プロパティがないため、 length は 0
Array.prototype.shift.call(plainObj);
console.log(plainObj);
// { length: 0 }
```

仕様書
---

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

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

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

関連情報
----

* インデックス付きコレクションのガイド
* `Array`
* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
* `Array.prototype.splice()`
Array.prototype.push()
======================

**`push()`** は `Array` インスタンスのメソッドで、配列の末尾に指定された要素を追加します。また返値として配列の新しい長さを返します。

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

構文
--


```js
push()
push(element1)
push(element1, element2)
push(element1, element2, /\* …, \*/ elementN)
```

### 引数

`element1`, …, `elementN`

配列の末尾に追加する要素。

### 返値

メソッドが呼び出されたオブジェクトの新しい `length` プロパティ。

解説
--

`push()` メソッドは配列の末尾に要素を追加します。

`Array.prototype.unshift()` は `push()` と同様の動作ですが、配列の先頭に適用されます。

`push()` メソッドは変更メソッドです。これは、 `this` の長さとコンテンツを変更します。 `this` の値はそのままで、最後に要素を追加した新しい配列を返したい場合は、代わりに `arr.concat([element0, element1, /* ... ,*/ elementN])` を使用することができます。要素が余分な配列に包まれていることに注意してください。そうでなければ、要素が配列そのものである場合、 `concat()` の動作により、単一の要素として挿入されるのではなく、分散されてしまうでしょう。

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

例
-

### 配列に要素を追加する

以下のコードは 2 つの要素を持つ配列 `sports` を生成し、それに 2 つの要素を追加します。コードの実行後、変数 `total` には 4 が入ります。


```js
const sports = ["soccer", "baseball"];
const total = sports.push("football", "swimming");

console.log(sports); // ['soccer', 'baseball', 'football', 'swimming']
console.log(total); // 4
```

### ２つの配列をマージする

この例ではスプレッド構文を使用して、二番目の配列から最初の配列へすべての要素を挿入します。


```js
const vegetables = ["parsnip", "potato"];
const moreVegs = ["celery", "beetroot"];

// 1 つ目の配列に 2 つ目の配列をマージさせます
vegetables.push(...moreVegs);

console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']
```


2 つの配列の結合は、 `concat()` メソッドでも行うことができます。

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

`push()` メソッドは `this` の `length` プロパティを読み込みます。そして、 `length` から始まる `this` の各インデックスを `push()` に渡された引数で設定します。最後に、`length` に直前の長さにプッシュされた要素数を加えた値を設定します。


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

const plainObj = {};
// length プロパティがないので、長さは 0
Array.prototype.push.call(plainObj, 1, 2);
console.log(plainObj);
// { '0': 1, '1': 2, length: 2 }
```

### オブジェクトを配列のように使用する

前述したように、`push` は内部的には汎用的なので、その利点を活かすことができます。この例が示しているように、オブジェクト上で `Array.prototype.push` は正しく動作します。

オブジェクトの集合を保存するために、配列を生成していないことに注意してください。代わりに、集合をオブジェクト自体に保存して、配列を扱っているかのように見せかけるために `Array.prototype.push` 上で `call` を使用しています。そして、JavaScript は実行コンテキストの確立を許可しているおかげで、これは動作します。


```js
const obj = {
  length: 0,

  addElem(elem) {
    // obj.length は、要素が追加されるたびに
    // 自動的に増加する。
    [].push.call(this, elem);
  },
};

// 例示のために空のオブジェクトを追加する。
obj.addElem({});
obj.addElem({});
console.log(obj.length); // 2
```


`obj` は配列ではありませんが、本当の配列を扱っているかのように `push` メソッドは `obj` の `length` プロパティを増加させできていることに注意してください。

仕様書
---

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

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

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

関連情報
----

* このメソッドの修正を含んだ `Array.prototype.push` のポリフィル (`core-js`)
* インデックス付きコレクションのガイド
* `Array.prototype.pop()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
* `Array.prototype.splice()`
Array.prototype.toString()
==========================

**`toString()`** は `Array` インスタンスのメソッドで、指定された配列とその要素を表す文字列を返します。

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

構文
--


```js
toString()
```

### 引数

なし。

### 返値

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

解説
--

`Array` オブジェクトは `Object` の `toString` メソッドをオーバーライドしています。配列の `toString` メソッドは内部的に `join()` を呼び出します。そちらで配列を結合し、配列のすべての要素をカンマで区切って一つの文字列に収めて返します。 `join` メソッドが利用できないか関数ではなかった場合、代わりに `Object.prototype.toString` が使用され、 `[object Array]` を返します。


```js
const arr = [];
arr.join = 1; // `join` を関数ではないものに再代入
console.log(arr.toString()); // [object Array] と出力

console.log(Array.prototype.toString.call({ join: () => 1 })); // 1 と出力
```


配列を文字列値として表す必要がある場合や、配列が文字列の結合として参照されるとき、 JavaScript は `toString` メソッドを自動的に呼び出します。

`Array.prototype.toString` は他の配列も含めて、再帰的にそれぞれの要素を文字列に変換します。Array.prototype.toString` が返す文字列には区切り文字がないので、入れ子配列は平坦化されたように見えます。


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

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


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


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

例
-

### toString() の使用


```js
const array1 = [1, 2, "a", "1a"];

console.log(array1.toString()); // "1,2,a,1a"
```

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

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


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

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

`toString()` は汎用的です。このメソッドは `this` が `join()` メソッドを持っていることを期待します。ない場合は、代わりに `Object.prototype.toString()` を使用します。


```js
console.log(Array.prototype.toString.call({ join: () => 1 }));
// 1; a number
console.log(Array.prototype.toString.call({ join: () => undefined }));
// undefined
console.log(Array.prototype.toString.call({ join: "not function" }));
// "[object Object]"
```

仕様書
---

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

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

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

関連情報
----

* インデックス付きコレクションのガイド
* `Array`
* `Array.prototype.join()`
* `Array.prototype.toLocaleString()`
* `TypedArray.prototype.toString()`
* `String.prototype.toString()`
Array.prototype.pop()
=====================

**`pop()`** メソッドは、配列から**最後**の要素を取り除き、その要素を返します。このメソッドは配列の長さを変化させます。

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

構文
--


```js
pop()
```

### 引数

なし。

### 返値

配列の最後の要素。配列が空だった場合は、`undefined`。

解説
--

`pop()` メソッドは配列の最後の要素を取り除き、呼び出し元にその値を返します。 `pop()` を空の配列に対して呼び出すと、 `undefined` を返します。

`Array.prototype.shift()` は `pop()` と同様の動作をしますが、配列の最初の要素に適用されます。

`pop()` は変更を行うメソッドです。 `this` の長さと内容を変更します。 `this` の値は変更せずに、最後の要素を取り除いた新しい配列を返したい場合は、代わりに `arr.slice(0, -1)` を使用することができます。

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

例
-

### 配列の最後の要素を取り除く

以下のコードは、4 つの要素を含んだ配列 `myFish` を生成し、その後その最後の要素を取り除き、変数に代入しています。


```js
const myFish = ["angel", "clown", "mandarin", "sturgeon"];

const popped = myFish.pop();

console.log(myFish); // ['angel', 'clown', 'mandarin' ]

console.log(popped); // 'sturgeon'
```

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

`pop()` メソッドは `this` の `length` プロパティを読み込みます。正規化された長さが 0 の場合、`length` は再び `0` に設定されます（以前は負の値または `undefined` であった可能性があります）。そうでない場合は、`length - 1` のプロパティが返され、削除されます。


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  2: 4,
};
console.log(Array.prototype.pop.call(arrayLike));
// 4
console.log(arrayLike);
// { length: 2, unrelated: 'foo' }

const plainObj = {};
// length プロパティがないので、長さは 0
Array.prototype.pop.call(plainObj);
console.log(plainObj);
// { length: 0 }
```

### 配列風のオブジェクトの使用

`push` と `pop` は意図的に汎用的になっており、以下の例で示すように、それを使用して有利に進めることができます。

この例では、オブジェクトの集合を格納するために配列を作成していないことに注意してください。その代わりに、オブジェクト自体に集合を格納し、 `Array.prototype.push` と `Array.prototype.pop` で `call` を使用して、これらのメソッドが配列を使用していると考えるように仕向けています。


```js
const collection = {
  length: 0,
  addElements(...elements) {
    // obj.length は、要素が追加されるたびに
    // 自動的に増加します。

    // push が返す値を返します。つまり、
    // length プロパティの新しい値です。
    return [].push.call(this, ...elements);
  },
  removeElement() {
    // obj.length は、要素が削除されるたびに
    // 自動的にデクリメントされます。

    // push が返す値を返します。つまり、
    // 取り除かれた要素です。
    return [].pop.call(this);
  },
};

collection.addElements(10, 20, 30);
console.log(collection.length); // 3
collection.removeElement();
console.log(collection.length); // 2
```

仕様書
---

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

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

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

関連情報
----

* インデックス付きコレクションのガイド
* `Array.prototype.push()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
* `Array.prototype.splice()`