Object.defineProperty() - JavaScript

Object.defineProperty()
=======================

静的メソッドの **`Object.defineProperty()`** は、あるオブジェクトに新しいプロパティを直接定義したり、オブジェクトの既存のプロパティを変更したりして、そのオブジェクトを返します。

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

構文
--

```js
Object.defineProperty(obj, prop, descriptor);
```

### 引数

`obj`

プロパティを定義するオブジェクトです。

`prop`

定義または変更するプロパティの名前または `Symbol` です。

`descriptor`

定義または変更するプロパティの記述子です。

### 返値

この関数に渡されたオブジェクトをそのまま返します。

解説
--

このメソッドで、あるオブジェクトのプロパティを明示的に追加または変更することができます。代入による通常のプロパティ追加では、プロパティ列挙 (`for...in` ループや `Object.keys` メソッド) に現れ、値は変更可能で、また削除も可能なプロパティが生成されます。このメソッドでは、これらの詳細事項を既定値から変えることが可能です。既定では、`Object.defineProperty()` を使って追加された値は不変になります。

プロパティの記述子は、データ記述子とアクセサー記述子の二つに分かれます。**データ記述子**は値を持つプロパティで、その値は書き換え可能にも不可能にもできます。**アクセサー記述子**は、関数のゲッターとセッターの組で表されるプロパティです。記述子はこれら二種類のどちらかでなければならず、両方になることはできません。

どちらの形でも記述子はオブジェクトで表現します。共通して以下のオプションのキーを持つことができます (注: ここでいう**既定値**とは、`Object.defineProperty()` を使ってプロパティを定義する場合です)。

`configurable`

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

`enumerable`

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

**データ記述子**は以下のオプションキーも持ちます。

`value`

プロパティに関連づけられた値です。有効な JavaScript の値 (number, object, function など) である必要があります。
**既定値は `undefined` です。**

`writable`

`true` である場合のみ、プロパティに関連づけられた値は代入演算子で変更することができます。
**既定値は `false` です。**

**アクセサー記述子**の場合はオプションとして次のキーも持つことができます。

`get`

 プロパティのゲッターとなる関数で、ゲッターを設けない場合は `undefined` です。プロパティにアクセスするとこの関数が引数なしでコールされます。この関数内で `this` はアクセスしようとしたプロパティを持つオブジェクトになります (プロパティを定義するために作成した記述子オブジェクトではありません)。返値はこのプロパティの値として使われます。
 **既定値は `undefined` です。**

`set`

 プロパティのセッターとなる関数で、セッターがない場合は `undefined` です。プロパティに値が割り当てられたとき、その値を引数としてこの関数がコールされます。この関数内で `this` は割り当てようとしたプロパティを持つオブジェクトになります。
 **既定値は `undefined` です。**

記述子に `value`, `writable`, `get`, `set` のいずれのキーもない場合、データ記述子として扱われます。記述子に `value` または `writable` と、`get` または `set` のキーの両方がある場合は、例外が発生します。

これらのキーは必ずしも記述子が直接所有しているとは限らないことに留意してください。継承されたプロパティも同様です。これらの既定値が存在することを保証するには、先行して `Object` を凍結しておくか、すべてのオプションを明示的に指定するか、`Object.create(null)` で `null` に設定するかします。

```js
// \_\_proto\_\_ を使うやり方
var obj = {};
var descriptor = Object.create(null); // 意図しないキーの継承を防止します。
descriptor.value = "static";

// 既定で継承不可、変更不可、書換不可のプロパティとなります。
Object.defineProperty(obj, "key", descriptor);

// 明示的な指定
Object.defineProperty(obj, "key", {
  enumerable: false,
  configurable: false,
  writable: false,
  value: "static",
});

// 同じオブジェクトを再利用
function withValue(value) {
  var d =
    withValue.d ||
    (withValue.d = {
      enumerable: false,
      writable: false,
      configurable: false,
      value: value,
    });

  // 値の代入で重複操作を防ぐ
  if (d.value !== value) d.value = value;

  return d;
}
// このように使います。
Object.defineProperty(obj, "key", withValue("static"));

// freeze が利用できるなら、オブジェクトのプロトタイプのプロパティ
// (value, get, set, enumerable, writable, configurable) を
// 追加・削除することを防ぐことができます。
(Object.freeze || Object)(Object.prototype);
```

例
-

### プロパティの作成

オブジェクトに指定されたプロパティが存在しないとき、`Object.defineProperty()` は指定された形で新たなプロパティを生成します。記述子のキーは省略することができ、そのようなキーには既定値が適用されます。

```js
var o = {}; // 新しいオブジェクトの生成

// データ記述子により、defineProperty を用いて
// オブジェクトプロパティを追加する例
Object.defineProperty(o, "a", {
  value: 37,
  writable: true,
  enumerable: true,
  configurable: true,
});
// o オブジェクトに 'a' プロパティが存在するようになり、その値は 37 となります

// アクセサー記述子により、defineProperty を用いて
// オブジェクトプロパティを追加する例
var bValue = 38;
Object.defineProperty(o, "b", {
  // メソッド名ショートハンドを利用しています(ES2015 の機能)。
  // 次のように書いているのと同じことです:
  // get: function() { return bValue; },
  // set: function(newValue) { bValue = newValue; },
  get() {
    return bValue;
  },
  set(newValue) {
    bValue = newValue;
  },
  enumerable: true,
  configurable: true,
});
o.b; // 38
// o オブジェクトに 'b' プロパティが存在するようになり、
// その値は 38 となります
// o.b は再定義されない限り、その値は常に bValue と同じです。

// (訳注:データとアクセサーを)両方を混在させることはできません:
Object.defineProperty(o, "conflict", {
  value: 0x9f91102,
  get() {
    return 0xdeadbeef;
  },
});
// TypeError が発生します。value はデータ記述子にのみ、
// get はアクセサー記述子にのみ存在していなければなりません。
```

### プロパティの変更

プロパティが既に存在している場合、`Object.defineProperty()` は記述子の値および現在のオブジェクトの設定に基づいて、プロパティの変更を試みます。元の記述子で `configurable` 属性が `false` なら、そのプロパティは「変更不可」です。変更不可のプロパティは記述子の属性を変更することができません。データプロパティで `writable` なら、値を変更することができますし、`writable` 属性を `true` から `false` に変更することができます。変更不可のプロパティはデータとアクセサーの種別を切り替えることはできません。

変更不可なプロパティに変更を加えようとすると、新旧の値が同じでない限り `TypeError` が発生します (可能な場合の `value` と `writable` の変更は除きます)。

#### writable 属性

`writable` プロパティ属性が `false` に設定されているとき、そのプロパティは「書き込み不可」になります。代入ができなくなります。

```js
var o = {}; // 新しいオブジェクトの生成

Object.defineProperty(o, "a", {
  value: 37,
  writable: false,
});

console.log(o.a); // 37 がログ出力されます
o.a = 25; // エラーは発生しません
// (strict モードでは発生します。同じ値を代入したとしても。)
console.log(o.a); // 37 がログ出力されます。代入文は動作しません。

// strict mode
(function () {
  "use strict";
  var o = {};
  Object.defineProperty(o, "b", {
    value: 2,
    writable: false,
  });
  o.b = 3; // TypeError がスローされます: "b" is read-only
  return o.b; // 上の行は動作せず 2 が返ります(訳注:正しくは「ここに制御は来ません」)
})();
```

例で見たように、書き込み不可のプロパティに書き込もうとしても変更されず、またエラーは発生しません。

#### enumerable 属性

`enumerable` プロパティ属性は、そのプロパティが `Object.assign()` や スプレッド演算子で採り上げられるかどうかを定義します。`Symbol` 以外のプロパティでは、 `for...in` ループや `Object.keys()` に現れるかどうかも定義します。

```js
var o = {};
Object.defineProperty(o, "a", {
  value: 1,
  enumerable: true,
});
Object.defineProperty(o, "b", {
  value: 2,
  enumerable: false,
});
Object.defineProperty(o, "c", {
  value: 3,
}); // enumerable の既定値は false
o.d = 4; // このようにプロパティを生成するとき、
// enumerable の既定値は true
Object.defineProperty(o, Symbol.for("e"), {
  value: 5,
  enumerable: true,
});
Object.defineProperty(o, Symbol.for("f"), {
  value: 6,
  enumerable: false,
});

for (var i in o) {
  console.log(i);
}
// 'a' と 'd' がログされます(順不同)

Object.keys(o); // ['a', 'd']

o.propertyIsEnumerable("a"); // true
o.propertyIsEnumerable("b"); // false
o.propertyIsEnumerable("c"); // false
o.propertyIsEnumerable("d"); // true
o.propertyIsEnumerable(Symbol.for("e")); // true
o.propertyIsEnumerable(Symbol.for("f")); // false

var p = { ...o };
p.a; // 1
p.b; // undefined
p.c; // undefined
p.d; // 4
p[Symbol.for("e")]; // 5
p[Symbol.for("f")]; // undefined
```

#### configurable 属性

`configurable` 属性は、プロパティをオブジェクトから削除できるかとプロパティの属性 (`value` と `writable` 以外) を変更できるかを同時に制御します。

```js
var o = {};
Object.defineProperty(o, "a", {
  get() {
    return 1;
  },
  configurable: false,
});

Object.defineProperty(o, "a", {
  configurable: true,
}); // TypeError が発生
Object.defineProperty(o, "a", {
  enumerable: true,
}); // TypeError が発生
Object.defineProperty(o, "a", {
  set() {},
}); // TypeError が発生 (set は未定義であった)
Object.defineProperty(o, "a", {
  get() {
    return 1;
  },
}); // TypeError が発生 (新たな get は全く同じであるにもかかわらず)
Object.defineProperty(o, "a", {
  value: 12,
}); // TypeError が発生 ('configurable' が false でも 'value' は変更できますが、ここでは 'get' アクセサーがあるため変更できません)

console.log(o.a); // logs 1
delete o.a; // 何も起きません
console.log(o.a); // logs 1
```

`o.a` の `configurable` 属性が `true` である場合、エラーが発生することなく最終的にプロパティが削除されます。

### プロパティおよび既定値の追加

属性の既定値がどう適用されるかを考えることは重要です。値の割り当てにドット表記を用いた場合と `Object.defineProperty()` を用いた場合とでは、以下の例で示したとおりに違いがあります。

```js
var o = {};

o.a = 1;
// これは以下と同じです。
Object.defineProperty(o, "a", {
  value: 1,
  writable: true,
  configurable: true,
  enumerable: true,
});

// その一方で、
Object.defineProperty(o, "a", { value: 1 });
// これは以下と同じです。
Object.defineProperty(o, "a", {
  value: 1,
  writable: false,
  configurable: false,
  enumerable: false,
});
```

### 独自のゲッターおよびセッター

例として自律的に記録を行うオブジェクトを作成してみます。`temperature` プロパティに値が代入されると、配列 `archive` に要素が一つ追加されます。

```js
function Archiver() {
  var temperature = null;
  var archive = [];

  Object.defineProperty(this, "temperature", {
    get() {
      console.log("get!");
      return temperature;
    },
    set(value) {
      temperature = value;
      archive.push({ val: temperature });
    },
  });

  this.getArchive = function () {
    return archive;
  };
}

var arc = new Archiver();
arc.temperature; // 'get!'
arc.temperature = 11;
arc.temperature = 13;
arc.getArchive(); // [{ val: 11 }, { val: 13 }]
```

次の例では、ゲッターが常に同じ値を返すようにしています。

```js
var pattern = {
  get() {
    return "I always return this string, " + "whatever you have assigned";
  },
  set() {
    this.myname = "this is my name string";
  },
};

function TestDefineSetAndGet() {
  Object.defineProperty(this, "myproperty", pattern);
}

var instance = new TestDefineSetAndGet();
instance.myproperty = "test";
console.log(instance.myproperty);
// I always return this string, whatever you have assigned

console.log(instance.myname); // this is my name string
```

### プロパティの継承

アクセサープロパティを継承されると、その派生クラスでもプロパティがアクセスされたり書き換えられるときに `get` と `set` が呼ばれます。これらのメソッドが値を保持するために変数を使っていると、すべてのオブジェクトがその値を共有することになります。

```js
function myclass() {}

var value;
Object.defineProperty(myclass.prototype, "x", {
  get() {
    return value;
  },
  set(x) {
    value = x;
  },
});

var a = new myclass();
var b = new myclass();
a.x = 1;
console.log(b.x); // 1
```

この問題を回避する方法は値を別のプロパティで保持することです。`get` と `set` メソッド内で `this` はアクセス／変更されようとしているプロパティを納めるオブジェクトを指しています。

```js
function myclass() {}

Object.defineProperty(myclass.prototype, "x", {
  get() {
    return this.stored_x;
  },
  set(x) {
    this.stored_x = x;
  },
});

var a = new myclass();
var b = new myclass();
a.x = 1;
console.log(b.x); // undefined
```

アクセサープロパティとは違い、データプロパティは常にオブジェクト自身に格納されるのであって、prototype に格納されるわけではありません。しかし、書き込み不可能なデータプロパティを継承している場合、継承先オブジェクトでも書き換えは阻止されます。

```js
function myclass() {}

myclass.prototype.x = 1;
Object.defineProperty(myclass.prototype, "y", {
  writable: false,
  value: 1,
});

var a = new myclass();
a.x = 2;
console.log(a.x); // 2
console.log(myclass.prototype.x); // 1
a.y = 2; // 無視されます。strict モードではエラーが発生します
console.log(a.y); // 1
console.log(myclass.prototype.y); // 1
```

仕様書
---

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

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

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

関連情報
----

* プロパティの列挙可能性と所有権
* `Object.defineProperties()`
* `Object.propertyIsEnumerable()`
* `Object.getOwnPropertyDescriptor()`
* `get`
* `set`
* `Object.create()`
* `Reflect.defineProperty()`


Object.prototype.valueOf() - JavaScript

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

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

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

Object.prototype.toString()
===========================

**`toString()`** メソッドは、オブジェクトを表す文字列を返します。

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

構文
--
```

obj.toString()
```

### 返値

オブジェクトを表す文字列です。

解説
--

すべてのオブジェクトは `toString` メソッドを持ち、オブジェクトが文字列値として表される場面や、文字列が期待される構文で参照されたときに自動的に呼び出されます。既定で、 `toString()` メソッドは `Object` の子孫にあたるあらゆるオブジェクトに継承されています。このメソッドがカスタムオブジェクト中で上書きされていない場合、 `toString()` は "`[object type]`" という文字列を返します (`type` は そのオブジェクトの型)。以下のコードがこれを例示しています。

```js
const o = new Object();
o.toString(); // [object Object] を返す
```

**メモ:** JavaScript 1.8.5 から、 `toString()` を `null` に対して呼び出した場合には `[object Null]` を、 `undefined` に対して呼び出した場合には `[object Undefined]` を返すようになり、これは ECMAScript 5th Edition とその後のエラッタによって定義されました。

toString() を使用したオブジェクトクラスの検出を参照してください。

引数
--

Number と BigInt の `toString()` は、オプションの引数 `radix` で基数の値を取り、最小値は 2 で最大値は 36 です。

`radix` を使用すると、十進数 (1,2,3,4,5,.........) を他の基数の数字に変換することができます。以下の例では十進数を二進数 (バイナリ) に変換しています。
```

let baseTenInt = 10;
console.log(baseTenInt.toString(2));
// 期待される結果は "1010"
```

BigInt についても同じです。

```js
let bigNum = BigInt(20);
console.log(bigNum.toString(2));
// 期待される結果は "10100"
```

よくある基数としては次のものがあります。

* 2 は二進数になります。
* 8 は八進数になります。
* 10 は 十進数になります。
* 16 は 十六進数になります。
例
-

### 既定の toString メソッドの上書き

既定の `toString()` メソッドに代わって呼び出される関数を作ることができます。 `toString()` メソッドは引数を取らず、文字列を返す必要があります。 `toString()` メソッドを作成した場合は好きな文字列を返すことができますが、オブジェクトに関する情報を伝えるのが一番役に立つでしょう。

以下のコードは `Dog` オブジェクト型を定義し、 `Dog` 型のオブジェクト `theDog` を生成しています。

```js
function Dog(name, breed, color, sex) {
  this.name = name;
  this.breed = breed;
  this.color = color;
  this.sex = sex;
}

theDog = new Dog("Gabby", "Lab", "chocolate", "female");
```

このカスタムオブジェクト上で `toString()` メソッドを呼び出した場合、メソッドは `Object` から継承された既定値を返します。

```js
theDog.toString(); // [object Object] を返す
```

以下のコードでは、 `dogToString()` を生成および割り当てし、既定の `toString()` メソッドを上書きします。この関数はオブジェクトの `name`, `breed`, `color`, `sex` を "`property = value;`" の形で含む文字列を生成します。

```js
Dog.prototype.toString = function dogToString() {
  const ret =
    "Dog " +
    this.name +
    " is a " +
    this.sex +
    " " +
    this.color +
    " " +
    this.breed;
  return ret;
};
```

または、 ES6 の テンプレート文字列を使用した例です。

```js
Dog.prototype.toString = function dogToString() {
  return `Dog ${this.name} is a ${this.sex} ${this.color} ${this.breed}`;
};
```

前者のコードの中で、 `theDog` が文字列の文脈で使用されるたびに、 JavaScript は自動的に `dogToString()` 関数を呼び出し、以下の文字列を返します。

```js
"Dog Gabby is a female chocolate Lab";
```

### toString() を使用したオブジェクトクラスの判別

`toString()` はすべてのオブジェクトに対し、(既定では) そのクラスを得るために使用することができます。

すべてのオブジェクトで `Object.prototype.toString()` を使うためには、 `Function.prototype.call()` または `Function.prototype.apply()` を、第 1 引数 (`thisArg`) に調べたいオブジェクトを渡して呼び出す必要があります。

```js
const toString = Object.prototype.toString;

toString.call(new Date()); // [object Date]
toString.call(new String()); // [object String]
toString.call(Math); // [object Math]

// Since JavaScript 1.8.5
toString.call(undefined); // [object Undefined]
toString.call(null); // [object Null]
```

このような `toString()` の使用は信頼できません。オブジェクトは `Object.prototype.toString()` の動作を `Symbol.toStringTag` プロパティを定義することで変更でき、それによって次のように予想外の動作になります。

```js
const myDate = new Date();
Object.prototype.toString.call(myDate); // [object Date]

myDate[Symbol.toStringTag] = "myDate";
Object.prototype.toString.call(myDate); // [object myDate]

Date.prototype[Symbol.toStringTag] = "prototype polluted";
Object.prototype.toString.call(new Date()); // [object prototype polluted]
```

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.toSource()`
* `Object.prototype.valueOf()`
* `Number.prototype.toString()`
* `Symbol.toPrimitive`


Object.defineProperties() - JavaScript

Object.defineProperties()
=========================

**`Object.defineProperties()`** メソッドは、オブジェクトに直接新しいプロパティを定義し、あるいは既存のプロパティを変更して、そのオブジェクトを返します。

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

構文
--
```

Object.defineProperties(obj, props)
```

### 引数

`obj`

プロパティを定義または変更するオブジェクト。

`props`

キーが定義または変更されるプロパティの名前を表し、値がそれらのプロパティを記述するオブジェクトであるオブジェクトです。 `props` の各値は、データ記述子かアクセサー記述子のいずれかでなければなりませんが、両方を指定することはできません (詳細は `Object.defineProperty()` を参照してください)。

データ記述子およびアクセサー記述子は、オプションで以下のキーを含むことができます。

`configurable`

 プロパティの記述子が変更でき、プロパティが対応するオブジェクトから削除できるときのみ `true`。
 **既定値は `false`。**

`enumerable`

 対応するオブジェクトのプロパティを列挙したとき表示される場合のみ `true`。
 **既定値は `false`。**

データ記述子には以下のオプションのキーもあります。

`value`

 プロパティに関連づける値。 JavaScript で有効な任意の値です (数値、オブジェクト、関数など)。
 **既定値は `undefined`。**

`writable`

 プロパティに関連づけられた値が代入演算子で変更できる場合のみ `true`。
 **既定値は `false`。**

アクセサー記述子には、以下のオプションのキーもあります。

`get`

 プロパティのゲッターとして用いられる関数。ゲッターがなければ `undefined` になります。関数の返値がプロパティの値として使用されます。
 **既定値は `undefined`。**

`set`

 プロパティのセッターとして用いられる関数。セッターがなければ `undefined` になります。関数はただひとつの引数として、プロパティに代入された新たな値を受取ります。
 **既定値は `undefined`。**

記述子が `value`, `writable`, `get` `set` キーのいずれでもない場合は、データ記述子として扱われます。記述子に `value` または `writable` と `get` または `set` キーの両方があった場合は、例外が発生します。

### 返値

関数に渡されたオブジェクト。

例
-

### Object.defineProperties の使用

```js
var obj = {};
Object.defineProperties(obj, {
  property1: {
    value: true,
    writable: true,
  },
  property2: {
    value: "Hello",
    writable: false,
  },
  // etc. etc.
});
```

ポリフィル
-----

すべての名前とプロパティが自身の初期値を参照する基本的な実行環境において、 `Object.defineProperties` は以下の JavaScript による再実装とほぼ同等です(`isCallable` のコメントに注意)。

```js
function defineProperties(obj, properties) {
  function convertToDescriptor(desc) {
    function hasProperty(obj, prop) {
      return Object.prototype.hasOwnProperty.call(obj, prop);
    }

    function isCallable(v) {
      // 注意: 関数以外の値が呼び出し可能である場合、必要に応じて変更。
      return typeof v === "function";
    }

    if (typeof desc !== "object" || desc === null)
      throw new TypeError("bad desc");

    var d = {};

    if (hasProperty(desc, "enumerable")) d.enumerable = !!desc.enumerable;
    if (hasProperty(desc, "configurable")) d.configurable = !!desc.configurable;
    if (hasProperty(desc, "value")) d.value = desc.value;
    if (hasProperty(desc, "writable")) d.writable = !!desc.writable;
    if (hasProperty(desc, "get")) {
      var g = desc.get;

      if (!isCallable(g) && typeof g !== "undefined")
        throw new TypeError("bad get");
      d.get = g;
    }
    if (hasProperty(desc, "set")) {
      var s = desc.set;
      if (!isCallable(s) && typeof s !== "undefined")
        throw new TypeError("bad set");
      d.set = s;
    }

    if (("get" in d || "set" in d) && ("value" in d || "writable" in d))
      throw new TypeError("identity-confused descriptor");

    return d;
  }

  if (typeof obj !== "object" || obj === null) throw new TypeError("bad obj");

  properties = Object(properties);

  var keys = Object.keys(properties);
  var descs = [];

  for (var i = 0; i < keys.length; i++)
    descs.push([keys[i], convertToDescriptor(properties[keys[i]])]);

  for (var i = 0; i < descs.length; i++)
    Object.defineProperty(obj, descs[i][0], descs[i][1]);

  return obj;
}
```

仕様書
---

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

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

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

関連情報
----

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


Object.values() - JavaScript

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

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

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

Object.setPrototypeOf()
=======================

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

**警告:** オブジェクトの `[[Prototype]]` を変更すると、 最近の JavaScript エンジンがプロパティへのアクセスを最適化する方法の特質上、すべてのブラウザーや JavaScript エンジンで、操作がとても低速になります。さらに、プロトタイプを変更することの性能への影響は細かく広範囲にわたり、 `Object.setPrototypeOf(...)` 文に費やされる時間だけではなく、 `[[Prototype]]` が変更されたすべてのオブジェクトへのアクセスを持つ***すべて***のコードに影響する可能性があります。

この機能は言語の一部であるため、その機能の実装による負荷は (理念上は) エンジンの開発者によります。エンジンの開発者がこの問題に対処するまでの間、性能が気になる場合は、オブジェクトの `[[Prototype]]` を変更することは避けるべきです。代わりに、 `Object.create()` を使用して必要な `[[Prototype]]` をもつオブジェクトを生成してください。

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

構文
--
```

Object.setPrototypeOf(obj, prototype)
```

### 引数

`obj`

プロトタイプを設定するオブジェクト。

`prototype`

オブジェクトの新しいプロトタイプ (オブジェクトまたは `null`)。

### 返値

指定されたオブジェクト。

解説
--

`[[Prototype]]` が変更されるオブジェクトが `Object.isExtensible()` に応じて拡張不可の場合、 `TypeError` 例外を投げます。`prototype` 引数がオブジェクトまたは `null` ではない場合(つまり、数値、文字列、boolean、 `undefined` のいずれか)、何もしません。さもなければ、このメソッドは `obj` の `[[Prototype]]` を新しい値に変更します。

`Object.setPrototypeOf()` は、 ECMAScript 2015 仕様書にあります。一般的には、オブジェクトのプロトタイプを設定するための適切な方法と考えられています。もっと物議を醸す `Object.prototype.__proto__` プロパティがあります。

プロトタイプチェーンの追加
-------------

`Object.getPrototypeOf()` と `Object.prototype.__proto__` の組み合わせによってプロトタイプチェーン全体を新しいプロトタイプオブジェクトに追加できます。

```js
/\*\*
 \*\*\* Object.appendChain(@object, @prototype)
 \*
 \* Appends the first non-native prototype of a chain to a new prototype.
 \* Returns @object (if it was a primitive value it will transformed into an object).
 \*
 \*\*\* Object.appendChain(@object [, "@arg\_name\_1", "@arg\_name\_2", "@arg\_name\_3", "..."], "@function\_body")
 \*\*\* Object.appendChain(@object [, "@arg\_name\_1, @arg\_name\_2, @arg\_name\_3, ..."], "@function\_body")
 \*
 \* Appends the first non-native prototype of a chain to the native Function.prototype object, then appends a
 \* new Function(["@arg"(s)], "@function\_body") to that chain.
 \* Returns the function.
 \*
 \*\*/

Object.appendChain = function (oChain, oProto) {
  if (arguments.length < 2) {
    throw new TypeError("Object.appendChain - 引数が足りません");
  }
  if (typeof oProto !== "object" && typeof oProto !== "string") {
    throw new TypeError(
      "Object.appendChain の第二引数は object か string でなければなりません",
    );
  }

  var oNewProto = oProto,
    oReturn =
      (o2nd =
      oLast =
        oChain instanceof this ? oChain : new oChain.constructor(oChain));

  for (
    var o1st = this.getPrototypeOf(o2nd);
    o1st !== Object.prototype && o1st !== Function.prototype;
    o1st = this.getPrototypeOf(o2nd)
  ) {
    o2nd = o1st;
  }

  if (oProto.constructor === String) {
    oNewProto = Function.prototype;
    oReturn = Function.apply(null, Array.prototype.slice.call(arguments, 1));
    this.setPrototypeOf(oReturn, oLast);
  }

  this.setPrototypeOf(o2nd, oNewProto);
  return oReturn;
};
```

### 使い方

#### 最初の例: チェーンをプロトタイプに追加する

```js
function Mammal() {
  this.isMammal = "yes";
}

function MammalSpecies(sMammalSpecies) {
  this.species = sMammalSpecies;
}

MammalSpecies.prototype = new Mammal();
MammalSpecies.prototype.constructor = MammalSpecies;

var oCat = new MammalSpecies("Felis");

console.log(oCat.isMammal); // 'yes'

function Animal() {
  this.breathing = "yes";
}

Object.appendChain(oCat, new Animal());

console.log(oCat.breathing); // 'yes'
```

#### 二番目の例: そのコンストラクタのインスタンスにプリミティブ値を変換し、プロトタイプにそのチェーンを追加する

```js
function MySymbol() {
  this.isSymbol = "yes";
}

var nPrime = 17;

console.log(typeof nPrime); // 'number'

var oPrime = Object.appendChain(nPrime, new MySymbol());

console.log(oPrime); // '17'
console.log(oPrime.isSymbol); // 'yes'
console.log(typeof oPrime); // 'object'
```

#### 三番目の例: チェーンを Function.prototype オブジェクトに追加し、新しい関数をそのチェーンに追加する

```js
function Person(sName) {
  this.identity = sName;
}

var george = Object.appendChain(
  new Person("George"),
  'console.log("Hello guys!!");',
);

console.log(george.identity); // 'George'
george(); // 'Hello guys!!'
```

例
-

### Object.setPrototypeOf の使用

```js
var dict = Object.setPrototypeOf({}, null);
```

ポリフィル
-----

`Object.setPrototypeOf` が利用できない場合、より古い `Object.prototype.__proto__` プロパティを使って、簡単に定義することができます。

```js
if (!Object.setPrototypeOf) {
  // Chrome および FireFox で動作しますが、 IE では動作しません
  Object.prototype.setPrototypeOf = function (obj, proto) {
    if (obj.__proto__) {
      obj.__proto__ = proto;
      return obj;
    } else {
      // Object.create(null) のプロトタイプを返したい場合
      var Fn = function () {
        for (var key in obj) {
          Object.defineProperty(this, key, {
            value: obj[key],
          });
        }
      };
      Fn.prototype = proto;
      return new Fn();
    }
  };
}
```

仕様書
---

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

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

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

関連情報
----

* `Reflect.setPrototypeOf()`
* `Object.prototype.isPrototypeOf()`
* `Object.getPrototypeOf()`
* `Object.prototype.__proto__`


Object.prototype.propertyIsEnumerable() - JavaScript

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

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.prototype.constructor - JavaScript

Object.prototype.constructor
============================

**`constructor`** プロパティは、インスタンスオブジェクトを生成した `Object` のコンストラクター関数への参照を返します。なお、このプロパティの値は*関数そのものへの参照*であり、関数名を含んだ文字列ではありません。

値が `1`, `true`, `"test"` のようなプリミティブ値の場合は読み取り専用です。

解説
--

(`Object.create(null)` で生成されたオブジェクトを除いて) すべてのオブジェクトが `constructor` プロパティを持っています。明示的にコンストラクター関数を用いることなく生成されたオブジェクト (オブジェクトリテラルや配列リテラルなど) は、 `constructor` プロパティがそのオブジェクトの基礎オブジェクトのコンストラクター型を指します。

```js
let o = {};
o.constructor === Object; // true

let o = new Object();
o.constructor === Object; // true

let a = [];
a.constructor === Array; // true

let a = new Array();
a.constructor === Array; // true

let n = new Number(3);
n.constructor === Number; // true
```

例
-

### オブジェクトのコンストラクターの表示

以下の例では、コンストラクター (`Tree`) と、その型のオブジェクト (`theTree`) を生成します。そして、 `theTree` オブジェクトの `constructor` プロパティを表示します。

```js
function Tree(name) {
  this.name = name;
}

let theTree = new Tree("Redwood");
console.log("theTree.constructor is " + theTree.constructor);
```

この例の出力は次のとおりです。

```js
theTree.constructor is function Tree(name) {
  this.name = name
}
```

### オブジェクトのコンストラクターの変更

`constructor` プロパティに代入することができるのは、対応するコンストラクター関数を持たない `null` および `undefined` 以外の値 (`String`、`Number`、`Boolean` など) ですが、プリミティブ値には変更が適用されません (例外は発生しません)。これは、プリミティブ値 (`null` と `undefined` を除く) にどのようなプロパティを設定しても効果がないのと同じ仕組みによるものです。つまり、このようなプリミティブをオブジェクトとして使用すると、対応するコンストラクターのインスタンスが生成され、文の実行後すぐに破棄されることになります。

```js
let val = null;
val.constructor = 1; //TypeError: val is null

val = "abc";
val.constructor = Number; //val.constructor === String

val.foo = "bar"; //暗黙的に String('abc') のインスタンスが生成され、 foo プロパティに代入する
val.foo === undefined; //true になる。 String('abc') の新しいインスタンスがこの比較のために生成され、 foo プロパティがないため
```

つまり、上記のプリミティブ値を除いて、基本的に `constructor` プロパティの値を変更することができます。**なお、 `constructor` プロパティを変更しても、 instanceof 演算子には影響しません**。

```js
let a = [];
a.constructor = String;
a.constructor === String; // true
a instanceof String; //false
a instanceof Array; //true

a = new Foo();
a.constructor = "bar";
a.constructor === "bar"; // true

//etc.
```

オブジェクトが封印または凍結されていた場合は、変更の効果がなくなり、例外は発生しません。

```js
let a = Object.seal({});
a.constructor = Number;
a.constructor === Object; //true
```

### 関数のコンストラクターの変更

多くの場合、このプロパティは**関数コンストラクター**としての関数の定義に使用され、将来の **new** およびプロトタイプ継承チェーンでの呼び出しに使われます。

```js
function Parent() {
  /\* ... \*/
}
Parent.prototype.parentMethod = function parentMethod() {};

function Child() {
  Parent.call(this); // すべてが正しく初期化されていることを確認
}
Child.prototype = Object.create(Parent.prototype); // 子のプロトタイプを親のプロトタイプで再定義

Child.prototype.constructor = Child; // 元のコンストラクターとして Child を返す
```

しかし、いつこの最後の行を実行する必要があるのでしょうか。残念ながら、正しい答えは、*場合による*ということです。

元のコンストラクターを再割り当てすることが重要である場合と、これがコードの未使用の一行になる場合を定義してみましょう。

以下の場合を見てみてください。オブジェクトが自分自身を生成するために `create()` メソッドを持っています。

```js
function Parent() {
  /\* ... \*/
}
function CreatedConstructor() {
  Parent.call(this);
}

CreatedConstructor.prototype = Object.create(Parent.prototype);

CreatedConstructor.prototype.create = function create() {
  return new this.constructor();
};

new CreatedConstructor().create().create(); // TypeError undefined is not a function since constructor === Parent
```

上記の例では、コンストラクターが Parent にリンクしているため、例外が発生します。

これを防ぐには、利用しようとしている必要なコンストラクターを代入するだけです。

```js
function Parent() {
  /\* ... \*/
}
function CreatedConstructor() {
  /\* ... \*/
}

CreatedConstructor.prototype = Object.create(Parent.prototype);
CreatedConstructor.prototype.constructor = CreatedConstructor; // 将来使用するために正しいコンストラクターを設定

CreatedConstructor.prototype.create = function create() {
  return new this.constructor();
};

new CreatedConstructor().create().create(); // とてもよくなった
```

これで、コンストラクターの変更が有用である理由が明確になりました。

もう一つの例を考えてみましょう。

```js
function ParentWithStatic() {}

ParentWithStatic.startPosition = { x: 0, y: 0 }; // Static member property
ParentWithStatic.getStartPosition = function getStartPosition() {
  return this.startPosition;
};

function Child(x, y) {
  this.position = {
    x: x,
    y: y,
  };
}

Child.prototype = Object.create(ParentWithStatic.prototype);
Child.prototype.constructor = Child;

Child.prototype.getOffsetByInitialPosition =
  function getOffsetByInitialPosition() {
    let position = this.position;
    let startPosition = this.constructor.getStartPosition(); // error undefined is not a function, since the constructor is Child

    return {
      offsetX: startPosition.x - position.x,
      offsetY: startPosition.y - position.y,
    };
  };
```

この例を正しく動作させるためには、コンストラクターとして `Parent` を保持するか、静的プロパティを `Child` のコンストラクターに再代入するかする必要があります。

```js
...
Child = Object.assign(Child, ParentWithStatic); // Notice that we assign it before we create(...) a prototype below
Child.prototype = Object.create(ParentWithStatic.prototype);
...
```

または、 `Parent` のコンストラクター識別子を `Child` コンストラクター関数の別のプロパティに代入し、そのプロパティからアクセスします。

```js
...
Child.parentConstructor = ParentWithStatic
Child.prototype = Object.create(ParentWithStatic.prototype)
...
   let startPosition = this.constructor.parentConstructor.getStartPosition()
...
```

**メモ:** コンストラクターを手動で更新したり設定したりすると、異なる結果や混乱する結果を導くことがあります。これを防ぐためには、それぞれの場合に応じて `constructor` の役割を定義することが必要です。多くの場合、 `constructor` 使用されず、再割り当ての必要はありません。

仕様書
---

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

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

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

関連情報
----

* クラス宣言
* クラスのコンストラクター
* 用語集: コンストラクター


Object.getOwnPropertyDescriptors() - JavaScript

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

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

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


Object.fromEntries() - JavaScript

Object.fromEntries()
====================

**`Object.fromEntries()`** メソッドは、キーと値の組み合わせのリストをオブジェクトに変換します。

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

構文
--
```

Object.fromEntries(iterable);
```

### 引数

`iterable`

反復処理プロトコルを実装している `Array` や `Map` やその他の反復処理可能なオブジェクトです。

### 返値

反復可能な項目から作成されたプロパティを持つ新しいオブジェクト。

説明
--

`Object.fromEntries()` メソッドは、キーと値のリストを取り、これらの項目から作成されたプロパティを持つ新しいオブジェクトを返します。引数の *iterable* は `@@iterator` メソッドを実装しており、オブジェクトのような二つの要素を持ち、最初の要素がプロパティキーとして使われる値であり、次の要素がプロパティのキーに関連付けられる値であるようなオブジェクトであることが求められます。

`Object.fromEntries()` は `Object.entries()` の逆の動作をします。

例
-

### Map から Object への変換

`Object.fromEntries` では、 `Map` を `Object` に変換することができます。

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

### Array から Object への変換

`Object.fromEntries` では、 `Array` を `Object` に変換することができます。

```js
const arr = [
  ["0", "a"],
  ["1", "b"],
  ["2", "c"],
];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }
```

### オブジェクトの変形

`Object.fromEntries`、逆のメソッド `Object.entries()`、配列操作メソッドを使用して、以下のようにオブジェクトを変形することができます。

```js
const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries(
  Object.entries(object1).map(([key, val]) => [key, val \* 2]),
);

console.log(object2);
// { a: 2, b: 4, c: 6 }
```

仕様書
---

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

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

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

関連情報
----

* `Object.entries()`
* `Object.keys()`
* `Object.values()`
* `Map.prototype.entries()`
* `Map.prototype.keys()`
* `Map.prototype.values()`


Object.prototype.__lookupSetter__() - JavaScript

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

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

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

構文
--

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

### 引数

`sprop`

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

### 返値

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

解説
--

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

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

例
-

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

```js
var obj = {
  set foo(value) {
    this.bar = value;
  },
};

// 標準外かつ非推奨の方法
obj.\_\_lookupSetter\_\_("foo");
// (function(value) { this.bar = value; })

// 標準準拠の方法
Object.getOwnPropertyDescriptor(obj, "foo").set;
// (function(value) { this.bar = value; })
```

仕様書
---

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

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

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

関連情報
----

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


Object.assign() - JavaScript

Object.assign()
===============

**`Object.assign()`** メソッドは、すべての列挙可能な自身のプロパティの値を、 1 つ以上の*コピー元オブジェクト*から*コピー先オブジェクト*にコピーするために使用されます。変更されたコピー先オブジェクトを返します。

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

構文
--

```js
Object.assign(target, ...sources);
```

### 引数

`target`

コピー先オブジェクト — コピー元のプロパティを適用するもので、変更後に返されます。

`sources`

コピー元オブジェクト (単数または複数) — 適用したいプロパティを含むオブジェクトです。

### 返値

コピー先オブジェクトです。

解説
--

コピー先オブジェクトのプロパティは、コピー元に同じキーのプロパティがあると上書きされます。より後のコピー元のプロパティが、より前のものを同様に上書きします。

`Object.assign()` メソッドは、コピー元オブジェクトから*列挙可能 (enumerable)* かつ*直接所有 (own)* のプロパティだけをコピー先オブジェクトにコピーします。この際、コピー元オブジェクトには `[[Get]]`、コピー先オブジェクトには `[[Set]]` を使いますので、ゲッターとセッターを呼び出すことになります。これはプロパティの*代入 (assign)* であり、プロパティをコピーしたり新しく定義したりするのとは異なります。そのため、コピー元にゲッターが存在する場合、新しいプロパティをプロトタイプにマージする用途には不適切でしょう。

プロパティ定義を (列挙可能属性も含めて) プロトタイプの中にコピーするには、このメソッドではなく `Object.getOwnPropertyDescriptor()` と `Object.defineProperty()` を使用してください。

`String` と `Symbol` の両方のプロパティがコピーされます。

エラーが発生した場合、例えばプロパティが書き込み不可の場合は、 `TypeError` が発生しますが、エラーが発生する前にプロパティが追加される場合、 `target` オブジェクトが変更されることがあります。

**メモ:** `Object.assign()` はコピー元の値が `null` や `undefined` でも例外を発生させません。

ポリフィル
-----

このポリフィルは、 ES5 にシンボルがないため、シンボルのプロパティに対応していません。

```js
if (typeof Object.assign !== "function") {
  // Must be writable: true, enumerable: false, configurable: true
  Object.defineProperty(Object, "assign", {
    value: function assign(target, varArgs) {
      // .length of function is 2
      "use strict";
      if (target === null || target === undefined) {
        throw new TypeError("Cannot convert undefined or null to object");
      }

      var to = Object(target);

      for (var index = 1; index < arguments.length; index++) {
        var nextSource = arguments[index];

        if (nextSource !== null && nextSource !== undefined) {
          for (var nextKey in nextSource) {
            // Avoid bugs when hasOwnProperty is shadowed
            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
              to[nextKey] = nextSource[nextKey];
            }
          }
        }
      }
      return to;
    },
    writable: true,
    configurable: true,
  });
}
```

例
-

### オブジェクトの複製

```js
const obj = { a: 1 };
const copy = Object.assign({}, obj);
console.log(copy); // { a: 1 }
```

### 深い複製についての注意

`Object.assign()` はプロパティの値をコピーするため、深い複製を行うには別な方法を使用する必要があります。

元の値がオブジェクトへの参照である場合、参照の値のみをコピーするからです。

```js
function test() {
  "use strict";

  let obj1 = { a: 0, b: { c: 0 } };
  let obj2 = Object.assign({}, obj1);
  console.log(JSON.stringify(obj2)); // { "a": 0, "b": { "c": 0}}

  obj1.a = 1;
  console.log(JSON.stringify(obj1)); // { "a": 1, "b": { "c": 0}}
  console.log(JSON.stringify(obj2)); // { "a": 0, "b": { "c": 0}}

  obj2.a = 2;
  console.log(JSON.stringify(obj1)); // { "a": 1, "b": { "c": 0}}
  console.log(JSON.stringify(obj2)); // { "a": 2, "b": { "c": 0}}

  obj2.b.c = 3;
  console.log(JSON.stringify(obj1)); // { "a": 1, "b": { "c": 3}}
  console.log(JSON.stringify(obj2)); // { "a": 2, "b": { "c": 3}}

  // Deep Clone
  obj1 = { a: 0, b: { c: 0 } };
  let obj3 = JSON.parse(JSON.stringify(obj1));
  obj1.a = 4;
  obj1.b.c = 4;
  console.log(JSON.stringify(obj3)); // { "a": 0, "b": { "c": 0}}
}

test();
```

### オブジェクトのマージ

```js
const o1 = { a: 1 };
const o2 = { b: 2 };
const o3 = { c: 3 };

const obj = Object.assign(o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
console.log(o1); // { a: 1, b: 2, c: 3 }, コピー先オブジェクト自体が変化する。
```

### 同じプロパティを持つオブジェクトのマージ

```js
const o1 = { a: 1, b: 1, c: 1 };
const o2 = { b: 2, c: 2 };
const o3 = { c: 3 };

const obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
```

プロパティは、引数の順でより後にあるオブジェクトが同じプロパティを持っていると上書きされます。

### シンボル型のプロパティのコピー

```js
const o1 = { a: 1 };
const o2 = { [Symbol("foo")]: 2 };

const obj = Object.assign({}, o1, o2);
console.log(obj); // { a : 1, [Symbol("foo")]: 2 } (cf. bug 1207182 on Firefox)
Object.getOwnPropertySymbols(obj); // [Symbol(foo)]
```

### プロトタイプチェーン上のプロパティと列挙可能ではないプロパティはコピー不可

```js
const obj = Object.create(
  { foo: 1 },
  {
    // foo is on obj's prototype chain.
    bar: {
      value: 2, // bar は列挙可能なプロパティではない。
    },
    baz: {
      value: 3,
      enumerable: true, // baz は直接所有で列挙可能なプロパティ。
    },
  },
);

const copy = Object.assign({}, obj);
console.log(copy); // { baz: 3 }
```

### プリミティブはオブジェクトでラップされる

```js
const v1 = "abc";
const v2 = true;
const v3 = 10;
const v4 = Symbol("foo");

const obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
// プリミティブ値はラップされ、 null と undefined は無視される
// なお、文字列をラップした時だけ、直接所有で列挙可能なプロパティが存在する
console.log(obj); // { "0": "a", "1": "b", "2": "c" }
```

### 例外が発生すると実行中のコピー作業が中断される

```js
const target = Object.defineProperty({}, "foo", {
  value: 1,
  writable: false,
}); // target.foo is a read-only property

Object.assign(target, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 });
// TypeError: "foo" is read-only
// target.foo に代入しようとすると、この例外が発生する

console.log(target.bar); // 2, 一番目のコピー元オブジェクトはコピーされている
console.log(target.foo2); // 3, 二番目のコピー元の最初のプロパティもコピーされている
console.log(target.foo); // 1, ここで例外が発生
console.log(target.foo3); // undefined, assign メソッドが終了したので foo3 はコピーされない
console.log(target.baz); // undefined, 三番目のコピー元もコピーされない
```

### アクセサーのコピー

```js
const obj = {
  foo: 1,
  get bar() {
    return 2;
  },
};

let copy = Object.assign({}, obj);
console.log(copy);
// { foo: 1, bar: 2 }
// copy.bar の値は obj.bar のゲッターの返値。

// 記述子を完全にコピーする代入関数
function completeAssign(target, ...sources) {
  sources.forEach((source) => {
    let descriptors = Object.keys(source).reduce((descriptors, key) => {
      descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
      return descriptors;
    }, {});

    // 既定では、 Object.assign は列挙可能なシンボルもコピーする
    Object.getOwnPropertySymbols(source).forEach((sym) => {
      let descriptor = Object.getOwnPropertyDescriptor(source, sym);
      if (descriptor.enumerable) {
        descriptors[sym] = descriptor;
      }
    });
    Object.defineProperties(target, descriptors);
  });
  return target;
}

copy = completeAssign({}, obj);
console.log(copy);
// { foo:1, get bar() { return 2 } }
```

仕様書
---

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

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

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

関連情報
----

* `Object.assign` のポリフィルは `core-js` で利用できます
* `Object.defineProperties()`
* プロパティの列挙可能性と所有権
* オブジェクトリテラルでのスプレッド構文の使用


Object.prototype.toLocaleString() - JavaScript

Object.prototype.toLocaleString()
=================================

**`toLocaleString()`** メソッドは、オブジェクトを表す文字列を返します。このメソッドは、ロケール固有の目的のために派生オブジェクトによって上書きするためのものです。

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

構文
--
```

obj.toLocaleString()
```

### 返値

オブジェクトを表現する文字列です。

解説
--

`Object` の `toLocaleString` は `toString()` を呼び出した結果を返します。

この関数は、すべての人が使うわけではありませんが、オブジェクトに汎用的な `toLocaleString` メソッドを与えるために提供されています。以下のリストを参照してください。

### toLocaleString を上書きしているオブジェクト

* `Array`: `Array.prototype.toLocaleString()`
* `Number`: `Number.prototype.toLocaleString()`
* `Date`: `Date.prototype.toLocaleString()`
* `TypedArray`: `TypedArray.prototype.toLocaleString()`
* `BigInt`: `BigInt.prototype.toLocaleString()`
例
-

### Array における toLocaleString() の上書き

`Array` オブジェクトでは、 `toLocaleString()` を使用して配列の値を文字列として表示したり、オプションでロケール固有の識別子 (通貨記号など) を付加して表示したりすることができます。

例を示します。

```js
const testArray = [4, 7, 10];

let euroPrices = testArray.toLocaleString("fr", {
  style: "currency",
  currency: "EUR",
});
// "4,00 €,7,00 €,10,00 €"
```

### Date における toLocaleString() の上書き

`Date` オブジェクトでは、 `toLocaleString()` を使用して、特定のロケールに適した日付表示を出力します。

例を示します。

```js
const testDate = new Date(Date.now());
// "Date Fri May 29 2020 18:04:24 GMT+0100 (British Summer Time)"

let deDate = testDate.toLocaleString("de");
// "29.5.2020, 18:04:24"

var frDate = testDate.toLocaleString("fr");
//"29/05/2020 à 18:04:24"
```

### Number における toLocaleString() の上書き

`Number` オブジェクトでは、 `toLocaleString()` を使用して、特定のロケールに適した数値表示、例えば正しい区切り文字を使って出力します。

例を示します。

```js
const testNumber = 2901234564;
// "2901234564"

let deNumber = testNumber.toLocaleString("de");
// "2.901.234.564"

let frNumber = testNumber.toLocaleString("fr");
// "2 901 234 564"
```

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.toString()`


Object.prototype.__proto__ - JavaScript

Object.prototype.\_\_proto\_\_
==============================

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

**警告:** オブジェクトの `[[Prototype]]` を変更することは、最新の JavaScript エンジンがプロパティアクセスを最適化する仕組み上、***すべての***ブラウザーや JavaScript エンジンにおいて、とても低速な操作となります。プロトタイプの継承関係を変更することによる性能上の影響は微細で広範囲にわたり、単に `obj.__proto__ = ...` という文の実行時間に留まらず、 `[[Prototype]]` が変更された***いずれかの***オブジェクトへのアクセスを持つ***あらゆる***コードに及ぶ可能性があります。性能を気にしている場合、オブジェクトの `[[Prototype]]` の変更は避けるべきです。代わりに、 `Object.create()` を使用して求める `[[Prototype]]` をもつオブジェクトを新たに生成してください。

**警告:** `Object.prototype.__proto__` は現時点でほとんどのブラウザーが対応していますが、そのプロパティの存在と正確な動作は、ウェブブラウザーの互換性を確保するためのレガシー機能として、 ECMAScript 2015 で初めて標準化されました。より広く対応させるには、代わりに `Object.getPrototypeOf()` を使用してください。

`__proto__` は `Object.prototype` のアクセサープロパティ (ゲッター関数およびセッター関数) で、アクセスされるオブジェクトの内部の `[[Prototype]]` (オブジェクトまたは `null` のどちらか) を暴露します。

`__proto__` の使用は、論争の的になり、推奨されていません。もともと ECMAScript 言語仕様には含まれていませんでしたが、現在のブラウザーでは結局それを実装しています。最近になって、 `__proto__` プロパティはウェブブラウザー間の互換性を保つために ECMAScript2015 の仕様で標準化されたので、将来的には対応されることになります。これは非推奨扱いで、代わりに `Object.getPrototypeOf`/`Reflect.getPrototypeOf` および `Object.setPrototypeOf`/`Reflect.setPrototypeOf` を推奨しています (とはいえ、オブジェクトの `[[Prototype]]` の設定は、性能が気になる場合には避けるべき低速の操作ですが)。

また、 `__proto__` プロパティは、生成時に `[[Prototype]]` オブジェクトを設定するために `Object.create()` の代わりとしてもオブジェクトリテラルの定義で使用されます。参照: オブジェクト初期化子 / リテラル構文

解説
--

`__proto__` ゲッター関数はオブジェクトの内部の `[[Prototype]]` の値を外部に公開します。オブジェクトリテラルを使用して生成されたオブジェクトでは、この値は `Object.prototype` です。配列リテラルを使用して生成されたオブジェクトでは、この値は `Array.prototype` です。関数では、この値は `Function.prototype` です。 `new fun` を使用して生成されたオブジェクトでは、 `fun` が JavaScript の (`Array`、`Boolean`、`Date`、 `Number`、 `Object`、 `String` などによって提供された内蔵コンストラクター関数のうちの一つである場合は — JavaScript の進化によって追加された新しいコンストラクタを含みます)、この値は常に `fun.prototype` です。 `new fun` を使用して生成されたオブジェクトでは、 `fun` がスクリプトで定義された関数である場合、この値は常に `fun.prototype` の値です。 (すなわち、コンストラクターがほかのオブジェクトを明示的に返さない場合、または `fun.prototype` に再代入されていない場合)。

`__proto__` のセッターでオブジェクトの `[[Prototype]]` を変更することができます。オブジェクトは、 `Object.isExtensible()` に応じて拡張可能である必要があります。拡張可能ではない場合、 `TypeError` が発生します。与えられた値はオブジェクト、または `null` である必要があります。他の値が与えられた場合は何もしません。

プロトタイプが継承のためにどのように使用されるかを理解するには、ガイド記事の継承とプロトタイプチェーンを参照してください。

`__proto__` プロパティは、ゲッター関数とセッター関数からなる `Object` 上の簡単なアクセサープロパティです。最終的にの `Object` を参照する `__proto__` に対してのプロパティアクセスはこのプロパティを探します。しかし、 `Object` を参照しないアクセスはこのプロパティを探しません。 `Object` が参照される前にいくつかの他の `__proto__` プロパティが見つけられた場合、そのプロパティは、 `Object` 上で見つけられたプロパティを隠します。

例
-

### \_\_proto\_\_ の使用

```js
function Circle() {}
const shape = {};
const circle = new Circle();

// オブジェクトプロトタイプの設定
// 非推奨。 参考用です。 実際のコードで使用しないでください。
shape.__proto__ = circle;

// オブジェクトプロトタイプの取得
console.log(shape.__proto__ === Circle); // false

const ShapeA = function () {};
const ShapeB = {
  a() {
    console.log("aaa");
  },
};
console.log((ShapeA.prototype.__proto__ = ShapeB));

const shapea = new ShapeA();
shapea.a(); // aaa
console.log(ShapeA.prototype === shapea.__proto__); // true

// または
const ShapeC = function () {};
const ShapeD = {
  a() {
    console.log("a");
  },
};

const shapeC = new ShapeC();
shapeC.__proto__ = ShapeD;
shapeC.a(); // a
console.log(ShapeC.prototype === shapeC.__proto__); // false

// または
function Test() {}
Test.prototype.myname = function () {
  console.log("myname");
};

const a = new Test();
console.log(a.__proto__ === Test.prototype); // true
a.myname(); // myname

// または
const fn = function () {};
fn.prototype.myname = function () {
  console.log("myname");
};

var obj = {
  \_\_proto\_\_: fn.prototype,
};

obj.myname(); // myname
```

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.isPrototypeOf()`
* `Object.getPrototypeOf()`
* `Object.setPrototypeOf()`


Object.create() - JavaScript

Object.create()
===============

**`Object.create()`** メソッドは、既存のオブジェクトを新しく生成されるオブジェクトのプロトタイプとして使用して、新しいオブジェクトを生成します。

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

構文
--

```js
Object.create(proto);
Object.create(proto, propertiesObject);
```

### 引数

`proto`

新たに生成されるオブジェクトのプロトタイプになるべきオブジェクトです。

`propertiesObject` 省略可

指定されていて、 `undefined` でない場合、それ自身の列挙可能なプロパティ (つまり、それ自身に定義されているものであり、プロトタイプチェーンの中での列挙可能なプロパティでは*ない*もの) が、それらのプロパティ名を伴う一連のプロパティ記述子を指定し、新たに生成されるオブジェクトに追加されることになります。これらのプロパティは、 `Object.defineProperties()` の 2 番目の引数に対応するものです。

### 返値

指定したプロトタイプオブジェクトとプロパティを持つ新しいオブジェクトです。

### 例外

`proto` 引数は次のいずれかになります。

* `null` または
* `Object` ただしプリミティブラッパーオブジェクトを除く

`proto` がどちらでもない場合、 `TypeError` が発生します。

カスタムオブジェクトと Null オブジェクト
-----------------------

完全なカスタムオブジェクト (特に `null` オブジェクトから作成されたもの、基本的にはメンバーを持たないカスタムオブジェクト) から生成された新しいオブジェクトは、予想外の振る舞いをすることがあります。これは特にデバッグ時に当てはまります。一般的なオブジェクト-プロパティ変換/検出ユーティリティ関数はエラーを生成したり、単に情報を失ったりする可能性があるからです (特にエラーを無視するサイレントエラートラップを使用している場合)。例えば、ここに 2 つのオブジェクトがあります。

```js
oco = Object.create( {} );   // 通常のオブジェクトを生成
ocn = Object.create( null ); // "null" オブジェクトを生成

> console.log(oco) // {} -- 普通に見えます
> console.log(ocn) // {} -- これまでのところ、普通に見えます

oco.p = 1; // 通常オブジェクトに単純なプロパティを生成
ocn.p = 0; // "null" オブジェクトに単純なプロパティを生成

> console.log(oco) // {p: 1} -- まだ普通に見えます
> console.log(ocn) // {p: 0} -- まだ普通に見えますが、待ってください...
```

上記のように、今のところすべてが正常なように見えます。しかし、実際に使ってみると、その違いはすぐに明らかになります。

```js
> "oco is: " + oco // "oco is: [object Object]" と表示

> "ocn is: " + ocn // エラーが発生: Cannot convert object to primitive value
```

多くの最も基本的な組み込み機能のほんの一部をテストするだけで、問題の大きさがより明確にわかります。

```js
> alert(oco) // [object Object] と表示
> alert(ocn) // エラーが発生: Cannot convert object to primitive value

> oco.toString() // [object Object] と表示
> ocn.toString() // エラーが発生: ocn.toString is not a function

> oco.valueOf() // {} と表示
> ocn.valueOf() // エラーが発生: ocn.valueOf is not a function

> oco.hasOwnProperty("p") // "true" と表示
> ocn.hasOwnProperty("p") // エラーが発生: ocn.hasOwnProperty is not a function

> oco.constructor // "Object() { [native code] }" と表示
> ocn.constructor // "undefined" と表示
```

このように、これらの違いにより、一見単純そうに見える問題であっても、デバッグがすぐに迷走してしまうことがあります。例えば、以下のようなものです。

*シンプルな共通デバッグ関数です。*

```js
// 与えられたオブジェクトの最上位のプロパティ名と値の組を表示
function ShowProperties(obj) {
  for (var prop in obj) {
    console.log(prop + ": " + obj[prop] + "\n");
  }
}
```

*このような単純な結果ではありません (特にサイレントエラートラップがエラーメッセージを隠していた場合)。*

```js
ob={}; ob.po=oco; ob.pn=ocn; // 上記のテストオブジェクトをプロパティ値として使用して、複合オブジェクトを生成します。

> ShowProperties( ob ) // 最上位のプロパティを表示
- po: [object Object]
- Error: Cannot convert object to primitive value

最初のプロパティのみが表示されることに注意してください。
```

(*しかし、同じオブジェクトが単に順番が違うだけで作成されている場合 — 少なくともいくつかの実装では...*)

```js
ob={}; ob.pn=ocn; ob.po=oco; // 同じ複合オブジェクトを再度作成しますが、同じプロパティを異なる順序で作成します。

> ShowProperties( ob ) // 最上位のプロパティを表示
- Error: Cannot convert object to primitive value

どちらのプロパティも表示されないことに注意してください。
```

なお、このような順序の変化は、静的にはここにあるような異なる固定されたコードによって生じることがありますが、動的には、このようなプロパティを追加するコードの分岐が、入力やランダム変数によって実行される順序が変わることで生じることもあります。ただし、どのような順序でメンバーを追加しても、実際の反復順序は保証されません。

また、 Object.create() で生成されたオブジェクトに Object.entries() を使用すると、空の配列が返されることにも注意してください。

```js
var obj = Object.create({ a: 1, b: 2 });

> console.log(Object.entries(obj)); // "[]" と表示
```

#### いくつかの解決しない方法

オブジェクトメソッドが不足していることについての良い解決策は、すぐには見つかりません。

不足しているオブジェクトメソッドを標準オブジェクトから直接追加してもうまくいきません。

```js
ocn = Object.create( null ); // "null" オブジェクトを生成 (既出と同じ)

ocn.toString = Object.toString; // 新しいオブジェクトにはメソッドがないので、標準オブジェクトから直接代入してみる

> ocn.toString // "toString() { [native code] }" と表示 -- 存在しないメソッドが来たように見えます
> ocn.toString == Object.toString // "true" と表示 -- 標準オブジェクトのメソッドと同じように見えるメソッド

> ocn.toString() // エラー: Function.prototype.toString requires that 'this' be a Function
```

不足しているオブジェクトメソッドを新しいオブジェクトの「プロトタイプ」に直接追加してもうまくいきません。なぜなら、新しいオブジェクトは本当のプロトタイプを持っておらず (これがすべての問題における真の原因です)、プロトタイプを**直接**追加することはできないからです。

```js
ocn = Object.create( null ); // "null" オブジェクトを生成 (既出と同じ)

ocn.prototype.toString = Object.toString; // エラー: Cannot set property 'toString' of undefined

ocn.prototype = {};                       // プロトタイプを生成してみる
ocn.prototype.toString = Object.toString; // 新しいオブジェクトにはメソッドがないので、標準オブジェクトから代入してみる

> ocn.toString() // エラー: ocn.toString is not a function
```

`Object.setPrototypeOf()` の第 2 引数に標準オブジェクト自身の名前を指定して、不足しているオブジェクトメソッドを追加しようとしても、うまくいきません。

```js
ocn = Object.create( null );        // "null" オブジェクトを生成 (既出と同じ)
Object.setPrototypeOf(ocn, Object); // 間違い。新しいオブジェクトのプロトタイプを Object() 関数に設定している

> ocn.toString() // エラー: Function.prototype.toString requires that 'this' be a Function
```

#### いくつかの解決方法

繰り返しになりますが、欠落しているオブジェクトメソッドを**標準オブジェクト**から直接追加しても動作しません。しかし、**ジェネリック**メソッドを直接追加すると、動作します。

```js
ocn = Object.create( null ); // "null" オブジェクトを生成 (既出と同じ)

ocn.toString = toString; // 新しいオブジェクトにはメソッドがないので、ジェネリック版から直接代入する

> ocn.toString() // "[object Object]" と表示
> "ocn is: " + ocn // "ocn is: [object Object]" と表示

ob={}; ob.pn=ocn; ob.po=oco; // 複合オブジェクトを生成 (既出と同じ)

> ShowProperties(ob) // 最上位のプロパティを表示
- po: [object Object]
- pn: [object Object]
```

しかし、ジェネリック**プロトタイプ**を新しいオブジェクトのプロトタイプとして設定すると、さらに効果的です。

```js
ocn = Object.create(null); // "null" オブジェクトを生成 (既出と同じ)
Object.setPrototypeOf(ocn, Object.prototype); // 新しいオブジェクトのプロトタイプを (標準オブジェクトではなく) 「ジェネリック」オブジェクトに設定
```

(*上記の文字列関連の関数に加えて、以下の関数も追加されています*)

```js
> ocn.valueOf() // {} と表示
> ocn.hasOwnProperty("x") // "false" と表示
> ocn.constructor // "Object() { [native code] }" と表示

// ...そして、それ以外の Object.prototype のすべてのプロパティとメソッドも
```

このように、この方法で変更されたオブジェクトは、普通のオブジェクトと同じように見えます。

例
-

### `Object.create()` を用いた古典的な継承

以下の例は、古典的な継承をするための `Object.create()` の使用方法です。これは、すべての JavaScript が対応している単一継承です。

```js
// Shape - スーパークラス
function Shape() {
  this.x = 0;
  this.y = 0;
}

// スーパークラスのメソッド
Shape.prototype.move = function (x, y) {
  this.x += x;
  this.y += y;
  console.info("Shape moved.");
};

// Rectangle - サブクラス
function Rectangle() {
  Shape.call(this); // call super constructor.
}

// サブクラスはスーパークラスを拡張する
Rectangle.prototype = Object.create(Shape.prototype);

// Rectangle.prototype.constructor を Rectangle に設定しないと、
// Shape (親) の prototype.constructor を取ることになります。
// これを防ぐために、 prototype.constructor を Rectangle (子) に設定します。
Rectangle.prototype.constructor = Rectangle;

var rect = new Rectangle();

console.log("Is rect an instance of Rectangle?", rect instanceof Rectangle); // true
console.log("Is rect an instance of Shape?", rect instanceof Shape); // true
rect.move(1, 1); // Outputs, 'Shape moved.'
```

### Object.create() と propertiesObject 引数の併用

```js
var o;

// プロトタイプを null にしてオブジェクトを生成
o = Object.create(null);

o = {};
// これは次のものと同等です。
o = Object.create(Object.prototype);

// いくつかのサンプルプロパティを持つオブジェクトを作成
// する例です。(2 番目の引数は、キーを\*プロパティ記述子\*に
// マッピングしていることに注意してください。)
o = Object.create(Object.prototype, {
  // foo は普通の「値プロパティ」です
  foo: {
    writable: true,
    configurable: true,
    value: "hello",
  },
  // bar はゲッターとセッター (アクセサー) によるプロパティです
  bar: {
    configurable: false,
    get: function () {
      return 10;
    },
    set: function (value) {
      console.log("Setting `o.bar` to", value);
    },
    /\* ES2015 のアクセサーでは、このようになります。
 get() { return 10; },
 set(value) {
 console.log('Setting `o.bar` to', value);
 } \*/
  },
});

function Constructor() {}
o = new Constructor();
// これは次のものと同等です。
o = Object.create(Constructor.prototype);
// もちろん、コンストラクター関数に実際の初期化
// コードがある場合は、 Object.create() には反映
// されません

// プロトタイプが新規の空オブジェクトである新しいオブジェクトを
// 生成し、単一のプロパティ 'p' を値を 42 にして追加します。
o = Object.create({}, { p: { value: 42 } });

// 既定では、プロパティは書き込み可能、列挙可能、構成可能ではありません
o.p = 24;
o.p;
// 42

o.q = 12;
for (var prop in o) {
  console.log(prop);
}
// 'q'

delete o.p;
// false

// ES3 プロパティを指定
o2 = Object.create(
  {},
  {
    p: {
      value: 42,
      writable: true,
      enumerable: true,
      configurable: true,
    },
  },
);
/\* 次のものと同じではありません。
これはプロトタイプが {p: 42 } であるオブジェクトを生成します。
o2 = Object.create({p: 42}) \*/
```

仕様書
---

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

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

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

関連情報
----

* `Object.create` のポリフィルは `core-js` で利用できます
* `Object.defineProperty()`
* `Object.defineProperties()`
* `Object.prototype.isPrototypeOf()`
* `Reflect.construct()`
* John Resig の getPrototypeOf() の投稿


Object.prototype.__defineSetter__() - JavaScript

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

**警告:** この機能は非推奨となり、オブジェクト初期化子の構文または `Object.defineProperty()` API を使用してセッターを定義する方法で置き換えられました。

ただし、ウェブ上では広く実装され利用されているため、ブラウザーが実装をやめる可能性は極めて低いと考えられます。

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

構文
--

```js
\_\_defineSetter\_\_(prop, fun);
```

### 引数

`prop`

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

`fun`

プロパティへ値を設定しようとしたときに呼び出される関数です。この関数は以下の形式をとります。

```js
function(val) { . . . }
```

`val`

`prop` へ代入しようとする値を保持する変数の別名です。

### 返値

`undefined` です。

解説
--

`__defineSetter__` メソッドにより、既存のオブジェクトにセッターを定義することができます。

例
-

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

```js
var o = {};
o.\_\_defineSetter\_\_("value", function (val) {
  this.anotherValue = val;
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

### 標準準拠の方法

```js
// set 演算子の使用
var o = {
  set value(val) {
    this.anotherValue = val;
  },
};
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5

// Object.defineProperty の使用
var o = {};
Object.defineProperty(o, "value", {
  set: function (val) {
    this.anotherValue = val;
  },
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

仕様書
---

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

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

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

関連情報
----

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


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

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

**`Object` コンストラクター**は、与えられた値のオブジェクトラッパーを生成します。

* その値が `null` または `undefined` である場合、空のオブジェクトを生成して返します。
* そうでない場合は、与えらえた値に対応する型のオブジェクトを返します。
* 値がすでにオブジェクトであった場合は、その値を返します。

コンストラクターではない場面で `Object` が呼び出された場合は、 `new Object()` と同様に動作します。

構文
--

```js
new Object();
new Object(value);
```

### 引数

`value`

任意の値。

例
-

### 新しい Object の生成

```js
let o = new Object();
o.foo = 42;

console.log(o);
// Object { foo: 42 }
```

### `undefined` や `null` 型を指定して `Object` を使用

以下の例は、空の `Object` オブジェクトを `o` に格納します。

```js
let o = new Object();
```

```js
let o = new Object(undefined);
```

```js
let o = new Object(null);
```

仕様書
---

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

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

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

関連情報
----

* オブジェクト初期化子


Object.groupBy() - JavaScript

Object.groupBy()
================

Limited availability
--------------------

This feature is not Baseline because it does not work in some of the most widely-used browsers.

* Learn more
* See full compatibility
* Report feedback

**メモ:** 一部のブラウザーのあるバージョンでは、このメソッドは `Array.prototype.group()` というメソッドとして実装されていました。ウェブの互換性の問題により、現在は静的メソッドとして実装されています。詳細はブラウザーの互換性を確認してください。

**`Object.groupBy()`** 静的メソッドは、指定されたコールバック関数によって返された文字列値に従って、指定された反復可能な要素をグループ化します。返されるオブジェクトには、グループごとに個別のプロパティがあり、グループ内の要素を含む配列が格納されます。

このメソッドは、グループ名が文字列で表現できる場合に使用します。任意の値をキーとして要素をグループ化する必要がある場合は、代わりに `Map.groupBy()` を使用してください。

構文
--

```js
Object.groupBy(items, callbackFn)
```

### 引数

`items`

要素がグループ化される反復可能な要素（`Array` など）。

`callbackFn`

反復可能な各要素に対して実行される関数。これは、現在の要素のグループを示すプロパティのキー（文字列またはシンボル）に変換できる値を返す必要があります。この関数は以下の引数で呼び出されます。

`element`

現在処理中の要素。

`index`

現在処理中の要素のインデックス。

### 返値

すべてのグループのプロパティを持つ `null`-prototype object で、それぞれに関連するグループの要素を含む配列が割り当てられたものです。

解説
--

`Object.groupBy()` は、指定された `callbackFn` 関数を反復可能な要素ごとに 1 回呼び出します。コールバック関数は、関連付けられた要素のグループを示す文字列またはシンボル（どちらの型でもない値は文字列変換されます）を返す必要があります。`callbackFn` が返す値は、`Map.groupBy()` が返すオブジェクトのキーとして使用されます。各キーには、コールバックが同じ値を返したすべての要素を含む連想配列があります。

返されたオブジェクトの要素と元の反復可能な要素は同じです（ディープコピーではありません）。要素の内部構造を変更すると、反復可能な要素と返されたオブジェクトの両方に反映されます。

例
-

### Object.groupBy() の使用

最初に、さまざまな食品の在庫を表すオブジェクトを含む配列を定義します。 それぞれの食品は `type` （種類）と `quantity` （量）を保有しています。

```js
const inventory = [
  { name: "asparagus", type: "vegetables", quantity: 5 },
  { name: "bananas", type: "fruit", quantity: 0 },
  { name: "goat", type: "meat", quantity: 23 },
  { name: "cherries", type: "fruit", quantity: 5 },
  { name: "fish", type: "meat", quantity: 22 },
];
```

以下のコードでは、`type` プロパティの値によって要素をグループ化します。

```js
const result = Object.groupBy(inventory, ({ type }) => type);

/\* 結果:
{
 vegetables: [
 { name: 'asparagus', type: 'vegetables', quantity: 5 },
 ],
 fruit: [
 { name: "bananas", type: "fruit", quantity: 0 },
 { name: "cherries", type: "fruit", quantity: 5 }
 ],
 meat: [
 { name: "goat", type: "meat", quantity: 23 },
 { name: "fish", type: "meat", quantity: 22 }
 ]
}
\*/
```

このアロー関数は、呼び出されるたびに配列のそれぞれの要素の 型 を返すだけです。 関数の引数 { type } は、関数の引数に対するオブジェクトの分割構文の基本例であることに注意してください。 これは、引数として渡されたオブジェクトの `type` プロパティを展開し、関数本体の `type` という名前の変数に代入します。 これは、関数内の要素に関連する値にアクセスするためのとても簡潔な方法です。

また、要素の 1 つまたは複数のプロパティの値から推測されるグループを作成することもできます。 以下は、`quantity` フィールドの値に基づいて、項目を `ok` または `restock` グループに入れる、とても似たような例です。

```js
function myCallback({ quantity }) {
  return quantity > 5 ? "ok" : "restock";
}

const result2 = Object.groupBy(inventory, myCallback);

/\* 結果:
{
 restock: [
 { name: "asparagus", type: "vegetables", quantity: 5 },
 { name: "bananas", type: "fruit", quantity: 0 },
 { name: "cherries", type: "fruit", quantity: 5 }
 ],
 ok: [
 { name: "goat", type: "meat", quantity: 23 },
 { name: "fish", type: "meat", quantity: 22 }
 ]
}
\*/
```

仕様書
---

| Specification |
| --- |
| Array Grouping # sec-object.groupby |

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

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

関連情報
----

* `Object.groupBy` のポリフィル (`core-js`)
* インデックス付きコレクション
* `Array.prototype.reduce()`
* `Object.fromEntries()`
* `Map.groupBy()`


Object.freeze() - JavaScript

Object.freeze()
===============

**`Object.freeze()`** メソッドはオブジェクトを**凍結**します。凍結されたオブジェクトは変更できなくなります。オブジェクトを凍結すると、新しいプロパティを追加したり、既存のプロパティを削除したりすることができなくなり、既存のプロパティに対する列挙可否、構成可否、書き込み可否の変更ができなくなり、既存のプロパティの値が変更できなくなります。加えて、オブジェクトを凍結するとプロトタイプも変更できなくなります。`freeze()` は渡されたものと同じオブジェクトを返します。

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

構文
--
```

Object.freeze(obj)
```

### 引数

`obj`

凍結するオブジェクトです。

### 返値

この関数に渡されたオブジェクトです。

説明
--

凍結されたオブジェクトにプロパティのセットを追加あるいは削除することはできません。実行しようとすると暗黙に失敗するか、または `TypeError` 例外が発生して失敗します (多くの場合は、ただし厳格モードではこれに限りません)。

凍結されたオブジェクトデータプロパティについては、値を変更することはできず、構成可否、書き込み可否の属性は false に設定されます。アクセサープロパティ (ゲッターおよびセッター) は同様に動作します (そして、値を変更しているかのようにみえます)。なお、オブジェクトである値については、それも凍結されていない限り変更可能です。オブジェクトとして、配列は凍結可能です。凍結すると、要素が変更可能ではなくなり、配列に対する要素の追加や削除ができなくなります。

`freeze()` は関数に渡されたものと同じオブジェクトを返します。凍結されたコピーを生成する訳では*ありません*。

ECMAScript 5 では、このメソッドの引数がオブジェクトではない (プリミティブである) 場合、`TypeError` が発生します。ECMAScript 2015 では、オブジェクトではない引数は通常の凍結済みのオブジェクトである場合と同様に扱い、単純に返されます。

```js
> Object.freeze(1)
TypeError: 1 is not an object // ES5 のコード

> Object.freeze(1)
1                             // ES2015 のコード
```

要素を伴う `ArrayBufferView` (en-US) では、メモリー上のビューであり絶対的に他の問題の可能性があるため、`TypeError` が発生します。

```js
> Object.freeze(new Uint8Array(0)) // 要素なし
Uint8Array []

> Object.freeze(new Uint8Array(1)) // 要素あり
TypeError: Cannot freeze array buffer views with elements

> Object.freeze(new DataView(new ArrayBuffer(32))) // 要素なし
DataView {}

> Object.freeze(new Float64Array(new ArrayBuffer(64), 63, 0)) // 要素なし
Float64Array []

> Object.freeze(new Float64Array(new ArrayBuffer(64), 32, 2)) // 要素あり
TypeError: Cannot freeze array buffer views with elements
```

なお、標準の 3 つのプロパティ (`buf.byteLength`, `buf.byteOffset` and `buf.buffer`) は読み取り専用ですので (`ArrayBuffer` または `SharedArrayBuffer` の場合)、これらのプロパティを凍結しようとする理由はありません。

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

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

例
-

### オブジェクトの凍結

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

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

// 凍結
const o = Object.freeze(obj);

// 返値は渡したオブジェクトとまったく同じものです。
o === obj; // true

// オブジェクトは凍結されています。
Object.isFrozen(obj); // === true

// すべての変更が失敗するようになりました
obj.foo = "quux"; // 暗黙的に何も行われません
// 暗黙的にプロパティは追加されません
obj.quaxxor = "the friendly duck";

// また、厳格モードではこれらの試みに対して TypeError が発生します
function fail() {
  "use strict";
  obj.foo = "sparky"; // TypeError が発生
  delete obj.foo; // TypeError が発生
  delete obj.quaxxor; // 属性 'quaxxor' が追加されたことがないため true を返す
  obj.sparky = "arf"; // TypeError が発生
}

fail();

// Object.defineProperty; から変更を試みますが、
// 以下のどちらの文も TypeError が発生します。
Object.defineProperty(obj, "ohai", { value: 17 });
Object.defineProperty(obj, "foo", { value: "eit" });

// プロトタイプを変更することもできず、
// 以下のどちらの文も TypeError が発生します。
Object.setPrototypeOf(obj, { x: 20 });
obj.__proto__ = { x: 20 };
```

### 配列の凍結

```js
let a = [0];
Object.freeze(a); // 配列が変更できなくなりました。

a[0] = 1; // 暗黙に失敗

// 厳格モードで試みると TypeError が発生します
function fail() {
  "use strict";
  a[0] = 1;
}

fail();

// push を試みる
a.push(2); // TypeError が発生
```

凍結されたオブジェクトは*不変*になります。しかし、*定数*であるとは限りません。以下の例では、凍結されたオブジェクトが定数ではないことを示しています (凍結が浅い)。

```js
const obj1 = {
  internal: {},
};

Object.freeze(obj1);
obj1.internal.a = "aValue";

obj1.internal.a; // 'aValue'
```

定数オブジェクトになるには、参照のつながり全体 (他のオブジェクトへの直接または間接的な参照) が不変で凍結されたオブジェクトのみを参照していなければなりません。凍結されるオブジェクトは、オブジェクト全体の中にあるオブジェクトの*状態* (値と他のオブジェクトへの参照) がすべて固定されているので、不変ということができます。なお、文字列、数値、真偽値はすべて不変となり、関数や配列はオブジェクト扱いです。

#### 浅い凍結とは

`Object.freeze(object)` を呼び出した結果は、`object` の直属のプロパティにのみ適用され、`object` 上*のみ*に対するその後のプロパティの追加、削除、値の再割り当て操作を禁止します。これらのプロパティの値がオブジェクトそのものであった場合、これらのオブジェクトは凍結されず、プロパティの追加、削除、値の再割り当て操作の対象になり得ます。

```js
const employee = {
  name: "Mayank",
  designation: "Developer",
  address: {
    street: "Rohini",
    city: "Delhi",
  },
};

Object.freeze(employee);

employee.name = "Dummy"; // 非 strict モードでは暗黙に失敗
employee.address.city = "Noida"; // 子オブジェクトの属性は変更できる

console.log(employee.address.city); // 出力: "Noida"
```

オブジェクトを不変にするには、オブジェクト型のプロパティをそれぞれ再帰的に凍結させてください (深い凍結)。オブジェクトが参照グラフに閉路を含まないことが分かっている場合は、デザインパターンに基づいてケースバイケースのパターンを使用してください。そうでないと、無限ループが発生します。`deepFreeze()` をパス (例えば配列) 引数を受け取る内部関数を持つよう拡張すると、オブジェクトを不変にするプロセスにいるときに、`deepFreeze()` が再帰的に呼び出されることを防ぐことができます。凍結させてはいけない [window] のようなオブジェクトを凍結させる危険性がなおあります。

```js
function deepFreeze(object) {
  // オブジェクトで定義されたプロパティ名を取得
  const propNames = Object.getOwnPropertyNames(object);

  // 自分自身を凍結する前にプロパティを凍結

  for (const name of propNames) {
    const value = object[name];

    if (value && typeof value === "object") {
      deepFreeze(value);
    }
  }

  return Object.freeze(object);
}

const obj2 = {
  internal: {
    a: null,
  },
};

deepFreeze(obj2);

obj2.internal.a = "anotherValue"; // 非 strict モードでは暗黙に失敗
obj2.internal.a; // null
```

仕様書
---

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

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

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

関連情報
----

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


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

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

**`Int16Array()`** は型付き配列のコンストラクターで、プラットフォームのバイト順による 2 の補数形式の 16 ビット符号付き整数値の配列を生成します。バイト順の制御が必要な場合は、代わりに `DataView` を使用してください。中身は `0` で初期化されます。生成されると、配列の中の要素はオブジェクトのメソッドを使用するか、配列の標準的な添字の構文を使用するか (すなわち、ブラケット構文を使用するか) して参照することができます。

構文
--
```

new Int16Array(); // new in ES2017
new Int16Array(length);
new Int16Array(typedArray);
new Int16Array(object);
new Int16Array(buffer [, byteOffset [, length]]);
```

### 引数

`length`

`length` 引数付きで呼び出されると、メモリ内に内部的な配列バッファーを作成し、大きさは `length` *を `BYTES_PER_ELEMENT`* で乗じたバイト数になり、ゼロになることもあります。

`typedArray`

`typedArray` 引数付きで呼び出されると、これはあらゆる型付き配列型 (例えば `Int32Array`) にすることができますが、 `typedArray` を新しい型付き配列にコピーします。 `typedArray` の中のそれぞれの値は、新しい配列にコピーされる前にコンストラクターの対応する型に変換されます。新しい型付き配列の長さは `typedArray` 引数の長さと同じになります。

`object`

`object` 引数付きで呼び出されると、あたかも `TypedArray.from()` メソッドであるかのように新しい型付き配列が生成されます。

`buffer`, `byteOffset`, `length`

`buffer` と、オプションで `byteOffset` と `length` 引数を指定して呼び出されると、指定された `ArrayBuffer` を表示する型付き配列ビューが生成されます。 `byteOffset` および `length` 引数は、型付き配列ビューが表示するメモリ範囲を指定する。 両方を省略した場合は `buffer` の全てを表示し、 `length` のみを省略した場合は `buffer` の残りを表示します。

例
-

### 様々な方法による Int16Array の生成

```js
// From a length
var int16 = new Int16Array(2);
int16[0] = 42;
console.log(int16[0]); // 42
console.log(int16.length); // 2
console.log(int16.BYTES\_PER\_ELEMENT); // 2

// From an array
var arr = new Int16Array([21, 31]);
console.log(arr[1]); // 31

// From another TypedArray
var x = new Int16Array([21, 31]);
var y = new Int16Array(x);
console.log(y[0]); // 21

// From an ArrayBuffer
var buffer = new ArrayBuffer(8);
var z = new Int16Array(buffer, 0, 4);

// From an iterable
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var int16 = new Int16Array(iterable);
// Int16Array[1, 2, 3]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray-constructors |

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

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

### 互換性メモ

ECMAScript 2015 から、 `Int16Array` コンストラクターは構築に `new` 演算子が必要になりました。 `Int16Array` コンストラクターを `new` なしで関数として呼び出すと、 `TypeError` が発生するようになりました。

```js
var dv = Int16Array([1, 2, 3]);
// TypeError: calling a builtin Int16Array constructor
// without new is forbidden
```

```js
var dv = new Int16Array([1, 2, 3]);
```

関連情報
----

* JavaScript 型付き配列
* `ArrayBuffer`
* `DataView`


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

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

**`TypeError()`** コンストラクターは、演算が実行できなくなった時の新しいエラーを生成します。特に値が期待された型ではなかった場合です (ただし、それに限りません)。

構文
--
```

new TypeError([message[, fileName[, lineNumber]]])
```

### 引数

`message` 省略可

人間が読むためのエラーの説明です。

`fileName` 省略可

例外が発生したコードを含むファイルの名前です。

`lineNumber` 省略可

例外が発生したコードの行番号です。

例
-

### TypeError の捕捉

```js
try {
  null.f();
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "null has no properties"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### TypeError の生成

```js
try {
  throw new TypeError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-nativeerror-constructors |

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

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

関連情報
----

* `Error`


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

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

**`Int8Array()`** は型付き配列のコンストラクターで、 2 の補数形式の 8 ビット符号付き整数値の型付き配列を生成します。中身は `0` で初期化されます。生成されると、配列の中の要素はオブジェクトのメソッドを使用するか、配列の標準的な添字の構文を使用するか (すなわち、ブラケット構文を使用するか) して参照することができます。

構文
--
```

new Int8Array(); // new in ES2017
new Int8Array(length);
new Int8Array(typedArray);
new Int8Array(object);
new Int8Array(buffer [, byteOffset [, length]]);
```

### 引数

`length`

`length` 引数付きで呼び出されると、メモリ内に内部的な配列バッファーを作成し、大きさは `length` *を `BYTES_PER_ELEMENT`* で乗じたバイト数になり、ゼロになることもあります。

`typedArray`

`typedArray` 引数付きで呼び出されると、これはあらゆる型付き配列型 (例えば `Int32Array`) にすることができますが、 `typedArray` を新しい型付き配列にコピーします。 `typedArray` の中のそれぞれの値は、新しい配列にコピーされる前にコンストラクターの対応する型に変換されます。新しい型付き配列の長さは `typedArray` 引数の長さと同じになります。

`object`

`object` 引数付きで呼び出されると、あたかも `TypedArray.from()` メソッドであるかのように新しい型付き配列が生成されます。

`buffer`, `byteOffset`, `length`

`buffer` と、オプションで `byteOffset` と `length` 引数を指定して呼び出されると、指定された `ArrayBuffer` を表示する型付き配列ビューが生成されます。 `byteOffset` および `length` 引数は、型付き配列ビューが表示するメモリ範囲を指定する。 両方を省略した場合は `buffer` の全てを表示し、 `length` のみを省略した場合は `buffer` の残りを表示します。

例
-

### 様々な方法による Int8Array の生成

```js
// 長さの指定
var int8 = new Int8Array(2);
int8[0] = 42;
console.log(int8[0]); // 42
console.log(int8.length); // 2
console.log(int8.BYTES\_PER\_ELEMENT); // 1

// 配列から
var arr = new Int8Array([21, 31]);
console.log(arr[1]); // 31

// 他の型付き配列から
var x = new Int8Array([21, 31]);
var y = new Int8Array(x);
console.log(y[0]); // 21

// ArrayBuffer から
var buffer = new ArrayBuffer(8);
var z = new Int8Array(buffer, 1, 4);

// 反復可能オブジェクトから
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var int8 = new Int8Array(iterable);
// Int8Array[1, 2, 3]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray-constructors |

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

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

### 互換性メモ

ECMAScript 2015 から、 `Int8Array` コンストラクターは構築に `new` 演算子が必要になりました。 `Int8Array` コンストラクターを `new` なしで関数として呼び出すと、 `TypeError` が発生するようになりました。

```js
var dv = Int8Array([1, 2, 3]);
// TypeError: calling a builtin Int8Array constructor
// without new is forbidden
```

```js
var dv = new Int8Array([1, 2, 3]);
```

関連情報
----

* JavaScript 型付き配列
* `ArrayBuffer`
* `DataView`


Math.LOG2E - JavaScript

Math.LOG2E
==========

**`Math.LOG2E`** プロパティは 2 を底とした e の対数、約 1.442 を表します。

Math.LOG2E

=

log
2

(
e
)
≈
1.442

\mathtt{\mi{Math.LOG2E}} = \log\_2(e) \approx 1.442

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

| `Math.LOG2E` のプロパティ属性 |
| --- |
| 書込可能 | 不可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

解説
--

`LOG2E` は `Math` オブジェクトの静的プロパティなので、 `Math` オブジェクトを生成してプロパティとして使用するのではなく、常に `Math.LOG2E` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.LOG2E の使用

以下の関数は、2 を底とした e の対数を返します。

```js
function getLog2e() {
  return Math.LOG2E;
}

getLog2e(); // 1.4426950408889634
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log2e |

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

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

関連情報
----

* `Math.exp()`
* `Math.log()`
* `Math.log2()`


Math.sqrt() - JavaScript

Math.sqrt()
===========

**`Math.sqrt()`** 関数は、ある数の平方根を返します。すなわち、

∀
x
≥
0
,

M
a
t
h
.
s
q
r
t
(
x
)

=

x

=
the unique

y
≥
0

such that

y
2

=
x

\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} ; y \geq 0 ; \text{such that} ; y^2 = x

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

構文
--
```

Math.sqrt(x)
```

### 引数

`x`

数値です。

### 返値

与えられた数値の平方根です。数値が負の場合、 `NaN` を返します。

解説
--

`x` の値が負の数であった場合、 `Math.sqrt()` は `NaN` を返します。

`sqrt()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.sqrt()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.sqrt() の使用

```js
Math.sqrt(9); // 3
Math.sqrt(2); // 1.414213562373095

Math.sqrt(1); // 1
Math.sqrt(0); // 0
Math.sqrt(-1); // NaN
Math.sqrt(-0); // -0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt |

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

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

関連情報
----

* `Math.cbrt()`
* `Math.exp()`
* `Math.log()`
* `Math.pow()`


Math.min() - JavaScript

Math.min()
==========

**`Math.min()`** は静的関数で、引数で渡されたもののうち最小の値を返します。または引数のいずれかが数値以外で、数値に変換できない場合は `NaN` を返します。

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

構文
--
```

Math.min([value1[, value2[, ...]]])
```

### 引数

`value1, value2, ...`

最小値が選択して返される 0 個以上の数値です。

### 返値

与えられた数のうちの最小の値です。1 つ以上の引数を数値に変換することができなかった場合は `NaN` を返します。引数が与えられなかった場合の結果は `Infinity` です。

解説
--

`min()` は `Math` の静的メソッドなので、常に `Math.min()` として使用し、自分で `Math` オブジェクトを生成してそのメソッドとして使用しないでください。 (`Math` にはコンストラクターがありません)。

引数が与えられなかった場合の結果は `Infinity` です。

1 つでも数値に変換できない引数が渡された場合、結果は `NaN` になります。

例
-

### Math.min() の使用

変数 `x` と `y` の小さい方を `z` に代入します。

```js
var x = 10,
  y = -20;
var z = Math.min(x, y);
```

### Math.min() で値をクリップする

`Math.min()` は、次のようにしきい値以下に値をクリップするために用いられることがあります。

```js
var x = f(foo);

if (x > boundary) {
  x = boundary;
}
```

これは次のように書くことができます。

```js
var x = Math.min(f(foo), boundary);
```

`Math.max()` を用いれば、反対に、しきい値以上に値をクリップすることができます。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.min |

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

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

関連情報
----

* `Math.max()`


Math.max() - JavaScript

Math.max()
==========

**`Math.max()`** 関数は、入力引数として与えられた 0 個以上の数値のうち最大の数を返します。引数がなかった場合は -`Infinity` を返します。

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

構文
--

```js
Math.max()
Math.max(value0)
Math.max(value0, value1)
Math.max(value0, value1, /\* … ,\*/ valueN)
```

### 引数

`value1`, `value2`, … , `valueN`

最大値を選択して返すための、 0 個以上の数値です。

### 返値

与えられた数のうちの最大の値です。何れかの引数が `NaN` であるか、それに変換された場合は `NaN` を返します。引数が与えられなかった場合は -`Infinity` を返します。

解説
--

`max()` は `Math` の静的メソッドですので、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.max()` として使用してください（`Math` はコンストラクターではありません）。

`Math.max.length` は 2 であり、最低でも 2 つの引数を処理するよう設計されていることを示唆しています。

例
-

### Math.max() の使用

```js
Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20
```

### 配列の最大値の取得

`Array.prototype.reduce()` を使用して、数値の配列の中にある最大値の要素を、それぞれの値を比較して探し出すことができます。

```js
const arr = [1, 2, 3];
const max = arr.reduce((a, b) => Math.max(a, b), -Infinity);
```

次の関数では `Function.prototype.apply()` を使用して配列の最大値を取得します。 `getMaxOfArray([1, 2, 3])` は `Math.max(1, 2, 3)` と同等ですが、 `getMaxOfArray()` はプログラム的に構築された配列に使用することができます。これは比較的要素が少ない配列に対して使用してください。

```js
function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}
```

新しいスプレッド構文で、 `apply` によって配列の最大値を得る方法をより短く書くことができます。

```js
const arr = [1, 2, 3];
const max = Math.max(...arr);
```

しかし、スプレッド構文の (`...`) と `apply` のどちらも、配列に膨大な要素があった場合は、配列の要素を関数の引数として渡そうとするため、失敗したり、誤った結果を返したりすることがあります。詳しくは apply を組み込み関数と共に利用するを参照してください。 `reduce` の方法はこの問題が発生しません。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.max |

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

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

関連情報
----

* `Math.min()`


Math.cosh() - JavaScript

Math.cosh()
===========

**`Math.cosh()`** 関数は、引数として与えた数の双曲線余弦 (ハイパーボリックコサイン) を返します。これは定数 e を使用して次のように表すことができます。

Math.cosh(x)

=

e
x

+

e

-
x

2

\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}

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

構文
--
```

Math.cosh(x)
```

### 引数

`x`

数値。

### 返値

指定された数値の双曲線余弦 (ハイパーボリックコサイン) です。

解説
--

`cosh()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.cosh()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.cosh() の使用

```js
Math.cosh(0); // 1
Math.cosh(1); // 1.5430806348152437
Math.cosh(-1); // 1.5430806348152437
```

ポリフィル
-----

これは `Math.exp()` 関数を使用して次のようにエミュレートできます。

```js
Math.cosh =
  Math.cosh ||
  function (x) {
    return (Math.exp(x) + Math.exp(-x)) / 2;
  };
```

または `Math.exp()` 関数を一度だけ呼び出すようにすると、次のようになります。

```js
Math.cosh =
  Math.cosh ||
  function (x) {
    var y = Math.exp(x);
    return (y + 1 / y) / 2;
  };
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cosh |

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

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

関連情報
----

* `Math.acosh()`
* `Math.asinh()`
* `Math.atanh()`
* `Math.sinh()`
* `Math.tanh()`