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

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

構文
--


```js
toReversed()
```

### 引数

なし。

### 返値

要素を逆順に格納した新しい配列です。

解説
--

`toReversed()` メソッドは、呼び出した配列オブジェクトの要素を逆順に並べ替えて新しい配列を返します。

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

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

例
-

### 配列内の要素を反転

次の例では、 3 つの要素を格納した配列 `items` を作成し、次に `items` の逆の配列を新しく作成します。このとき `items` 配列は変更されません。


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

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

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

`toReversed()` の返値は決して疎配列にはなりません。空のスロットは返す配列の `undefined` になります。


```js
console.log([1, , 3].toReversed()); // [3, undefined, 1]
console.log([1, , 3, 4].toReversed()); // [4, 3, undefined, 1]
```

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

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


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  2: 4,
};
console.log(Array.prototype.toReversed.call(arrayLike));
// [4, undefined, undefined]
// '0' と '1' インデックスは存在しませんので、未定義となります。
```

仕様書
---

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

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

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

関連情報
----

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

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

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

構文
--


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

### 引数

`element1`, …, `elementN`

`arr` の先頭に追加する要素。

### 返値

メソッドを呼び出した後のオブジェクトの新しい `length` プロパティの値です。

解説
--

`unshift` メソッドは、与えられた要素を配列風オブジェクトの一番最初に挿入します。

`Array.prototype.push()` は `unshift()` と似た動作をしますが、配列の末尾に対して行う点が異なります。

複数の要素が引数として渡された場合、引数として渡されたものと全く同じ順番で、オブジェクトの最初のチャンクに挿入されることに注意してください。したがって、 `unshift` を `n` 個の引数で **1 回**呼び出すのと、**1 個**の引数で `n` 回（例えばループを使って）呼び出すのとでは同じ結果にはなりません。

例をご覧ください。


```js
let arr = [4, 5, 6];

arr.unshift(1, 2, 3);
console.log(arr);
// [1, 2, 3, 4, 5, 6]

arr = [4, 5, 6]; // 配列をリセット

arr.unshift(1);
arr.unshift(2);
arr.unshift(3);

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


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

例
-

### unshift の使用


```js
const arr = [1, 2];

arr.unshift(0); // 呼び出しの返値は 3、新しい配列の長さ
// arr is [0, 1, 2]

arr.unshift(-2, -1); // 新しい配列の長さは 5
// arr is [-2, -1, 0, 1, 2]

arr.unshift([-4, -3]); // 新しい配列の長さは 6
// arr is [[-4, -3], -2, -1, 0, 1, 2]

arr.unshift([-7, -6], [-5]); // 新しい配列の長さは 8
// arr is [ [-7, -6], [-5], [-4, -3], -2, -1, 0, 1, 2 ]
```

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

`unshift()` メソッドは `this` の `length` プロパティを読み込みます。 `0` から `length - 1` までの範囲にあるすべてのインデックスを、引数の数だけ右にシフトします（この数だけ値を増加します）。次に、 `0` から始めるには、各インデックスを `unshift()` に渡した引数で設定します。最後に、`length` を前回の長さに、前に追加した要素の数を加えた値に設定します。


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

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

仕様書
---

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

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

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

関連情報
----

* `Array.prototype.unshift` の修正を含むポリフィル (`core-js`)
* インデックス付きコレクションのガイド
* `Array`
* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.shift()`
* `Array.prototype.concat()`
* `Array.prototype.splice()`
Array() コンストラクター
================

**`Array()`** コンストラクターは `Array` オブジェクトを生成します。

構文
--


```js
new Array()
new Array(element1)
new Array(element1, element2)
new Array(element1, element2, /\* …, \*/ elementN)
new Array(arrayLength)

Array()
Array(element1)
Array(element1, element2)
Array(element1, element2, /\* …, \*/ elementN)
Array(arrayLength)
```


**メモ:** `Array()` は `new` を付けてもつけなくても呼び出せます。どちらも新しい `Array` のインスタンスを生成します。

### 引数

`element1`, …, `elementN`

JavaScript の配列は、与えられた要素で初期化されますが、 `Array` コンストラクターに単一の引数が渡され、その引数が数値であった場合は例外です (下記の `arrayLength` 引数を参照してください)。なお、この特殊な場合は JavaScript の配列が `Array` コンストラクターで生成されたときのみであり、角ブラケット構文で配列リテラルを作成した場合は当てはまりません。

`arrayLength`

`Array` コンストラクターに渡された唯一の引数が 0 から 232-1 の間（両端を含む）の整数であった場合は、新しい JavaScript の配列を返し、その `length` プロパティがその値になります（**メモ:** これは `arrayLength` 個の空のスロットを持つ配列であり、実際に `undefined` の値が入ったスロットではありません。疎配列を参照してください）。

### 例外

`RangeError`

引数が数値 1 つ (`arrayLength`) だけであるものの、その値が整数でないか、 0 ～ 232 - 1 （両端を含む）の範囲内になかった場合に発生します。

例
-

### 配列リテラル記法

配列はリテラル記法を使用して生成することができます。


```js
const fruits = ["りんご", "バナナ"];

console.log(fruits.length); // 2
console.log(fruits[0]); // "りんご"
```

### 単一の引数を持つ Array コンストラクター

配列は単一の数値の引数を持つコンストラクターで生成することができます。配列は `length` プロパティにその値が設定され生成され、その配列の要素は空スロットになります。


```js
const arrayEmpty = new Array(2);

console.log(arrayEmpty.length); // 2
console.log(arrayEmpty[0]); // undefined。実際は空スロット
console.log(0 in arrayEmpty); // false
console.log(1 in arrayEmpty); // false
```



```js
const arrayOfOne = new Array("2"); // 数値の 2 ではなく文字列の "2"

console.log(arrayOfOne.length); // 1
console.log(arrayOfOne[0]); // "2"
```

### 複数の引数を持つ Array コンストラクター

2 つ以上の引数がコンストラクターに渡された場合、与えられた要素を持つ新しい `Array` が生成されます。


```js
const fruits = new Array("りんご", "バナナ");

console.log(fruits.length); // 2
console.log(fruits[0]); // "りんご"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array-constructor |

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

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

関連情報
----

* インデックス付きコレクションガイド
* `Array`
Array.prototype.at()
====================

Baseline 2022
-------------

Newly availableSince March 2022, this feature works across the latest devices and browser versions. This feature might not work in older devices or browsers.

* Learn more
* See full compatibility
* Report feedback
**`at()`** は `Array` インスタンスのメソッドで、整数値を受け取り、その位置にある項目を返します。正の整数値と負の整数値が使用できます。負の整数は、配列の最後の項目から前へ数えます。

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

構文
--


```js
at(index)
```

### 引数

`index`

返される配列要素のゼロ基点の添字（位置）で、整数に変換されます。負の添字を使用した場合は、配列の末尾から逆に数えた位置です。`index < 0` であれば、 `index + array.length` がアクセスされます。

### 返値

配列の中で指定された位置に一致する要素です。`index < -array.length` または `index >= array.length` の場合は、対応するプロパティにアクセスしようとせず、常に `undefined` を返します。

解説
--

`at()` メソッドは、`index` が負でない場合、ブラケット記法と等価です。例えば、`array[0]` と `array.at(0)` は、どちらも最初の項目を返します。しかし、配列の末尾から要素を数える場合、PythonやRのように `array[-1]` を使用することはできません。角括弧内の値はすべて文字列プロパティとしてリテラルに扱われるため、結局、配列のインデックスではなく通常の文字列プロパティである `array["-1"]` を読むことになります。

通常、`length` にアクセスし、そこからインデックスを計算します。例えば、 `array[array.length - 1]` のようになります。 `at()` メソッドでは相対インデックスが可能なので、これを短縮して `array.at(-1)` とすることができます。

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

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

例
-

### 配列の末尾の値を返す

以下の例は、指定された配列の中で最後に見つかった要素を返す関数を提供します。


```js
// 項目付きの配列
const cart = ["りんご", "バナナ", "なし"];

// 指定された配列の最後の項目を返す関数
function returnLast(arr) {
  return arr.at(-1);
}

// 配列 'cart' の最後の項⽬を取得する
const item1 = returnLast(cart);
console.log(item1); // 'なし'

// 配列 'cart' に商品を追加
cart.push("みかん");
const item2 = returnLast(cart);
console.log(item2); // 'みかん'
```

### メソッドの比較

この例では、 `Array` の最後から 1 つ目の項目を選択するさまざまな方法を比較しています。以下に示すどの方法も有効ですが、`at()` メソッドの簡潔さと読みやすさが際立っています。


```js
// 項目付きの配列
const colors = ["red", "green", "blue"];

// length プロパティの使用
const lengthWay = colors[colors.length - 2];
console.log(lengthWay); // 'green'

// slice() メソッドを使用。配列を返すことに注意。
const sliceWay = colors.slice(-2, -1);
console.log(sliceWay[0]); // 'green'

// at() メソッドを使用
const atWay = colors.at(-2);
console.log(atWay); // 'green'
```

### 配列以外のオブジェクトでの at() の呼び出し

`at()` メソッドは、`this` の `length` プロパティを読み込んで、アクセスする添字を計算します。


```js
const arrayLike = {
  length: 2,
  0: "a",
  1: "b",
  2: "c", // length が 2 なので at() からは無視される
};
console.log(Array.prototype.at.call(arrayLike, 0)); // "a"
console.log(Array.prototype.at.call(arrayLike, 2)); // undefined
```

仕様書
---

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

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

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

関連情報
----

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

**`@@unscopables`** は `Array.prototype` のデータプロパティで、すべての `Array` インスタンスで共有されます。 ES2015 以前の ECMAScript 標準には含まれておらず、 `with` 文のバインディングの目的では無視されるプロパティ名を含んでいます。

値
-

以下の名前で `true` に設定された `null` プロトタイプオブジェクトです。

| `Array.prototype[@@unscopables]` のプロパティ属性 |
| --- |
| 書込可能 | 不可 |
| 列挙可能 | 不可 |
| 設定可能 | 可 |

解説
--

`Array` プロパティのうち、既定で `with` 文のバインディング目的では無視されるものは次のとおりです。

* `at()`
* `copyWithin()`
* `entries()`
* `fill()`
* `find()`
* `findIndex()`
* `findLast()`
* `findLastIndex()`
* `flat()`
* `flatMap()`
* `includes()`
* `keys()`
* `toReversed()`
* `toSorted()`
* `toSpliced()`
* `values()`

`Array.prototype[@@unscopables]` は、上記のプロパティ名をすべて `true` の値で持つ、空のオブジェクトです。このプロトタイプは `null` なので、 `Object.prototype` のプロパティ、例えば `toString` は偶然にスコープ付けできなくなることはなく、 `with` 文の中の `toString()` は引き続き配列の中で呼び出すことができます。

自作オブジェクトに `unscopables` を設定する方法については、 `Symbol.unscopables` を見てください。

例
-

ECMAScript 2015 以前に書かれた以下のコードで `keys.push('something')` を呼び出すことを考えてみてください。


```js
var keys = [];

with (Array.prototype) {
  keys.push("something");
}
```


ECMAScript 2015 で `Array.prototype.keys()` メソッドが導入されたとき、もし `@unscopables` データプロパティも導入されていなければ、 `keys.push('something')` の呼び出しは壊れていました。 JavaScript ランタイムが `keys` を `Array.prototype.keys()` メソッドであると解釈し、この例のコードで定義された配列 `keys` とは解釈しませんでした。

すなわち、 `@unscopables` データプロパティが `Array.prototype` にあるのは、 ECMAScript 2015 で導入された `Array` プロパティを `with` 文のバインドの目的では無視するようにし、 ECMAScript 2015 以前に書かれたコードを壊さず、期待どおりに動作し続けられるようにするものです。

仕様書
---

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

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

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

関連情報
----

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

**`Array[@@species]`** 静的アクセサープロパティは、配列のメソッドからの返値を構築するのに使われたコンストラクターを返します。

**警告:** `@@species` が存在することで、任意のコードを実行でき、セキュリティの脆弱性を生み出す可能性があります。また、ある種の最適化が非常に難しくなります。エンジンの実装者はこの機能を除去するかどうかを調査しています。使用可能であれば、この機能に頼ることは避けてください。 `toReversed()` のような現代の配列メソッドは `@@species` を使用せず、常に新しい `Array` 基本クラスのインスタンスを返します。

構文
--


```js
Array[Symbol.species]
```

### 返値

`get @@species` が呼び出されたコンストラクター (`this`) の値です。この返値は、新しい配列を作成する配列メソッドの返値を作成するために使用されます。

解説
--

`@@species` アクセサープロパティは、 `Array` オブジェクトの既定のコンストラクターを返します。サブクラスのコンストラクターはコンストラクターに代入することで、これをオーバーライドすることができます。既定の実装は基本的に次の通りです。


```js
// 説明のための仮説的な実装
class Array {
  static get [Symbol.species]() {
    return this;
  }
}
```


この多相的な実装のために、派生したサブクラスの `@@species` も既定値でコンストラクター自身を返すことになります。


```js
class SubArray extends Array {}
SubArray[Symbol.species] === SubArray; // true
```


既存の配列を変更せずに新しい配列インスタンスを返す配列メソッド（例えば `filter` や `map` ）を呼び出す場合、配列の `constructor[@@species]` にアクセスすることになります。返されたコンストラクターは、配列メソッドの返値を作成するために使用されます。これにより、配列メソッドが配列とは無関係のオブジェクトを返すようにすることが技術的に可能になります。


```js
class NotAnArray {
  constructor(length) {
    this.length = length;
  }
}

const arr = [0, 1, 2];
arr.constructor = { [Symbol.species]: NotAnArray };
arr.map((i) => i); // NotAnArray { '0': 0, '1': 1, '2': 2, length: 3 }
arr.filter((i) => i); // NotAnArray { '0': 1, '1': 2, length: 0 }
arr.concat([1, 2]); // NotAnArray { '0': 0, '1': 1, '2': 2, '3': 1, '4': 2, length: 5 }
```

例
-

### 通常のオブジェクトの species

`@@species` プロパティは、`Array` オブジェクトの既定のコンストラクター関数である `Array` コンストラクターを返します。


```js
Array[Symbol.species]; // [Function: Array]
```

### 派生オブジェクトの spicies

派生コレクションオブジェクト（たとえば、独自の配列である `MyArray`）では、`MyArray` の species は `MyArray` コンストラクターです。しかし、派生クラスのメソッドで、親である `Array` オブジェクトを返すためにこれをオーバーライドしたいかもしれません。


```js
class MyArray extends Array {
  // MyArray species を親である ArrayBuffer コンストラクタにオーバーライド。
  static get [Symbol.species]() {
    return Array;
  }
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-array-@@species |

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

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

関連情報
----

* `Array[@@species]` のポリフィルと、影響を受けるすべての `Array` メソッドでの `@@species` の対応 (`core-js`)
* インデックス付きコレクションガイド
* `Array`
* `Symbol.species`
Array.prototype.indexOf()
=========================

**`indexOf()`** は `Array` インスタンスのメソッドで、引数に与えられた内容と同じ内容を持つ最初の配列要素の添字を返します。存在しない場合は -1 を返します。

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

構文
--


```js
indexOf(searchElement)
indexOf(searchElement, fromIndex)
```

### 引数

`searchElement`

検索する配列要素です。

`fromIndex` 省略可

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

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

### 返値

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

解説
--

`indexOf()` メソッドは `searchElement` と配列の要素を厳密等価（三重イコール演算子 `===` で使われるのと同じ方法）を使って比較します。 `NaN` の値は等しい値として比較されることはないので、`indexOf()` は `searchElement` が `NaN` のときには常に `-1` を返します。

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

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

例
-

### indexOf() の使用

以下の例は `indexOf()` を使って、配列中のある値の位置を探しています。


```js
const array = [2, 9, 9];
array.indexOf(2); // 0
array.indexOf(7); // -1
array.indexOf(9, 2); // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0
```


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


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

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


```js
const indices = [];
const array = ["a", "b", "a", "c", "a", "d"];
const element = "a";
let idx = array.indexOf(element);
while (idx !== -1) {
  indices.push(idx);
  idx = array.indexOf(element, idx + 1);
}
console.log(indices);
// [0, 2, 4]
```

### 要素が配列内に存在するかどうかを調べ、配列を更新する


```js
function updateVegetablesCollection(veggies, veggie) {
  if (veggies.indexOf(veggie) === -1) {
    veggies.push(veggie);
    console.log(`New veggies collection is: ${veggies}`);
  } else {
    console.log(`${veggie} already exists in the veggies collection.`);
  }
}

const veggies = ["potato", "tomato", "chillies", "green-pepper"];

updateVegetablesCollection(veggies, "spinach");
// New veggies collection is: potato,tomato,chillies,green-pepper,spinach
updateVegetablesCollection(veggies, "spinach");
// spinach already exists in the veggies collection.
```

### 疎配列での indexOf() の使用

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


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

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

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


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

仕様書
---

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

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

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

関連情報
----

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

**`unicodeSets`** は `RegExp` インスタンスのアクセサープロパティで、この正規表現に `v` フラグが使用されているかどうかを返します。

解説
--

`RegExp.prototype.unicodeSets` は `v` フラグが使用されている場合は `true` を、そうでない場合は `false` を返します。`v` フラグは `u` フラグを「アップグレード」したもので、Unicode 関連の機能をより有効にするものです（`u` と `v` は同じ正規表現を互換性のない方法で解釈するので、両方のフラグを使用すると `SyntaxError` になります。）`v` フラグを使用すると、`u` フラグの説明で述べたすべての機能に加えて、以下の機能が得られます。

* `\p` エスケープシーケンスは、文字だけでなく、文字列のプロパティにも一致します。
* 文字クラス構文がアップグレードされ、複数の Unicode 文字の照合だけでなく、交差、和集合、差集合の構文ができるようになります。
* 文字クラスの補集合の構文 `[^...]` は、一致結果を否定する代わりに補集合クラスを構築し、大文字小文字を区別しない照合との混乱を避けることができます。詳しくは 補集合クラスと大文字小文字を区別しない照合を参照してください。

一部の `u` モードの正規表現は `v` モードで無効になることがあります。具体的には、文字クラスの構文が異なり、文字通りに表示できない文字があります。詳しくは `v` モード文字クラスを参照してください。

**メモ:** `v`モードは書記素クラスターを 1 文字として解釈しません。例えば、`/[🇺🇳]/v` は `"🇺"` に一致します。

`unicodeSets` の設定アクセサーは `undefined` です。このプロパティを直接変更することはできません。

例
-

### unicodeSets プロパティの使用


```js
const regex = /[\p{Script\_Extensions=Greek}&&\p{Letter}]/v;

console.log(regex.unicodeSets); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.unicodesets |

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

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

関連情報
----

* `RegExp.prototype.lastIndex`
* `RegExp.prototype.dotAll`
* `RegExp.prototype.global`
* `RegExp.prototype.hasIndices`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`
* RegExp v flag with set notation and properties of strings on v8.dev (2022)
RegExp.leftContext ($`)
=======================

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

**メモ:** グローバルに最後の一致状態を公開する `RegExp` の静的プロパティは、すべて非推奨です。詳しくは非推奨の RegExp 機能を参照してください。

**`RegExp.leftContext`** は静的アクセサープロパティで、最近一致した文字列の前の部分文字列を返します。`RegExp["$`"]` はこのプロパティの別名です。

解説
--

`leftContext` は `RegExp` の静的プロパティですので、作成した `RegExp` オブジェクトのプロパティとしてではなく、常に `RegExp.leftContext` または `RegExp["$`"]` として使用してください。

`leftContext` の値は `RegExp` の（ただし `RegExp` のサブクラスではない）インスタンスが照合に成功するたびに更新されます。照合が行われていない場合、または直近の正規表現にキャプチャグループが格納されていない場合、`leftContext` は空文字列になります。`leftContext` の設定アクセサーは `undefined` なので、このプロパティを直接変更することはできません。

ドットプロパティアクセサー (`RegExp.$`` ) で短縮エイリアスを使用することはできません。``` は識別子の一部として有効ではないので、`SyntaxError` が発生します。代わりにブラケット記法を使用してください。

`$`` は `String.prototype.replace()` の置換文字列でも使用できますが、`RegExp["$`"]` の古いプロパティとは無関係です。

例
-

### leftContext と $` の使用


```js
const re = /world/g;
re.test("hello world!");
RegExp.leftContext; // "hello "
RegExp["$`"]; // "hello "
```

仕様書
---

| Specification |
| --- |
| Legacy RegExp features # additional-properties-of-the-regexp-constructor |

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

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

関連情報
----

* `RegExp.input ($_)`
* `RegExp.lastMatch ($&)`
* `RegExp.lastParen ($+)`
* `RegExp.rightContext ($')`
* `RegExp.$1, …, RegExp.$9`
RegExp.prototype.hasIndices
===========================

**`hasIndices`** は `RegExp` インスタンスのプロパティで、その正規表現で `d` フラグが使用されたかどうかを示します。

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

解説
--

`RegExp.prototype.hasIndices` の値は `d` フラグが使用されている場合に `true` となり、そうでない場合は `false` となります。`d` フラグは、正規表現の照合結果に各キャプチャグループの部分文字列の開始と終了のインデックスを含めることを示します。これは正規表現の解釈や照合の動作を変更するものではなく、照合結果に追加情報を与えるだけです。

このフラグは、主に `exec()` の返値に影響します。`d` フラグが存在する場合、`exec()` によって返される配列は、`exec()` メソッドの返値に記述されているように、追加の `indices` プロパティを持ちます。他のすべての正規表現関連のメソッド（`String.prototype.match()` など）は、内部的に `exec()` を呼び出すので、正規表現に `d` フラグがある場合、インデックスも返します。

`hasIndices` の設定アクセサーは `undefined` です。このプロパティを直接変更することはできません。

例
-

グループと後方参照 > グループと一致結果の添字の使用に詳しい使用例があります。

### hasIndices の使用


```js
const str1 = "foo bar foo";

const regex1 = /foo/dg;

console.log(regex1.hasIndices); // true

console.log(regex1.exec(str1).indices[0]); // [0, 3]
console.log(regex1.exec(str1).indices[0]); // [8, 11]

const str2 = "foo bar foo";

const regex2 = /foo/;

console.log(regex2.hasIndices); // false

console.log(regex2.exec(str2).indices); // undefined
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.hasIndices |

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

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

関連情報
----

* `RegExp.prototype.lastIndex`
* `RegExp.prototype.exec()`
* `RegExp.prototype.dotAll`
* `RegExp.prototype.global`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`
RegExp.lastParen ($+)
=====================

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

**メモ:** グローバルに最後の一致状態を公開する `RegExp` の静的プロパティは、すべて非推奨です。詳しくは非推奨の RegExp 機能を参照してください。

**`RegExp.lastParen`** は静的アクセサープロパティで、最後に一致した括弧で括られた部分文字列があれば返します。`RegExp["$+"]` はこのプロパティの別名です。

解説
--

`lastParen` は `RegExp` の静的プロパティですので、作成した `RegExp` オブジェクトのプロパティとしてではなく、常に `RegExp.lastParen` または `RegExp["$+"]` として使用してください。

`lastParen` の値は `RegExp` の（ただし `RegExp` のサブクラスではない）インスタンスが照合に成功するたびに更新されます。照合が行われていない場合、または直近の正規表現にキャプチャグループが格納されていない場合、`lastParen` は空文字列になります。`lastParen` の設定アクセサーは `undefined` なので、このプロパティを直接変更することはできません。

ドットプロパティアクセサー (`RegExp.$+`) で短縮エイリアスを使用することはできません。`+` は識別子の一部として有効ではないので、`SyntaxError` が発生します。代わりにブラケット記法を使用してください。

例
-

### lastParen と $+ の使用


```js
const re = /(hi)/g;
re.test("hi there!");
RegExp.lastParen; // "hi"
RegExp["$+"]; // "hi"
```

仕様書
---

| Specification |
| --- |
| Legacy RegExp features # additional-properties-of-the-regexp-constructor |

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

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

関連情報
----

* `RegExp.input ($_)`
* `RegExp.lastMatch ($&)`
* `RegExp.leftContext ($`)`
* `RegExp.rightContext ($')`
* `RegExp.$1, …, RegExp.$9`
RegExp.rightContext ($')
========================

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

**メモ:** グローバルに最後の一致状態を公開する `RegExp` の静的プロパティは、すべて非推奨です。詳しくは非推奨の RegExp 機能を参照してください。

**`RegExp.rightContext`** は静的アクセサープロパティで、最新の一致に続く部分文字列が入ります。`RegExp["$'"]` はこのプロパティの別名です。

解説
--

`rightContext` は `RegExp` の静的プロパティですので、作成した `RegExp` オブジェクトのプロパティとしてではなく、常に `RegExp.rightContext` または `RegExp["$'"]` として使用してください。

`rightContext` の値は `RegExp` の（ただし `RegExp` のサブクラスではない）インスタンスが照合に成功するたびに更新されます。照合が行われていない場合、または直近の正規表現にキャプチャグループが格納されていない場合、`rightContext` は空文字列になります。`rightContext` の設定アクセサーは `undefined` なので、このプロパティを直接変更することはできません。

ドットプロパティアクセサー (`RegExp.$'`) で短縮エイリアスを使用することはできません。`'` は識別子の一部として有効ではないので、`SyntaxError` が発生します。代わりにブラケット記法を使用してください。

`$'` は `String.prototype.replace()` の置換文字列でも使用できますが、`RegExp["$'"]` の古いプロパティとは関係ありません。

例
-

### rightContext と $' の使用


```js
const re = /hello/g;
re.test("hello world!");
RegExp.rightContext; // " world!"
RegExp["$'"]; // " world!"
```

仕様書
---

| Specification |
| --- |
| Legacy RegExp features # additional-properties-of-the-regexp-constructor |

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

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

関連情報
----

* `RegExp.input ($_)`
* `RegExp.lastMatch ($&)`
* `RegExp.lastParen ($+)`
* `RegExp.leftContext ($`)`
* `RegExp.$1, …, RegExp.$9`