Array[@@species] - JavaScript

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() - JavaScript

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()`


Array.prototype.forEach() - JavaScript

Array.prototype.forEach()
=========================

**`forEach()`** メソッドは、与えられた関数を、配列の各要素に対して一度ずつ実行します。

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

構文
--

```js
forEach(callbackFn)
forEach(callbackFn, thisArg)
```

### 引数

`callbackFn`

配列のそれぞれの要素に対して実行する関数。返値は破棄されます。この関数は以下の引数で呼び出されます。

`element`

現在処理中の配列の要素です。

`index`

現在処理中の配列の要素のインデックスです。

`array`

`forEach()` が呼び出されている配列です。

`thisArg` 省略可

`callbackFn` を実行するときに `this` として使用する値です。反復処理メソッドを参照してください。

### 返値

なし (`undefined`)。

解説
--

`forEach()` メソッドは反復処理メソッドです。指定された関数 `callbackFn` を配列に含まれる各要素に対して一度ずつ、昇順で呼び出します。 `map()` と異なり、 `forEach()` は常に `undefined` を返し、連鎖させることはできません。典型的な使用する用途は、チェーンの終わりで副次効果を実行することです。

`callbackFn` は値が割り当てられている配列インデックスに対してのみ呼び出されます。疎配列で空のスロットに対しては呼び出されません。

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

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

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

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

例外を発生する以外の方法で、 `forEach()` ループを止めたり脱出したりする方法はありません。そのような動作を行う場合、 `forEach()` メソッドは適切な方法ではありません。

早期終了は `for`, `for...of`, `for...in` のようなループ文で行うことができます。また、`every()`, `some()`, `find()`, `findIndex()` のような配列メソッドも、それ以上の反復処理が不要な場合は、直ちに反復処理を停止します。

`forEach()` は同期関数を期待します。プロミスを待ちません。`forEach` のコールバックとしてプロミス（または非同期関数）を使用する場合は、その意味合いを理解しておくようにしてください。

```js
const ratings = [5, 4, 5];
let sum = 0;

const sumFunction = async (a, b) => a + b;

ratings.forEach(async (rating) => {
  sum = await sumFunction(sum, rating);
});

console.log(sum);
// 本来期待される出力: 14
// 実際の出力: 0
```

一連の非同期処理を順次または並列に実行するには、プロミスの合成を参照してください。

例
-

### 不連続な配列に対する forEach() の使用

```js
const arraySparse = [1, 3, /\* 空 \*/, 7];
let numCallbackRuns = 0;

arraySparse.forEach((element) => {
  console.log({ element });
  numCallbackRuns++;
});

console.log({ numCallbackRuns });

// { element: 1 }
// { element: 3 }
// { element: 7 }
// { numCallbackRuns: 3 }
```

3 と 7 の間の値がないところで、コールバック関数が呼び出されなかったことが分かります。

### for ループから forEach への変換

```js
const items = ["item1", "item2", "item3"];
const copyItems = [];

// before
for (let i = 0; i < items.length; i++) {
  copyItems.push(items[i]);
}

// after
items.forEach((item) => {
  copyItems.push(item);
});
```

### 配列の内容の出力

**メモ:** 配列の内容をコンソールに表示するために、配列の整形済みのバージョンを表示する `console.table()` を使用することができます。

以下の例では同じことを `forEach()` を使用して行う他の方法を説明しています。

次のコードは配列の要素ごとに、コンソールに 1 行ずつ要素の内容を出力します。

```js
const logArrayElements = (element, index /\*, array \*/) => {
  console.log(`a[${index}] = ${element}`);
};

// 配列の 2 の位置には項目が存在しないため、
// スキップされることに注意してください
[2, 5, , 9].forEach(logArrayElements);
// 出力結果:
// a[0] = 2
// a[1] = 5
// a[3] = 9
```

### thisArg の使用

以下の（不自然な）例は、配列の中の各項目からオブジェクトのプロパティを更新します。

```js
class Counter {
  constructor() {
    this.sum = 0;
    this.count = 0;
  }
  add(array) {
    // Only function expressions will have its own this binding
    array.forEach(function countEntry(entry) {
      this.sum += entry;
      ++this.count;
    }, this);
  }
}

const obj = new Counter();
obj.add([2, 5, 9]);
console.log(obj.count); // 3
console.log(obj.sum); // 16
```

`thisArg` 引数 (`this`) が `forEach()` に提供されているため、`callbackFn` の呼び出しのたびにこれが渡されます。コールバックはこれを `this` の値として使用します。

**メモ:** コールバック関数の受け渡しにアロー関数式を使用した場合、`thisArg` 引数は、アロー関数が文法的に `this` の値に結び付けられているため省略可能です。

### オブジェクトをコピーする関数

次のコードは与えられたオブジェクトのコピーを生成します。

 オブジェクトのコピーを作成するには様々な方法があります。
 以下のものは一つの方法で、`Array.prototype.forEach()` が `Object.*` ユーティリティ関数を使用して、どのように動作するかを説明しています。

```js
const copy = (obj) => {
  const copy = Object.create(Object.getPrototypeOf(obj));
  const propNames = Object.getOwnPropertyNames(obj);
  propNames.forEach((name) => {
    const desc = Object.getOwnPropertyDescriptor(obj, name);
    Object.defineProperty(copy, name, desc);
  });
  return copy;
};

const obj1 = { a: 1, b: 2 };
const obj2 = copy(obj1); // obj2 looks like obj1 now
```

### 反復処理中の配列の変更

次の例では `one`, `two`, `four` をログ出力します。

 値 `two` を含む項目に到達すると、配列全体の最初の項目が取り出され、残りのすべての項目が 1 つずつ繰り上がります。
 要素 `four` は配列の前の方の位置にあるので、 `three` は飛ばされます。

`forEach()` は反復処理の前に配列のコピーを生成しません。

```js
const words = ["one", "two", "three", "four"];
words.forEach((word) => {
  console.log(word);
  if (word === "two") {
    words.shift(); // 'one' が配列から削除される
  }
}); // one // two // four

console.log(words); // ['two', 'three', 'four']
```

### 配列の平坦化

 次の例は学習目的だけのものです。
 組み込みメソッドを使用して配列を平坦化したい場合は、`Array.prototype.flat()` を使用することができます。

```js
const flatten = (arr) => {
  const result = [];
  arr.forEach((item) => {
    if (Array.isArray(item)) {
      result.push(...flatten(item));
    } else {
      result.push(item);
    }
  });
  return result;
};

// 使用方法
const nested = [1, 2, 3, [4, 5, [6, 7], 8, 9]];
console.log(flatten(nested)); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
```

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

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

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

仕様書
---

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

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

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

関連情報
----

* `Array.prototype.forEach` のポリフィル (`core-js`)
* インデックス付きコレクションのガイド
* `Array`
* `Array.prototype.find()`
* `Array.prototype.map()`
* `Array.prototype.filter()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `TypedArray.prototype.forEach()`
* `Map.prototype.forEach()`
* `Set.prototype.forEach()`


RegExp.prototype.unicodeSets - JavaScript

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 ($`) - JavaScript

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 - JavaScript

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 ($+) - JavaScript

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 ($') - JavaScript

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`


RegExp.prototype[@@replace]() - JavaScript

RegExp.prototype[@@replace]()
=============================

**`[@@replace]()`** メソッドは文字列内の `this` パターンの一部または、すべての一致箇所を `replacement` で置き換え、置換結果を新しい文字列として返します。 `replacement` は文字列にするか、関数にしてすべての一致箇所ごとに呼び出されるようにすることができます。

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

構文
--

```js
regexp[Symbol.replace](str, replacement)
```

### 引数

`str`

置換の対象となる文字列 (`String`) です。

`replacement`

文字列または関数を取ることができます。

* 文字列の場合は、現在の正規表現で一致した部分文字列をそれで置き換えます。特殊な置換パターンの数値に対応しています。`String.prototype.replace()` ページの置換文字列としての文字列の指定の節を参照してください。
* 関数の場合は、一致するごとに呼び出され、返値が置換文字列として使用されます。この関数に提供される引数については、`String.prototype.replace()` ページの置換文字列としての関数の指定で記述されています。

### 返値

一部またはすべてのパターンの一致箇所が置換内容によって置き換えられた新しい文字列です。

解説
--

このメソッドは `String.prototype.replace()` の中で、 `pattern` 引数が `RegExp` オブジェクトであった場合に内部的に呼び出されます。たとえば、次の 2 つの例は同じ結果を返します。

```js
"abc".replace(/a/, "A");

/a/[Symbol.replace]("abc", "A");
```

正規表現がグローバル（`g` フラグ付き）である場合、正規表現の `exec()` メソッドは `exec()` が `null` を返すまで繰り返し呼び出されます。そうでない場合、`exec()` は一度だけ呼び出されます。それぞれの `exec()` の結果に対して、 `String.prototype.replace()` の解説に基づいて置き換える準備をします。

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

```js
const re = /a/y;

for (let i = 0; i < 5; i++) {
  console.log("aaa".replace(re, "b"), re.lastIndex);
}

// baa 1
// aba 2
// aab 3
// aaa 0
// baa 1
```

正規表現が粘着的でグローバルな場合、粘着的に照合します。すなわち、 `lastIndex` 以降の出現には一致しません。

```js
console.log("aa-a".replace(/a/gy, "b")); // "bb-a"
```

もし現在の一致が空文字列であったとしても、 `lastIndex` は進みます。正規表現が Unicode 対応であれば、Unicode コードポイントが 1 つ進みます。そうでない場合は、 UTF-16 コード単位 1 つ分進みます。

```js
console.log("😄".replace(/(?:)/g, " ")); // " \ud83d \ude04 "
console.log("😄".replace(/(?:)/gu, " ")); // " 😄 "
```

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

例
-

### 直接呼出し

`this` と引数の順序が異なる点を除いて、このメソッドは `String.prototype.replace()` とほとんど同じ使い方ができます。

```js
const re = /-/g;
const str = "2016-01-01";
const newstr = re[Symbol.replace](str, ".");
console.log(newstr); // 2016.01.01
```

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

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

```js
class MyRegExp extends RegExp {
  constructor(pattern, flags, count) {
    super(pattern, flags);
    this.count = count;
  }
  [Symbol.replace](str, replacement) {
    // Perform @@replace |count| times.
    let result = str;
    for (let i = 0; i < this.count; i++) {
      result = RegExp.prototype[Symbol.replace].call(this, result, replacement);
    }
    return result;
  }
}

const re = new MyRegExp("\\d", "", 3);
const str = "01234567";
const newstr = str.replace(re, "#"); // String.prototype.replace calls re[@@replace].
console.log(newstr); // ###34567
```

仕様書
---

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

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

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

関連情報
----

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


RegExp.prototype.ignoreCase - JavaScript

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]() - JavaScript

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() - JavaScript

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 - JavaScript

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]() - JavaScript

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.sticky - JavaScript

RegExp.prototype.sticky
=======================

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

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

解説
--

`RegExp.prototype.sticky` の値が `true` ならば `y` フラグが使われており（粘着的正規表現）、そうでなければ `false` になります。`y` フラグはこの正規表現が対象の文字列を `lastIndex` プロパティで示されたインデックスからのみ照合を試みることを示します（そしてグローバル正規表現とは異なり、それ以降のインデックスからの照合は試みません）。

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

粘着的正規表現とグローバル正規表現の両方の場合は、次のようになります。

* `lastIndex` で照合を開始します。
* 照合が成功したら、`lastIndex` は一致部分の末尾まで進みます。
* `lastIndex` が現在照合している文字列の範囲を超えたら、`lastIndex` は 0 をリセットします。

ただし、`exec()` メソッドについては、照合に失敗したときの動作が異なります。

* `exec()` メソッドが粘着的な正規表現で呼び出された場合、その正規表現が `lastIndex` での照合に失敗した場合は、正規表現は直ちに `null` を返し `lastIndex` を 0 にリセットします。
* `exec()` メソッドがグローバル正規表現で呼び出された場合、その正規表現が `lastIndex` での照合に失敗した場合は、次の文字から照合しようとし、一致するものが見つかるか文字列の末尾に達するまで進みます。

`exec()` メソッドでは、粘着的かつグローバルな正規表現は、粘着的かつグローバルでない正規表現と同じ動作をします。`test()` は `exec()` の単純なラッパーなので、`test()` はグローバルフラグを無視して同様に粘着的な照合を行います。しかし、他にもグローバル正規表現の挙動を特殊化するメソッドがたくさんあるため、 一般的にはグローバルフラグは粘着フラグと直交します。

* `String.prototype.matchAll()`（`RegExp.prototype[@@matchAll]()` を呼び出す）では `y`, `g`, `gy` はすべて異なります。
    + `y` の正規表現については、`matchAll()` では例外が発生します。`[@@matchAll]()` は `exec()` の結果を 1 つだけ生成しますが、その正規表現の `lastIndex` を更新します。
    + `g` または `gy` の正規表現については、`exec()` の結果を生成するイテレーターを返します。
* `String.prototype.match()`（`RegExp.prototype[@@match]()` を呼び出す）では `y`, `g`, `gy` はすべて異なります。
    + `y` の正規表現については、`exec()` の結果を返し、その正規表現の `lastIndex` を更新します。
    + `g` または `gy` の正規表現については、すべての `exec()` の結果を配列で返します。
* `String.prototype.search()` （`RegExp.prototype[@@search]()` を呼び出す）では `g` フラグは常に無視されます。
    + `y` または `gy` の正規表現については、常に `0`（文字列の一致箇所の最も先頭）または `-1` （先頭に一致しなかった場合）を返し、存在した場合でも `lastIndex` を更新しません。
    + `g` の正規表現については、文字列中で最初に一致した箇所のインデックスを返します。一致するものが見つからなかった場合は `-1` を返します。
* `String.prototype.split()` （`RegExp.prototype[@@split]()` を呼び出す）では `y`, `g`,`gy` はすべて同じ動作をします。
* `String.prototype.replace()`（`RegExp.prototype[@@replace]()` を呼び出す）では、`y`, `g`, `gy` はすべて異なります。
    + `y` の正規表現については、現在の `lastIndex` の位置で置換を一度実行し、`lastIndex` を更新します。
    + `g` および `gy` の正規表現については、`exec()` に一致したすべての箇所を置換します。
* `String.prototype.replaceAll()`（`RegExp.prototype[@@replace]()` を呼び出す）では `y`, `g`, `gy` はすべて異なります。
    + `y` の正規表現については、`replaceAll()` は例外が発生します。
    + `g` および `gy` の正規表現については、`exec()` に一致したすべての箇所を置換します。
例
-

### sticky フラグのついた正規表現の使用

```js
const str = "#foo#";
const regex = /foo/y;

regex.lastIndex = 1;
regex.test(str); // true
regex.lastIndex = 5;
regex.test(str); // false （lastIndex は粘着フラグで考慮されます）
regex.lastIndex; // 0 （照合に失敗した後でリセット）
```

### アンカーになる sticky フラグ

Firefox の SpiderMonkey エンジンの一部のバージョンでは `^` 指定に関するバグがあり、 `^` アサーションで始まり、 sticky フラグを使うことで一致しない式を許可していました。このバグは Firefox 3.6 以降で発生し（それ以前は sticky が実装されていてもバグはありませんでした）、2015 年に修正されました。このバグのためか、仕様書では特に注意を促しているという事実があります。

>
> パターンとともに `y` フラグが使用された場合、 `^` は常に入力の始まりにのみ一致するか、（*rer*.[[Multiline]] が `true` の場合）行の先頭に一致するかです。
>
>
>

以下は正しい挙動の例です。

```js
const regex = /^foo/y;
regex.lastIndex = 2;
regex.test("..foo"); // false - インデックス 2 は文字列の先頭ではない

const regex2 = /^foo/my;
regex2.lastIndex = 2;
regex2.test("..foo"); // false - インデックス 2 は文字列または行の先頭ではない
regex2.lastIndex = 2;
regex2.test(".\nfoo"); // true - インデックス 2 は行の先頭
```

仕様書
---

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

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

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

関連情報
----

* `sticky` フラグのポリフィル (`core-js`)
* `RegExp.prototype.lastIndex`
* `RegExp.prototype.dotAll`
* `RegExp.prototype.global`
* `RegExp.prototype.hasIndices`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.unicode`


RegExp.prototype.source - JavaScript

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.prototype.exec() - JavaScript

RegExp.prototype.exec()
=======================

**`exec()`** は `RegExp` インスタンスのメソッドで、指定された文字列の中でこの正規表現と一致するものを検索し、その結果の配列、または `null` を返します。

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

構文
--

```js
exec(str)
```

### 引数

`str`

正規表現の照合を実施する文字列。すべての値は文字列に強制されますので、省略したり `undefined` を渡したりすると `exec()` は文字列 `"undefined"` を検索するようになりますが、これは望むところではないでしょう。

### 返値

照合に失敗した場合は、 `exec()` メソッドは `null` を返し、 `lastIndex` を `0` に設定します。

照合に成功した場合、 `exec()` メソッドは配列を返し、正規表現オブジェクトの `lastIndex` プロパティを更新します。返された配列は、一致したテキストを最初の項目として持ち、その後、一致したテキストの括弧によるキャプチャグループに対して 1 つずつの項目を持ちます。

`index`

文字列中で一致した位置の 0 から始まるインデックスです。

`input`

照合対象であった元の文字列です。

`groups`

名前付きキャプチャグループを示す `null` プロトタイプオブジェクトで、そのキーが名前となり、値がキャプチャグループ、またはキャプチャグループが定義されていなければ `undefined` です。詳しくはキャプチャグループを参照してください。

`indices` 省略可

このプロパティは `d` フラグが設定されている場合にのみ存在します。これは配列で、それぞれの要素は部分文字列の一致した境界を表します。この配列のそれぞれの要素のインデックスは `exec()` が返す配列の中の一致する部分文字列のインデックスに対応します。言い換えれば、最初の `indices` 項目は照合する文字列全体を表し、2 つ目の `indices` 項目は最初のキャプチャグループなどを表します。各項目自身は 2 要素の配列で、最初の数字は一致の開始インデックスを表し、2 つ目の数字はその終了インデックスを表します。

配列 `indices` にはさらに `groups` プロパティがあり、すべての名前付きキャプチャグループの `null` プロトタイプオブジェクトを保持します。キーはキャプチャグループの名前であり、それぞれの値は 2 つ要素の配列で、最初の数字はキャプチャグループの始めるインデックス、 2 つ目の数字は終わりのインデックスです。正規表現に名前付きキャプチャグループが含まれていない場合、 `groups` は `undefined` となります。

解説
--

JavaScript の `RegExp` オブジェクトは、 global または sticky フラグが設定されている場合（例えば `/foo/g` や `/foo/y`）は**ステートフル**になります。これは前回の一致位置を `lastIndex` に格納します。これを内部的に使用することで、 `exec()` はテキストの文字列内で（キャプチャグループのある）複数の一致を反復処理することができます。これは単なる文字列の一致を取得する `String.prototype.match()` とは対照的です。

`exec()` を使用する場合、グローバルフラグは sticky フラグが設定されているときには影響しません。照合は常に粘着的に行われます。

`exec()` は正規表現のプリミティブメソッドです。他の多くの正規表現メソッドは、内部的に `exec()` を呼び出します。これは `@@replace` のような文字列のメソッドからも呼び出されます。`exec()` 自体は強力ですが（そして最も効率的です）、多くの場合、最も明確に意図を伝えるものではありません。

* 正規表現が文字列に一致するかどうかだけが必要で、実際に何が一致するかを見る必要がない場合は、代わりに `RegExp.prototype.test()` を使用してください。
* グローバル正規表現のすべての出現を探す場合で、キャプチャグループのような情報が不要な場合は、代わりに `String.prototype.match()` を使用してください。さらに、 `String.prototype.matchAll()` は、一致した文字列を反復処理することで、（キャプチャグループを持つ）文字列の複数の部分の照合を簡略化するのに役立ちます。
* 文字列内の位置のインデックスを知るため照合する場合は、代わりに`String.prototype.search()`メソッドを使用してください。
例
-

### exec() の使用

次の例を想像してみてください。

```js
// "quick brown" の後に "jumps" が来るものを、その間の文字を無視して一致させます。
// "brown" と "jumps" を取得します。
// 大文字と小文字は区別しません。
const re = /quick\s(?<color>brown).+?(jumps)/dgi;
const result = re.exec("The Quick Brown Fox Jumps Over The Lazy Dog");
```

このスクリプト実行後の `result` の状態は次のようになります。

| プロパティ | 値 |
| --- | --- |
| `[0]` | `"Quick Brown Fox Jumps"` |
| `[1]` | `"Brown"` |
| `[2]` | `"Jumps"` |
| `index` | `4` |
| `indices` | `[[4, 25], [10, 15], [20, 25]]``groups: { color: [10, 15 ]}` |
| `input` | `"The Quick Brown Fox Jumps Over The Lazy Dog"` |
| `groups` | `{ color: "brown" }` |

それに加えて、この正規表現がグローバルであるため、 `re.lastIndex` は `25` に設定されます。

### 連続した一致の検索

正規表現で `g` フラグを使用する場合、同じ文字列で成功する一致を見つけるために `exec()` メソッドを複数回使うことができます。その際、検索は正規表現オブジェクトの `lastIndex` プロパティで指定された位置の `str` の部分文字列から始まります（{jsxref("RegExp.prototype.test()", "test()")}} も `lastIndex` プロパティの位置から始めます）。なお、別な文字列を検索する場合でも `lastIndex` プロパティはリセットされず、既存の `lastIndex` から検索を始めます。

例えば、次のスクリプトを考えてみてください。

```js
const myRe = /ab\*/g;
const str = "abbcdefabh";
let myArray;
while ((myArray = myRe.exec(str)) !== null) {
  let msg = `${myArray[0]} を見つけました。`;
  msg += `次の照合は ${myRe.lastIndex} からです。`;
  console.log(msg);
}
```

このスクリプトは以下のテキストを表示します。
```

abb を見つけました。次の照合は 3 からです。
ab を見つけました。次の照合は 9 からです。
```

**警告:** 無限ループに陥る落とし穴がたくさんあります。

* 正規表現リテラル（または `RegExp` コンストラクター）を `while` 条件内に配置しないでください。反復処理するたびに正規表現が再作成され、 `lastIndex` がリセットされます。
* グローバルフラグ (`g`) が設定されているかを確認してください。さもないと `lastIndex` が進行しなくなります。
* 正規表現が長さゼロの文字（例えば `/^/gm`）に一致する可能性がある場合、同じ位置に留まるのを避けるために、 `lastIndex` を毎回手動で増やしてください。

通常、このようなコードを `String.prototype.matchAll()` で置き換えることで、エラーの可能性を下げることができます。

### RegExp リテラルでの exec() の使用

`RegExp` オブジェクトを作成せずに `exec()` を使用することもできます。

```js
const matches = /(hello \S+)/.exec("This is a hello world!");
console.log(matches[1]);
```

これで 'hello world!' を含んだメッセージをログ出力します。

仕様書
---

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

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

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

関連情報
----

* JavaScript ガイドの正規表現の章
* `RegExp`


RegExp.$1, …, RegExp.$9 - JavaScript

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 ($&) - JavaScript

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 ($_) - JavaScript

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]() - JavaScript

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 - JavaScript

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 - JavaScript

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] - JavaScript

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 - JavaScript

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`


RegExp: lastIndex - JavaScript

RegExp: lastIndex
=================

**`lastIndex`** は `RegExp` インスタンスのデータプロパティで、次の照合を開始する位置を指定します。

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

値
-

非負の整数です。

| `RegExp: lastIndex` のプロパティ属性 |
| --- |
| 書込可能 | 可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

解説
--

このプロパティは、正規表現インスタンスがグローバル検索を示すために `g` フラグを使用した場合、または粘着的検索を示すために `y` フラグを使用した場合にのみ設定されます。`exec()` が指定された入力に対して呼び出されたとき、以下の規則が適用されます。

* `lastIndex` が入力の長さよりも大きい場合、 `exec()` は一致するものを見つけられず、 `lastIndex` は 0 に設定されます。
* `lastIndex` が入力の長さ以下であった場合、 `exec()` は `lastIndex` から一致するものを探そうとします。
    + `exec()` が一致するものを見つけた場合 `lastIndex` は入力の中の一致する文字列の末尾の位置に設定されます。
    + `exec()` が一致するものを見つけられなかった場合、 `lastIndex` は 0 に設定されます。

他の正規表現関連のメソッド、`RegExp.prototype.test()`、`String.prototype.match()`、`String.prototype.replace()` などは `exec()` を呼び出しので、`lastIndex` における影響は異なります。詳細はそれぞれのページを参照してください。

例
-

### lastIndex の使用

例えば、以下の一連の処理を考えてみてください。

```js
const re = /(hi)?/g;
```

空文字列に一致します。

```js
console.log(re.exec("hi"));
console.log(re.lastIndex);
```

`["hi", "hi"]` を返し、 `lastIndex` は 2 になります。

```js
console.log(re.exec("hi"));
console.log(re.lastIndex);
```

返値は `["", undefined]` で、 0 番目の要素が一致文字列となる空の配列です。この場合、 `lastIndex` が 2 (現在も 2) であり、`hi` の長さが 2 であるため、空の文字列となります。

### lastIndex を sticky の正規表現で使用

`lastIndex` プロパティは書き込み可能です。これを設定することで、正規表現が指定したインデックスから次の検索を開始するようになります。

`y` フラグはほとんどの場合 `lastIndex` を設定する必要があります。これは常に `lastIndex` ちょうどの位置で照合し、それ以降の位置では照合を試みません。これは通常パーサーを書くときに、現在の位置のトークンのみに一致させたい場合に便利です。

```js
const stringPattern = /"[^"]\*"/y;
const input = `const message = "Hello world";`;

stringPattern.lastIndex = 6;
console.log(stringPattern.exec(input)); // null

stringPattern.lastIndex = 16;
console.log(stringPattern.exec(input)); // ['"Hello world"']
```

### lastIndex の巻き戻し

`g` フラグも `lastIndex` を設定することで恩恵を受けることができます。よくある使用例として、グローバル検索の途中で文字列が変更された場合があります。この場合、文字列が短くなると特定の一致を見逃してしまう可能性があります。この場合は `lastIndex` を巻き戻すことで回避できます。

```js
const mdLinkPattern = /\[[^[\]]+\]\((?<link>[^()\s]+)\)/dg;

function resolveMDLink(line) {
  let match;
  let modifiedLine = line;
  while ((match = mdLinkPattern.exec(modifiedLine))) {
    const originalLink = match.groups.link;
    const resolvedLink = originalLink.replaceAll(/^files|\/index\.md$/g, "");
    modifiedLine =
      modifiedLine.slice(0, match.indices.groups.link[0]) +
      resolvedLink +
      modifiedLine.slice(match.indices.groups.link[1]);
    // Rewind the pattern to the end of the resolved link
    mdLinkPattern.lastIndex += resolvedLink.length - originalLink.length;
  }
  return modifiedLine;
}

console.log(
  resolveMDLink(
    "[`lastIndex`](files/ja/web/javascript/reference/global\_objects/regexp/lastindex/index.md)",
  ),
); // [`lastIndex`](/ja/web/javascript/reference/global\_objects/regexp/lastindex)
console.log(
  resolveMDLink(
    "[`ServiceWorker`](files/ja/web/api/serviceworker/index.md) and [`SharedWorker`](files/ja/web/api/sharedworker/index.md)",
  ),
); // [`ServiceWorker`](/ja/web/api/serviceworker) and [`SharedWorker`](/ja/web/api/sharedworker)
```

`mdLinkPattern.lastIndex += resolvedLink.length - originalLink.length` の行を削除して、2 番目の例を実行してみてください。文字列が短縮された後、`lastIndex` が既にリンクのインデックスを過ぎているため、2 番目のリンクが正しく置換されないことがわかります。

**警告:** この例はデモ専用のためのものです。Markdown を扱うには、正規表現の代わりに構文解析ライブラリーを使用してください。

### 検索の最適化

以前の出現を無視できるポイントに `lastIndex` を設定することで、検索を最適化することができます。例えば、この代わりに、

```js
const stringPattern = /"[^"]\*"/g;
const input = `const message = "Hello " + "world";`;

// 文字列の前の部分はすでに処理したことにする
let offset = 26;
const remainingInput = input.slice(offset);
const nextString = stringPattern.exec(remainingInput);
console.log(nextString[0]); // "world"
offset += nextString.index + nextString.length;
```

次のように考えてみてください。

```js
stringPattern.lastIndex = offset;
const nextString = stringPattern.exec(remainingInput);
console.log(nextString[0]); // "world"
offset = stringPattern.lastIndex;
```

これは、文字列のスライスを避けるようになるので、より性能が高まる可能性があります。

### 副作用の回避

それぞれの `exec()` の実行毎に入力が異なる場合、`exec()` によって発生する副作用が混乱を招きかねません。

```js
const re = /foo/g;
console.log(re.test("foo bar")); // true
console.log(re.test("foo baz")); // false。lastIndex がゼロではないため
```

これは `lastIndex` を手で変更する場合にはさらに混乱します。副作用を収めるために、各入力が完全に処理された後に `lastIndex` をリセットすることを忘れないでください。

```js
const re = /foo/g;
console.log(re.test("foo bar")); // true
re.lastIndex = 0;
console.log(re.test("foo baz")); // true
```

抽象化すれば、`exec()` を呼び出す前に `lastIndex` に具体的な値を設定するように要求することができます。

```js
function createMatcher(pattern) {
  // コピーを作成し、元の正規表現が更新されないようする
  const regex = new RegExp(pattern, "g");
  return (input, offset) => {
    regex.lastIndex = offset;
    return regex.exec(input);
  };
}

const matchFoo = createMatcher(/foo/);
console.log(matchFoo("foo bar", 0)[0]); // "foo"
console.log(matchFoo("foo baz", 0)[0]); // "foo"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-regexp-instances |

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

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

関連情報
----

* `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.prototype[@@search]() - JavaScript

RegExp.prototype[@@search]()
============================

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

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

構文
--

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

### 引数

`str`

検索対象の文字列 (`String`) です。

### 返値

正規表現で指定された文字列が最初に一致したインデックスの値、または一致する文字列が見つからなかった場合は `-1` を返します。

解説
--

このメソッドは、 `String.prototype.search()` の内部で呼び出されます。たとえば、次の 2 つの例は同じ結果を返します。

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

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

このメソッドは `@@split` や `@@matchAll` とは異なり、正規表現をコピーしません。しかし、`@@match` や `@@replace` とは異なり、実行を始めるときには `lastIndex` を 0 に設定し、終了するときには前回の値に戻すので、一般的に副作用を避けることができます。つまり、このメソッドでは `g` フラグは効果がなく、 `lastIndex` が 0 でない場合でも常に文字列の最初に一致した部分を返します。これは、粘着的正規表現が常に文字列の先頭を厳密に検索することも意味しています。

```js
const re = /[abc]/g;
re.lastIndex = 2;
console.log("abc".search(re)); // 0

const re2 = /[bc]/y;
re2.lastIndex = 1;
console.log("abc".search(re2)); // -1
console.log("abc".match(re2)); // [ 'b' ]
```

`@@search` は常に正規表現の `exec()` を 1 回だけ呼び出し、結果の `index` プロパティを返すか、結果が `null` の場合は `-1` を返します。

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

例
-

### 直接呼出し

このメソッドは、`this` と引数順が異なることを除いて `String.prototype.search()` とほぼ同じ方法で使用できます。

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

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

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

```js
class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this.pattern = str;
  }
  [Symbol.search](str) {
    return str.indexOf(this.pattern);
  }
}

const re = new MyRegExp("a+b");
const str = "ab a+b";
const result = str.search(re); // String.prototype.search は再定義した [@@search] を呼び出す。
console.log(result); // 3
```

仕様書
---

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

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

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

関連情報
----

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


RegExp.prototype.test() - JavaScript

RegExp.prototype.test()
=======================

**`test()`** メソッドは、正規表現と指定された文字列の一致を調べるための検索を実行します。 `true` または `false` を返します。

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

構文
--
```

regexObj.test(str)
```

### 引数

`str`

正規表現にマッチさせる文字列。

### 返値

正規表現と指定した文字列 `str` の間に一致するものがあった場合は、`true`。そうでない場合は、`false`。

解説
--

あるパターンがある文字列内で見つかるかどうか調べたいときは、 `test()` を使用してください。 `test()` は論理値を返します。これは (一致した場所のインデックス番号、または見つからない場合は `-1` を返す) `String.prototype.search()` メソッドとは異なります。

より多くの情報を得るためには (実行が遅くなりますが)、 `exec()` メソッドを使用してください (`String.prototype.match()` メソッドと同様)。

`exec()` と同様に (またはその組み合わせで)、 `test()` は同じグローバル正規表現インスタンスで複数回呼び出されると、前回の一致の先に進むことになります。

例
-

### test() の使用

"`hello`" が文字列の先頭近くに含まれているかを真偽値で確認する簡単な例です。

```js
const str = "hello world!";
const result = /^hello/.test(str);

console.log(result); // true
```

次の例では、テストの成否によってメッセージを表示します。

```js
function testInput(re, str) {
  let midstring;
  if (re.test(str)) {
    midstring = "contains";
  } else {
    midstring = "does not contain";
  }
  console.log(`${str} ${midstring} ${re.source}`);
}
```

### グローバルフラグを持つ正規表現の test() の使用

正規表現にグローバルフラグが設定されている場合、 `test()` は正規表現が所有する `lastIndex` の値を加算します。 (`exec()` も同様に `lastIndex` プロパティの値を加算します。)

その後にさらに `test(str)` を呼び出すと、 `str` を `lastIndex` から検索します。 `lastIndex` プロパティは `test()` が `true` を返すたびに増え続けます。

**メモ:** `test()` が `true` を返す限り、 `lastIndex` は別な文字列をテストした場合であっても、リセット*されません*。

`test()` が `false` を返した場合、正規表現の `lastIndex` プロパティを呼び出すと `0` にリセットされます。

次の例はその挙動を示しています。

```js
const regex = /foo/g; // "global" フラグを設定

// regex.lastIndex は 0 です。
regex.test("foo"); // true

// regex.lastIndex は 3 です。
regex.test("foo"); // false

// regex.lastIndex は 0 です。
regex.test("barfoo"); // true

// regex.lastIndex は 6 です。
regex.test("foobar"); //false

// regex.lastIndex は 0 です。
// (...以下略)
```

仕様書
---

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

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

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

関連情報
----

* JavaScript ガイドの正規表現
* `RegExp`
* `RegExp.prototype`


RegExp.prototype.toString() - JavaScript

RegExp.prototype.toString()
===========================

**`toString()`** メソッドは正規表現を表す文字列を返します。

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

構文
--
```

regexObj.toString();
```

### 返値

呼び出し元のオブジェクトを表す文字列です。

解説
--

`RegExp` オブジェクトの `toString()` メソッドは、 `Object` オブジェクトのものを上書きします。つまり `Object.prototype.toString()` を継承しません。 `RegExp` オブジェクトにおける `toString()` メソッドは、その正規表現オブジェクトを表す文字列を返します。

例
-

### toString() の使用

以下の例は `RegExp` オブジェクトの文字列の値を表示します。:

```js
var myExp = new RegExp("a+b+c");
console.log(myExp.toString()); // logs '/a+b+c/'

var foo = new RegExp("bar", "g");
console.log(foo.toString()); // logs '/bar/g'
```

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

ECMAScript 5 以降では、空の正規表現は "/(?:)/" 文字列を返し、"\n" などの行末記号はエスケープされます。

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

new RegExp("\n").toString() === "/\n/"; // true, prior to ES5
new RegExp("\n").toString() === "/\\n/"; // true, starting with ES5
```

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.toString()`


RegExp.prototype.dotAll - JavaScript

RegExp.prototype.dotAll
=======================

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

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

解説
--

`RegExp.prototype.dotAll` の値は `s` フラグが使用されている場合は `true`、それ以外の場合は `false` です。`s` フラグは、ドット特殊文字 (`.`) が追加で行末記号 ("newline") 文字と一致することを示します。これ以外の場合は一致しません。

* U+000A LINE FEED (LF) (`\n`)
* U+000D CARRIAGE RETURN (CR) (`\r`)
* U+2028 LINE SEPARATOR
* U+2029 PARAGRAPH SEPARATOR

これは事実上、ドットが基本多言語面 (BMP) のすべての文字と一致することを意味します。アストラル文字と一致させるには、`u` (Unicode) フラグを使用する必要があります。両方のフラグを組み合わせて使用すると、ドットは例外なく任意の Unicode 文字に一致します。

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

例
-

### dotAll の使用

```js
const str1 = "bar\nexample foo example";

const regex1 = /bar.example/s;

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

console.log(str1.replace(regex1, "")); // foo example

const str2 = "bar\nexample foo example";

const regex2 = /bar.example/;

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

console.log(str2.replace(regex2, ""));
// bar
// example foo example
```

仕様書
---

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

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

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

関連情報
----

* `dotAll` フラグのポリフィル (`core-js`)
* `RegExp.prototype.lastIndex`
* `RegExp.prototype.global`
* `RegExp.prototype.hasIndices`
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
* `RegExp.prototype.unicode`


RegExp() コンストラクター - JavaScript

RegExp() コンストラクター
=================

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

正規表現について詳しく知りたい方は JavaScript ガイド の 正規表現 を参照してください。

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

構文
--

```js
new RegExp(pattern)
new RegExp(pattern, flags)
RegExp(pattern)
RegExp(pattern, flags)
```

**メモ:** `RegExp()` は `new` があってもなくても呼び出すことができますが、効果が異なることがあります。返値を参照してください。

### 引数

`pattern`

正規表現のテキストです。他の `RegExp` オブジェクトであっても構いません。

`flags` 省略可

指定された場合、 `flags` は追加するフラグを含む文字列です。または、`RegExp` オブジェクトが `pattern` に提供された場合は、`flags` の文字列はそのオブジェクトのフラグをすべて置き換えます（そして `lastIndex` は 0 にリセットされます）。

`flags` は以下の値を任意の組み合わせを含んだ文字列を指定することができます。

`d` (indices)

部分文字列の一致にインデックスを生成します。

`g` (global)

最初に一致した後で停止せずに、一致するものをすべて探します。

`i` (ignore case)

照合時に、大文字小文字の違いを無視します。

`m` (multiline)

先頭および末尾を示す文字（`^` と `$`）が、複数の行にまたがって機能します。すなわち、入力文字列全体の先頭および末尾だけでなく、それぞれの（`\n` や `\r` で区切られた）行の先頭および末尾に一致します。

`s` (dotAll)

`.` が改行文字に一致できるようにします。

`u` (unicode)

`pattern` を Unicode コードポイントの並びとして扱います。

`v` (unicodeSets)

文字列のプロパティだけでなく、文字クラスでも集合表記を可能にする `u` フラグのアップグレード版です。

`y` (sticky)

対象文字列中の正規表現の `lastIndex` プロパティによって示された位置からのみ照合するようになります。それより後の位置からの照合は試みません。

### 返値

`RegExp(pattern)` は以下のすべてに該当すると、`pattern` を直接返します。

* `RegExp()` が `new` なしで呼び出された
* `pattern` が正規表現である
* `pattern.constructor === RegExp` （ふつうはサブクラスではないという意味）
* `flags` が `undefined` である

その他のすべての場合においては、`RegExp()` を呼び出す際に `new` を使用しても使用しなくても、新しい `RegExp` オブジェクトが作成されます。`pattern` が正規表現の場合、新しいオブジェクトのソースは `pattern.source` になります。それ以外の場合は、`pattern` は文字列に変換されます。`flags` 引数が `undefined` でない場合、新しいオブジェクトの `flags` は引数の値となり、そうでない場合、その `flags` は `pattern.flags` になります（`pattern` が正規表現の場合）。

### 例外

`SyntaxError`

以下のいずれかが成立すると発生します。

* `pattern` が有効な正規表現として解釈できない場合
* `flags` に繰り返して使われた文字や、許可されている文字以外が含まれていた場合。

例
-

### リテラル記法とコンストラクター

`RegExp` オブジェクトを生成するのに*リテラル記法*と*コンストラクター*の 2 つの方法があります。

* **リテラル記法**はパターンを 2 本のスラッシュの間に取り、2 番目のスラッシュの後にオプションのフラグが続くものです。
* **コンストラクター関数**は文字列または `RegExp` オブジェクトを最初の引数として取り、2 番目の引数としてオプションのフラグの文字列を取ります。

以下の 3 つの式は、同じ正規表現を生成するものです。

```js
/ab+c/i;
new RegExp(/ab+c/, "i"); // リテラル表記
new RegExp("ab+c", "i"); // コンストラクター
```

正規表現は、使用する前にコンパイルする必要があります。この処理により、より効率的に照合を行うことができます。コンパイルして `RegExp` オブジェクトを取得するには 2 つの方法があります。

リテラル記法を使用すると、式が評価されるときに正規表現のコンパイルが行われた結果になります。一方、`RegExp` オブジェクトのコンストラクターである `new RegExp('ab+c')` は、正規表現を実行時にコンパイルする結果になります。

動的な入力から正規表現を構築したい場合は、文字列を最初の引数として `RegExp()` コンストラクターを使用してください。

### 動的な入力から正規表現を構築

```js
const breakfasts = ["bacon", "eggs", "oatmeal", "toast", "cereal"];
const order = "Let me get some bacon and eggs, please";

order.match(new RegExp(`\\b(${breakfasts.join("|")})\\b`, "g"));
// Returns ['bacon', 'eggs']
```

仕様書
---

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

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

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

関連情報
----

* 多くの現代的な `RegExp` 機能（`dotAll`、`sticky` フラグ、名前付きキャプチャグループなど）のポリフィル (`core-js`)
* JavaScript ガイド内の正規表現の章
* `String.prototype.match()`
* `String.prototype.replace()`


Object.getPrototypeOf() - JavaScript

Object.getPrototypeOf()
=======================

**`Object.getPrototypeOf()`** メソッドは、指定されたオブジェクトのプロトタイプ (つまり、内部プロパティ `[[Prototype]]` の値) を返します。

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

構文
--
```

Object.getPrototypeOf(obj)
```

### 引数

`obj`

プロトタイプを取得したいオブジェクト。

### 返値

指定されたオブジェクトのプロトタイプです。何も継承していないオブジェクトの場合は `null` です。

例
-

### getPrototypeOf の使用

```js
var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true
```

### オブジェクト以外の型変換

ES5 では引数 *obj* がオブジェクトではない場合 `TypeError` が発生します。しかし ES2015 では対応する `Object` に変換されてから処理されます。

```js
Object.getPrototypeOf("foo");
// TypeError: "foo" is not an object (ES5 code)
Object.getPrototypeOf("foo");
// String.prototype (ES2015 code)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getprototypeof |

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

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

### Opera 固有のメモ

古いバージョンの Opera は `Object.getPrototypeOf()` に対応していませんが、 Opera 10.50 以降で標準外の `Object.prototype.__proto__` に対応しています。

関連情報
----

* `Object.prototype.isPrototypeOf()`
* `Object.setPrototypeOf()`
* `Object.prototype.__proto__`
* John Resig 氏の記事 : getPrototypeOf
* `Reflect.getPrototypeOf()`


Object.getOwnPropertyNames() - JavaScript

Object.getOwnPropertyNames()
============================

**`Object.getOwnPropertyNames()`** メソッドは、与えられたオブジェクトで発見されたすべての直接のプロパティを含む配列を (シンボルを使用したものを除き、列挙不可能なプロパティを含んで) 返します。

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

構文
--
```

Object.getOwnPropertyNames(obj)
```

### 引数

`obj`

オブジェクトで、これ自身の列挙可能および列挙不可能なプロパティが返されます。

### 返値

指定されたオブジェクトで発見された、列挙可能および列挙不可能なプロパティに対応する文字列を要素とする配列。

解説
--

`Object.getOwnPropertyNames()` は、 `obj` で発見された列挙可能および列挙不可能なプロパティに対応する文字列を要素とする配列を返します。配列内における列挙可能なプロパティの順序は、オブジェクトで `for...in` (または `Object.keys()`) を実行して見つかるものの順序と同じです。 ES6 によれば、オブジェクトの整数のキーは (列挙可能であっても列挙不可能であっても) 最初の配列に昇順で追加され、その後に挿入順を表す文字列キーが続きます。

ES5 では、このメソッドの引数がオブジェクトではない (プリミティブである) 場合、 `TypeError` が発生します。 ES2015 では、引数がオブジェクトではない場合はオブジェクトに型変換されます。

```js
Object.getOwnPropertyNames("foo");
// TypeError: "foo" is not an object (ES5 code)

Object.getOwnPropertyNames("foo");
// ["0", "1", "2", "length"] (ES2015 code)
```

例
-

### Object.getOwnPropertyNames() の使用

```js
var arr = ["a", "b", "c"];
console.log(Object.getOwnPropertyNames(arr).sort()); // .sort() は配列のメソッド
// ["0", "1", "2", "length"] と出力される

// 配列風オブジェクト
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.getOwnPropertyNames(obj).sort()); // .sort() は配列のメソッド
// ["0", "1", "2"] と出力される

// Array.forEach を使ったプロパティと値の出力
Object.getOwnPropertyNames(obj).forEach(function (val, idx, array) {
  console.log(val + " -> " + obj[val]);
});
// 出力結果
// 0 -> a
// 1 -> b
// 2 -> c

// 列挙不可能なプロパティ
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
      enumerable: false,
    },
  },
);
my_obj.foo = 1;

console.log(Object.getOwnPropertyNames(my_obj).sort());
// ["foo", "getFoo"] と出力されます
```

列挙可能なプロパティのみ取得したい場合は `Object.keys()` を参照するか、 `for...in` ループを用いるかしてください。 (なお、 for...in ループでは `hasOwnProperty()` でフィルタリングされない限りは、そのオブジェクト上で直接見つかるプロパティだけでなく、プロトタイプチェーン上の列挙可能なプロパティも返されることに注意してください。)

プロトタイプチェーン上のプロパティは配列に含まれません。

```js
function ParentClass() {}
ParentClass.prototype.inheritedMethod = function () {};

function ChildClass() {
  this.prop = 5;
  this.method = function () {};
}
ChildClass.prototype = new ParentClass();
ChildClass.prototype.prototypeMethod = function () {};

console.log(
  Object.getOwnPropertyNames(
    new ChildClass(), // ["prop", "method"]
  ),
);
```

### 列挙不可能なプロパティのみを取得する

ここでは `Array.prototype.filter()` 関数を使用して、 (`Object.keys()` で取得した) 列挙可能なキーを (`Object.getOwnPropertyNames()` で取得した) すべてのキーからフィルタリングし、出力として列挙不可能なキーのみを取得します。

```js
var target = myObject;
var enum_and_nonenum = Object.getOwnPropertyNames(target);
var enum_only = Object.keys(target);
var nonenum_only = enum_and_nonenum.filter(function (key) {
  var indexInEnum = enum_only.indexOf(key);
  if (indexInEnum == -1) {
    // このキーが enum\_only の中になければ、
    // そのキーは列挙不可能であることを意味するので、
    // true を返してフィルターの中に残します。
    return true;
  } else {
    return false;
  }
});

console.log(nonenum_only);
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertynames |

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

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

関連情報
----

* プロパティの列挙可能性と所有権 (en-US)
* `Object.prototype.hasOwnProperty()`
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.keys()`
* `Array.forEach()`


Object.getOwnPropertySymbols() - JavaScript

Object.getOwnPropertySymbols()
==============================

**`Object.getOwnPropertySymbols()`** メソッドは、与えられたオブジェクト上で直接見つかるシンボルプロパティすべての配列を返します。

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

構文
--

```js
Object.getOwnPropertySymbols(obj);
```

### 引数

`obj`

シンボルプロパティが返されるオブジェクトです。

### 返値

与えられたオブジェクト上で直接見つかるシンボルプロパティすべての配列です。

解説
--

`Object.getOwnPropertyNames()` と同様、与えられたオブジェクトのすべてのシンボルプロパティをシンボルの配列として取得することができます。 `Object.getOwnPropertyNames()` 自体はオブジェクトのシンボルプロパティを含まず、文字列プロパティのみを含むことに注意して下さい。

すべてのオブジェクトが最初に自身のシンボルプロパティを持っているとは限らないので、 `Object.getOwnPropertySymbols()` は、オブジェクトにシンボルプロパティを設定しない限りは空の配列を返します。

例
-

### getOwnPropertySymbols の使用

```js
var obj = {};
var a = Symbol("a");
var b = Symbol.for("b");

obj[a] = "localSymbol";
obj[b] = "globalSymbol";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // 2
console.log(objectSymbols); // [Symbol(a), Symbol(b)]
console.log(objectSymbols[0]); // Symbol(a)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertysymbols |

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

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

関連情報
----

* `Object.getOwnPropertyNames()`
* `Symbol`


Object.isFrozen() - JavaScript

Object.isFrozen()
=================

**`Object.isFrozen()`** はオブジェクトが凍結されているかどうかを判定します。

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

構文
--
```

Object.isFrozen(obj)
```

### 引数

`obj`

確認したいオブジェクトです。

### 返値

与えられたオブジェクトが凍結されているかどうかを示す `Boolean`。

解説
--

オブジェクトが拡張可能ではなく、すべてのプロパティは設定変更不可であり、そしてすべてのデータプロパティ (これはゲッターやセッターコンポーネントを持つアクセサプロパティではないものを指します) が書き込み不可である場合に、凍結されているとなります。

例
-

### Object.isFrozen の使用

```js
// 新しいオブジェクトは拡張可能であるので、凍結されていません
Object.isFrozen({}); // === false

// 拡張可能ではない空のオブジェクトは、他に何もしなくても
// 凍結されています
var vacuouslyFrozen = Object.preventExtensions({});
Object.isFrozen(vacuouslyFrozen); // === true

// プロパティをひとつ持つ新しいオブジェクトも拡張可能であり、
// それゆえ凍結されていません
var oneProp = { p: 42 };
Object.isFrozen(oneProp); // === false

// オブジェクトを拡張不可にしても、それは凍結されません
// なぜなら、まだプロパティが設定変更可能
// (かつ書き込み可能) であるからです
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp); // === false

// ...しかしプロパティを削除すると、そのオブジェクトは
// 他に何もしなくても凍結されます
delete oneProp.p;
Object.isFrozen(oneProp); // === true

// 書き込み不可であるが設定変更可能なプロパティを持つ、
// 拡張不可のオブジェクトは、凍結されていません
var nonWritable = { e: "plep" };
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, "e", {
  writable: false,
}); // 書き込み不可にします
Object.isFrozen(nonWritable); // === false

// プロパティを設定変更不可にすると、
// オブジェクトは凍結されます
Object.defineProperty(nonWritable, "e", {
  configurable: false,
}); // 設定変更不可にします
Object.isFrozen(nonWritable); // === true

// 設定変更不可であるが書き込み可能なプロパティを持つ、
// 拡張不可のオブジェクトは、やはり凍結されていません
var nonConfigurable = { release: "the kraken!" };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, "release", {
  configurable: false,
});
Object.isFrozen(nonConfigurable); // === false

// プロパティを書き込み不可にすると、オブジェクトは
// 凍結されます
Object.defineProperty(nonConfigurable, "release", {
  writable: false,
});
Object.isFrozen(nonConfigurable); // === true

// 設定変更可能なアクセサープロパティを持つ拡張不可の
// オブジェクトは、凍結されていません
var accessor = {
  get food() {
    return "yum";
  },
};
Object.preventExtensions(accessor);
Object.isFrozen(accessor); // === false

// ...しかしプロパティを設定変更不可にすると、
// オブジェクトは凍結されます
Object.defineProperty(accessor, "food", {
  configurable: false,
});
Object.isFrozen(accessor); // === true

// なお、オブジェクトを凍結するもっとも簡単な方法は、
// Object.freeze を呼び出すことです
var frozen = { 1: 81 };
Object.isFrozen(frozen); // === false
Object.freeze(frozen);
Object.isFrozen(frozen); // === true

// 定義によると、凍結されたオブジェクトは拡張不可です
Object.isExtensible(frozen); // === false

// また、凍結されたオブジェクトは封印されています
Object.isSealed(frozen); // === true
```

### オブジェクト以外の型強制

ES5 では、このメソッドの引数がオブジェクトではない場合 (プリミティブの場合)、 `TypeError` が発生します。 ES2015 以降では、オブジェクトでない引数は、それが凍結された通常のオブジェクトであるかのように扱われ、単に `true` を返します。

```js
Object.isFrozen(1);
// TypeError: 1 is not an object (ES5 code)

Object.isFrozen(1);
// true (ES2015 code)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.isfrozen |

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

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

関連情報
----

* `Object.freeze()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.seal()`
* `Object.isSealed()`


Object.entries() - JavaScript

Object.entries()
================

**`Object.entries()`** メソッドは、引数に与えたオブジェクトが所有する、文字列をキーとした列挙可能なプロパティの組 `[key, value]` からなる配列を返します。これは `for...in` ループでの反復処理と同様ですが、違いは `for...in` ループではプロトタイプチェーン内のプロパティも列挙されることです。

**`Object.entries()`** で返される配列の順序は、`for...in` ループによる順序と同じです。異なる順序にする必要があるのであれば、`Object.entries(obj).sort((a, b) => b[0].localeCompare(a[0]));` のようにして、まず配列を整列する必要があります。

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

構文
--

```js
Object.entries(obj);
```

### 引数

`obj`

返されることになる文字列をキーとした列挙可能な所有プロパティの組 `[key, value]` を持つオブジェクト。

### 返値

引数に与えたオブジェクトが所有する、文字列をキーとした列挙可能なプロパティの組 `[key, value]` の配列。

解説
--

`Object.entries()` は、`object` に直接存在する文字列をキーとした列挙可能プロパティの組 `[key, value]` が配列要素に対応した配列を返します。プロパティの順序はオブジェクト内のプロパティに対してループさせた時の順序と同じになります。

ポリフィル
-----

ネイティブで `Object.entries` に対応していない古い環境に互換性を持たせる場合は、以下のいずれかを使用することができます。

* `Object.entries` の試験的実装である tc39/proposal-object-values-entries (IE に対応する必要がない場合)
* es-shims/Object.entries リポジトリーにあるポリフィル
* または、単純に、下記の配布可能なポリフィルを使うこともできます。

```js
if (!Object.entries) {
  Object.entries = function (obj) {
    var ownProps = Object.keys(obj),
      i = ownProps.length,
      resArray = new Array(i); // preallocate the Array
    while (i--) resArray[i] = [ownProps[i], obj[ownProps[i]]];

    return resArray;
  };
}
```

上記のポリフィルのコードスニペットで、IE 9 以前の対応が必要な場合、`Object.keys()` のポリフィル (`Object.keys` ページにあるようなもの) も必要となります。

例
-

```js
const obj = { foo: "bar", baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

// 配列風オブジェクト
const obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

// ランダムなキー順序を持つ配列風オブジェクト
const anObj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]

// 列挙可能でないプロパティ getFoo がある
const myObj = Object.create(
  {},
  {
    getFoo: {
      value() {
        return this.foo;
      },
    },
  },
);
myObj.foo = "bar";
console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]

// オブジェクトでない引数はオブジェクトへと型強制されます
console.log(Object.entries("foo")); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]

// プリミティブにはプロパティがないため、文字列を除くすべてのプリミティブ型に対して空の配列を返します (上記の例を参照)
console.log(Object.entries(100)); // [ ]

// 行儀のよいキーと値の反復処理
const obj = { a: 5, b: 7, c: 9 };
for (const [key, value] of Object.entries(obj)) {
  console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
}

// または配列の展開の使用
Object.entries(obj).forEach(([key, value]) => {
  console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
});
```

### `Object` から `Map` への変換

`new Map()` コンストラクターは `entries` による反復処理に対応しています。`Object.entries` を使うと、`Object` から `Map` へと簡単に変換できます。

```js
const obj = { foo: "bar", baz: 42 };
const map = new Map(Object.entries(obj));
console.log(map); // Map(2) {"foo" => "bar", "baz" => 42}
```

### `Object` の反復処理

配列の分割代入を使って、オブジェクトを簡単に反復処理することができます。

```js
const obj = { foo: "bar", baz: 42 };
Object.entries(obj).forEach(([key, value]) => console.log(`${key}: ${value}`)); // "foo: bar", "baz: 42"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.entries |

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

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

関連情報
----

* `Object.entries` のポリフィルは `core-js` で利用できます
* プロパティの列挙可能性と所有権
* `Object.keys()`
* `Object.values()`
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.fromEntries()`
* `Object.getOwnPropertyNames()`
* `Map.prototype.entries()`
* `Map.prototype.keys()`
* `Map.prototype.values()`


Object.preventExtensions() - JavaScript

Object.preventExtensions()
==========================

**`Object.preventExtensions()`** メソッドはすでにプロパティが追加されたオブジェクトで、新しいプロパティを抑制します (すなわち、オブジェクトのさらなる拡張を抑制します)。

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

構文
--
```

Object.preventExtensions(obj)
```

### 引数

`obj`

拡張を不可能にしたいオブジェクトです。

### 返値

拡張不可能にされたオブジェクトです。

解説
--

新しいプロパティを追加できる場合、オブジェクトは拡張可能です。 `Object.preventExtensions()` はオブジェクトを拡張不可能と標示することで、その時点で持っているプロパティ以外のプロパティを持たせることを不可能にします。拡張不可能なオブジェクトのプロパティは通常、依然として*削除*できることに注意してください。拡張不可能なオブジェクトへ新たにプロパティを追加しようとしても、暗黙的あるいは `TypeError` エラーを発生させて失敗します (通常は strict mode (en-US) において、ただしこれに限定はされません)。

`Object.preventExtensions()` は、自身のプロパティの追加のみを抑制します。オブジェクトプロトタイプにプロパティを追加することは可能です。

このメソッドは対象の `[[prototype]]` を不変にし、それ以降のあらゆる `[[prototype]]` への再代入は `TypeError` を発生します。この動作は `[[prototype]]` 内部プロパティ固有のものであり、他のプロパティは変更可能なままです。

拡張可能なオブジェクトを拡張不可能にする方法はありますが、逆の方法はありません。

例
-

### Object.preventExtensions の使用

```js
// Object.preventExtensions は拡張不可能にしたオブジェクトを返します
var obj = {};
var obj2 = Object.preventExtensions(obj);
obj === obj2; // true

// 既定でオブジェクトは拡張可能です
var empty = {};
Object.isExtensible(empty); // === true

// この性質は変更できます
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// Object.defineProperty で拡張不可能なオブジェクトに
// 新しいプロパティを追加する際、エラーが発生します
var nonExtensible = { removable: true };
Object.preventExtensions(nonExtensible);
Object.defineProperty(nonExtensible, "new", {
  value: 8675309,
}); // TypeError が発生

// 厳格モードでは、拡張不可能なオブジェクトに
// 新たなプロパティを追加しようとすると TypeError が発生します
function fail() {
  "use strict";
  // TypeError が発生
  nonExtensible.newProperty = "FAIL";
}
fail();
```

拡張不可能なオブジェクトのプロトタイプは不変になります。

```js
var fixed = Object.preventExtensions({});
// TypeError が発生
fixed.__proto__ = { oh: "hai" };
```

### オブジェクト以外の型強制

ES5 では、このメソッドの引数がオブジェクトではない場合 (プリミティブの場合)、 `TypeError` が発生します。 ES2015 以降では、オブジェクトでない引数は、それが拡張不可能な通常のオブジェクトであるかのように扱われ、単にそれを返します。

```js
Object.preventExtensions(1);
// TypeError: 1 is not an object (ES5 code)

Object.preventExtensions(1);
// 1 (ES2015 code)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.preventextensions |

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

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

関連情報
----

* `Object.isExtensible()`
* `Object.seal()`
* `Object.isSealed()`
* `Object.freeze()`
* `Object.isFrozen()`
* `Reflect.preventExtensions()`


Object.hasOwn() - JavaScript

Object.hasOwn()
===============

**`Object.hasOwn()`** 静的メソッドは、指定されたオブジェクトが、指定されたプロパティを自身のプロパティとして持っている場合に `true` を返します。そのプロパティが継承されている場合、または存在しない場合、このメソッドは `false` を返します。

**メモ:** `Object.hasOwn()` 静的メソッドは `Object.hasOwnProperty()` インスタンスメソッドに代わるものとして意図されています。

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

構文
--

```js
hasOwn(instance, prop);
```

### 引数

`instance`

テストする JavaScript オブジェクトのインスタンス。

`prop`

テストするプロパティの名前の `String` または Symbol。

### 返値

指定されたオブジェクトが指定されたプロパティを直接定義している場合、`true` を返します。それ以外の場合は `false` を返します。

解説
--

**`Object.hasOwn()`** メソッドは、指定されたプロパティがオブジェクトの直接のプロパティである場合、そのプロパティ値が `null` または `undefined` であっても、`true` を返します。プロパティが継承されているか、またはまったく宣言されていない場合、このメソッドは `false` を返します。`in` 演算子とは異なり、このメソッドは、オブジェクトのプロトタイプチェーンで指定されたプロパティをチェックしません。

`Object.hasOwnProperty()` よりも推奨される理由は、`Object.create(null)` を使って作成したオブジェクトや、継承した `hasOwnProperty()` メソッドをオーバーライドしたオブジェクトに対して動作することです。これらの問題は、外部オブジェクトの `Object.prototype.hasOwnProperty()` を呼び出すことで回避できますが、`Object.hasOwn()` の方がより直感的に理解しやすいでしょう。

例
-

### hasOwn を使ってプロパティの存在を調べる

次のコードは、`example` オブジェクトに `prop` という名前のプロパティが含まれているかどうかを判断する方法を示しています。

```js
const example = {};
Object.hasOwn(example, "prop"); // false - 'prop' は定義されていない

example.prop = "exists";
Object.hasOwn(example, "prop"); // true - 'prop' は定義されている

example.prop = null;
Object.hasOwn(example, "prop"); // true - null として定義されている

example.prop = undefined;
Object.hasOwn(example, "prop"); // true - undefined として定義されている
```

### 直接のプロパティと継承されたプロパティ

以下の例では、直接のプロパティとプロトタイプチェーンを通じて継承されたプロパティを区別します。

```js
const example = {};
example.prop = "exists";

// `hasOwn` は直接のプロパティの場合のみ true を返す
Object.hasOwn(example, "prop"); // returns true
Object.hasOwn(example, "toString"); // returns false
Object.hasOwn(example, "hasOwnProperty"); // returns false

// `in` 演算子は直接または継承されたプロパティの場合に true を返す
"prop" in example; // returns true
"toString" in example; // returns true
"hasOwnProperty" in example; // returns true
```

### オブジェクトのプロパティの反復処理

オブジェクトの列挙可能なプロパティを反復処理するには、以下のようにします。

```js
const example = { foo: true, bar: true };
for (const name of Object.keys(example)) {
  // …
}
```

もし `for...in` を使う必要がある場合には、`Object.hasOwn()` を使うことで継承されたプロパティをスキップすることができます。

```js
const example = { foo: true, bar: true };
for (const name in example) {
  if (Object.hasOwn(example, name)) {
    // …
  }
}
```

### 配列のインデックスが存在するかどうかを調べる

`Array` の要素は直接のプロパティとして定義されているので、`hasOwn()` メソッドで特定のインデックスが存在するかどうかを調べることができます。

```js
const fruits = ["Apple", "Banana", "Watermelon", "Orange"];
Object.hasOwn(fruits, 3); // true ('Orange')
Object.hasOwn(fruits, 4); // false - not defined
```

### hasOwnProperty の問題となるケース

このセクションでは、`hasOwn()` が `hasOwnProperty` に影響する問題から免れることを示します。まず、`hasOwnProperty()` が再実装されたオブジェクトで使用することができます。

```js
const foo = {
  hasOwnProperty() {
    return false;
  },
  bar: "The dragons be out of office",
};

if (Object.hasOwn(foo, "bar")) {
  console.log(foo.bar); //true - hasOwnProperty() が再実装されていても結果に影響しない
}
```

また、`Object.create(null)` を使って作成されたオブジェクトのテストにも使用することができます。これらは `Object.prototype` を継承していないため、`hasOwnProperty()` はアクセスできません。

```js
const foo = Object.create(null);
foo.prop = "exists";
if (Object.hasOwn(foo, "prop")) {
  console.log(foo.prop); //true - オブジェクトの作成方法に関係なく動作する
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.hasown |

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

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

関連情報
----

* Polyfill of `Object.hasOwn` in `core-js`
* `Object.hasOwnProperty()`
* プロパティの列挙可能性と所有権
* `Object.getOwnPropertyNames()`
* `for...in`
* `in` 演算子
* 継承とプロトタイプチェーン


Object.prototype.__lookupGetter__() - JavaScript

Object.prototype.\_\_lookupGetter\_\_()
=======================================

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

**`__lookupGetter__`** メソッドは、指定されたプロパティに結びつけられているゲッター関数を返します。

構文
--

```js
\_\_lookupGetter\_\_(sprop);
```

### 引数

`sprop`

ゲッター関数を返すプロパティの名前を表す文字列です。

### 返値

指定されたプロパティへのゲッターとしてバインドされている関数です。

解説
--

オブジェクトのプロパティに対してゲッター関数が定義されていても、そのプロパティを通してゲッター関数への参照を得ることはできません。そのプロパティは、ゲッター関数の返値を参照するからです。 `__lookupGetter__` を使うことで、そのゲッター関数への参照を得ることができます。

これは標準化された `Object.getOwnPropertyDescriptor()` と `Object.getPrototypeOf()` を使用する方法で行うことが可能になりました。

例
-

### プロパティゲッターを取得するための標準準拠の方法と標準外の方法

```js
var obj = {
  get foo() {
    return Math.random() > 0.5 ? "foo" : "bar";
  },
};

// 標準外かつ非推奨の方法
obj.\_\_lookupGetter\_\_("foo");
// (function() { return Math.random() > 0.5 ? 'foo' : 'bar'; })

// 標準準拠の方法
Object.getOwnPropertyDescriptor(obj, "foo").get;
// (function() { return Math.random() > 0.5 ? 'foo' : 'bar'; })
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_lookupGetter\_\_ |

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

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

関連情報
----

* `Object.prototype.__lookupGetter__` のポリフィルは `core-js` で利用できます
* `Object.prototype.__lookupSetter__()`
* `get` 演算子
* `Object.getOwnPropertyDescriptor()` と
 `Object.getPrototypeOf()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()`
* JavaScript ガイド: ゲッターとセッターの定義


Object.isSealed() - JavaScript

Object.isSealed()
=================

**`Object.isSealed()`** メソッドは、オブジェクトが封印されているかどうかを判定します。

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

構文
--
```

Object.isSealed(obj)
```

### 引数

`obj`

確認したいオブジェクトです。

### 返値

与えられたオブジェクトが封印されているかどうかを示す `Boolean`。

解説
--

オブジェクトが封印されている場合は `true` が、そうでない場合は `false` が返ります。オブジェクトが拡張不可かつすべてのプロパティが設定変更不可であり、それゆえ削除できない場合 (ただし書き込み不可である必要はありません) 場合に、封印されているとなります。

例
-

### Object.isSealed の使用

```js
// 既定でオブジェクトは封印されていません
var empty = {};
Object.isSealed(empty); // === false

// 空のオブジェクトを拡張不可にすると、
// そのまま封印状態になります
Object.preventExtensions(empty);
Object.isSealed(empty); // === true

// 空でないオブジェクトでは、そのプロパティをすべて設定変更不可にしない限り
// 上記と同じにはなりません
var hasProp = { fee: "fie foe fum" };
Object.preventExtensions(hasProp);
Object.isSealed(hasProp); // === false

// そこですべてのプロパティを設定変更不可にすると、
// オブジェクトは封印状態になります
Object.defineProperty(hasProp, "fee", {
  configurable: false,
});
Object.isSealed(hasProp); // === true

// オブジェクトを封印する最も簡単な方法は、
// もちろん Object.seal です
var sealed = {};
Object.seal(sealed);
Object.isSealed(sealed); // === true

// 封印されたオブジェクトはその定義により、拡張できません
Object.isExtensible(sealed); // === false

// 封印されたオブジェクトは凍結されているかも
// しれませんが、必ずしもそうではありません
Object.isFrozen(sealed); // === true
// すべてのプロパティが書き込み不能でもあります

var s2 = Object.seal({ p: 3 });
Object.isFrozen(s2); // === false
// "p" は依然書き込み可能です

var s3 = Object.seal({
  get p() {
    return 0;
  },
});
Object.isFrozen(s3); // === true
// アクセサプロパティでは設定変更が可能かという事柄だけになります
```

### オブジェクト以外の型強制

ES5 では、このメソッドの引数がオブジェクトではない場合 (プリミティブの場合)、 `TypeError` が発生します。 ES2015 以降では、オブジェクトでない引数は、それが封印された通常のオブジェクトであるかのように扱われ、単に `true` それを返します。

```js
Object.isSealed(1);
// TypeError: 1 is not an object (ES5 code)

Object.isSealed(1);
// true (ES2015 code)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.issealed |

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

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

関連情報
----

* `Object.seal()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.freeze()`
* `Object.isFrozen()`


Object.prototype.hasOwnProperty() - JavaScript

Object.prototype.hasOwnProperty()
=================================

**`hasOwnProperty()`** メソッドは、オブジェクト自身が（継承されていない）指定されたプロパティを持っているかどうかを示す真偽値を返します。

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

構文
--
```

obj.hasOwnProperty(prop)
```

### 引数

*prop*

テストするプロパティの名前の `String` または Symbol 。

### 返値

`Boolean` で、オブジェクトが指定されたプロパティを自身のプロパティとして持っているかどうかを示す

解説
--

`Object` のすべての子孫は `hasOwnProperty` メソッドを継承しています。このメソッドはあるオブジェクトが指定されたプロパティを、そのオブジェクトの直接のプロパティとして持っているかどうかを特定するのに使うことができます。 `in` 演算子とは異なり、このメソッドはオブジェクトのプロトタイプチェーンをたどってチェックしません。 `Object` が `Array` の場合、 `hasOwnProperty` メソッドはある添字が存在するかどうかを調べることができます。

注
-

`hasOwnProperty` はプロパティの値が `null` または `undefined` であっても true を返します。

```js
o = new Object();
o.propOne = null;
o.hasOwnProperty("propOne"); // true を返す
o.propTwo = undefined;
o.hasOwnProperty("propTwo"); // true を返す
```

例
-

### hasOwnProperty を使ってプロパティの存在を調べる

オブジェクト `o` が `prop` という名前のプロパティを持っているかどうかを特定する例を以下に示します。

```js
o = new Object();
o.hasOwnProperty("prop"); // false を返す
o.prop = "exists";
o.hasOwnProperty("prop"); // true を返す
```

### 直接のプロパティと継承されたプロパティ

以下の例では、直接のプロパティとプロトタイプチェーンを通じて継承されたプロパティを区別します。

```js
o = new Object();
o.prop = "exists";
o.hasOwnProperty("prop"); // true を返す
o.hasOwnProperty("toString"); // false を返す
o.hasOwnProperty("hasOwnProperty"); // false を返す
```

### オブジェクトのプロパティの反復処理

以下の例では、継承されたプロパティを除いてオブジェクトのプロパティを反復処理する方法を示します。なお、 `for...in` ループですでに列挙可能なアイテムのみが反復処理されるので、 `hasOwnProperty` 自体は列挙可能なアイテムに厳密に限定されているため、ループ内に列挙できないプロパティが見られないことに基づいて想定するべきではありません (`Object.getOwnPropertyNames()` のように)。

```js
var buz = {
  fog: "stack",
};

for (var name in buz) {
  if (buz.hasOwnProperty(name)) {
    console.log("this is fog (" + name + ") for sure. Value: " + buz[name]);
  } else {
    console.log(name); // toString or something else
  }
}
```

### プロパティ名としての hasOwnProperty の使用

JavaScript は `hasOwnProperty` というプロパティ名を保護していません。したがって、オブジェクトがこの名前のプロパティを持っている場合が存在すれば、正しい結果を得るためには*外部の* `hasOwnProperty` を使用する必要があります。

```js
var foo = {
  hasOwnProperty: function () {
    return false;
  },
  bar: "Here be dragons",
};

foo.hasOwnProperty("bar"); // 常に false を返す

// 別な Object の hasOwnProperty 使用して、
// this を foo に設定して呼び出す
({}).hasOwnProperty.call(foo, "bar"); // true

// この目的では、 Object プロトタイプの hasOwnProperty プロパティを
// 使用することもできます。
Object.prototype.hasOwnProperty.call(foo, "bar"); // true
```

なお、後者の場合は新しくオブジェクトを生成しません。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.hasownproperty |

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

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

関連情報
----

* プロパティの列挙可能性と所有権 (en-US)
* `Object.getOwnPropertyNames()`
* `for...in`
* `in`
* 継承とプロトタイプチェーン