recursal/MDN huggingface dataset:
String.prototype.toWellFormed()
===============================

**`toWellFormed()`** は `String` 値のメソッドで、この文字列のすべての孤立サロゲートを Unicode 置換文字 U+FFFD に置き換えた文字列を返します。

構文
--


```js
toWellFormed()
```

### 返値

この文字列のコピーで、孤立サロゲートをすべて Unicode 置換文字 U+FFFD に置き換えた新しい文字列です。 もし `str` が整形式 であれば、やはり新しい文字列が返されます（基本的には `str` のコピーです）。

解説
--

JavaScript の文字列は UTF-16 でエンコードされています。UTF-16 エンコーディングにはサロゲートペアという概念があり、これは UTF-16 文字、Unicode コードポイント、書記素クラスターで詳しく紹介されています。

`toWellFormed()` はこの文字列のコード単位を走査し、すべての孤立サロゲートをUnicode 置換文字 U+FFFD `&#fffd;` に置き換えます。これは、返す文字列が整形式であることを保証し、`encodeURI` のような整形式文字列を期待する関数で使用することができます。カスタム実装と比較して、`toWellFormed()` は、エンジンが文字列の内部表現に直接アクセスすることができるので、より効率的です。

整形式ではない文字列が `TextEncoder` のような特定の文脈で使用された場合、自動的に同じ置換文字を使って整形された文字列に変換されます。孤立サロゲートがレンダリングされるとき、それらは置換文字（疑問符が内側にある菱形）としてもレンダリングされます。

例
-

### toWellFormed() の使用


```js
const strings = [
  // 孤立高サロゲート
  "ab\uD800",
  "ab\uD800c",
  // 孤立低サロゲート
  "\uDFFFab",
  "c\uDFFFab",
  // 整形式
  "abc",
  "ab\uD83D\uDE04c",
];

for (const str of strings) {
  console.log(str.toWellFormed());
}
// Logs:
// "ab�"
// "ab�c"
// "�ab"
// "c�ab"
// "abc"
// "ab😄c"
```

### encodeURI() のエラーを防止

`encodeURI` は渡された文字列が整形式でない場合、エラーを発生させます。これは `toWellFormed()` によって文字列を最初に整形式文字列に変換しておくことで防ぐことができます。


```js
const illFormed = "https://example.com/search?q=\uD800";

try {
  encodeURI(illFormed);
} catch (e) {
  console.log(e); // URIError: URI malformed
}

console.log(encodeURI(illFormed.toWellFormed())); // "https://example.com/search?q=%EF%BF%BD"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.towellformed |

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

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

関連情報
----

* `String.prototype.toWellFormed` のポリフィル (`core-js`)
* `String.prototype.isWellFormed()`
* `String.prototype.normalize()`
String.prototype.codePointAt()
==============================

**`codePointAt()`** は `String` のメソッドで、指定されたインデックスから始まる文字の Unicode コードポイント値である非負の整数を返します。インデックスは Unicode コードポイントではなく、UTF-16 コード単位に基づくことに注意してください。

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

構文
--


```js
codePointAt(index)
```

### 引数

`index`

返す文字の 0 基点のインデックスです。整数に変換され、`undefined` は 0 に変換されます。

### 返値

指定された位置 `index` にある文字のコードポイント値を表す非負の整数値です。

* `index` が `0` – `str.length - 1` の範囲外であれば、`codePointAt()` は `undefined` を返します。
* `index` の位置の要素が UTF-16 高サロゲートであった場合、そのコードポイントのサロゲートペアを返します。
* `index` の位置の要素が UTF-16 低サロゲートであった場合、低サロゲートコードポイントのみを返します。
解説
--

文字列の中の文字は、左から右に向けてインデックス付けされています。最初の文字の添字は `0` であり、最後の文字の添字は `str` という名前の文字列であれば `str.length - 1` です。

Unicode のコードポイントは `0` から `1114111` (`0x10FFFF`) までの範囲です。UTF-16 では、それぞれの文字列のインデックスは `0` ～ `65536` のコード単位です。上位のコードポイントは 16 ビットのサロゲート擬似文字のペアによって表されます。したがって、`codePointAt()` は文字列の 2 つのインデックスにまたがるコードポイントを返す可能性があります。Unicode に関する情報はUTF-16 文字、Unicode コードポイント、書記素クラスターを参照してください。

例
-

### codePointAt() の使用


```js
"ABC".codePointAt(0); // 65
"ABC".codePointAt(0).toString(16); // 41

"😍".codePointAt(0); // 128525
"\ud83d\ude0d".codePointAt(0); // 128525
"\ud83d\ude0d".codePointAt(0).toString(16); // 1f60d

"😍".codePointAt(1); // 56845
"\ud83d\ude0d".codePointAt(1); // 56845
"\ud83d\ude0d".codePointAt(1).toString(16); // de0d

"ABC".codePointAt(42); // undefined
```

### codePointAt() の繰り返し

要素が UTF-16 の低サロゲートである `index` へのインデックス付けは、低サロゲートのみを返すので、文字列のインデックスをループに使わない方がよいでしょう。


```js
const str = "\ud83d\udc0e\ud83d\udc71\u2764";

for (let i = 0; i < str.length; i++) {
  console.log(str.codePointAt(i).toString(16));
}
// '1f40e', 'dc0e', '1f471', 'dc71', '2764'
```


代わりに、`for...of` 文やスプレッド構文を使用してください。どちらも文字列の `@@iterator` を呼び出し、コードポイント単位で反復処理をします。それから、`codePointAt(0)` でそれぞれの要素のコードポイントを取得してください。


```js
for (const codePoint of str) {
  console.log(codePoint.codePointAt(0).toString(16));
}
// '1f40e', '1f471', '2764'

[...str].map((cp) => cp.codePointAt(0).toString(16));
// ['1f40e', '1f471', '2764']
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.codepointat |

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

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

関連情報
----

* `String.prototype.codePointAt` のポリフィル (`core-js`)
* `String.fromCodePoint()`
* `String.fromCharCode()`
* `String.prototype.charCodeAt()`
* `String.prototype.charAt()`
String.prototype.sub()
======================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

**`sub()`** メソッドは、文字列を `<sub>` 要素に埋め込んだ文字列 (`<sub>str</sub>`) を生成し、文字列が下付き文字として表示されるようにします。

**警告:** HTML ラッパーメソッドはすべて非推奨となっており、互換性目的のみで標準化されています。代わりに DOM API の `document.createElement()` などを使用してください。

構文
--


```js
sub()
```

### 返値

開始タグ `<sub>` で始まり、テキスト `str` が来て、終了タグ `</sub>` が来る文字列です。

例
-

### sub() および sup() メソッドの使用

以下の例は、 `sub()` と `sup()` メソッドを使用して文字列を整形しています。


```js
const superText = "上付き文字";
const subText = "下付き文字";

console.log(`これは ${superText.sup()} の見え方を示しています。`);
// "これは<sup>上付き文字</sup>の見え方を示しています。"

console.log(`これは ${subText.sub()} の見え方を示しています。`);
// "これは<sub>下付き文字</sub>の見え方を示しています。"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.sub |

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

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

関連情報
----

* `String.prototype.sub` のポリフィル (`core-js`)
* `String.prototype.sup()`
String.prototype.toUpperCase()
==============================

**`toUpperCase()`** メソッドは、呼び出す文字列の値を（文字列でない場合、文字列に変換して）大文字に変換して返します。

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

構文
--


```js
toUpperCase()
```

### 返値

呼び出す文字列の値を大文字に変換した新しい文字列です。

解説
--

`toUpperCase()` メソッドは、大文字に変換された文字列の値を返します。このメソッドは、文字列自身の値に影響を与えません（JavaScript の文字列は不変です）。

例
-

### 基本的な使用


```js
console.log("alphabet".toUpperCase()); // 'ALPHABET'
```

### 文字列でない `this` 値を文字列に変換する

このメソッドは `this` に文字列でない値を設定した場合、文字列に変換します。


```js
const a = String.prototype.toUpperCase.call({
  toString() {
    return "abcdef";
  },
});

const b = String.prototype.toUpperCase.call(true);

// 'ABCDEF TRUE' と表示
console.log(a, b);
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.touppercase |

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

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

関連情報
----

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`
String.prototype.small()
========================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

**`small()`** メソッドは、文字列を `<small>` 要素に埋め込んだ文字列 (`<small>str</small>`) を生成し、文字列が小さなフォントで表示されるようにします。

**警告:** HTML ラッパーメソッドはすべて非推奨となっており、互換性目的のみで標準化されています。代わりに DOM API の `document.createElement()` などを使用してください。

構文
--


```js
small()
```

### 返値

開始タグ `<small>` で始まり、テキスト `str` が来て、終了タグ `</small>` が来る文字列です。

例
-

### small() の使用

以下の例では文字列のメソッドを使用して、文字列の大きさを変更しています。


```js
const worldString = "Hello, world";

console.log(worldString.small()); // <small>Hello, world</small>
console.log(worldString.big()); // <big>Hello, world</big>
console.log(worldString.fontsize(7)); // <font size="7">Hello, world</fontsize>
```


`element.style` オブジェクトを使用すると、要素の `style` 属性を使用して、次のようにもっと汎用的に操作することができます。


```js
document.getElementById("yourElemId").style.fontSize = "0.7em";
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.small |

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

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

関連情報
----

* `String.prototype.small` のポリフィル (`core-js`)
* `String.prototype.fontsize()`
* `String.prototype.big()`
String.prototype.blink()
========================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

**`blink()`** メソッドは、文字列を (`<blink>str</blink>`) に埋め込んだ文字列を生成し、古いブラウザーにおいて文字列を点滅させるために使用します。

**警告:** HTML ラッパーメソッドはすべて非推奨となっており、互換性目的のみで標準化されています。`blink()` の場合、`<blink>` 要素自体が現代のブラウザーから削除されており、テキストを点滅させることは、複数のアクセシビリティ標準で忌避されています。この要素を使用することは避けてください。

構文
--


```js
blink()
```

### 返値

`<blink>` 開始タグで始まり、`str` のテキストが来て、 `</blink>` 終了タグが来る文字列です。

例
-

### blink() の使用

以下の例では文字列のメソッドを使用して、文字列の整形方法を変化させています。


```js
const worldString = "Hello, world";

console.log(worldString.blink()); // <blink>Hello, world</blink>
console.log(worldString.bold()); // <b>Hello, world</b>
console.log(worldString.italics()); // <i>Hello, world</i>
console.log(worldString.strike()); // <strike>Hello, world</strike>
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.blink |

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

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

関連情報
----

* `String.prototype.blink` のポリフィル (`core-js`)
* `String.prototype.bold()`
* `String.prototype.italics()`
* `String.prototype.strike()`
String.prototype.strike()
=========================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

**`strike()`** メソッドは、文字列を `<strike>` 要素に埋め込んだ文字列 (`<strike>str</strike>`) を生成し、文字列が取り消されたテキストとして表示されるようにします。

**警告:** HTML ラッパーメソッドはすべて非推奨となっており、互換性目的のみで標準化されています。代わりに DOM API の `document.createElement()` などを使用してください。

構文
--


```js
strike()
```

### 返値

開始タグ `<strike>` で始まり、テキスト `str` が来て、終了タグ `</strike>` が来る文字列です。

例
-

### strike() の使用

以下の例では文字列のメソッドを使用して、文字列の形式を変更しています。


```js
const worldString = "Hello, world";

console.log(worldString.blink()); // <blink>Hello, world</blink>
console.log(worldString.bold()); // <b>Hello, world</b>
console.log(worldString.italics()); // <i>Hello, world</i>
console.log(worldString.strike()); // <strike>Hello, world</strike>
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.strike |

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

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

関連情報
----

* `String.prototype.strike` のポリフィル (`core-js`)
* `String.prototype.blink()`
* `String.prototype.bold()`
* `String.prototype.italics()`
String.fromCharCode()
=====================

**`String.fromCharCode()`** 静的メソッドは、指定された UTF-16 コード単位の並びから生成された文字列を返します。

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

構文
--


```js
String.fromCharCode(num1)
String.fromCharCode(num1, num2)
String.fromCharCode(num1, num2, /\* …, \*/ numN)
```

### 引数

`numN`

UTF-16 コード単位を表す数値の並びです。範囲は `0` から `65535` (`0xFFFF`) までです。数値が `0xFFFF` を超えた場合は切り捨てられます。妥当性チェックは行われません。

### 返値

指定された `N` 個の UTF-16 コード単位から生成された、長さ `N` の文字列です。

解説
--

`fromCharCode()` は `String` の静的メソッドなので、自分で生成した `String` オブジェクトのメソッドではなく、常に `String.fromCharCode()` として使用するようにしてください。

Unicode のコードポイントは `0` から `1114111` (`0x10FFFF`) までの範囲です。`charAt()` は常に `65536` より小さい値を返しますが、これは上位のコードポイントは 16 ビットのサロゲート擬似文字のペアによって表されているからです。したがって、`65535` より大きい値を持つ完全な文字を取得するには、`charAt(i)` だけでなく `charAt(i + 1)` も取得するか（2 つの文字を持つ文字列を操作する場合と同じです）、または `codePointAt(i)` と `String.fromCodePoint()` を使用する必要があります。Unicode に関する情報はUTF-16 文字、Unicode コードポイント、書記素クラスターを参照してください。

`fromCharCode()` は 16 ビット値のみで動作するため（`\u` エスケープシーケンスと同様）、補助文字を返すためにはサロゲートペアが必要です。例えば、`String.fromCharCode(0xD83C, 0xDF03)` と `\uD83C\uDF03` はコードポイント `U+1F303` "Night with Stars" です。補助コードポイントの値（例: `0x1f303`）とそれを表す両方のサロゲート値（例: `0xd83c` や `0xdf03`）との間には数学的な関係がありますが、補助コードポイントを使用するたびにサロゲートペアの値を計算したり参照したりする、余分なステップが必要になります。このため、実際のコードポイント値に基づいて補助文字を返すことができる `String.fromCodePoint()` を使用した方が便利です。例えば、 `String.fromCodePoint(0x1f303)` はコードポイント `U+1F303` "Night with Stars" を返します。

例
-

### fromCharCode() の使用

BMP 文字は、 UTF-16 では単一のコード単位を使用します。


```js
String.fromCharCode(65, 66, 67); // "ABC" を返す
String.fromCharCode(0x2014); // "—" を返す
String.fromCharCode(0x12014); // これも "—" を返す。1 の桁は削除され無視される
String.fromCharCode(8212); // これも "—" を返す。8212 は 0x2014 の 10 進数形
```


補助文字は、 UTF-16 では、 2 つのコード単位（すなわちサロゲートペア）を必要とします。


```js
String.fromCharCode(0xd83c, 0xdf03); // Code Point U+1F303 "Night with
String.fromCharCode(55356, 57091); // Stars" === "\uD83C\uDF03"

String.fromCharCode(0xd834, 0xdf06, 0x61, 0xd834, 0xdf07); // "\uD834\uDF06a\uD834\uDF07"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.fromcharcode |

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

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

関連情報
----

* `String.fromCodePoint()`
* `String.prototype.charAt()`
* `String.prototype.charCodeAt()`
* `String.prototype.codePointAt()`
Array.of()
==========

**`Array.of()`** 静的メソッドは、引数の数や型にかかわらず、可変長引数から、新しい `Array` インスタンスを生成します。

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

構文
--


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

### 引数

`element1`, …, `elementN`

生成する配列の要素。

### 返値

新しい `Array` インスタンス。

解説
--

`Array.of()` と `Array()` コンストラクターの違いは整数引数の扱いにあります。 `Array.of(7)` は単一の要素、`7` を持つ配列を作成しますが、 `Array(7)` は `length` プロパティが 7 の空の配列を作成します（これは `undefined` の値を持つ実在のスロットではなく、7 つの空のスロットの配列を意味します）。


```js
Array.of(7); // [7]
Array(7); // 7 つの空スロットの配列

Array.of(1, 2, 3); // [1, 2, 3]
Array(1, 2, 3); // [1, 2, 3]
```


`Array.of()` メソッドは汎用ファクトリーメソッドです。例えば、 `Array` のサブクラスが `of()` メソッドを継承した場合、継承した `of()` メソッドは `Array` インスタンスではなく、サブクラスの新しいインスタンスを返します。実際には、 `this` 値には新しい配列の長さを表す単一の引数を受け入れる任意のコンストラクタ関数を指定することができ、コンストラクタは `of()` に渡された引数の数だけ呼び出されます。最終的な `length` は、すべての要素が代入されたときに再度設定されます。もし `this` の値がコンストラクター関数でない場合、代わりにプレーンな `Array` コンストラクターが使用されます。

例
-

### Array.of() の使用


```js
Array.of(1); // [1]
Array.of(1, 2, 3); // [1, 2, 3]
Array.of(undefined); // [undefined]
```

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

`of()` メソッドは、新しい配列の長さを表す単一の引数を受け入れるコンストラクター関数で呼び出すことができます。


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

console.log(Array.of.call(NotArray, 1, 2, 3));
// NotArray called with length 3
// NotArray { '0': 1, '1': 2, '2': 3, length: 3 }

console.log(Array.of.call(Object)); // [Number: 0] { length: 0 }
```


`this` の値がコンストラクターでない場合は、プレーンな `Array` オブジェクトを返します。


```js
console.log(Array.of.call({}, 1)); // [ 1 ]
```

仕様書
---

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

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

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

関連情報
----

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

**`[@@iterator]()`** は `Array` インスタンスのメソッドで、反復可能プロトコル を実装しており、スプレッド構文 や `for...of` ループのような反復可能オブジェクトを期待するほとんどの構文で配列を利用することができます。配列の各インデックスの値を返す配列イテレーターオブジェクトを返します。

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

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

構文
--


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

### 引数

なし。

### 返値

`Array.prototype.values()` の返値と同じです。これは配列内のすべてのインデックスの値を生成する新しい反復可能イテレーターオブジェクトです。

例
-

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

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

#### HTML


```html
<ul id="letterResult"></ul>
```


#### JavaScript


```js
const arr = ["a", "b", "c"];
const letterResult = document.getElementById("letterResult");
for (const letter of arr) {
  const li = document.createElement("li");
  li.textContent = letter;
  letterResult.appendChild(li);
}
```


#### 結果

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

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


```js
const arr = ["a", "b", "c", "d", "e"];
const arrIter = arr[Symbol.iterator]();
console.log(arrIter.next().value); // a
console.log(arrIter.next().value); // b
console.log(arrIter.next().value); // c
console.log(arrIter.next().value); // d
console.log(arrIter.next().value); // e
```

### 文字列と文字列配列を同じ関数で処理

文字列と配列はどちらもイテレータープロトコルを実装しているので、汎用関数は両方の入力を同じ方法で処理するように設計することができます。これは、 `Array.prototype.values()` を直接呼び出すよりも優れており、入力が配列であるか、少なくともそのようなメソッドを持つオブジェクトであることを要求されます。


```js
function logIterable(it) {
  if (typeof it[Symbol.iterator] !== "function") {
    console.log(it, "is not iterable.");
    return;
  }
  for (const letter of it) {
    console.log(letter);
  }
}

// Array
logIterable(["a", "b", "c"]);
// a
// b
// c

// String
logIterable("abc");
// a
// b
// c

// Number
logIterable(123);
// 123 is not iterable.
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype-@@iterator |

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

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

関連情報
----

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

**`lastIndexOf()`** は `Array` インスタンスのメソッドで、配列中で与えられた要素が見つかった最後の添字を返します。もし存在しなければ -1 を返します。配列は `fromIndex` から逆向きに検索されます。

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

構文
--


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

### 引数

`searchElement`

検索する配列要素です。

`fromIndex` 省略可

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

* インデックスが負の場合、配列の末尾からさかのぼって数えます。 `fromIndex < 0` の場合、 `fromIndex + array.length` が使用されます。
* `fromIndex < -array.length` の場合、配列は検索が行われず、 `-1` が返されます。概念的には、配列の先頭より前の存在しない位置から始めて、そこから逆方向に進むと考えることができます。途中には配列要素はないので、 `searchElement` は決して見つかりません。
* `fromIndex >= array.length` または `fromIndex` が省略された場合、 `array.length - 1` が使用され、配列全体が検索されます。概念的には、配列の末尾の先にある存在しない位置から始めて、そこから後方に進むと考えることができます。最終的に配列の本当の末尾に到達し、この点から実在する配列要素を逆探索し始めます。

### 返値

配列内の最後の `searchElement` のインデックスです。見つからなかった場合は `-1` です。

解説
--

`lastIndexOf()` メソッドは `searchElement` と配列の要素を厳密な等価性（`===` 演算子を使用するアルゴリズムと同じ）を使用して比較します。 `NaN` 値が等しいものとして比較されることはないので、 `searchElement` が `NaN` の場合、`lastIndexOf()` は常に `-1` を返します。

`lastIndexOf()` メソッドは疎配列の空スロットをスキップします。

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

例
-

### lastIndexOf() の使用

`lastIndexOf()` を使って配列中のある値の位置を探す例を以下に示します。


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


`lastIndexOf()` を使用して `NaN` を検索することはできません。


```js
const array = [NaN];
array.lastIndexOf(NaN); // -1
```

### ある要素の存在をすべて見つける

以下の例は `lastIndexOf` を使って、与えられた配列中のある値の添字すべてを探しています。`push` を使って、値が見つかる度に別の配列にその添字を追加しています。


```js
const indices = [];
const array = ["a", "b", "a", "c", "a", "d"];
const element = "a";
let idx = array.lastIndexOf(element);
while (idx !== -1) {
  indices.push(idx);
  idx = idx > 0 ? array.lastIndexOf(element, idx - 1) : -1;
}

console.log(indices);
// [4, 2, 0]
```


 ここで `idx == 0` の場合を分けて扱わないといけないことに注意してください。
 なぜなら、もし検索する値が配列の最初の要素にあると、その値は `fromIndex` パラメータにかかわらずいつもヒットしてしまうのです。
 これは `indexOf()` メソッドとは異なります。

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

疎配列の空のスロットを検索するために `lastIndexOf()` を使用することはできません。


```js
console.log([1, , 3].lastIndexOf(undefined)); // -1
```

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

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


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

仕様書
---

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

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

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

関連情報
----

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

**`with()`** は `Array` インスタンスのメソッドで、ブラケット記法に対応するコピーメソッドです。これは、指定された位置の要素を指定された値で置き換えた新しい配列を返します。

構文
--


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

### 引数

`index`

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

* インデックスが負の場合は、配列の末尾から逆に数えます。 `index < 0` の場合、 `index + array.length` が使用されます。
* 正規化後のインデックスが範囲を超えていた場合は、 `RangeError` 例外が発生します。

`value`

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

### 返値

インデックス `index` の要素を `value` に置き換えた新しい配列です。

### 例外

`RangeError`

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

解説
--

`with()` メソッドは、配列の指定された位置の値を変更し、指定されたインデックスの要素を指定された値で置き換えた新しい配列を返します。元の配列は変更しません。これにより、配列メソッドを連鎖させながら操作を行うことができます。

`with()` と `at()` を組み合わせることで、負のインデックスを用いた配列の書き込みと読み込み（それぞれ）ができます。

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

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

例
-

### 単一の要素を変更した新しい配列を作成


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

### 配列メソッドの連鎖

`with()` メソッドを使用すると、配列の単一の要素を更新してから、他の配列メソッドを適用することができます。


```js
const arr = [1, 2, 3, 4, 5];
console.log(arr.with(2, 6).map((x) => x \*\* 2)); // [1, 4, 36, 16, 25]
```

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

`with()` メソッドは常に密配列を生成します。


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

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

`with()` メソッドは新しい配列を生成して返します。このメソッドは `this` の `length` プロパティを読み込み、次にキーが `length` より小さい非負の整数である各プロパティにアクセスします。`this` の各プロパティにアクセスすると、プロパティのキーに等しいインデックスの配列要素がプロパティの値に設定されます。最後に、配列の `index` の値が `value` に設定されます。


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

仕様書
---

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

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

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

関連情報
----

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