recursal/MDN huggingface dataset:
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()
=======================

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

**`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
=======================

**`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() コンストラクター
=================

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

**`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.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()
=================

**`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.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.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()
=================

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

**`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`
* 継承とプロトタイプチェーン