recursal/MDN huggingface dataset:
RegExp.prototype.ignoreCase
===========================

**`ignoreCase`** プロパティは、"`i`" フラグが正規表現で使われているかどうかを示します。`ignoreCase` は、正規表現インスタンスごとの読み取り専用プロパティです。

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

解説
--

`RegExp.prototype.ignoreCase` は、`i` フラグが指定されている場合は `true` を、そうでなければ `false` を返します。`i` フラグは、文字列の照合を試みる際に、大文字小文字を無視することを示します。大文字小文字を区別しない照合は、期待される文字セットと照合する文字列を同じ大文字小文字に対応付けすることで行われます。

正規表現が Unicode 対応の場合、大文字小文字の対応付けは `CaseFolding.txt` で指定された*単純な大文字小文字の変換*を行います。この対応付けは常に 1 つのコードポイントに対応付けされるので、例えば `ß` (U+00DF LATIN SMALL LETTER SHARP S) を `ss` に対応付けすることはありません（単純な大文字小文字の変換ではなく完全な大文字小文字の変換です）。例えば、`ſ` (U+017F LATIN SMALL LETTER LONG S) は `s` (U+0073 LATIN SMALL LETTER S) に、`K` (U+212A KELVIN SIGN) は `k` (U+006B LATIN SMALL LETTER K) に大文字小文字を区別します。したがって、`ſ` と `K` は `/[a-z]/ui` で一致します。

正規表現が Unicode 非対応の場合、大文字小文字の対応付けは Unicode 既定の大文字小文字変換 を使用します。`String.prototype.toUpperCase()` で使用されているアルゴリズムと同じです。例えば、`Ω` (U+2126 OHM SIGN, オーム記号) と `Ω` (U+03A9 GREEK CAPITAL LETTER OMEGA, ギリシャ語のオメガの大文字) は、既定の大文字小文字変換によってそれ自体に対応付けされますが、単純な大文字小文字の変換では `ω` (U+03C9 GREEK SMALL LETTER OMEGA, ギリシャ語のオメガの小文字) に対応付けされるため、`"ω"` は `/[\u2126]/ui` と `/[\u03a9]/ui` に一致しますが、`/[\u2126]/i` や `/[\u03a9]/i`　には一致しません。このアルゴリズムは、基本ラテンブロック外のコードポイントがブロック内のコードポイントに対応付けされるのを防ぐため、前述の `ſ` や `K` は `/[a-z]/i` では一致しません。

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

例
-

### ignoreCase の使用


```js
const regex = /foo/i;

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

仕様書
---

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

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

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.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`
RegExp.prototype[@@split]()
===========================

**`[@@search]()`** は `RegExp` インスタンスのメソッドで、 `String.prototype.split` にセパレーターとして正規表現が渡されたときにどのように動作するのかを指定します。

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

構文
--


```js
regexp[Symbol.split](str)
regexp[Symbol.split](str, limit)
```

### 引数

`str`

分割操作の対象。

`limit` 省略可

検出される分割数の制限を指定する整数。 `[@@split]()` メソッドは、 `this` RegExp パターン (または上記の構文では `regexp`) に一致するたびに、分割項目の数が `limit` と一致するか、文字列が `this` パターンを満たなくなるまで、分割を行います。

### 返値

要素として部分文字列を含む配列 (`Array`)。

解説
--

このメソッドは `String.prototype.split()` において、`RegExp` がセパレーターとして渡された場合に内部的に呼び出されます。たとえば、次の 2 つの例は同じ結果を返します。


```js
"a-b-c".split(/-/);

/-/[Symbol.split]("a-b-c");
```


このメソッドは、`RegExp` のサブクラスで `split()` の動作をカスタマイズするために存在します。

`RegExp.prototype[@@split]()` ベースメソッドは、次のように動作します。

* `@@species` を使用して新しい正規表現を構築し、元の正規表現が変更され内容にするところから始まります。
* 正規表現の `g` （「グローバル」）フラグは無視され、 `y` （「粘着的」）フラグは元々表示されていない場合でも常に適用されます。
* 対象とする文字列が空で、正規表現が空文字列に一致する場合（例えば `/a?/`）は、空の配列を返します。そうでない場合、正規表現が空文字列に一致しなければ `[""]` を返します。
* 照合は `this.exec()` を連続して呼び出すことで行われます。正規表現は常に粘着的なので、文字列に沿って移動し、その度に一致する文字列、インデックス、キャプチャグループが得られます。
* 一致するごとに、最後に一致した文字列の終わりと、現在一致した文字列の始めの間の部分文字列が、最初の配列に追加されます。その後、キャプチャグループの値が 1 つずつ追加されます。
* 現在一致している文字列が空文字列であったり、正規表現が現在の位置で一致しなかったりした場合（粘着的なので）、`lastIndex` が進められます。正規表現が Unicode 対応であれば、Unicode コードポイント分進みます。そうでなければ、 UTF-16 コード単位 1 つ分進みます。
* 正規表現が対象の文字列と一致しない場合は、対象の文字列を配列で囲んでそのまま返します。
* 返される配列の長さは、指定された場合は `limit` 引数を超えることはありません。そのため、配列が既に埋まっている場合、最後の一致するグループとそのキャプチャグループがすべて返す配列に存在するとは限りません。
例
-

### 直接呼出し

`this` の扱いと引数の並び順を除いて、このメソッドは `String.prototype.split()` とほとんど同じように使用できます。


```js
const re = /-/g;
const str = "2016-01-02";
const result = re[Symbol.split](str);
console.log(result); // ["2016", "01", "02"]
```

### サブクラスで @@split を使用する

既定の動作を修正するために、`RegExp` のサブクラスで `[@@split]()` メソッドをオーバーライドできます。


```js
class MyRegExp extends RegExp {
  [Symbol.split](str, limit) {
    const result = RegExp.prototype[Symbol.split].call(this, str, limit);
    return result.map((x) => `(${x})`);
  }
}

const re = new MyRegExp("-");
const str = "2016-01-02";
const result = str.split(re); // String.prototype.split calls re[@@split].
console.log(result); // ["(2016)", "(01)", "(02)"]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@split |

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

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

関連情報
----

* `RegExp.prototype[@@split]` のポリフィル (`core-js`)
* `String.prototype.split()`
* `RegExp.prototype[@@match]()`
* `RegExp.prototype[@@matchAll]()`
* `RegExp.prototype[@@replace]()`
* `RegExp.prototype[@@search]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
* `Symbol.split`
RegExp.prototype.compile()
==========================

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

**メモ:** `compile()` メソッドは互換性のためにのみ定義されています。`compile()` を使用すると、それまで不変であった正規表現のソースとフラグが変更可能なものとなり、ユーザーの期待を裏切る可能性があります。代わりに `RegExp()` コンストラクターを使用して新しい正規表現オブジェクトを構築してください。

**`compile()`** は `RegExp` インスタンスのメソッドで、 `RegExp` オブジェクトが既に作成された後、新しいソースとフラグで正規表現を再コンパイルするために使用します。

構文
--


```js
compile(pattern, flags)
```

### 引数

`pattern`

正規表現のテキスト

`flags`

フラグ値の組み合わせです。

例
-

### compile() の使用

次の例では、新しいパターンとフラグで正規表現を再コンパイルする方法を示します。


```js
const regexObj = new RegExp("foo", "gi");
regexObj.compile("new foo", "g");
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.compile |

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

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

関連情報
----

* `RegExp`
RegExp.prototype.flags
======================

**`flags`** は `RegExp` インスタンスのプロパティで、現在の正規表現オブジェクトのフラグから成る文字列を返します。

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

解説
--

`RegExp.prototype.flags` には値として文字列があります。`flags` プロパティのフラグはアルファベット順で並べ替えられます（左から右に、例えば `"dgimsuvy"`）。 実際には、他のフラグアクセサー（`hasIndices`、`global`など）を 1 つずつ呼び出し、結果を連結します。

すべての組み込み関数は、個々のフラグアクセサーを読み込む代わりに `flags` プロパティを読み込みます。

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

例
-

### flags の使用


```js
/foo/ig.flags; // "gi"
/bar/myu.flags; // "muy"
```

仕様書
---

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

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

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

関連情報
----

* `RegExp.prototype.flags` のポリフィル (`core-js`)
* `RegExp.prototype.source`
RegExp.prototype[@@matchAll]()
==============================

**`[@@match]()`** は `RegExp` インスタンスのメソッドで、 `String.prototype.matchAll` がどのように動作するのかを指定します。

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

構文
--


```js
regexp[Symbol.matchAll](str)
```

### 引数

`str`

文字列 (`String`) で、照合の対象となるものです。

### 返値

一致したものを表す反復可能なイテレーターオブジェクト（再起動不可）です。それぞれの一致部分は `RegExp.prototype.exec()` の返値と同じ形の配列です。

解説
--

このメソッドは内部的に `String.prototype.matchAll()` を呼び出します。例えば、以下の 2 つの例は同じ結果を返します。


```js
"abc".matchAll(/a/g);

/a/g[Symbol.matchAll]("abc");
```


`@@split` と同様、 `@@matchAll` は `@@species` を使用して新しい正規表現を作成するところから始め、何があっても元の正規表現を変更することを避けます。 `lastIndex` は元の正規表現の値から始まります。


```js
const regexp = /[a-c]/g;
regexp.lastIndex = 1;
const str = "abc";
Array.from(str.matchAll(regexp), (m) => `${regexp.lastIndex} ${m[0]}`);
// [ "1 b", "1 c" ]
```


入力がグローバル正規表現であるかどうかの検証は `String.prototype.matchAll()` で行われます。`@@matchAll` は入力を検証しません。正規表現がグローバルでない場合、返されたイテレーターは `exec()` の結果を一度返し、その後 `undefined` を返します。正規表現がグローバルである場合、返されたイテレーターの `next()` メソッドが呼び出されるたびに、正規表現の `exec()` を呼び出し、結果を返します。

正規表現が粘着的でグローバルな場合、粘着的な照合を行います。つまり `lastIndex` 以降は照合しません。


```js
console.log(Array.from("ab-c".matchAll(/[abc]/gy)));
// [ [ "a" ], [ "b" ] ]
```


現在の照合が空文字列の場合、`lastIndex` が進みます。正規表現に `u` フラグがある場合、Unicode コードポイント 1 つ分進みます。


```js
console.log(Array.from("😄".matchAll(/(?:)/g)));
// [ [ "" ], [ "" ], [ "" ] ]

console.log(Array.from("😄".matchAll(/(?:)/gu)));
// [ [ "" ], [ "" ] ]
```


このメソッドは `RegExp` サブクラスで `matchAll()` の動作をカスタマイズするために存在します。

例
-

### 直接呼び出し

このメソッドは `String.prototype.matchAll()`, とほぼ同様に使用することができますが、 `this` の値と引数の順序が違う点が異なります。


```js
const re = /[0-9]+/g;
const str = "2016-01-02";
const result = re[Symbol.matchAll](str);

console.log(Array.from(result, (x) => x[0]));
// [ "2016", "01", "02" ]
```

### サブクラスでの @@matchAll の使用

`RegExp` のサブクラスは `[@@matchAll]()` メソッドを上書きして既定の動作を変更することができます。

例えば、 `Array` をイテレーターの代わりに返すことができます。


```js
class MyRegExp extends RegExp {
  [Symbol.matchAll](str) {
    const result = RegExp.prototype[Symbol.matchAll].call(this, str);
    return result ? Array.from(result) : null;
  }
}

const re = new MyRegExp("([0-9]+)-([0-9]+)-([0-9]+)", "g");
const str = "2016-01-02|2019-03-07";
const result = str.matchAll(re);

console.log(result[0]);
// [ "2016-01-02", "2016", "01", "02" ]

console.log(result[1]);
// [ "2019-03-07", "2019", "03", "07" ]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp-prototype-matchall |

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

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

関連情報
----

* `RegExp.prototype[@@matchAll]` のポリフィル (`core-js`)
* `String.prototype.matchAll()`
* `RegExp.prototype[@@match]()`
* `RegExp.prototype[@@replace]()`
* `RegExp.prototype[@@search]()`
* `RegExp.prototype[@@split]()`
* `Symbol.matchAll`
RegExp.prototype.source
=======================

**`source`** は `RegExp` のアクセサープロパティで、正規表現オブジェクトのソーステキストの入った文字列を返します。これには、両端の 2 つのスラッシュやフラグは含まれません。

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

解説
--

概念的には、`source` プロパティは正規表現リテラルの 2 つのスラッシュの間のテキストです。この言語では、返される文字列が適切にエスケープされている必要があり、`source` の両端にスラッシュを連結すると、解析可能な正規表現リテラルが形成されます。例えば、`new RegExp("/")` の場合、`source` は `\\/` です。これは `/` を生成し、結果のリテラルは `///` です。同様に、改行文字はすべてエスケープされます。結果が解析可能である限り、他にも文字は必要ありません。空文字列の正規表現では `(?:)` という文字列を返します。

例
-

### source の使用


```js
const regex = /fooBar/gi;

console.log(regex.source); // "fooBar", /.../ と "gi" は含まれません。
```

### 空の正規表現とエスケープ


```js
new RegExp().source; // "(?:)"

new RegExp("\n").source === "\\n"; // true。ES5 以降
```

仕様書
---

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

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

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

関連情報
----

* `RegExp.prototype.flags`
RegExp.$1, …, RegExp.$9
=======================

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

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

**`RegExp.$1, …, RegExp.$9`** は静的アクセサープロパティで、括弧で括られた部分文字列に一致したものを返します。

解説
--

`$1`–`$9` は `RegExp` の静的プロパティであり、常に `RegExp.$1`, `RegExp.$2`, のように扱います。作成した `RegExp` オブジェクトのプロパティとしては使用できません。

`$1, …, $9` の値は `RegExp` の（ただし `RegExp` のサブクラスではない）インスタンスが一致に成功するたびに更新されます。一致したものがなかったか、最後に一致したものに対応するキャプチャグループがなかった場合、それぞれのプロパティは空文字列になります。それぞれのプロパティの設定アクセサーは `undefined` ですので、直接プロパティを変更することはできません。

括弧で括られた部分文字列の数に制限はありませんが、 `RegExp` オブジェクトは最初の 9 つの部分文字列しか保持できません。返された配列のインデックスを使用すると、すべての括弧付き部分文字列にアクセスすることができます。

`$1, …, $9` は `String.prototype.replace()` メソッドの置換テキストでも使用することができますが、古い `RegExp.$n` には関係しません。

例
-

### $n と RegExp.prototype.test() の使用

次のスクリプトは、`RegExp` インスタンスの `test()` メソッドを使用して、一般的な文字列で数値を取得しています。


```js
const str = "Test 24";
const number = /(\d+)/.test(str) ? RegExp.$1 : "0";
number; // "24"
```


`re.test(str)` 呼び出しと `RegExp.$n` プロパティの間で他の正規表現を使用する操作は、副作用がある可能性があることに注意してください。そのため、これらの特殊なプロパティへのアクセスは即座に行うべきで、そうしないと予期せぬ結果になる可能性があります。

仕様書
---

| 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.rightContext ($')`
RegExp.lastMatch ($&)
=====================

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

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

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

解説
--

`lastMatch` は `RegExp` の静的プロパティです。個々の正規表現オブジェクトのプロパティではありません。そのかわりに、常に、`RegExp.lastMatch` または `RegExp["$&"]` として使用してください。

`lastMatch` の値は `RegExp` インスタンス（`RegExp` のサブクラスではない）が一致するたびに更新されます。照合がない場合、`lastMatch` は空文字列になります。`lastMatch` の設定アクセサーは `undefined` なので、このプロパティを直接変更することはできません。

ドットプロパティアクセサー (`RegExp.$&`) で短縮形式の別名を使用することはできません。その場合、パーサーは `&` という表現を期待して `SyntaxError` が発生します。プロパティへのアクセスにはブラケット記法を使用してください。

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

例
-

### lastMatch と $& の使用


```js
const re = /hi/g;
re.test("hi there!");
RegExp.lastMatch; // "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.lastParen ($+)`
* `RegExp.leftContext ($`)`
* `RegExp.rightContext ($')`
* `RegExp.$1, …, RegExp.$9`
RegExp.input ($\_)
==================

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

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

**`RegExp.input`** は静的アクセサープロパティで、正規表現の一致した文字列を返します。`RegExp.$_` はこのプロパティのエイリアスです。

解説
--

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

`input` の値は `RegExp` インスタンス（ただし `RegExp` のサブクラスではない）が照合に成功するたびに更新されます。今まで一度も一致するものがなかった場合、 `input` は空文字列です。`input` に値を設定することはできますが、正規表現の他の動作には影響せず、値は次に行われた照合が成功した場合に再び上書きされます。

例
-

### input と $\_ の使用


```js
const re = /hi/g;
re.test("hi there!");
RegExp.input; // "hi there!"
re.test("foo"); // 新しい検査、一致しない
RegExp.$_; // "hi there!"
re.test("hi world!"); // 新しい検査、一致する
RegExp.$_; // "hi 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.lastMatch ($&)`
* `RegExp.lastParen ($+)`
* `RegExp.leftContext ($`)`
* `RegExp.rightContext ($')`
* `RegExp.$1, …, RegExp.$9`
RegExp.prototype[@@match]()
===========================

**`[@@match]()`** は `RegExp` インスタンスのメソッドで、 `String.prototype.match()` がどのように動作するのかを指定します。さらに、これが存在するかどうかが、そのオブジェクトが正規表現とみなされるかどうかにも影響します。

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

構文
--


```js
regexp[Symbol.match](str)
```

### 引数

`str`

文字列 (`String`) で、照合の対象となるものです。

### 返値

配列 (`Array`) で、内容はグローバル (`g`) フラグがあるかどうかで変わります。一致するものが見つからなければ `null` になります。

* `g` フラグが使用された場合は、この正規表現全体に一致したすべての結果となりますが、キャプチャグループは含まれません。
* `g` フラグが使用されなかった場合は、最初に一致したもの全体と、関連するキャプチャグループが返されます。この場合、 `match()` は `RegExp.prototype.exec()` （一部の追加のプロパティを配列で含む）の結果と同じになります。
解説
--

このメソッドは、`String.prototype.match()` で内部的に呼び出されます。

たとえば、次の 2 つの例は同じ結果を返します。


```js
"abc".match(/a/);

/a/[Symbol.match]("abc");
```


正規表現がグローバル（`g` フラグ付き）である場合、この正規表現の `exec()` メソッドは、 `exec()` が `null` を返すまで繰り返し呼び出されます。そうでない場合、 `exec()` は一度だけ呼び出され、その結果が `@@match` の返値となります。

`@@match` は `exec()` を `null` が返るまで呼び出し続け、最後の照合に失敗すると自動的に正規表現の `lastIndex` を 0 にリセットします。しかし、正規表現が粘着的であるもののグローバルではない場合、 `lastIndex` はリセットされません。この場合、 `match()` を呼び出すたびに異なる結果を返すかもしれません。


```js
const re = /[abc]/y;
for (let i = 0; i < 5; i++) {
  console.log("abc".match(re), re.lastIndex);
}
// [ 'a' ] 1
// [ 'b' ] 2
// [ 'c' ] 3
// null 0
// [ 'a' ] 1
```


正規表現が粘着的かつグローバルな場合、粘着的な照合、つまり `lastIndex` 以降の照合は行われません。


```js
console.log("ab-c".match(/[abc]/gy)); // [ 'a', 'b' ]
```


もし正規表現が Unicode 対応であれば、 Unicode コードポイント 1 つ分進みます。


```js
console.log("😄".match(/(?:)/g)); // [ '', '', '' ]
console.log("😄".match(/(?:)/gu)); // [ '', '' ]
```


このメソッドは `RegExp` サブクラス内で照合の動作をカスタマイズするために存在します。

さらに、`@@match` プロパティはオブジェクトが正規表現であるかどうかをチェックするために使われます。

例
-

### 直接呼び出し

このメソッドは、*ほとんど* `String.prototype.match()` と同じ方法で使用することができますが、 `this` と引数の並び順が異なります。


```js
const re = /[0-9]+/g;
const str = "2016-01-02";
const result = re[Symbol.match](str);
console.log(result); // ["2016", "01", "02"]
```

### サブクラスで @@match を使用

`RegExp` のサブクラスは、既定の動作を修正するために `[@@match]()` メソッドをオーバーライドできます。


```js
class MyRegExp extends RegExp {
  [Symbol.match](str) {
    const result = RegExp.prototype[Symbol.match].call(this, str);
    if (!result) return null;
    return {
      group(n) {
        return result[n];
      },
    };
  }
}

const re = new MyRegExp("([0-9]+)-([0-9]+)-([0-9]+)");
const str = "2016-01-02";
const result = str.match(re); // String.prototype.match は re[@@match] を呼び出す
console.log(result.group(1)); // 2016
console.log(result.group(2)); // 01
console.log(result.group(3)); // 02
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@match |

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

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

関連情報
----

* `RegExp.prototype[@@match]` のポリフィル (`core-js`)
* `String.prototype.match()`
* `RegExp.prototype[@@matchAll]()`
* `RegExp.prototype[@@replace]()`
* `RegExp.prototype[@@search]()`
* `RegExp.prototype[@@split]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`
* `Symbol.match`
RegExp.prototype.global
=======================

**`global`** は `RegExp` インスタンスのプロパティで、`g` フラグが正規表現で使われているかどうかを返します。

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

解説
--

`RegExp.prototype.global` は、`g` フラグが使用された場合は `true`、そうでない場合は `false` になります。`g` フラグは、正規表現が文字列内のすべての可能なマッチに対してテストされるべきであることを示します。 `exec()` を呼び出すたびに `lastIndex` プロパティが更新され、次の `exec()` の呼び出しが次の文字から始まるようになります。

`String.prototype.matchAll()` や `String.prototype.replaceAll()` のようないくつかのメソッドは、引数が正規表現である場合、それがグローバルであることを検証します。正規表現の `@@match` および `@@replace`（`String.prototype.match()` と `String.prototype.replace()` によって呼び出されます）も、正規表現がグローバルである場合に異なる動作をします。

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

例
-

### global の使用


```js
const regex = /foo/g;
console.log(regex.global); // true

const str = "fooexamplefoo";
const str1 = str.replace(regex, "");
console.log(str1); // example

const regex1 = /foo/;
const str2 = str.replace(regex1, "");
console.log(str2); // examplefoo
```

仕様書
---

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

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

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

関連情報
----

* `RegExp.prototype.lastIndex`
* `RegExp.prototype.dotAll`
* `RegExp.prototype.hasIndices`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`
RegExp.prototype.multiline
==========================

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

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

解説
--

`RegExp.prototype.multiline` の値は `m` フラグが使われていたならば `true` となり、そうでなければ `false` になります。`m` フラグは複数行の入力文字列が複数行として扱われるべきであることを示します。例えば、`m` フラグが使われた場合、`^` と `$` は文字列の全体の先頭と末尾だけに一致する特殊文字から、文字列内のそれぞれの行の先頭と末尾に一致する特殊文字に変化します。

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

例
-

### multiline の使用


```js
const regex = /foo/m;

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

仕様書
---

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

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

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.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`
RegExp[@@species]
=================

**`RegExp[@@species]`** は静的なアクセサープロパティで、特定の `RegExp` メソッドのコピーされた正規表現を構築するのに使用された `RegExp` コンストラクターを返します。

**警告:** `@@species` が存在すると、任意のコードの実行が可能になり、セキュリティ上の脆弱性が生じる可能性があります。また、ある種の最適化も非常に難しくなります。エンジンの実装者たちは、この機能を削除するかどうか調査しています。可能であれば、この機能に頼ることは避けてください。

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

構文
--


```js
RegExp[Symbol.species]
```

### 返値

`get @@species` が呼び出されたコンストラクター (`this`) の値。この返値は、コピーした `RegExp` インスタンスを作成するために使用されます。

解説
--

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


```js
// 説明のための架空の基礎実装
class RegExp {
  static get [Symbol.species]() {
    return this;
  }
}
```


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


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


一部の `RegExp` メソッドは、`exec()` を実行する前に現在の正規表現インスタンスのコピーを作成します。そのため、`lastIndex` への変更が保持されないような副作用があります。`@@species` プロパティは、新しいインスタンスのコンストラクターを決定するために使用されます。正規表現インスタンスをコピーするメソッドは以下の通りです。

* `[@@matchAll]()`
* `[@@split]()`
例
-

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

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


```js
RegExp[Symbol.species]; // function RegExp()
```

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

派生クラスのコレクションオブジェクト（たとえば、独自の正規表現を表す `MyRegExp`）では、 `MyRegExp` の species は `MyRegExp` コンストラクターです。しかし、派生クラスのメソッドで親である `RegExp` オブジェクトを返すようにこれをオーバーライドしたくなるかもしれません。


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


または、これを使用してコピープロセスを監視することができます。


```js
class MyRegExp extends RegExp {
  constructor(...args) {
    console.log("Creating a new MyRegExp instance with args:", args);
    super(...args);
  }
  static get [Symbol.species]() {
    console.log("Copying MyRegExp");
    return this;
  }
  exec(value) {
    console.log("Executing with lastIndex:", this.lastIndex);
    return super.exec(value);
  }
}

Array.from("aabbccdd".matchAll(new MyRegExp("[ac]", "g")));
// Creating a new MyRegExp instance with args: [ '[ac]', 'g' ]
// Copying MyRegExp
// Creating a new MyRegExp instance with args: [ MyRegExp /[ac]/g, 'g' ]
// Executing with lastIndex: 0
// Executing with lastIndex: 1
// Executing with lastIndex: 2
// Executing with lastIndex: 5
// Executing with lastIndex: 6
```

仕様書
---

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

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

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

関連情報
----

* `RegExp`
* `Symbol.species`
RegExp.prototype.unicode
========================

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

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

解説
--

`RegExp.prototype.unicode` の値は `true` ならば `u` フラグが使用されていることを示し、そうでなければ `false` となります。`u` フラグは Unicode に関連する様々な機能を有効にします。 "u" フラグを使用すると、次のようになります。

* Unicode コードポイントエスケープ ( \u{xxxx}, \p{UnicodePropertyValue}) は、ID エスケープの代わりにそのように解釈されます。例えば、 `/\u{61}/u` は `"a"` に一致しますが、`/\u{61}/` （`u` フラグなし）は `"u".repeat(61)` に一致します。 `\u` が `u` 1 文字と同等になるからです。
* サロゲートペアは 2 つの別々の文字ではなく、全体の文字として解釈されます。例えば `/[😄]/u` は`"😄"` にのみ一致し、`"\ud83d"` には一致しません。
* `lastIndex` が自動的に進む場合（`exec()` を呼び出した場合など）、Unicode 正規表現は UTF-16 コード単位ではなく Unicode コードポイント単位で進みます。

 構文の間違いを防ぐために、構文解析の動作を変更したものが他にもあります（正規表現構文の厳格モードに似ています）。これらの構文はすべて非推奨であり、ウェブの互換性のためだけに残されているもの
 ですので、頼らないでください。

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

### Unicode 対応モード

Unicode 対応モードと言う言葉を使うときは、`u` または `v` のどちらかのフラグがついた正規表現を指し、この場合は正規表現が Unicode に関連した機能（Unicode 文字クラスエスケープなど）が利用できるようになり、もっと厳格化した構文ルールになります。`u` と `v` は同じ正規表現を互換性のない方法で解釈するため、両方のフラグを使用すると `SyntaxError` になります。

同様に、正規表現が `u` フラグも `v` フラグも持たない場合、Unicode 非対応モードとなります。この場合、正規表現は UTF-16 コード単位の並びとして解釈され、たくさんの古い構文が構文エラーにならなくなります。

例
-

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


```js
const regex = /\u{61}/u;

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

仕様書
---

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

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

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`