recursal/MDN huggingface dataset:
グループと後方参照
=========

グループは複数のパターンを全体としてグループ化し、グループをキャプチャすることで、正規表現パターンを使用して文字列と一致する場合に、追加の副一致情報を提供します。後方参照は、同じ正規表現で以前に捕捉したグループを参照します。

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

種類
--

| 文字 | 意味 |
| --- | --- |
| `(*x*)` | **キャプチャグループ:** `*x*` に一致し、一致した内容を記憶します。例えば `/(foo)/` は "foo bar" の "foo" に一致し、記憶します。
正規表現は複数のキャプチャグループを持つことができます。結果、一般的にキャプチャグループ内の左括弧と同じ順にある、配列の要素のキャプチャグループに一致しています。たいていの場合、これはキャプチャグループ自身の順番です。これはキャプチャグループがネストしている場合に重要です。一致は結果の要素の添字 (`[1], …, [n]`) や、あらかじめ定義されている `RegExp` オブジェクトのプロパティ (`$1, …, $9`) を使ってアクセスできます。
キャプチャグループはパフォーマンス上の損失があります。一致した部分文字列を使わない場合はキャプチャしない括弧（後述）を使ったほうがいいでしょう。

`String.prototype.match()` は、`/.../g` フラグが設定されている場合、グループを返しません。しかし、
 `String.prototype.matchAll()` を使用して、すべての一致したものを取得することができます。
  |
| `(?<Name>x)` | **名前付きキャプチャグループ:** "x" に一致し、`<Name>` で指定された名前に従い、返される一致の `groups` プロパティに記憶されます。山括弧 ('`<`' と '`>`') にはグループ名が必須です。
例えば、電話番号からアメリカのエリアコードを取り出す際、 `/\((?<area>\d\d\d)\)/` を使うことができます。 結果の番号は `matches.groups.area` に表示されます。 |
| `(?:*x*)` | **非キャプチャグループ:** "x" に一致しますが、一致した内容は記憶しません。一致した部分文字列は、結果の配列の要素 (`[1], …, [n]`) や、あらかじめ定義されている `RegExp` オブジェクトのプロパティ (`$1, …, $9`) から呼び出すことはできません。
  |
| `\*n*` | 
 "n" に正の整数が入ります。正規表現内において n 番目の括弧の部分に一致した最新の部分文字列への後方参照となります（括弧の数は左からカウントします）。例えば
 `/apple(,)\sorange\1/` は "apple, orange, cherry, peach" の
 "apple, orange," に一致します。
  |
| `\k<Name>` | `<Name>` で指定された**名前付きキャプチャグループ**に一致する最後の部分文字列の後方参照です。
例えば、 `/(?<title>\w+), yes \k<title>/` は、 "Do you copy? Sir, yes Sir!" の中の "Sir, yes Sir" に一致します。

**メモ:** `\k` は、ここでは、名前付きキャプチャグループの後方参照を開始することを示すために使用されています。
 |

例
-

### グループの使用


```js
const personList = `First\_Name: John, Last\_Name: Doe
First\_Name: Jane, Last\_Name: Smith`;

const regexpNames = /First\_Name: (\w+), Last\_Name: (\w+)/gm;
for (const match of personList.matchAll(regexpNames)) {
  console.log(`Hello ${match[1]} ${match[2]}`);
}
```

### 名前付きグループの使用


```js
const personList = `First\_Name: John, Last\_Name: Doe
First\_Name: Jane, Last\_Name: Smith`;

const regexpNames =
  /First\_Name: (?<firstname>\w+), Last\_Name: (?<lastname>\w+)/gm;
for (const match of personList.matchAll(regexpNames)) {
  console.log(`Hello ${match.groups.firstname} ${match.groups.lastname}`);
}
```

### グループと後方参照の使用


```js
const quote = `Single quote "'" and double quote '"'`;
const regexpQuotes = /(['"]).\*?\1/g;
for (const match of quote.matchAll(regexpQuotes)) {
  console.log(match[0]);
}
```

### グループと一致結果の添字の使用

`d` フラグが指定された場合、各キャプチャグループの添字を返します。これは、それぞれの一致したグループと元のテキストを関連付ける場合、例えば、コンパイラーの診断を提供する場合に特に有益です。


```js
const code = `function add(x, y) {
 return x + y;
}`;
const functionRegexp =
  /(function\s+)(?<name>[$\_\p{ID\_Start}][$\u200c\u200d\p{ID\_Continue}]\*)/du;
const match = functionRegexp.exec(code);
const lines = code.split("\n");
lines.splice(
  1,
  0,
  " ".repeat(match.indices[1][1] - match.indices[1][0]) +
    "^".repeat(match.indices.groups.name[1] - match.indices.groups.name[0]),
);
console.log(lines.join("\n"));
// function add(x, y) {
// ^^^
// return x + y;
// }
```

関連情報
----

* `RegExp` 名前付きキャプチャグループが `core-js` で利用できます。
* 正規表現ガイド
    + 文字クラス
    + アサーション
    + 数量詞
    + Unicode プロパティエスケープ
* `RegExp()` コンストラクター
* ECMAScript 仕様書の ClassRanges（英語）
標準組み込みオブジェクト
============

本章では JavaScript の標準組み込みオブジェクトについて、それらのメソッドやプロパティと共にすべて文書化しています。

ここでいう「グローバルオブジェクト (global objects)」 (または標準組み込みオブジェクト) という用語を**グローバルオブジェクト** (the global object) と混同しないでください。ここで、『グローバルオブジェクト』は**グローバルスコープにあるオブジェクト**を指します。 (訳注: 日本語では複数形や the による区別ができないため、ここでは後者の **the global object** を『グローバルオブジェクト』と表記して区別します。)

後者の『グローバルオブジェクト』自体は、グローバルスコープ中で `this` 演算子を使ってアクセスすることができます。実際、グローバルスコープは『グローバルオブジェクト』のプロパティと、もしあれば継承されたプロパティから**構成されています**。

グローバルスコープ内のその他のオブジェクトは、ユーザースクリプトによって作られたり、ホストアプリケーションによって提供されたりします。ブラウザー上で提供されている利用可能なオブジェクトについては、API リファレンスで文書化されています。

DOM と中核の JavaScript との違いについての詳しい情報は、JavaScript 技術概説をご覧ください。

標準オブジェクト (カテゴリー別)
-----------------

### 値プロパティ

これらのグローバルプロパティは、単なる値を返します。プロパティもメソッドも持ちません。

* `Infinity`
* `NaN`
* `undefined`
* `globalThis`
### 関数プロパティ

これらのグローバル関数 (オブジェクト上ではなくグローバルに呼ばれる関数) は、呼び出し元に直接結果を返します。

* `eval()`
* Non-standard
 `uneval()`
* `isFinite()`
* `isNaN()`
* `parseFloat()`
* `parseInt()`
* `encodeURI()`
* `encodeURIComponent()`
* `decodeURI()`
* `decodeURIComponent()`
* **非推奨**
    + 非推奨
     `escape()`
    + 非推奨
     `unescape()`
### 基本オブジェクト

他のすべてのオブジェクトの基礎となる、主要な基本オブジェクトです。一般的なオブジェクト、関数、そしてエラーを表すオブジェクトが含まれます。

* `Object`
* `Function`
* `Boolean`
* `Symbol`
### エラーオブジェクト

エラーオブジェクトは基本オブジェクトの特殊型です。これらのオブジェクトには、基本的な `Error` 型の他に、いくつかの特殊なエラー型があります。

* `Error`
* `AggregateError`
* `EvalError`
* `InternalError`
* `RangeError`
* `ReferenceError`
* `SyntaxError`
* `TypeError`
* `URIError`
### 数値と日付

数値、日付、数学計算を表す基本的なオブジェクトです。

* `Number`
* `BigInt`
* `Math`
* `Date`
### テキスト処理

これらのオブジェクトは、文字列を表したりその操作をサポートしたりします。

* `String`
* `RegExp`
### 索引付きコレクション

これらのオブジェクトは、インデックス値で順序付けされたデータのコレクションを表します。これには、(型付けされた) 配列や配列に似た構造体も含まれます。

* `Array`
* `Int8Array`
* `Uint8Array`
* `Uint8ClampedArray`
* `Int16Array`
* `Uint16Array`
* `Int32Array`
* `Uint32Array`
* `Float32Array`
* `Float64Array`
* `BigInt64Array`
* `BigUint64Array`
### キー付きコレクション

これらのオブジェクトは、キーを使ったコレクションを表します。反復可能なコレクション (`Map` と `Set`) は挿入順に容易に反復処理することができます。

* `Map`
* `Set`
* `WeakMap`
* `WeakSet`
### 構造化データ

これらのオブジェクトは、構造化データバッファおよび JavaScript Object Notation (JSON) を用いて書かれたデータを表現、操作します。

* `ArrayBuffer`
* `SharedArrayBuffer`
* `Atomics`
* `DataView`
* `JSON`
### 制御抽象化オブジェクト

制御抽象化オブジェクトは、特に非同期のコードを (例えば深く入り組んだコールバックを使用せずに) 構造化するのに役立ちます。

* `Promise`
* `Generator`
* `GeneratorFunction`
* `AsyncFunction`
* `AsyncGenerator`
* `AsyncGeneratorFunction`
### リフレクション

* `Reflect`
* `Proxy`
### 国際化

中核の ECMAScript に言語に固有の機能を追加するものです。

* `Intl`
* `Intl.Collator`
* `Intl.DateTimeFormat`
* `Intl.ListFormat`
* `Intl.NumberFormat`
* `Intl.PluralRules`
* `Intl.RelativeTimeFormat`
* `Intl.Locale`
### WebAssembly

* `WebAssembly`
* `WebAssembly.Module`
* `WebAssembly.Instance`
* `WebAssembly.Memory`
* `WebAssembly.Table`
* `WebAssembly.CompileError`
* `WebAssembly.LinkError`
* `WebAssembly.RuntimeError`
### その他

* `arguments`
単語境界アサーション: \b, \B
==================

**単語境界アサーション**は、文字列の現在の位置が単語境界であるかどうかを調べます。単語境界とは、次の文字が単語文字で、前の文字が単語文字でない場合、またはその逆の場合です。

構文
--


```regex
\b
\B
```

解説
--

`\b` は文字列の現在の位置が単語境界であることを表明します。`\B` はこの表明とは逆で、現在の位置が単語境界でないことを表明します。両者ともアサーションなので、他の文字エスケープや文字クラスエスケープとは異なり、`\b` と `\B` は文字を消費しません。

単語文字は次の通りです。

* 英文字 (A–Z, a–z)、数字 (0–9)、アンダースコア (\_)。
* 正規表現が Unicode 対応で `i` フラグが設定されている場合、大文字小文字の変換によって上記の文字のいずれかに正規化される他の Unicode 文字。

単語文字は `\w` 文字クラスエスケープでも一致します。

範囲外の入力位置は非単語文字とみなされます。 例えば、次の例は照合に成功します。


```js
/\ba/.exec("abc");
/c\b/.exec("abc");

/\B /.exec(" abc");
/ \B/.exec("abc ");
```

例
-

### 単語の検出

次の例は、文字列が "thanks" または "thank you" という単語を含んでいるかどうかを検出します。


```js
function hasThanks(str) {
  return /\b(thanks|thank you)\b/i.test(str);
}

hasThanks("Thanks! You helped me a lot."); // true
hasThanks("Just want to say thank you for all your work."); // true
hasThanks("Thanksgiving is around the corner."); // false
```


**警告:** すべての言語で単語の境界が明確に定義されているわけではありません。日本語やタイ語のように空白の区切りがない言語を扱う場合は、代わりに `Intl.Segmenter` のような高度なライブラリーを使って単語を検索してください。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Assertion |

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

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

関連情報
----

* アサーション
* 正規表現リファレンス
* 入力境界アサーション: `^`, `$`
* 先読みアサーション: `(?=...)`, `(?!...)`
* 後読みアサーション: `(?<=...)`, `(?<!...)`
* 文字エスケープ: `\n`, `\u{...}`
後方参照: \1, \2
============

**後方参照**は、前回のキャプチャグループの部分一致を参照し、そのグループと同じテキストに一致します。名前付きキャプチャグループの場合は、名前付き後方参照構文を使用する方ができればよいでしょう。

構文
--


```regex
\N
```


**メモ:** `N` はリテラル文字ではありません。

### 引数

`N`

キャプチャグループの番号を参照する正の値。

解説
--

後方参照は、前回キャプチャグループによって一致したのと同じテキストに一致する方法です。キャプチャリンググループは 1 から数えるので、最初のキャプチャリンググループの結果は `\1` で参照し、2 つ目は `\2` で参照し、といった具合になります。`\0` は NUL 文字の文字エスケープです。

大文字と小文字を区別しない照合では、後方参照は元のテキストと異なる大文字と小文字を持つテキストと一致することがあります。


```js
/(b)\1/i.test("bB"); // true
```


後方参照は存在するキャプチャグループを参照しなければなりません。指定する数がキャプチャグループの総数より大きい場合、構文エラーが発生します。


```js
/(a)\2/u; // SyntaxError: Invalid regular expression: Invalid escape
```


Unicode 対応モードでない場合は、無効な後方参照は古い 8 進エスケープシーケンスになります。これはウェブの互換性のために非推奨の構文ですので、頼ってはいけません。


```js
/(a)\2/.test("a\x02"); // true
```


参照するキャプチャグループが一致しない場合（例えば、それが論理和の一致しない選択肢に属するため）、または、グループがまだ一致 していない場合（例えば、それが後方参照の正しい位置にあるため）、後方参照は常に成功します（空文字列に一致するかのように）。


```js
/(?:a|(b))\1c/.test("ac"); // true
/\1(a)/.test("a"); // true
```

例
-

### 引用符のペアリング

以下の関数は、文字列中の `title='xxx'` と `title="xxx"` のパターンに一致します。引用符が確実に一致するように、後方参照を使用して最初の引用符を参照します。2 つ目のキャプチャグループ (`[2]`) にアクセスすると、一致する引用符の間の文字列を返します。


```js
function parseTitle(metastring) {
  return metastring.match(/title=(["'])(.\*?)\1/)[2];
}

parseTitle('title="foo"'); // 'foo'
parseTitle("title='foo' lang='en'"); // 'foo'
parseTitle('title="Named capturing groups\' advantages"'); // "Named capturing groups' advantages"
```

### 重複する単語の照合

以下の関数は、文字列中の重複する単語（通常はタイプミス）を探します。なお、`\w` 文字クラスエスケープ は英字にのみ一致しますが、アクセント付きの文字や他のアルファベットには一致しません。より一般的な照合を行いたい場合は、文字列を空白で分割し、結果の配列を反復処理するとよいでしょう。


```js
function findDuplicates(text) {
  return text.match(/\b(\w+)\s+\1\b/i)?.[1];
}

findDuplicates("foo foo bar"); // 'foo'
findDuplicates("foo bar foo"); // undefined
findDuplicates("Hello hello"); // 'Hello'
findDuplicates("Hello hellos"); // undefined
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-DecimalEscape |

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

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

関連情報
----

* グループと後方参照
* 正規表現リファレンス
* キャプチャグループ: `(...)`
* 名前付きキャプチャグループ: `(?<name>...)`
* 名前付き後方参照: `\k<name>`
ワイルドカード: .
==========

**ワイルドカード**は改行文字を除くすべての文字に一致します。`s` フラグが設定された場合は、改行文字にも一致します。

構文
--


```regex
.
```

解説
--

`.` は改行文字を除くあらゆる文字に一致します。`s` フラグが設定された場合、`.` は改行文字にも一致します。

`.` に一致する正確な文字の集合は、正規用言が Unicode 対応モードであるかによります。Unicode 対応モードでは、`.` はあらゆる Unicode コードポイントに一致します。それ以外の場合は、あらゆる UTF-16 コード単位に一致します。例えば次のようになります。


```js
/../.test("😄"); // true。サロゲートペアとして 2 つの UTF-16 コード単位に一致します。
/../u.test("😄"); // false。1 つの Unicode 文字しかありません。
```

例
-

### 数量詞の使用

ワイルドカードはしばしば数量詞と共に使用され、次に関心がある文字が得られるまで、任意の文字列に一致します。 例えば、次の例では Markdown ページのタイトルを `# Title` という形で抽出します。


```js
function parseTitle(entry) {
  // タイトルがファイルの始めにはない可能性があるので、複数行モードを使用する。
  // m フラグは . を行末に一致させないので、タイトルは単一の行になければ
  // ならないことに注意する
  // 最初のキャプチャグループに一致したテキストを返す。
  return /^#[ \t]+(.+)$/m.exec(entry)?.[1];
}

parseTitle("# Hello world"); // "Hello world"
parseTitle("## Subsection"); // undefined
parseTitle(`
---
slug: Web/JavaScript/Reference/Regular\_expressions/Wildcard
---

# Wildcard: .

A \*\*wildcard\*\* matches all characters except line terminators.
`); // "Wildcard: ."
```

### コードブロックのコンテンツの照合

次の例は Markdown の 3 つのバックスティックで囲まれたコードブロックの内容に一致します。コードブロックの内容が複数行にまたがる可能性があるため、`.` を改行と一致させるために `s` フラグを使用しています。


```js
function parseCodeBlock(entry) {
  return /^```.\*?^(.+?)\n```/ms.exec(entry)?.[1];
}

parseCodeBlock(`
\`\`\`js
console.log("Hello world");
\`\`\`
`); // "console.log("Hello world");"

parseCodeBlock(`
A \`try...catch\` statement must have the blocks enclosed in curly braces.

\`\`\`js-nolint example-bad
try
 doSomething();
catch (e)
 console.log(e);
\`\`\`
`); // "try\n doSomething();\ncatch (e)\n console.log(e);"
```


**警告:** この例はあくまでデモンストレーションのためのものです。 Markdown を解析したい場合は、考慮すべきエッジケースがたくさんあるため、専用の Markdown パーサーを使用してください。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Atom |

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

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

関連情報
----

* 文字クラス
* 正規表現リファレンス
* 文字クラス: `[...]`, `[^...]`
* 文字クラスエスケープ: `\d`, `\D`, `\w`, `\W`, `\s`, `\S`
名前付きキャプチャグループ: (?<name>...)
===========================

**名前付きキャプチャグループ**は特定の種類のキャプチャグループで、グループに名前を付けることができます。グループの照合結果は、パターン内のインデックスではなく、この名前で後で識別することができます。

構文
--


```regex
(?<name>pattern)
```

### 引数

`pattern`

正規表現リテラルで使用することができるあらゆるものから成るパターンで、論理和を含みます。

`name`

グループの名前です。有効な識別子である必要があります。

解説
--

名前付きキャプチャグループは、キャプチャグループと同様に使用することができます 。結果の配列の一致インデックスも持っており、`\1`、`\2` などによって参照することができます。唯一の違いは、名前によって「追加的に」参照することができるということです。 キャプチャグループの一致する情報には、以下のようにしてアクセスすることができます。

* `RegExp.prototype.exec()`、`String.prototype.match()`、`String.prototype.matchAll()` の返値の `groups` プロパティ
* `String.prototype.replace()` および `String.prototype.replaceAll()` メソッドの `replacement` コールバック関数の `groups` 引数
* 同じパターン内の名前付き後方参照

同じパターン内は、すべての名前が一意でなければなりません。同じ名前を持つ複数の名前付きキャプチャグループは構文エラーとなります。


```js
/(?<name>)(?<name>)/; // SyntaxError: Invalid regular expression: Duplicate capture group name
```


重複する名前付きキャプチャグループが同じ論理和の選択肢にない場合、この制限は緩和されますので、どのような文字列入力に対しても、実際に一致できる名前付きキャプチャグループは 1 つだけです。これはかなり新しい機能なので、使う前にブラウザーの互換性をチェックしてください。


```js
/(?<year>\d{4})-\d{2}|\d{2}-(?<year>\d{4})/;
// 動作します。"year" をハイフンの前にも後にも置くことができます
```


結果の中に、名前付きキャプチャグループはすべて存在します。名前付きキャプチャグループが一致していない場合（例えば、論理和で一致しない選択肢に属している場合）、`groups` オブジェクトの対応するプロパティは `undefined` の値になります。


```js
/(?<ab>ab)|(?<cd>cd)/.exec("cd").groups; // [Object: null prototype] { ab: undefined, cd: 'cd' }
```


`d` フラグを使用することで、入力文字列中のそれぞれの名前付きキャプチャグループの開始と終わりのインデックスを取得することができます。`exec()` が返す配列の `indices` プロパティで取得することに加えて、`indices.groups` の名前でも取得することができます。

無名キャプチャグループに比べ、名前付きキャプチャグループには以下のような利点があります。

* 個々の部分一致の結果に説明的な名前を提供することができます。
* これにより、パターンに現れる順番を覚えておくことなく、部分一致の結果にアクセスすることができます。
* コードをリファクタリングするとき、他の参照を壊す心配をすることなく、キャプチャグループの順序を変更することができます。
例
-

### 名前付きキャプチャグループの使用

次の例は、Git のログ項目（`git log --format=%ct,%an -- filename` の出力）からタイムスタンプと作者名を解析します。


```js
function parseLog(entry) {
  const { author, timestamp } = /^(?<timestamp>\d+),(?<author>.+)$/.exec(
    entry,
  ).groups;
  return `${author} committed on ${new Date(
 parseInt(timestamp) \* 1000,
 ).toLocaleString()}`;
}

parseLog("1560979912,Caroline"); // "Caroline committed on 6/19/2019, 5:31:52 PM"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Atom |

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

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

関連情報
----

* 名前付きキャプチャグループのポリフィル (`core-js`)
* グループと後方参照
* 正規表現リファレンス
* キャプチャグループ: `(...)`
* 非キャプチャグループ: `(?:...)`
* 名前付き後方参照: `\k<name>`
* ESLint rule: `prefer-named-capture-group`
非キャプチャグループ: (?:...)
===================

**非キャプチャグループ**はサブパターンをグループ化し、グループ全体に数量詞を適用したり、グループ内で論理和を使用したりすることができます。これは JavaScript で発生したグループ化演算子のように動作します。キャプチャグループとは異なり、一致したテキストを記憶しないため、パフォーマンスが向上し、パターンが有用なキャプチャグループを含む場合の混乱を避けることができます。

構文
--


```regex
(?:pattern)
```

### 引数

`pattern`

正規表現リテラルで使用できるあらゆるものからなるパターンで、論理和も含まれます。

例
-

### サブパターンのグループ化と数量詞の適用

以下の例では、ファイルパスの末尾が `styles.css` か `styles.[a hex hash].css` かを検査します。`\.[\da-f]+` の部分全体はオプションであるため、これに `?` 量子化子を適用するには、これを新しいアトムにグループ化する必要があります。 非キャプチャグループを使用すると、必要のない余分な一致情報を生成しないため、パフォーマンスが向上します。


```js
function isStylesheet(path) {
  return /styles(?:\.[\da-f]+)?\.css$/.test(path);
}

isStylesheet("styles.css"); // true
isStylesheet("styles.1234.css"); // true
isStylesheet("styles.cafe.css"); // true
isStylesheet("styles.1234.min.css"); // false
```

### 論理和のグループ化

論理和は正規表現では最も優先順位が低くなります。 大きなパターンの一部として論理和を使いたい場合は、グループ化する必要があります。 論理和の一致したテキストに依存しない限り、非キャプチャグループを使うことをお勧めします。 次の例は、入力境界アサーションの記事と同じコードで、ファイルの拡張子に一致します。


```js
function isImage(filename) {
  return /\.(?:png|jpe?g|webp|avif|gif)$/i.test(filename);
}

isImage("image.png"); // true
isImage("image.jpg"); // true
isImage("image.pdf"); // false
```

### リファクタリング災害の防止

キャプチャグループはパターン内の位置によってアクセスされます。照合結果や後方参照からアクセスしている場合、キャプチャグループを追加または除去すると、他のキャプチャグループの位置も更新する必要があります。 特に、ほとんどのグループが純粋に構文上の目的（数量詞を適用するため、または論理和をグループ化するため）である場合、これはバグの原因となる可能性があります。 非キャプチャグループを使用することで、この問題を避けることができ、実際のキャプチャグループのインデックスを簡単に追跡することができます。

例えば、文字列中の `title='xxx'` というパターンと照合する関数があるとします（キャプチャグループから引用した例）。 引用符が確実に一致するように、後方参照を使って最初の引用符を参照しています。


```js
function parseTitle(metastring) {
  return metastring.match(/title=(["'])(.\*?)\1/)[2];
}

parseTitle('title="foo"'); // 'foo'
```


後で `name='xxx'` を `title=` の別名として追加することにした場合、別のグループに論理和をグループ化する必要があります。


```js
function parseTitle(metastring) {
  // おっと — 後方参照とインデックスアクセスが 1 つずつずれてしまいました
  return metastring.match(/(title|name)=(["'])(.\*?)\1/)[2];
}

parseTitle('name="foo"'); // null のプロパティが読めない (reading '2')
// \1 が "name" という文字列を指すようになったため、末尾が見つからない
```


キャプチャグループのインデックスを参照している場所をすべて探し出して 1 つ 1 つ更新するのではなく、キャプチャグループを使用しない方が良いでしょう。


```js
function parseTitle(metastring) {
  // 値を使用しないので、title|name の論理和はキャプチャしない
  return metastring.match(/(?:title|name)=(["'])(.\*?)\1/)[2];
}

parseTitle('name="foo"'); // 'foo'
```


名前付きキャプチャグループはリファクタリング災害を避けるためのもう一つの方法です。これにより、他のキャプチャグループが追加または削除されても影響を受けない、独自の名前でキャプチャグループにアクセスできるようになります。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Atom |

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

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

関連情報
----

* グループと後方参照
* 正規表現リファレンス
* キャプチャグループ: `(...)`
* 名前付きキャプチャグループ: `(?<name>...)`
入力境界アサーション: ^, $
================

**入力境界アサーション**は、文字列の減殺の位置が入力境界であるかどうかを検査します。入力境界は文字列の先頭または末尾です。`m` フラグが設定された場合は、行の先頭または末尾です。

構文
--


```regex
^
$
```

解説
--

`^` は現在の位置が入力の先頭であるかどうかを検査します。`$` は現在の位置が入力の末尾であるかどうかを検査します。どちらもアサーションであり、何も文字を消費しません。

より正確には、`^` は左側の文字が文字列の範囲外であることを、`$` は右側の文字が文字列の範囲外であることを表明します。`m` フラグが設定されている場合、`^` は左の文字が改行文字である場合にも一致し、`$` は右の文字が改行文字である場合にも一致します。

`m` フラグが設定されていない限り、`^` と `$` のアサーションはパターンの境界に配置したときのみ意味を持ちます。その左右に他の文字があるとアサーションが発生しなくなるからです。

`y` フラグはこれらのアサーションの意味を変えません。アンカー粘着フラグも参照してください。

例
-

### 末尾のスラッシュの除去

次の例は、URL 文字列から末尾のスラッシュを解除します。


```js
function removeTrailingSlash(url) {
  return url.replace(/\/$/, "");
}

removeTrailingSlash("https://example.com/"); // "https://example.com"
removeTrailingSlash("https://example.com/docs/"); // "https://example.com/docs"
```

### ファイル拡張子の照合

次の例は、常に文字列の最後に来るファイル拡張子を照合することで、ファイル型を調べます。


```js
function isImage(filename) {
  return /\.(?:png|jpe?g|webp|avif|gif)$/i.test(filename);
}

isImage("image.png"); // true
isImage("image.jpg"); // true
isImage("image.pdf"); // false
```

### 入力全体の照合

正規表現が入力の部分文字列だけでなく、入力全体と一致することを確認したい場合があります。例えば、文字列が有効な識別子かどうかを判定する場合、パターンの両端に入力境界のアサーションを追加することができます。


```js
function isValidIdentifier(str) {
  return /^[$\_\p{ID\_Start}][$\_\p{ID\_Continue}]\*$/u.test(str);
}

isValidIdentifier("foo"); // true
isValidIdentifier("$1"); // true
isValidIdentifier("1foo"); // false
isValidIdentifier(" foo "); // false
```


この関数は、codegen（コードを用いてコードを生成すること）を行う際に有益なものです。なぜなら、有効な識別子を、ドット記法をブラケット記法の代わりに用いるなど、他の文字列プロパティとは異なる形で使用することができるからです。


```js
const variables = ["foo", "foo:bar", " foo "];

function toAssignment(key) {
  if (isValidIdentifier(key)) {
    return `globalThis.${key} = undefined;`;
  }
  // JSON.stringify() escapes quotes and other special characters
  return `globalThis[${JSON.stringify(key)}] = undefined;`;
}

const statements = variables.map(toAssignment).join("\n");

console.log(statements);
// globalThis.foo = undefined;
// globalThis["foo:bar"] = undefined;
// globalThis[" foo "] = undefined;
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Assertion |

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

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

関連情報
----

* アサーション
* 正規表現リファレンス
* 単語境界アサーション: `\b`, `\B`
* 先読みアサーション: `(?=...)`, `(?!...)`
* 後読みアサーション: `(?<=...)`, `(?<!...)`
後読みアサーション: (?<=...), (?<!...)
=============================

**後読みアサーション**の「後読み」とは、それ以前の入力を指定されたパターンに照合しようとしますが、入力を消費することはありません。照合に成功した場合、入力の現在の位置はそのままです。パターン内のそれぞれのアトムは、逆順に照合します。

構文
--


```regex
(?<=pattern)
(?<!pattern)
```

### 引数

`pattern`

論理和を含む、正規表現リテラルで使用することができるあらゆるもので構成されるパターンです。

解説
--

正規表現は一般に左から右に照合します。これが先読みおよび後読みアサーションがこのように呼ばれる理由です。先読みアサーションは右にあるもの、後読みアサーションは左にあるものを表します。

`(?<=pattern)` アサーションが成功するためには、`pattern` が入力の現在の位置からみてすぐ左側ののテキストと一致しなければなりませんが、現在の位置は以降の入力と照合する前から変化しません。`(?<!pattern)` 形式はアサーションを否定します。`pattern` が入力の現在の位置のすぐ左側で一致しない場合に成功します。

後読みアサーションは、全般的には先読みと同じ意味づけを持ちます。 しかし、後読みアサーション内では、正規表現を逆順に照合します。例えば、次のようになります。


```js
/(?<=([ab]+)([bc]+))$/.exec("abc"); // ['', 'a', 'bc']
// Not ['', 'ab', 'c']
```


後読みで左から右に照合する場合は、最初に `[ab]+` に貪欲に照合して最初のグループが `"ab"` を捕捉し、残りの `"c"` は `[bc]+` に捕捉されるはずです。 しかし、ここでは `[bc]+` を最初に照合し、貪欲に `"bc"` を捕捉するため、`[ab]+` には `"a"` しか残りません。

この動作は妥当なものです。マッチャーはどこで照合を開始するかは分かりませんが（後読みが修正された長さでない可能性があるため）、どこで照合を終了するかは分かります（現在の位置です）。 したがって、現在の位置から開始し、逆方向に動作します（他の言語の正規表現では、この問題を避けるために固定長でない後読みを禁止しているものもあります）。

後読み内の量化されたキャプチャグループでは、逆順に照合されるため、入力文字列の右側ではなく、最も左側に一致するものがキャプチャされます。詳細はキャプチャグループのページを参照してください。後方参照は、逆順に照合されるため、参照するグループの左側に現れなければなりません。しかし、論理和は左から右へ試行されます。

例
-

### 消費せずに文字列を照合

先読みの場合と同様、後読みを使うと文字列を消費することなく文字列を照合し、有益な情報のみを抽出することができます。 例えば、次の例は価格ラベルの数字に一致する正規表現です。


```js
function getPrice(label) {
  return /(?<=\$)\d+(?:\.\d\*)?/.exec(label)?.[0];
}

getPrice("$10.53"); // "10.53"
getPrice("10.53"); // undefined
```


興味のある部分一致をキャプチャすることで、同様の効果が得られます。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Assertion |

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

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

関連情報
----

* アサーション
* 正規表現リファレンス
* 入力境界アサーション: `^`, `$`
* 単語境界アサーション: `\b`, `\B`
* 先読みアサーション: `(?=...)`, `(?!...)`
* キャプチャグループ: `(...)`
論理和: |
======

**論理和**は、複数の選択肢を指定します。いずれかの選択肢が入力に一致すると、その論理和全体が一致することになります。

構文
--


```regex
alternative1|alternative2
alternative1|alternative2|alternative3|…
```

### 引数

`alternativeN`

1 つの選択肢のパターンで、アトムとアサーションの並びで構成されます。いずれかの選択肢に一致した場合は、論理和全体に一致したと見なされます。

解説
--

正規表現の演算子 `|` は、2 つ以上の「選択肢」を区切ります。パターンは最初の選択肢との照合を試み、失敗すると 2 つ目に照合を試みます。例えば、次の例は `"ab"` ではなく `"a"` に一致します。


```js
/a|ab/.exec("abc"); // ['a']
```


`|` 演算子は正規表現の中では最も低い優先度になります。より大きなパターンの一部として論理和を使用したい場合は、グループ化する必要があります。

グループ化された論理和の後にさらに別の表現がある場合、照合は最初の選択肢を選択し、正規表現の残りの部分と照合しようとすることから始まります。正規表現の残りの部分が一致しなかった場合、マッチャーは代わりに次の選択肢を試みます。例えば、次のようになります、


```js
/(?:(a)|(ab))(?:(c)|(bc))/.exec("abc"); // ['abc', 'a', undefined, undefined, 'bc']
// Not ['abc', undefined, 'ab', 'c', undefined]
```


これは、最初の選択肢で `a` を選択することで、2 つ目の選択肢で `bc` を選択し、一致することが可能だからです。このプロセスは「バックトラッキング」と呼ばれ、マッチャーは最初に論理和を越え、その後の照合が失敗したときに論理和に戻ってくるからです。

また、一致しなかった選択肢の中に括弧を入れると、結果の配列に `undefined` が含まれることにも注意してください。

選択肢は空文字列であることもあり、その場合は空文字列に一致します（言い換えれば、常に一致します）。

選択肢は常に左から右に向けて試され、照合の方向には関係ありません（これは後読みで予約されています）。

例
-

### ファイル拡張子の照合

次の例は、入力境界アサーションの記事と同じコードを使用して、ファイル拡張子を照合します。


```js
function isImage(filename) {
  return /\.(?:png|jpe?g|webp|avif|gif)$/i.test(filename);
}

isImage("image.png"); // true
isImage("image.jpg"); // true
isImage("image.pdf"); // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Disjunction |

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

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

関連情報
----

* 文字クラス
* 正規表現リファレンス
* 修飾子: `*`, `+`, `?`, `{n}`, `{n,}`, `{n,m}`
* 文字クラス: `[...]`, `[^...]`
文字クラスエスケープ: \d, \D, \w, \W, \s, \S
==================================

**文字クラスエスケープ**は、文字の集合を表すエスケープシーケンスです。

構文
--


```regex
\d, \D
\s, \S
\w, \W
```


**メモ:** `,` is not part of the syntax.

解説
--

文字エスケープとは異なり、文字クラスエスケープは、文字クラスのように、事前に定義された文字の集合を表します。以下の文字クラスに対応しています。

`\d`

いずれかの数字に一致します。`[0-9]` と同等です。

`\w`

任意の単語文字に一致します。単語文字には文字 (A-Z, a-z)、数字 (0-9)、アンダースコア (\_) が含まれます。正規表現が Unicode 対応で `i` フラグが設定されている場合、大文字小文字の折りたたみによって上記の文字のいずれかに正規化される他の Unicode 文字にも一致します。

`\s`

任意のホワイトスペースまたは改行文字に一致します。

大文字形式の `\D`、`\W`、`\S` は、それぞれ `\d`、`\w`、`\s` の補集合文字クラスを作成します。これらは、小文字形式が一致する文字の集合にない任意の文字に一致します。

Unicode 文字クラスエスケープは˶`\p` および `\P`で始まりますが、Unicode 対応モードでのみ対応しています。Unicode 非対応モードでは、これらは `p` または `P` 文字の識別子エスケープです。

文字クラスエスケープは文字クラスで使用することができます。しかし、文字範囲の境界として使用することはできません。これはウェブの互換性のための非推奨構文としてのみ認められており、頼ってはいけません。

例
-

### ホワイトスペースでの分割

次の例は、文字列を単語の配列に分割します。すべての種類のホワイトスペース区切り文字に対応しています。


```js
function splitWords(str) {
  return str.split(/\s+/);
}

splitWords(`Look at the stars
Look how they\tshine for you`);
// ['Look', 'at', 'the', 'stars', 'Look', 'how', 'they', 'shine', 'for', 'you']
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-CharacterClassEscape |

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

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

関連情報
----

* 文字クラス
* 正規表現リファレンス
* 文字クラス: `[...]`, `[^...]`
* Unicode 文字クラスエスケープ: `\p{...}`, `\P{...}`
* 文字エスケープ: `\n`, `\u{...}`
* 論理和: `|`