recursal/MDN huggingface dataset:
Object.prototype.valueOf()
==========================

**`valueOf()`** メソッドは、指定されたオブジェクトのプリミティブな値を返します。

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

構文
--
```

object.valueOf()
```

### 返値

指定されたオブジェクトのプリミティブ値を返します。

**メモ:** (単項) プラス符号を `valueOf` の省略形として使用することができる場合があります。例えば、 `+new Number()` などです。単項プラスの使用も参照してください。

解説
--

JavaScript は `valueOf` メソッドを、オブジェクトをプリミティブな値に変換するときに呼び出します。あなたが自分で `valueOf` メソッドを実行する必要はほとんどなく、プリミティブな値が期待される場面にオブジェクトが出くわしたとき JavaScript が自動的に実行します。

既定で、 `valueOf` メソッドは `Object` の子孫にあたるあらゆるオブジェクトに継承されています。全ての組み込みコアオブジェクトは適切な値を返すためにこのメソッドを上書きしています。もしオブジェクトがプリミティブな値を持たない場合、 `valueOf` はオブジェクト自身を返します。

あなたのコードで組み込みオブジェクトをプリミティブな値にするために `valueOf` を呼ぶことができます。また、カスタムオブジェクトを作成した時に `Object.prototype.valueOf()` を上書きしてデフォルトの `Object` のメソッドの代わりにカスタムメソッドを呼び出すようにすることができます。

### カスタムオブジェクトでの valueOf の上書き

既定の `valueOf` メソッドに代わって呼び出される関数を作ることができます。その関数は引数を取ってはなりません。

`MyNumberType` というオブジェクト型があって、それに `valueOf` メソッドを作りたいとしましょう。以下のコードはユーザー定義関数をオブジェクトの `valueOf` メソッドに代入しています。


```js
MyNumberType.prototype.valueOf = function () {
  return customPrimitiveValue;
};
```


上のコードにより、 `MyNumberType` 型のオブジェクトがプリミティブな値で表されるべき文脈では常に、 JavaScript は自動的に上のコードで定義された関数を呼び出します。

オブジェクトの `valueOf` メソッドはたいてい JavaScript によって実行されますが、あなた自身も以下のように実行できます。


```js
myNumberType.valueOf();
```


**メモ:** 文字列型の文脈にあるオブジェクトは `toString()` メソッドを通じて変換されますが、これは `String` オブジェクトが `valueOf` を使って文字列型に変換されるのとは違います。すべてのオブジェクトは、 "`[object type]`" としか出力されないかもしれませんが、文字列変換できます。しかし多くのオブジェクトは数値や真偽値や関数には変換できません。

例
-

### カスタム型での valueOf の使用


```js
function MyNumberType(n) {
  this.number = n;
}

MyNumberType.prototype.valueOf = function () {
  return this.number;
};

var myObj = new MyNumberType(4);
myObj + 3; // 7
```

### 単項プラスの使用


```js
+"5"; // 5 (文字列から数値へ)
+""; // 0 (文字列から数値へ)
+"1 + 2"; // NaN (評価不能)
+new Date(); // (new Date()).getTime() と同じ
+"foo"; // NaN (文字列から数値へ)
+{}; // NaN
+[]; // 0 (toString() は空の文字列リストを返す)
+[1]; // 1
+[1, 2]; // NaN
+new Set([1]); // NaN
+BigInt(1); // Uncaught TypeError: Cannot convert a BigInt value to a number
+undefined; // NaN
+null; // 0
+true; // 1
+false; // 0
```

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.toString()`
* `parseInt()`
* `Symbol.toPrimitive`
Object.seal()
=============

**`Object.seal()`** メソッドは、オブジェクトを封印して、新しいオブジェクトを追加することを抑制し、すべての既存のプロパティを設定変更不可にします。現存するプロパティの値は、書き込み可能である限り変更できます。

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

構文
--
```

Object.seal(obj)
```

### 引数

`obj`

封印するオブジェクトです。

### 返値

封印されたオブジェクトです。

解説
--

既定では、オブジェクトは拡張可能 (新しいプロパティを追加できる状態) です。オブジェクトを封印することで、新しいオブジェクトの追加を抑制し、すべての既存のプロパティを設定変更を不可にします。これは、オブジェクトにあるプロパティ一式を固定かつ不変にする効果があります。プロパティを設定変更不可にすることで、データプロパティからアクセサプロパティへの変換やその逆を抑制しますが、データプロパティの値の変更は抑制しません。封印されたオブジェクトでプロパティの削除や追加、あるいはデータプロパティからアクセサプロパティへの変換およびその逆を試みると、暗黙的あるいは `TypeError` エラーを発生させて (もっとも一般的には strict mode において、ただしこれに限定はされません) 失敗します。

プロトタイプチェインには手をつけず、そのままにします。ただし、`Object.prototype.__proto__` プロパティは同様に封印されます。

### Object.freeze() との比較

`Object.freeze()` で凍結されたオブジェクトに存在するプロパティは不変になります。 `Object.seal()` で封印されたオブジェクトに存在するプロパティを変更することができます。

例
-

### Object.seal の使用


```js
var obj = {
  prop: function () {},
  foo: "bar",
};

// 新しいプロパティは追加でき、既存のプロパティは変更や削除ができます。
obj.foo = "baz";
obj.lumpy = "woof";
delete obj.prop;

var o = Object.seal(obj);

o === obj; // true
Object.isSealed(obj); // true

// 封印されたオブジェクトで、プロパティの値の変更は依然としてできます。
obj.foo = "quux";

// しかし、データプロパティからアクセサプロパティの変換やその逆はできません。
Object.defineProperty(obj, "foo", {
  get: function () {
    return "g";
  },
}); // TypeError が発生

// プロパティの値の変更を除き、あらゆる変更が失敗します。
obj.quaxxor = "the friendly duck";
// 暗黙的にプロパティは追加されません。
delete obj.foo;
// 暗黙的にプロパティは削除されません。

// また、 strict モードではこれらの試みに対して TypeErrors が発生します。
function fail() {
  "use strict";
  delete obj.foo; // TypeError が発生
  obj.sparky = "arf"; // TypeError が発生
}
fail();

// Object.defineProperty を用いて追加しようとしてもエラーが発生します
Object.defineProperty(obj, "ohai", {
  value: 17,
}); // TypeError が発生
Object.defineProperty(obj, "foo", {
  value: "eit",
}); // 既存のプロパティの値を変更
```

### 非オブジェクトの強制

ES5 では、このメソッドへの引数がオブジェクトではない場合 (プリミティブである場合)、 `TypeError` になります。 ES2015 では、オブジェクトではない引数は封印された通常のオブジェクトと同様に扱われ、単純にそれを返します。


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

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

仕様書
---

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

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

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

関連情報
----

* `Object.isSealed()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.freeze()`
* `Object.isFrozen()`
Object.prototype.\_\_defineGetter\_\_()
=======================================

**警告:** この機能は非推奨となり、オブジェクト初期化子の構文または `Object.defineProperty()` API を使用してゲッターを定義する方法で置き換えられました。この機能は広く実装されていますが、古い使い方であるために ECMAScript 仕様書で非推奨となっています。よりよい代替策が存在するので、このメソッドを使用しないでください。

**`__defineGetter__`** メソッドは、オブジェクトのプロパティと関数を結び付け、そのプロパティが参照されるときに呼び出されるようにします。

構文
--


```js
\_\_defineGetter\_\_(prop, func);
```

### 引数

`prop`

関数と結びつけるプロパティの名前を表す文字列です。

`func`

プロパティの値を参照するときに呼び出される関数です。

### 返値

`undefined` です。

解説
--

`__defineGetter__` を使用することで、既存のオブジェクトにゲッターを定義することができます。

例
-

### 標準外かつ非推奨の方法


```js
var o = {};
o.\_\_defineGetter\_\_("gimmeFive", function () {
  return 5;
});
console.log(o.gimmeFive); // 5
```

### 標準準拠の方法


```js
// get 演算子を使用
var o = {
  get gimmeFive() {
    return 5;
  },
};
console.log(o.gimmeFive); // 5

// Object.defineProperty を使用
var o = {};
Object.defineProperty(o, "gimmeFive", {
  get: function () {
    return 5;
  },
});
console.log(o.gimmeFive); // 5
```

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.__defineGetter__` のポリフィルは `core-js` で利用できます
* `Object.prototype.__defineSetter__()`
* `get` 演算子
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()`
* `Object.prototype.__lookupSetter__()`
* JavaScript ガイド: ゲッターとセッターの定義
* [Blog
Post] Deprecation of \_\_defineGetter\_\_ and \_\_defineSetter\_\_
* Firefox バグ 647423
Object.values()
===============

**`Object.values()`** メソッドは、指定されたオブジェクトが持つ列挙可能なプロパティの値を、 `for...in` ループで提供される場合と同じ順序で配列にして返します。 (違いは、 `for...in` ループではプロパティチェーン上のプロパティも同様に列挙するという点だけです。)

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

構文
--


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

### 引数

`obj`

返値となる列挙可能な自身のプロパティの値を持つオブジェクト。

### 返値

与えられたオブジェクトが所有する列挙可能なプロパティの値が入った配列。

解説
--

`Object.values()` は、`object` に直接存在する列挙可能な値が配列要素の文字列に対応した配列を返します。プロパティの順序はマニュアル操作でオブジェクト内のプロパティに対してループさせた時の順序と同じになります。

ポリフィル
-----

`Object.values` をネイティブで対応していない古い環境に対応するために、 tc39/proposal-object-values-entries や es-shims/Object.values などのリポジトリーにポリフィルがあります。

例
-

### Object.values の使用


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

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

// ランダムなキー順序を持つ配列風オブジェクト
// 数値のキーを使用すると、値はキーの番号順に返される
const arrayLikeObj2 = { 100: "a", 2: "b", 7: "c" };
console.log(Object.values(arrayLikeObj2)); // ['b', 'c', 'a']

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

// オブジェクトでない引数はオブジェクトへと型強制される
console.log(Object.values("foo")); // ['f', 'o', 'o']
```

仕様書
---

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

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

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

関連情報
----

* `Object.values` のポリフィルが `core-js` にあります
* プロパティの列挙可能性と所有権
* `Object.keys()`
* `Object.entries()`
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
Object.keys()
=============

**`Object.keys()`** メソッドは、指定されたオブジェクトが持つプロパティの **名前**の配列を、通常のループで取得するのと同じ順序で返します。

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

構文
--
```

Object.keys(obj)
```

### 引数

`obj`

自身の列挙可能なプロパティが返されるオブジェクトです。

### 返値

与えられたオブジェクトのすべての列挙可能なプロパティを表す文字列の配列。

解説
--

`Object.keys()` は、`object` で直接発見された列挙可能なプロパティに対応する文字列を要素とする配列を返します。プロパティの順序は、オブジェクトのプロパティをループにより手動で取得した場合と同じです。

例
-

### Object.keys の使用


```js
// 単純な配列
const arr = ["a", "b", "c"];
console.log(Object.keys(arr)); // console: ['0', '1', '2']

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

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

// getFoo は列挙可能ではないプロパティ
const myObj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
    },
  },
);
myObj.foo = 1;
console.log(Object.keys(myObj)); // console: ['foo']
```


列挙可能ではないものを含むすべてのプロパティを取得したい場合、`Object.getOwnPropertyNames()` をご覧ください。

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

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

ES2015 以降では、オブジェクトでない引数はオブジェクトへ変換されるようになりました。


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

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

ポリフィル
-----

`Object.keys` にネイティブに対応していない環境向けに互換性を確保するには、以下のコード部品をコピーしてください。


```js
// From https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global\_Objects/Object/keys
if (!Object.keys) {
  Object.keys = (function () {
    "use strict";
    var hasOwnProperty = Object.prototype.hasOwnProperty,
      hasDontEnumBug = !{ toString: null }.propertyIsEnumerable("toString"),
      dontEnums = [
        "toString",
        "toLocaleString",
        "valueOf",
        "hasOwnProperty",
        "isPrototypeOf",
        "propertyIsEnumerable",
        "constructor",
      ],
      dontEnumsLength = dontEnums.length;

    return function (obj) {
      if (
        typeof obj !== "function" &&
        (typeof obj !== "object" || obj === null)
      ) {
        throw new TypeError("Object.keys called on non-object");
      }

      var result = [],
        prop,
        i;

      for (prop in obj) {
        if (hasOwnProperty.call(obj, prop)) {
          result.push(prop);
        }
      }

      if (hasDontEnumBug) {
        for (i = 0; i < dontEnumsLength; i++) {
          if (hasOwnProperty.call(obj, dontEnums[i])) {
            result.push(dontEnums[i]);
          }
        }
      }
      return result;
    };
  })();
}
```


上記のコードは IE7 において (もしかすると IE8 でも)、他のウィンドウから渡されたオブジェクトの場合、列挙不可能な key を含むことに注意してください。

より簡単なブラウザーのポリフィルについては、Javascript - Object.keys Browser Compatibility をご覧ください。

仕様書
---

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

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

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

関連情報
----

* 列挙可能性とプロパティの所有権
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
* `Object.values()`
* `Object.entries()`
Object.prototype.isPrototypeOf()
================================

**`isPrototypeOf()`** メソッドは、オブジェクトが別のオブジェクトのプロトタイプチェーンに存在するかどうかを判定します。

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

**メモ:** `isPrototypeOf()` は、`instanceof` 演算子とは異なります。"`object instanceof AFunction`" 式では、`object` のプロトタイプチェーンは `AFunction` 自身ではなく、`AFunction.prototype` に対して判定されます。

構文
--
```

prototypeObj.isPrototypeOf(object)
```

### 引数

`object`

プロトタイプチェーンの検索対象。

### 返値

呼び出されたオブジェクトがプロトタイプチェーン内に指定されたオブジェクトを持つかどうかを示す `Boolean`。

### 発生するエラー

`TypeError`

`prototypeObj` が undefined か null の場合、`TypeError` 発生する

解説
--

`isPrototypeOf()` を用いると、オブジェクトが別のオブジェクト内のプロトタイプチェーンに存在するかどうかをチェックする事ができます。

例
-

### isPrototypeOf の使用

この例は、`baz` オブジェクトのプロトタイプチェーンに、`Baz.prototype` と `Bar.prototype`、`Foo.prototype`、`Object.prototype` が存在しているデモです。


```js
function Foo() {}
function Bar() {}
function Baz() {}

Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);

var baz = new Baz();

console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true
```


`isPrototypeOf()` メソッドは、`instanceof` 演算子と同様に、特定のプロトタイプチェーンから継承されたオブジェクトを扱うときにのみ機能するコードを持つ場合、たとえばそのオブジェクトに特定のメソッドやプロパティが存在することを保証する場合に特に便利です。

たとえば、`baz` オブジェクトが `Foo.prototype` に由来しているか検証してみます:


```js
if (Foo.prototype.isPrototypeOf(baz)) {
  // do something safe
}
```

仕様書
---

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

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

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

関連情報
----

* `instanceof`
* `Object.getPrototypeOf()`
* `Object.setPrototypeOf()`
* `Object.prototype.__proto__`
Object.prototype.propertyIsEnumerable()
=======================================

**`propertyIsEnumerable()`** メソッドは、指定されたプロパティが列挙可能で、かつオブジェクト自身のプロパティであるかどうかを示す論理値を返します。

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

構文
--


```js
propertyIsEnumerable(prop);
```

### 引数

`prop`

調べたいプロパティの名前です。

### 返値

`true` または `false` の値で、指定されたプロパティが列挙可能であり、かつオブジェクト自身のプロパティであるかどうかを示します。

解説
--

すべてのオブジェクトは `propertyIsEnumerable` メソッドを持っています。このメソッドはあるオブジェクトのプロパティが、プロトタイプチェーンを通じて継承されたプロパティを除いて `for...in` ループで列挙可能かどうかを特定することができます。もしオブジェクトが指定されたプロパティを持っていない場合、このメソッドは `false` を返します。

**メモ:** 列挙可能なプロパティは `for...in` ループで反復処理されますが、 `Symbol` は含まれないことに留意してください。

例
-

### `propertyIsEnumerable` の基本的な使い方

以下の例はオブジェクトと配列での `propertyIsEnumerable` の使い方を示しています。


```js
var o = {};
var a = [];
o.prop = "is enumerable";
a[0] = "is enumerable";

o.propertyIsEnumerable("prop"); // true を返す
a.propertyIsEnumerable(0); // true を返す
```

### ユーザー定義オブジェクトと組み込みオブジェクト

以下の例は、ユーザー定義プロパティと組み込みプロパティの列挙可能性を実証しています。


```js
var a = ["is enumerable"];

a.propertyIsEnumerable(0); // true を返す
a.propertyIsEnumerable("length"); // false を返す

Math.propertyIsEnumerable("random"); // false を返す
this.propertyIsEnumerable("Math"); // false を返す
```

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


```js
var a = [];
a.propertyIsEnumerable("constructor"); // false を返す

function firstConstructor() {
  this.property = "is not enumerable";
}

firstConstructor.prototype.firstMethod = function () {};

function secondConstructor() {
  this.method = function () {
    return "is enumerable";
  };
}

secondConstructor.prototype = new firstConstructor();
secondConstructor.prototype.constructor = secondConstructor;

var o = new secondConstructor();
o.arbitraryProperty = "is enumerable";

o.propertyIsEnumerable("arbitraryProperty"); // true を返す
o.propertyIsEnumerable("method"); // true を返す
o.propertyIsEnumerable("property"); // false を返す

o.property = "is enumerable";

o.propertyIsEnumerable("property"); // true を返す

// これらはすべて false を返します。これは、 (最後の 2 つは for-in で
// 反復処理可能であるにもかかわらず) propertyIsEnumerable が考慮しない
// プロトタイプであるためです。
o.propertyIsEnumerable("prototype"); // false を返す (as of JS 1.8.1/FF3.6)
o.propertyIsEnumerable("constructor"); // false を返す
o.propertyIsEnumerable("firstMethod"); // false を返す
```

仕様書
---

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

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

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

関連情報
----

* 列挙可能性とプロパティの所有権
* `for...in`
* `Object.keys()`
* `Object.defineProperty()`
Object.is()
===========

**`Object.is()`** は静的メソッドで、 2 つの値が同一値であるかどうかを判定します。

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

構文
--


```js
Object.is(value1, value2)
```

### 引数

`value1`

比較する 1 つ目の値。

`value2`

比較する 2 つ目の値。

### 返値

論理値で、 2 つの引数が同一値であるかどうかを表します。

解説
--

`Object.is()` は 2 つの値が同一値であるかどうかを判定します。2 つの値が以下の規則の一つに当てはまる場合に同一となります。

* どちらも `undefined`
* どちらも `null`
* どちらも `true` かどちらも `false`
* どちらも同じ文字群が同じ順で並ぶ同じ長さの文字列
* どちらも同じオブジェクト（すなわち両方の値がメモリー内の同じオブジェクトを参照）
* どちらも同じ数値の長整数
* どちらも同じシンボル値のシンボル
* どちらも数で、
    + どちらも `+0`
    + どちらも `-0`
    + どちらも `NaN`
    + あるいはどちらもゼロ以外で `NaN` でなく、同じ数値を持つ

`Object.is()` は `==` 演算子と等価ではありません。`==` 演算子は等価性比較の前に（同じ型でなければ）両辺に対して様々な型変換を適用します（結果、例えば `"" == false` は `true` と評価されます）が、`Object.is()` は両辺どちらの値にも型変換を行いません。

また、`Object.is()` は `===` 演算子とも同じでも*ありません*。`Object.is()` と `===` の唯一の違いは、符号付きのゼロと `NaN` の扱です。`===` 演算子は（そして `==` 演算子も）数値 `-0` と `+0` は同じものとして扱う一方、`NaN` は異なるものとして扱います。

例
-

### Object.is() の使用


```js
// ケース 1: === を用いるのと同じ結果になる評価式
Object.is(25, 25); // true
Object.is("foo", "foo"); // true
Object.is("foo", "bar"); // false
Object.is(null, null); // true
Object.is(undefined, undefined); // true
Object.is(window, window); // true
Object.is([], []); // false
const foo = { a: 1 };
const bar = { a: 1 };
const sameFoo = foo;
Object.is(foo, foo); // true
Object.is(foo, bar); // false
Object.is(foo, sameFoo); // true

// ケース 2: 符号付きのゼロ
Object.is(0, -0); // false
Object.is(+0, -0); // false
Object.is(-0, -0); // true

// ケース 3: NaN
Object.is(NaN, 0 / 0); // true
Object.is(NaN, Number.NaN); // true
```

仕様書
---

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

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

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

関連情報
----

* `Object.is` のポリフィル (`core-js`)
* 等価性の比較と同一性 — 標準搭載されている 3 つの同一性比較支援機能の比較
Object.getOwnPropertyDescriptors()
==================================

**`Object.getOwnPropertyDescriptors()`** メソッドは、指定したオブジェクトのすべてのプロパティ記述子を返します。

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

構文
--
```

Object.getOwnPropertyDescriptors(obj)
```

### 引数

`obj`

すべてのプロパティディスクリプタを取得するオブジェクト。

### 返値

オブジェクトのすべてのプロパティ記述子を含むオブジェクト。プロパティがない場合、空オブジェクトの可能性がある。

説明
--

このメソッドは、オブジェクトのすべての独自のプロパティの正確な記述の検査を可能にします。 JavaScript では、*プロパティ*は文字列値による名前または `Symbol` とプロパティ記述子で構成されています。プロパティ記述子の型と属性についての詳細情報は、`Object.defineProperty()` で確認してください。

*プロパティディスクリプタ* は、次の属性のいくつかを持ちます。

`value`

プロパティに関連づけられた値です (データディスクリプタのみ)。

`writable`

`true` である場合、プロパティに関連づけられた値は変更することができます (データ記述子のみ)。

`get`

プロパティのゲッターとして提供する関数、あるいはゲッターがない場合は `undefined` です (アクセサ記述子のみ)。

`set`

プロパティのセッターとして提供する関数、あるいはセッターがない場合は `undefined` です (アクセサ記述子のみ)。

`configurable`

`true` である場合、この種の記述子を変更することや、対応するオブジェクトからプロパティを削除することができます。

`enumerable`

`true` である場合、このプロパティは対応するオブジェクトでのプロパティ列挙に現れます。

例
-

### 浅いコピーの生成

`Object.assign()` メソッドは、ソースオブジェクトから対象のオブジェクトに対して enumerable とプロパティのみコピーできる一方、2 つの未知のオブジェクト間の浅いコピーのために、このメソッドと `Object.create()` を使用できます：


```js
Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj),
);
```

### サブクラスの作成

サブクラスを作成する通常の方法は、サブクラスを定義し、そのプロトタイプをスーパークラスのインスタンスに設定し、そのインスタンスにプロパティを定義することです。これは特にセッターやゲッターが無骨になることがあります。代わりに、プロトタイプを設定するためにこのコードを使用することもできます。


```js
function superclass() {}
superclass.prototype = {
  // Define your methods and properties here
};
function subclass() {}
subclass.prototype = Object.create(superclass.prototype, {
  // Define your methods and properties here
});
```

仕様書
---

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

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

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

関連情報
----

* `Object.getOwnPropertyDescriptor()`
* `Object.defineProperty()`
* Polyfill
Object.getOwnPropertyDescriptor()
=================================

**`Object.getOwnPropertyDescriptor()`** メソッドは、与えられたオブジェクトの特定のプロパティ (すなわち、あるオブジェクトの直接の表現であり、オブジェクトのプロトタイプチェーン内のものではない) の構成を記述したオブジェクトを返します。返されるオブジェクトは変更可能ですが、変更しても元のプロパティの構成には影響を与えません。

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

構文
--


```js
Object.getOwnPropertyDescriptor(obj, prop);
```

### 引数

`obj`

プロパティの確認を行うオブジェクトです。

`prop`

記述を受け取るプロパティの名前または `Symbol` です。

### 返値

指定したプロパティがオブジェクトにある場合は、プロパティ記述子で、それ以外の場合は `undefined` です。

解説
--

このメソッドで、プロパティの正確な定義を確認することができます。 JavaScript の*プロパティ*は、文字列値の名前または `Symbol` とプロパティ記述子から成ります。プロパティ記述子およびその属性についての詳細情報は、 `Object.defineProperty()` にあります。

*プロパティ記述子*は、以下の属性のいくつかを記録したものです。

`value`

プロパティに関連づけられた値です (データ記述子のみ)。

`writable`

`true` である場合、プロパティに関連づけられた値は変更することができます (データ記述子のみ)。

`get`

プロパティのゲッターとして提供する関数、あるいはゲッターがない場合は `undefined` です (アクセサー記述子のみ)。

`set`

プロパティのセッターとして提供する関数、あるいはセッターがない場合は `undefined` です (アクセサー記述子のみ)。

`configurable`

`true` である場合、この種の記述子を変更することや、対応するオブジェクトからプロパティを削除することができます。

`enumerable`

`true` である場合、このプロパティは対応するオブジェクトでのプロパティ列挙に現れます。

例
-

### Object.getOwnPropertyDescriptor の使用


```js
var o, d;

o = {
  get foo() {
    return 17;
  },
};
d = Object.getOwnPropertyDescriptor(o, "foo");
// d is {
// configurable: true,
// enumerable: true,
// get: /\*the getter function\*/,
// set: undefined
// }

o = { bar: 42 };
d = Object.getOwnPropertyDescriptor(o, "bar");
// d is {
// configurable: true,
// enumerable: true,
// value: 42,
// writable: true
// }

o = { [Symbol.for("baz")]: 73 };
d = Object.getOwnPropertyDescriptor(o, Symbol.for("baz"));
// d is {
// configurable: true,
// enumerable: true,
// value: 73,
// writable: true
// }

o = {};
Object.defineProperty(o, "qux", {
  value: 8675309,
  writable: false,
  enumerable: false,
});
d = Object.getOwnPropertyDescriptor(o, "qux");
// d is {
// value: 8675309,
// writable: false,
// enumerable: false,
// configurable: false
// }
```

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

ECMAScript 5 では、このメソッドへの最初の引数がオブジェクトでない (プリミティブである) 場合は、 `TypeError` が発生します。 ECMAScript 2015 では、最初の引数がオブジェクトでなくても、最初に強制的にオブジェクトに変換します。


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

Object.getOwnPropertyDescriptor("foo", 0);
// Object returned by ES2015 code: {
// configurable: false,
// enumerable: true,
// value: "f",
// writable: false
// }
```

仕様書
---

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

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

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

関連情報
----

* `Object.defineProperty()`
* `Reflect.getOwnPropertyDescriptor()`
Object.isExtensible()
=====================

**`Object.isExtensible()`** メソッドは、オブジェクトが拡張可能であるか (新しいプロパティを追加することができるかどうか) を判定します。

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

構文
--
```

Object.isExtensible(obj)
```

### 引数

`obj`

チェックするオブジェクトです。

### 返値

`Boolean` で、与えられたオブジェクトが拡張可能であるかどうかを示します。

解説
--

オブジェクトは既定では拡張可能です。つまり、新しいプロパティの追加が可能であり、`Object.prototype.__proto__` のプロパティに対応しているエンジンでは) `__proto__` プロパティを変更することができます。オブジェクトは `Object.preventExtensions()`, `Object.seal()`, `Object.freeze()` の何れかを用いる事で拡張不能に設定する事が可能です。

例
-

### Object.isExtensible の使用


```js
// 新規のオブジェクトは拡張可能
var empty = {};
Object.isExtensible(empty); // === true

// その設定は変える事が可能
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// seal メソッドで封印されたオブジェクトは拡張不可と定義される
var sealed = Object.seal({});
Object.isExtensible(sealed); // === false

// freeze メソッドで凍結されたオブジェクトも拡張不可と定義される
var frozen = Object.freeze({});
Object.isExtensible(frozen); // === false
```

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

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


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

Object.isExtensible(1);
// false (ES2015 code)
```

仕様書
---

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

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

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

関連情報
----

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