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

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

**`Proxy()`** コンストラクターは `Proxy` オブジェクトを生成するために使用します。

構文
--

```js
new Proxy(target, handler)
```

**メモ:** `Proxy()` は、`new` を使ってのみ構築することができます。`new` なしで呼び出そうとすると、`TypeError` が発生します。

### 引数

`target`

`Proxy` でラップするターゲットのオブジェクトです。あらゆる種類のオブジェクト、例えばネイティブ配列や関数、別のプロキシーなどがなることができます。

`handler`

関数をプロパティとして持つオブジェクトで、その関数で、 Proxy `p` に対して操作が行われた場合の挙動を定義します。

解説
--

`Proxy()` コンストラクターを使用すると、新しい `Proxy` オブジェクトを生成できます。
 このコンストラクターは 2 つの必須の引数を取ります。

* `target` はプロキシーを作成するオブジェクトです。
* `handler` はプロキシーのカスタム動作を定義するオブジェクトです。

handler を空にすると、ほとんどすべての点でターゲットとまったく同じように振る舞うプロキシーを作成します。 `handler` オブジェクト上で関数群のいずれかを定義することで、プロキシーの動作の特定の側面をカスタマイズすることができます。例えば、 `get()` を定義することで、 ターゲットのプロパティアクセサーのカスタマイズされたバージョンを提供することができます。

### ハンドラー関数

この節では、定義することができるすべてのハンドラー関数を列挙します。ハンドラー関数は、対象オブジェクトの呼び出しをトラップするので、*トラップ*と呼ばれることがあります。

`handler.apply()`

関数呼び出しのトラップです。

`handler.construct()`

`new` 演算子のトラップです。

`handler.defineProperty()`

`Object.defineProperty` のトラップです。

`handler.deleteProperty()`

`delete` 演算子のトラップです。

`handler.get()`

プロパティ値の取得のトラップです。

`handler.getOwnPropertyDescriptor()`

`Object.getOwnPropertyDescriptor` のトラップです。

`handler.getPrototypeOf()`

`Object.getPrototypeOf` のトラップです。

`handler.has()`

`in` 演算子のトラップです。

`handler.isExtensible()`

`Object.isExtensible` のトラップです。

`handler.ownKeys()`

`Object.getOwnPropertyNames` や `Object.getOwnPropertySymbols` のトラップです。

`handler.preventExtensions()`

`Object.preventExtensions` のトラップです。

`handler.set()`

プロパティ値の設定のトラップです。

`handler.setPrototypeOf()`

`Object.setPrototypeOf` のトラップです。

例
-

### 選択的にプロパティアクセサーのプロキシーを行う

この例では、ターゲットは `notProxied` と `proxied` の 2 つのプロパティを持っています。 `proxied` に別の値を返し、それ以外のアクセスをターゲットに許可するハンドラーを定義します。

```js
const target = {
  notProxied: "original value",
  proxied: "original value",
};

const handler = {
  get(target, prop, receiver) {
    if (prop === "proxied") {
      return "replaced value";
    }
    return Reflect.get(...arguments);
  },
};

const proxy = new Proxy(target, handler);

console.log(proxy.notProxied); // "original value"
console.log(proxy.proxied); // "replaced value"
```

仕様書
---

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

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

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

関連情報
----

* JavaScript Guide ガイドの `Proxy` と `Reflect`
* `Reflect`


handler.setPrototypeOf() - JavaScript

handler.setPrototypeOf()
========================

**`handler.setPrototypeOf()`** メソッドは、オブジェクトの `[[SetPrototypeOf]]` 内部メソッドに対するトラップです。`Object.setPrototypeOf()` などの操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  setPrototypeOf(target, prototype) {
  }
});
```

### 引数

次の引数は `setPrototypeOf()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`prototype`

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

### 返値

`setPrototypeOf()` メソッドは `[[Prototype]]` の変更に成功したら `true` を返し、そうでない場合は `false` を返します。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.setPrototypeOf()`
* `Reflect.setPrototypeOf()`

他にも、`[[SetPrototypeOf]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `target` が拡張可能でない場合、引数の `prototype` は `Object.getPrototypeOf(target)` と同じ値でなければなりません。
例
-

オブジェクトに新しいプロトタイプを設定することを禁止したい場合は、ハンドラーの `setPrototypeOf()` メソッドで `false` を返したり、例外を発生させたりするようにすることができます。

### アプローチ 1: false を返す

このアプローチでは、例外を発生させる変更操作は、それ自身で例外を生成する必要があります。

例えば、 `Object.setPrototypeOf()` は、それ自体が `TypeError` を発生させます。 `Reflect.setPrototypeOf()` のように、失敗しても通常は例外が発生しない操作で変更操作が行われた場合、例外は発生しません。

```js
const handlerReturnsFalse = {
  setPrototypeOf(target, newProto) {
    return false;
  },
};

const newProto = {},
  target = {};

const p1 = new Proxy(target, handlerReturnsFalse);
Object.setPrototypeOf(p1, newProto); // throws a TypeError
Reflect.setPrototypeOf(p1, newProto); // returns false
```

### アプローチ 2: 例外を発生

後者のアプローチでは、変更を試みるすべての操作で例外が発生します。このアプローチは、例外を発生しない操作でも失敗時に例外をは正させたい場合や、カスタムの例外値を発生させたい場合に最適です。

```js
const handlerThrows = {
  setPrototypeOf(target, newProto) {
    throw new Error("custom error");
  },
};

const newProto = {},
  target = {};

const p2 = new Proxy(target, handlerThrows);
Object.setPrototypeOf(p2, newProto); // throws new Error("custom error")
Reflect.setPrototypeOf(p2, newProto); // throws new Error("custom error")
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-setprototypeof-v |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.setPrototypeOf()`
* `Reflect.setPrototypeOf()`


handler.has() - JavaScript

handler.has()
=============

**`handler.has()`** は、オブジェクトの `[[HasProperty]]` 内部メソッドに対するトラップです。`in` 演算子などの操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  has(target, prop) {
  }
});
```

### 引数

次の引数は `has()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`prop`

存在を確認するプロパティ名です。

### 返値

`has` メソッドは論理値を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `in` 演算子: `foo in proxy`
* `with` チェック: `with(proxy) { (foo); }`
* `Reflect.has()`

他にも、`[[HasProperty]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* プロパティがターゲットオブジェクトの設定不可の独自プロパティとして存在する場合、存在しないとして報告されてはいけません。
* プロパティがターゲットオブジェクトの独自プロパティとして存在し、そのターゲットオブジェクトが拡張不可の場合、存在しないとして報告されてはいけません。
例
-

### in 演算子のトラップ

次のコードでは `in` 演算子をトラップします。

```js
const p = new Proxy(
  {},
  {
    has(target, prop) {
      console.log(`called: ${prop}`);
      return true;
    },
  },
);

console.log("a" in p);
// "called: a"
// true
```

次のコードでは不変条件に違反します。

```js
const obj = { a: 10 };
Object.preventExtensions(obj);

const p = new Proxy(obj, {
  has(target, prop) {
    return false;
  },
});

"a" in p; // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-hasproperty-p |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `in` 演算子
* `Reflect.has()`


handler.get() - JavaScript

handler.get()
=============

**`handler.get()`** は、オブジェクトの `[[Get]]` 内部メソッドに対するトラップです。プロパティアクセサーなどの操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  get(target, property, receiver) {
  }
});
```

### 引数

次の引数が `get()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクト

`property`

取得するプロパティの名称

`receiver`

プロキシー、またはプロキシーから継承するオブジェクトのどちらか

### 返値

`get()` メソッドはどんな値でも返すことができます。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* プロパティアクセス: `proxy[foo]` と `proxy.bar`
* `Reflect.get()`

他にも、`[[Get]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* ターゲットオブジェクトプロパティが書き込み不可、構成不可の自分自身のデータプロパティである場合、プロパティとして報告される値は、対応するターゲットオブジェクトプロパティの値と同じでなければなりません。
* 対応する対象オブジェクトのプロパティが、`[[Get]]` 属性として `undefined` を持つ、構成不可の自分自身のアクセサープロパティである場合、プロパティに対して報告される値は undefined でなければなりません。
例
-

### プロパティ値の取得のトラップ

次のコードではプロパティ値の取得をトラップします。

```js
const p = new Proxy(
  {},
  {
    get(target, property, receiver) {
      console.log(`called: ${property}`);
      return 10;
    },
  },
);

console.log(p.a);
// "called: a"
// 10
```

次のコードでは不変条件に違反します。

```js
const obj = {};
Object.defineProperty(obj, "a", {
  configurable: false,
  enumerable: false,
  value: 10,
  writable: false,
});

const p = new Proxy(obj, {
  get(target, property) {
    return 20;
  },
});

p.a; // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-get-p-receiver |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Reflect.get()`


handler.defineProperty() - JavaScript

handler.defineProperty()
========================

**`handler.defineProperty()`** は、オブジェクトの `[[DefineOwnProperty]]` 内部メソッドに対するトラップです。`Object.defineProperty()` などの操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  defineProperty(target, property, descriptor) {
  }
});
```

### 引数

 次の引数が `defineProperty()` メソッドに渡されます。
 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`property`

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

`descriptor`

定義や変更されるプロパティに対するディスクリプターです。

### 返値

`defineProperty()` メソッドはプロパティが正しく定義されたかどうかを表す論理値を返す必要があります。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.defineProperty()`, `Object.defineProperties()`
* `Reflect.defineProperty()`

他にも、`[[DefineOwnProperty]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* ターゲットオブジェクトが拡張不可の場合、プロパティは追加できません。
* ターゲットオブジェクトの構成不可の独自のプロパティとして存在しない場合、プロパティは構成不可とみなされ、追加や変更ができません。
* ターゲットオブジェクトの対応する構成可能なプロパティが存在する場合、プロパティは構成不可にすることができません。
* 対応するターゲットオブジェクトのプロパティが存在する場合、`Object.defineProperty(target, prop, descriptor)` は例外をスローしません。
* strict モードでは、`defineProperty` ハンドラーから `false` が返ってきた場合、`TypeError` 例外をスローします。
例
-

### defineProperty のトラップ

次のコードは `Object.defineProperty()` をトラップします。

```js
const p = new Proxy(
  {},
  {
    defineProperty(target, prop, descriptor) {
      console.log(`called: ${prop}`);
      return true;
    },
  },
);

const desc = { configurable: true, enumerable: true, value: 10 };
Object.defineProperty(p, "a", desc); // "called: a"
```

`Object.defineProperty()` または `Reflect.defineProperty()` を呼び出した時、 `defineProperty()` トラップに渡されるディスクリプターには制約があります。下記のプロパティのみが使用可能で、標準ではないプロパティは無視されます。

* `enumerable`
* `configurable`
* `writable`
* `value`
* `get`
* `set`

```js
const p = new Proxy(
  {},
  {
    defineProperty(target, prop, descriptor) {
      console.log(descriptor);
      return Reflect.defineProperty(target, prop, descriptor);
    },
  },
);

Object.defineProperty(p, "name", {
  value: "proxy",
  type: "custom",
}); // { value: 'proxy' }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-defineownproperty-p-desc |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.defineProperty()`
* `Reflect.defineProperty()`


handler.set() - JavaScript

handler.set()
=============

**`handler.set()`** は、オブジェクトの `[[Set]]` 内部メソッドに対するトラップです。プロパティの値を設定することに対するトラップです。

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

構文
--

```js
new Proxy(target, {
  set(target, property, value, receiver) {
  }
});
```

### 引数

次の引数は `set()` メソッドに渡されます。`this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`property`

プロパティを設定する名前または `Symbol` です。

`value`

設定するプロパティの新しい値です。

`receiver`

割り当てがもともと行われていたオブジェクトです。これは通常、プロキシーそのものです。しかし、 `set()` ハンドラーは内部的にプロトタイプチェーンや様々な他の方法経由で呼び出されます。

例えば、スクリプト上に `obj.name = "jen"` があり、`obj` はプロキシーではなく、独自の `.name` プロパティを持っていません。しかし、プロトタイプチェーンでプロキシーを持っています。その場合、そのプロキシーの `set()` ハンドラーが呼ばれて、 `obj` はレシーバーとして渡されます。

### 返値

`set()` メソッドは論理値を返します。

* `true` を返すと割り当てが成功したことを示します。
* `set()` メソッドの返値が `false` で、厳格モードで割り当てが起こった場合、 `TypeError` が発生します。
解説
--

### 介入

このトラップは下記の操作に介入できます。

* プロパティへの代入: `proxy[foo] = bar` や `proxy.foo = bar`
* `Reflect.set()`

他にも、`[[Set]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーで `TypeError` が発生します。

* 対応するターゲットオブジェクトのプロパティが書き込み不可かつ設定不可のデータプロパティの場合、プロパティの値と異なる値に変更することはできません。
* 対応するターゲットオブジェクトのプロパティが `[[Set]]` 属性として `undefined` を持つ設定不可のアクセスプロパティの場合、プロパティの値を設定することはできません。
* 厳格モードでは、`set()` ハンドラーから `false` を返す場合、 `TypeError` 例外が発生します。
例
-

### プロパティ値の設定のトラップ

次のコードではプロパティの値の設定をトラップします。

```js
const p = new Proxy(
  {},
  {
    set(target, prop, value, receiver) {
      target[prop] = value;
      console.log(`property set: ${prop} = ${value}`);
      return true;
    },
  },
);

console.log("a" in p); // false

p.a = 10; // "property set: a = 10"
console.log("a" in p); // true
console.log(p.a); // 10
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-set-p-v-receiver |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Reflect.set()`


handler.isExtensible() - JavaScript

handler.isExtensible()
======================

**`handler.isExtensible()`** は、オブジェクトの `[[IsExtensible]]` 内部メソッドに対するトラップです。`Object.isExtensible()` などの操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  isExtensible(target) {
  }
});
```

### 引数

 次の引数は `isExtensible()` メソッドに渡されます。
 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

### 返値

`isExtensible` メソッドは論理値を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.isExtensible()`
* `Reflect.isExtensible()`

他にも、`[[IsExtensible]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生させます。

* `Object.isExtensible(proxy)` は `Object.isExtensible(target)` と同じ値を返さなければなりません。
例
-

### getOwnPropertyNames のトラップ

次のコードでは `Object.isExtensible()` をトラップします。

```js
const p = new Proxy(
  {},
  {
    isExtensible(target) {
      console.log("called");
      return true;
    },
  },
);

console.log(Object.isExtensible(p));
// "called"
// true
```

次のコードでは不変条件に違反します。

```js
const p = new Proxy(
  {},
  {
    isExtensible(target) {
      return false;
    },
  },
);

Object.isExtensible(p); // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-isextensible |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.isExtensible()`
* `Reflect.isExtensible()`
* `Reflect.preventExtensions()`


handler.ownKeys() - JavaScript

handler.ownKeys()
=================

**`handler.ownKeys()`** メソッドは、オブジェクトの `[[OwnPropertyKeys]]` 内部メソッドに対するトラップです。 `Object.keys()`, `Reflect.ownKeys()` などの操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  ownKeys(target) {
  }
});
```

### 引数

次の引数は `ownKeys()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

### 返値

`ownKeys()` メソッドは列挙可能オブジェクトを返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.getOwnPropertyNames()`
* `Object.getOwnPropertySymbols()`
* `Object.keys()`
* `Reflect.ownKeys()`

他にも、`[[OwnPropertyKeys]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `ownKeys()` の結果は配列である必要があります。
* 配列のそれぞれの要素の型は、`String` または `Symbol` のどちらかです。
* 結果のリストはターゲットオブジェクトのすべての非設定の独自プロパティのキーを含みます。
* ターゲットオブジェクトが拡張可能でないなら、結果リストはターゲットオブジェクトのすべての独自プロパティのキーを含まなければなりません。そして、他の値を含みません。
例
-

### getOwnPropertyNames のトラップ

次のコードでは `Object.getOwnPropertyNames()` をトラップします。

```js
const p = new Proxy(
  {},
  {
    ownKeys(target) {
      console.log("called");
      return ["a", "b", "c"];
    },
  },
);

console.log(Object.getOwnPropertyNames(p));
// "called"
// [ 'a', 'b', 'c' ]
```

次のコードでは不変条件に違反します。

```js
const obj = {};
Object.defineProperty(obj, "a", {
  configurable: false,
  enumerable: true,
  value: 10,
});

const p = new Proxy(obj, {
  ownKeys(target) {
    return [123, 12.5, true, false, undefined, null, {}, []];
  },
});

console.log(Object.getOwnPropertyNames(p));

// TypeError: proxy [[OwnPropertyKeys]] must return an array
// with only string and symbol elements
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.getOwnPropertyNames()`
* `Reflect.ownKeys()`


handler.getOwnPropertyDescriptor() - JavaScript

handler.getOwnPropertyDescriptor()
==================================

**`handler.getOwnPropertyDescriptor()`** は、オブジェクトの `[[GetOwnProperty]]` 内部メソッドに対するトラップです。`Object.getOwnPropertyDescriptor()` などの操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  getOwnPropertyDescriptor(target, prop) {
  }
});
```

### 引数

次の引数は `getOwnPropertyDescriptor()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

`prop`

ディスクリプタを取得されるプロパティ名です。

### 返値

`getOwnPropertyDescriptor` メソッドはオブジェクト、または `undefined` を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.getOwnPropertyDescriptor()`
* `Reflect.getOwnPropertyDescriptor()`

他にも、`[[GetOwnProperty]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `getOwnPropertyDescriptor()` はオブジェクトか、または `undefined` を返さなければなりません。
* プロパティがターゲットオブジェクトの設定不可な独自のプロパティとして存在する場合、存在しないとして報告されてはいけません。
* プロパティがターゲットオブジェクトの独自のプロパティとして存在し、そのターゲットオブジェクトが拡張不可の場合、存在しないとして報告されてはいけません。
* プロパティがターゲットオブジェクトの独自のプロパティとして存在せず、そのターゲットオブジェクトが拡張不可の場合、存在するとして報告されてはいけません。
* プロパティがターゲットオブジェクトの独自のプロパティとして存在しないか、ターゲットオブジェクトの設定可能な独自のプロパティとして存在している場合、設定不可であるとして報告されてはいけません。
* `Object.getOwnPropertyDescriptor(target)` の結果を `Object.defineProperty()` に使用した時に、ターゲットオブジェクトに適用でき、例外を発生させません。
例
-

### getOwnPropertyDescriptor のトラップ

次のコードでは `Object.getOwnPropertyDescriptor()` をトラップします。

```js
const p = new Proxy(
  { a: 20 },
  {
    getOwnPropertyDescriptor(target, prop) {
      console.log(`called: ${prop}`);
      return { configurable: true, enumerable: true, value: 10 };
    },
  },
);

console.log(Object.getOwnPropertyDescriptor(p, "a").value);
// "called: a"
// 10
```

次のコードでは不変条件に違反します。

```js
const obj = { a: 10 };
Object.preventExtensions(obj);
const p = new Proxy(obj, {
  getOwnPropertyDescriptor(target, prop) {
    return undefined;
  },
});

Object.getOwnPropertyDescriptor(p, "a"); // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-getownproperty-p |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.getOwnPropertyDescriptor()`
* `Reflect.getOwnPropertyDescriptor()`


handler.preventExtensions() - JavaScript

handler.preventExtensions()
===========================

**`handler.preventExtensions()`** はオブジェクトの `[[PreventExtensions]]` 内部メソッドに対するトラップです。 `Object.preventExtensions()` のような操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  preventExtensions(target) {
  }
});
```

### 引数

次の引数は `preventExtensions()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

### 返値

`preventExtensions()` メソッドは論理値を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `Object.preventExtensions()`
* `Reflect.preventExtensions()`
* `Object.seal()`
* `Object.freeze()`

他にも、`[[PreventExtensions]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `Object.preventExtensions(proxy)` は、 `Object.isExtensible(proxy)` が `false` の場合のみ `true` を返します。
例
-

### preventExtensions のトラップ

次のコードでは `Object.preventExtensions()` をトラップします。

```js
const p = new Proxy(
  {},
  {
    preventExtensions(target) {
      console.log("called");
      Object.preventExtensions(target);
      return true;
    },
  },
);

console.log(Object.preventExtensions(p));
// "called"
// false
```

以下のコードは不変条件に違反しています。

```js
const p = new Proxy(
  {},
  {
    preventExtensions(target) {
      return true;
    },
  },
);

Object.preventExtensions(p); // TypeError is thrown
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-preventextensions |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.preventExtensions()`
* `Reflect.preventExtensions()`


handler.deleteProperty() - JavaScript

handler.deleteProperty()
========================

**`handler.deleteProperty()`** メソッドは、オブジェクトの `[[Get]]` 内部メソッドに対するトラップです。`delete` などの操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  deleteProperty(target, property) {
  }
});
```

### 引数

 次の引数が `deleteProperty` メソッドに渡されます。
 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクト

`property`

削除するプロパティの名前または `Symbol`

### 返値

`deleteProperty()` メソッドはプロパティが正しく削除されたかどうか示す論理値を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* `delete` 演算子: `delete proxy[foo]` や `delete proxy.foo`
* `Reflect.deleteProperty()`

他にも、`[[Delete]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* ターゲットオブジェクトの非設定独自プロパティとして存在する場合、プロパティは削除されません。
例
-

### プロパティ値の取得のトラップ

次のコードは `delete` 操作をトラップします。

```js
const p = new Proxy(
  {},
  {
    deleteProperty(target, prop) {
      if (!(prop in target)) {
        console.log(`property not found: ${prop}`);
        return false;
      }
      delete target[prop];
      console.log(`property removed: ${prop}`);
      return true;
    },
  },
);

p.a = 10;
console.log("a" in p); // true

const result1 = delete p.a; // "property removed: a"
console.log(result1); // true
console.log("a" in p); // false

const result2 = delete p.a; // "property not found: a"
console.log(result2); // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-delete-p |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `delete` operator
* `Reflect.deleteProperty()`


handler.getPrototypeOf() - JavaScript

handler.getPrototypeOf()
========================

**`handler.getPrototypeOf()`** メソッドは、オブジェクトの `[[GetPrototypeOf]]` 内部メソッドに対するトラップです。`Object.getPrototypeOf()` などの操作で使用されます。

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

構文
--

```js
new Proxy(obj, {
  getPrototypeOf(target) {
    // …
  }
});
```

### 引数

 次の引数は `getPrototypeOf()` メソッドに渡されます。
 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクトです。

### 返値

`getPrototypeOf()` メソッドはオブジェクト、または `null` を返さなければなりません。

解説
--

### 介入

このトラップは下記の操作に介入できます。

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

他にも、`[[GetPrototypeOf]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、プロキシーは `TypeError` を発生します。

* `getPrototypeOf` メソッドはオブジェクト、または `null` を返さなければなりません。
* `target`が拡張不可の場合、 `Object.getPrototypeOf(proxy)` メソッドは `Object.getPrototypeOf(target)` と同じ値を返さなければなりません。
例
-

### 基本的な使い方

```js
const obj = {};
const proto = {};
const handler = {
  getPrototypeOf(target) {
    console.log(target === obj); // true
    console.log(this === handler); // true
    return proto;
  },
};

const p = new Proxy(obj, handler);
console.log(Object.getPrototypeOf(p) === proto); // true
```

### getPrototypeOf トラップが発生する５つの方法

```js
const obj = {};
const p = new Proxy(obj, {
  getPrototypeOf(target) {
    return Array.prototype;
  },
});
console.log(
  Object.getPrototypeOf(p) === Array.prototype, // true
  Reflect.getPrototypeOf(p) === Array.prototype, // true
  p.__proto__ === Array.prototype, // true
  Array.prototype.isPrototypeOf(p), // true
  p instanceof Array, // true
);
```

### 2 種類の例外

```js
const obj = {};
const p = new Proxy(obj, {
  getPrototypeOf(target) {
    return "foo";
  },
});
Object.getPrototypeOf(p); // TypeError: "foo" is not an object or null

const obj = Object.preventExtensions({});
const p = new Proxy(obj, {
  getPrototypeOf(target) {
    return {};
  },
});
Object.getPrototypeOf(p); // TypeError: expected same prototype value
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-getprototypeof |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Object.getPrototypeOf()`
* `Reflect.getPrototypeOf()`


handler.construct() - JavaScript

handler.construct()
===================

**`handler.construct()`** メソッドは、オブジェクトの `[[Construct]]` 内部メソッドに対するトラップです。`new` 演算子などの操作で使用されます。結果としてのプロキシーオブジェクトが new 演算子を使用できるようにするためには、プロキシを初期化するために使用されるターゲット自体が有効なコンストラクターである必要があります。

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

構文
--

```js
new Proxy(target, {
  construct(target, argumentsList, newTarget) {
  }
});
```

### 引数

次の引数が `construct()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクト

`argumentsList`

コンストラクタに対する引数のリスト

`newTarget`

上記の `p` に呼び出された元のコンストラクターです。

### 返値

`construct` メソッドはオブジェクトを返す必要があります。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* The `new` 演算子: `new myFunction(...args)`
* `Reflect.construct()`

他にも、`[[Construct]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、呼び出されるとトラップで `TypeError` が発生します。

* 結果が `Object` でならなければならない。
例
-

### new 演算子のトラップ

次のコードでは `new` 操作をトラップします。

```js
const p = new Proxy(function () {}, {
  construct(target, argumentsList, newTarget) {
    console.log(`called: ${argumentsList}`);
    return { value: argumentsList[0] \* 10 };
  },
});

console.log(new p(1).value); // "called: 1"
// 10
```

次のコードでは不変条件に違反します。

```js
const p = new Proxy(function () {}, {
  construct(target, argumentsList, newTarget) {
    return 1;
  },
});

new p(); // TypeError is thrown
```

次のコードはプロキシーを正しく初期化していません。プロキシーの `target` の初期化は、それ自身が `new` 演算子に有効なコンストラクターでなければなりません。

```js
const p = new Proxy(
  {},
  {
    construct(target, argumentsList, newTarget) {
      return {};
    },
  },
);

new p(); // TypeError is thrown, "p" is not a constructor
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-construct-argumentslist-newtarget |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `new` 演算子
* `Reflect.construct()`


handler.apply() - JavaScript

handler.apply()
===============

**`handler.apply()`** メソッドは、オブジェクトの `[[Call]]` 内部メソッドに対するトラップです。関数呼び出しなどの操作で使用されます。

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

構文
--

```js
new Proxy(target, {
  apply(target, thisArg, argumentsList) {
  }
});
```

### 引数

次の引数が `apply()` メソッドに渡されます。 `this` はハンドラーにバインドされます。

`target`

ターゲットオブジェクト

`thisArg`

この呼び出しに対する `this` 引数

`argumentsList`

この呼び出しに対する引数リスト

### 返値

`apply()` メソッドはどんな値でも返すことができます。

解説
--

### 介入

このトラップは下記の操作に介入できます。

* 関数呼び出し: `proxy(...args)`
* `Function.prototype.apply()` and `Function.prototype.call()`
* `Reflect.apply()`

他にも、`[[Call]]` 内部メソッドを呼び出すあらゆる操作に介入できます。

### 不変条件

以下の不変条件に違反している場合、トラップが呼び出されると `TypeError` が発生します。

* `target` は呼び出し可能である必要があります。つまり関数オブジェクトでなければなりません。
例
-

### 関数呼び出しのトラップ

次のコードでは、関数呼び出しをトラップします。

```js
const p = new Proxy(function () {}, {
  apply(target, thisArg, argumentsList) {
    console.log(`called: ${argumentsList}`);
    return argumentsList[0] + argumentsList[1] + argumentsList[2];
  },
});

console.log(p(1, 2, 3)); // "called: 1,2,3"
// 6
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-object-internal-methods-and-internal-slots-call-thisargument-argumentslist |

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

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

関連情報
----

* `Proxy`
* `Proxy()` コンストラクター
* `Function.prototype.apply()`
* `Function.prototype.call()`
* `Reflect.apply()`


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

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

**`Uint8ClampedArray()`** は型付き配列のコンストラクターで、 0-255 に制約される 8 ビット符号なし整数値の配列を生成します。指定された値が [0,255] の範囲を超えた場合、 0 または 255 が代わりに設定されます。整数以外を指定しようとすると、最も近い整数が設定されます。中身は `0` で初期化されます。生成されると、配列の中の要素はオブジェクトのメソッドを使用するか、配列の標準的な添字の構文を使用するか (すなわち、ブラケット構文を使用するか) して参照することができます。

構文
--
```

new Uint8ClampedArray(); // new in ES2017
new Uint8ClampedArray(length);
new Uint8ClampedArray(typedArray);
new Uint8ClampedArray(object);
new Uint8ClampedArray(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` の残りを表示します。

例
-

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

```js
// 長さを指定
var uintc8 = new Uint8ClampedArray(2);
uintc8[0] = 42;
uintc8[1] = 1337;
console.log(uintc8[0]); // 42
console.log(uintc8[1]); // 255 (clamped)
console.log(uintc8.length); // 2
console.log(uintc8.BYTES\_PER\_ELEMENT); // 1

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

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

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

// 反復可能オブジェクトから
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var uintc8 = new Uint8ClampedArray(iterable);
// Uint8ClampedArray[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 から、 `Uint8ClampedArray` コンストラクターは構築に `new` 演算子が必要になりました。 `Uint8ClampedArray` コンストラクターを `new` なしで関数として呼び出すと、 `TypeError` が発生するようになりました。

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

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

関連情報
----

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


DataView.prototype.getUint8() - JavaScript

DataView.prototype.getUint8()
=============================

**`getUint8()`** メソッドは、符号なし 8 ビット整数 (unsigned byte) 値を `DataView` の指定されたバイト単位のオフセットの位置から読み取ります。

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

構文
--
```

dataview.getUint8(byteOffset)
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを読み取る位置です。

### 返値

符号なし 8 ビット整数。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るように設定されている場合に発生します。

解説
--

アライメントの強制はありません。複数バイトの値はどのオフセットからも読み取ることができます。

例
-

### getUint8 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getUint8(1); // 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getuint8 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.setInt16() - JavaScript

DataView.prototype.setInt16()
=============================

**`setUint16()`** メソッドは、符号付き 16 ビット整数 (short) 値を `DataView` の指定されたバイト単位のオフセットの位置に格納します。

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

構文
--
```

dataview.setInt16(byteOffset, value [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを格納する位置です。

`value`

設定する値です。

`littleEndian`

省略可 16 ビット整数をリトルエンディアンとビッグエンディアンのどちらの形式で格納するかを表します。 `false` または `undefined` の場合、ビッグエンディアン値が書き込まれます。

### 返値

`undefined`。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するように設定されている場合に発生します。

例
-

### setInt16 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setInt16(1, 3);
dataview.getInt16(1); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setint16 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.byteLength - JavaScript

DataView.prototype.byteLength
=============================

**`byteLength`** アクセサープロパティは、このビューの `ArrayBuffer` または `SharedArrayBuffer` の先頭から長さを (バイト単位で) 表します。

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

解説
--

`byteLength` プロパティは、設定アクセサー関数が `undefined` である、すなわち読み取りのみができるアクセサープロパティです。この値は `DataView` が構築されたときに確立され、変更することができません。 `DataView` がオフセットや `byteLength` を指定していなかった場合は、参照されている `ArrayBuffer` または `SharedArrayBuffer` の `byteLength` が返されます。

例
-

### byteLength プロパティの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.byteLength; // 8 (matches the byteLength of the buffer)

var dataview2 = new DataView(buffer, 1, 5);
dataview2.byteLength; // 5 (as specified when constructing the DataView)

var dataview3 = new DataView(buffer, 2);
dataview3.byteLength; // 6 (due to the offset of the constructed DataView)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-dataview.prototype.bytelength |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`
* `SharedArrayBuffer`


DataView.prototype.getUint16() - JavaScript

DataView.prototype.getUint16()
==============================

**`getUint16()`** メソッドは、符号なし 16 ビット整数 (unsigned short) 値を `DataView` の指定されたバイト単位のオフセットの位置から読み取ります。

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

構文
--
```

dataview.getUint16(byteOffset [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを読み取る位置です。

`littleEndian`

省略可 16 ビット整数がリトルエンディアンとビッグエンディアンのどちらの形式で格納されているかを表します。 `false` または `undefined` の場合、ビッグエンディアン値を読み取ります。

### 返値

符号なし 16 ビット整数。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るように設定されている場合に発生します。

解説
--

アライメントの強制はありません。複数バイトの値はどのオフセットからも読み取ることができます。

例
-

### getUint16 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getUint16(1); // 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getuint16 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getBigUint64() - JavaScript

DataView.prototype.getBigUint64()
=================================

**`getBigInt64()`** メソッドは、符号なし 64 ビット整数 (unsigned long long) を `DataView` の先頭からのバイト単位のオフセット位置から取得します。

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

構文
--

```js
getBigUint64(byteOffset);
getBigUint64(byteOffset, littleEndian);
```

### 引数

byteOffset

データを読み取るビューの先頭からのバイト単位のオフセットです。

littleEndian

省略可 64 ビット整数をリトルエンディアンまたはビッグエンディアンのどちらの形式で格納されているかを示します。 `false` または `undefined` の場合、ビッグエンディアンの値が読み取られます。

### 返値

`BigInt` です。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るような値に設定されたときに発生します。

解説
--

アライメントの制約はありません。複数バイトの値はどのオフセットからでも読み取ることができます。

例
-

### `getBigUint64` メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getBigUint64(0); // 0n
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getbiguint64 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`
* `BigInt`


DataView.prototype.setInt32() - JavaScript

DataView.prototype.setInt32()
=============================

**`setInt32()`** メソッドは、符号付き 32 ビット整数 (long) 値を `DataView` の指定されたバイト単位のオフセットの位置に格納します。

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

構文
--
```

dataview.setInt32(byteOffset, value [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを格納する位置です。

`value`

設定する値です。

`littleEndian`

省略可 32 ビット整数をリトルエンディアンとビッグエンディアンのどちらの形式で格納するかを表します。 `false` または `undefined` の場合、ビッグエンディアン値が書き込まれます。

### 返値

`undefined`。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するように設定されている場合に発生します。

例
-

### setInt32 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setInt32(1, 3);
dataview.getInt32(1); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setint32 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getUint32() - JavaScript

DataView.prototype.getUint32()
==============================

**`getUint32()`** メソッドは、符号なし 32 ビット整数 (unsigned long) 値を `DataView` の指定されたバイト単位のオフセットの位置から読み取ります。

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

構文
--
```

dataview.getUint32(byteOffset [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを読み取る位置です。

`littleEndian`

省略可 32 ビット整数がリトルエンディアンとビッグエンディアンのどちらの形式で格納されているかを表します。 `false` または `undefined` の場合、ビッグエンディアン値を読み取ります。

### 返値

符号なし 32 ビット整数。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るように設定されている場合に発生します。

解説
--

アライメントの強制はありません。複数バイトの値はどのオフセットからも読み取ることができます。

例
-

### getUint32 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getUint32(1); // 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getuint32 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getBigInt64() - JavaScript

DataView.prototype.getBigInt64()
================================

**`getBigInt64()`** メソッドは、符号つき 64 ビット整数 (long long) を `DataView` の先頭からのバイト単位のオフセット位置から取得します。

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

構文
--

```js
getBigInt64(byteOffset);
getBigInt64(byteOffset, littleEndian);
```

### 引数

byteOffset

データを読み取るビューの先頭からのバイト単位のオフセットです。

littleEndian

省略可 64 ビット整数をリトルエンディアンまたはビッグエンディアンのどちらの形式で格納されているかを示します。 `false` または `undefined` の場合、ビッグエンディアンの値が読み取られます。

### 返値

`BigInt` です。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るような値に設定されたときに発生します。

解説
--

アライメントの制約はありません。複数バイトの値はどのオフセットからでも読み取ることができます。

例
-

### `getBigInt64` メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getBigInt64(0); // 0n
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getbigint64 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`
* `BigInt`


DataView.prototype.setUint8() - JavaScript

DataView.prototype.setUint8()
=============================

**`setUint8()`** メソッドは、符号なし 8 ビット整数 (byte) 値を `DataView` の指定されたバイト単位のオフセットの位置に格納します。

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

構文
--
```

dataview.setUint8(byteOffset, value)
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを格納する位置です。

`value`

設定する値です。

### 返値

`undefined`。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するように設定されている場合に発生します。

例
-

### setUint8 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setUint8(1, 3);
dataview.getUint8(1); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setuint8 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getInt8() - JavaScript

DataView.prototype.getInt8()
============================

**`getInt8()`** メソッドは、符号付き 8 ビット整数 (byte) 値を `DataView` の指定されたバイト単位のオフセットの位置から読み取ります。

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

構文
--
```

dataview.getInt8(byteOffset)
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを読み取る位置です。

### 返値

符号付き 8 ビット整数。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るように設定されている場合に発生します。

解説
--

アライメントの強制はありません。複数バイトの値はどのオフセットからも読み取ることができます。

例
-

### getInt8 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getInt8(1); // 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getint8 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.setUint32() - JavaScript

DataView.prototype.setUint32()
==============================

**`setUint32()`** メソッドは、符号なし 32 ビット整数 (unsigned long) 値を `DataView` の指定されたバイト単位のオフセットの位置に格納します。

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

構文
--
```

dataview.setUint32(byteOffset, value [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを格納する位置です。

`value`

設定する値です。

`littleEndian`

省略可 32 ビット整数をリトルエンディアンとビッグエンディアンのどちらの形式で格納するかを表します。 `false` または `undefined` の場合、ビッグエンディアン値が書き込まれます。

### 返値

`undefined`。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するように設定されている場合に発生します。

例
-

### setUint32 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setUint32(1, 3);
dataview.getUint32(1); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setuint32 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.setFloat32() - JavaScript

DataView.prototype.setFloat32()
===============================

**`setFloat32()`** メソッドは、符号付き 32 ビット浮動小数点数 (float) 値を `DataView` の指定されたバイト単位のオフセットの位置に格納します。

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

構文
--
```

dataview.setFloat32(byteOffset, value [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを格納する位置です。

`value`

設定する値です。

`littleEndian`

省略可 32 ビット浮動小数点数をリトルエンディアンとビッグエンディアンのどちらの形式で格納するかを表します。 `false` または `undefined` の場合、ビッグエンディアン値が書き込まれます。

### 返値

`undefined`。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するように設定されている場合に発生します。

例
-

### setFloat32 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setFloat32(1, 3);
dataview.getFloat32(1); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setfloat32 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.setBigUint64() - JavaScript

DataView.prototype.setBigUint64()
=================================

**`setBigUint64()`** メソッドは、符号なし 64 ビット整数 (unsigned long long) を `DataView` の先頭からのバイト単位の指定されたオフセット位置に格納します。

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

構文
--

```js
setBigUint64(byteOffset, value);
setBigUint64(byteOffset, value, littleEndian);
```

### 引数

byteOffset

データを格納するビューの先頭からのバイト単位のオフセットです。

value

`BigInt` として設定する値です。符号なし 64 ビット整数に符合する最も大きな値は、 `2n ** 64n - 1n` (`18446744073709551615n`) です。これを上回ると、ゼロ (`0n`) になります。

littleEndian

省略可 64 ビット整数をリトルエンディアンまたはビッグエンディアンのどちらの形式で格納するかを示します。 `false` または `undefined` の場合、ビッグエンディアンの値が書き込まれます。

### 返値

`undefined` です。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するような値に設定されたときに発生します。

例
-

### `setBigUint64` メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setBigUint64(0, 3n);
dataview.getBigUint64(0); // 3n
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setbiguint64 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`
* `BigInt`


DataView.prototype.getInt16() - JavaScript

DataView.prototype.getInt16()
=============================

**`getInt16()`** メソッドは、符号付き 16 ビット整数 (short) 値を `DataView` の指定されたバイト単位のオフセットの位置から読み取ります。

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

構文
--
```

dataview.getInt16(byteOffset [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを読み取る位置です。

`littleEndian`

省略可 16 ビット整数がリトルエンディアンとビッグエンディアンのどちらの形式で格納されているかを表します。 `false` または `undefined` の場合、ビッグエンディアン値を読み取ります。

### 返値

符号付き 16 ビット整数。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るように設定されている場合に発生します。

解説
--

アライメントの強制はありません。複数バイトの値はどのオフセットからも読み取ることができます。

例
-

### getInt16 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getInt16(1); // 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getint16 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.buffer - JavaScript

DataView.prototype.buffer
=========================

**`buffer`** アクセサープロパティは、この `DataView` の構築時に参照された `ArrayBuffer` または `SharedArrayBuffer` を表します。

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

解説
--

`buffer` プロパティは、設定アクセサー関数が `undefined` である、すなわち読み取りのみができるアクセサープロパティです。この値は `DataView` が構築されたときに確立され、変更することができません。

例
-

### buffer プロパティの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.buffer; // ArrayBuffer { byteLength: 8 }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-dataview.prototype.buffer |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`
* `SharedArrayBuffer`


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

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

**`DataView()`** コンストラクターは、 `DataView` オブジェクトを生成するために使用します。

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

構文
--
```

new DataView(buffer [, byteOffset [, byteLength]])
```

### 引数

`buffer`

既存の `ArrayBuffer` または `SharedArrayBuffer` で、新しい `DataView` オブジェクトの背景となるストレージとして使用されます。

`byteOffset` 省略可

新しいビューが参照するバッファーの最初のバイトまでのオフセットをバイト単位で指定します。指定されていない場合、バッファービューは最初のバイトから始まります。

`byteLength` 省略可

バイト配列の要素数です。指定しない場合、ビューの長さはバッファーの長さと一致します。

### 返値

指定されたデータバッファーを表す `DataView` オブジェクトです。 (これはおそらくあまり役に立たない説明でした。)

返されるオブジェクトは、バイトの配列バッファーの「インタープリター」と考えることができます。 - これは読み書きの際に、バッファー内に正しく収まるように数値を変換する方法を知っています。これは、整数や浮動小数点数の変換、エンディアン、その他バイナリ形式で数値を表現する際の詳細を扱うことを意味します。

### 例外

`RangeError`

`byteOffset` や `byteLength` 引数の値がバッファーの末尾を超えて広がる結果になる場合に発生します。

例えば、バッファーが 16 バイトの長さで、 `byteOffset` が 8 バイト、 `byteLength` が 10 バイトの場合、バッファーの全長を 2 バイト超えるビューを展開しようとするので、このエラーが発生します。

例
-

### DataView の使用

```js
var buffer = new ArrayBuffer(16);
var view = new DataView(buffer, 0);

view.setInt16(1, 42);
view.getInt16(1); // 42
```

仕様書
---

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

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

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

関連情報
----

* `DataView`


DataView.prototype.getFloat64() - JavaScript

DataView.prototype.getFloat64()
===============================

**`getFloat64()`** メソッドは、符号付き 64 ビット浮動小数点数 (double) 値を `DataView` の指定されたバイト単位のオフセットの位置から読み取ります。

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

構文
--
```

dataview.getFloat64(byteOffset [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを読み取る位置です。

`littleEndian`

省略可 64 ビット浮動小数点数がリトルエンディアンとビッグエンディアンのどちらの形式で格納されているかを表します。 `false` または `undefined` の場合、ビッグエンディアン値を読み取ります。

### 返値

符号付き 64 ビット浮動小数点数。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るように設定されている場合に発生します。

解説
--

アライメントの強制はありません。複数バイトの値はどのオフセットからも読み取ることができます。

例
-

### getFloat64 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getFloat64(0); // 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getfloat64 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getFloat32() - JavaScript

DataView.prototype.getFloat32()
===============================

**`getFloat32()`** メソッドは、符号付き 32 ビット浮動小数点数 (float) 値を `DataView` の指定されたバイト単位のオフセットの位置から読み取ります。

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

構文
--
```

dataview.getFloat32(byteOffset [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを読み取る位置です。

`littleEndian`

省略可 32 ビット浮動小数点数がリトルエンディアンとビッグエンディアンのどちらの形式で格納されているかを表します。 `false` または `undefined` の場合、ビッグエンディアン値を読み取ります。

### 返値

符号付き 32 ビット浮動小数点数。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るように設定されている場合に発生します。

解説
--

アライメントの強制はありません。複数バイトの値はどのオフセットからも読み取ることができます。

例
-

### getFloat32 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getFloat32(1); // 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getfloat32 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getInt32() - JavaScript

DataView.prototype.getInt32()
=============================

**`getInt32()`** メソッドは、符号付き 32 ビット整数 (long) 値を `DataView` の指定されたバイト単位のオフセットの位置から読み取ります。

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

構文
--
```

dataview.getInt32(byteOffset [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを読み取る位置です。

`littleEndian`

省略可 32 ビット整数がリトルエンディアンとビッグエンディアンのどちらの形式で格納されているかを表します。 `false` または `undefined` の場合、ビッグエンディアン値を読み取ります。

### 返値

符号付き 32 ビット整数。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて読み取るように設定されている場合に発生します。

解説
--

アライメントの強制はありません。複数バイトの値はどのオフセットからも読み取ることができます。

例
-

### getInt32 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.getInt32(1); // 0
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getint32 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.setUint16() - JavaScript

DataView.prototype.setUint16()
==============================

**`setUint16()`** メソッドは、符号なし 16 ビット整数 (unsigned short) 値を `DataView` の指定されたバイト単位のオフセットの位置に格納します。

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

構文
--
```

dataview.setUint16(byteOffset, value [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを格納する位置です。

`value`

設定する値です。

`littleEndian`

省略可 16 ビット整数をリトルエンディアンとビッグエンディアンのどちらの形式で格納するかを表します。 `false` または `undefined` の場合、ビッグエンディアン値が書き込まれます。

### 返値

`undefined`。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するように設定されている場合に発生します。

例
-

### setUint16 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setUint16(1, 3);
dataview.getUint16(1); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setuint16 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.setBigInt64() - JavaScript

DataView.prototype.setBigInt64()
================================

**`setBigInt64()`** メソッドは、符号つき 64 ビット整数 (long long) を `DataView` の先頭からのバイト単位の指定されたオフセット位置に格納します。

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

構文
--

```js
setBigInt64(byteOffset, value);
setBigInt64(byteOffset, value, littleEndian);
```

### 引数

byteOffset

データを格納するビューの先頭からのバイト単位のオフセットです。

value

`BigInt` として設定する値です。符号つき 64 ビット整数に符合する最も大きな値は、 `2n ** (64n -1n) - 1n` (`9223372036854775807n`) です。これを上回ると、負の数 (`-9223372036854775808n`) になります。

littleEndian

省略可 64 ビット整数をリトルエンディアンまたはビッグエンディアンのどちらの形式で格納するかを示します。 `false` または `undefined` の場合、ビッグエンディアンの値が書き込まれます。

### 返値

`undefined` です。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するような値に設定されたときに発生します。

例
-

### `setBigInt64` メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setBigInt64(0, 3n);
dataview.getBigInt64(0); // 3n
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setbigint64 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`
* `BigInt`


DataView.prototype.setFloat64() - JavaScript

DataView.prototype.setFloat64()
===============================

**`setFloat64()`** メソッドは、符号付き 64 ビット浮動小数点数 (double) 値を `DataView` の指定されたバイト単位のオフセットの位置に格納します。

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

構文
--
```

dataview.setFloat64(byteOffset, value [, littleEndian])
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを格納する位置です。

`value`

設定する値です。

`littleEndian`

省略可 64 ビット浮動小数点数をリトルエンディアンとビッグエンディアンのどちらの形式で格納するかを表します。 `false` または `undefined` の場合、ビッグエンディアン値が書き込まれます。

### 返値

`undefined`。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するように設定されている場合に発生します。

例
-

### setFloat64 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setFloat64(0, 3);
dataview.getFloat64(0); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setfloat64 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


DataView.prototype.byteOffset - JavaScript

DataView.prototype.byteOffset
=============================

**`byteOffset`** アクセサープロパティは、このビューの `ArrayBuffer` または `SharedArrayBuffer` の先頭からオフセットを表します。

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

解説
--

`byteOffset` プロパティは、設定アクセサー関数が `undefined` である、すなわち読み取りのみができるアクセサープロパティです。この値は `DataView` が構築されたときに確立され、変更することができません。

例
-

### byteOffset プロパティの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.byteOffset; // 0 (no offset specified)

var dataview2 = new DataView(buffer, 3);
dataview2.byteOffset; // 3 (as specified when constructing the DataView)
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-dataview.prototype.byteoffset |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`
* `SharedArrayBuffer`


DataView.prototype.setInt8() - JavaScript

DataView.prototype.setInt8()
============================

**`setInt8()`** メソッドは、符号付き 8 ビット整数 (byte) 値を `DataView` の指定されたバイト単位のオフセットの位置に格納します。

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

構文
--
```

dataview.setInt8(byteOffset, value)
```

### 引数

`byteOffset`

ビューの先頭からのバイト単位のオフセットで、データを格納する位置です。

`value`

設定する値です。

### 返値

`undefined`。

### 発生するエラー

`RangeError`

`byteOffset` がビューの末尾を超えて格納するように設定されている場合に発生します。

例
-

### setInt8 メソッドの使用

```js
var buffer = new ArrayBuffer(8);
var dataview = new DataView(buffer);
dataview.setInt8(1, 3);
dataview.getInt8(1); // 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.setint8 |

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

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

関連情報
----

* `DataView`
* `ArrayBuffer`


WeakMap.prototype.has() - JavaScript

WeakMap.prototype.has()
=======================

**`has()`** メソッドは、特定のキーをもつ要素が `WeakMap` オブジェクト内に存在するかどうかを示す真偽値を返します。

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

構文
--
```

ws.has(key);
```

### 引数

`key`

`WeakMap` オブジェクトに存在するかテストする要素のキーです。

### 返値

Boolean

`WeakMap` オブジェクト内に特定のキーをもつ要素が存在していたら `true` を返します。さもなければ `false` を返します。

例
-

### has() メソッドの使用

```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.has(window); // true を返す
wm.has("baz"); // false を返す
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.has |

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

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

関連情報
----

* `WeakMap`
* `WeakMap.prototype.set()`
* `WeakMap.prototype.get()`


WeakMap.prototype.get() - JavaScript

WeakMap.prototype.get()
=======================

**`get()`** メソッドは、`WeakMap` オブジェクトから指定された要素を返します。

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

構文
--
```

wm.get(key);
```

### 引数

`key`

必須。`WeakMap` オブジェクトから返す要素のキーです。

### 返値

指定されたキーと関連した要素を返します。キーが `WeakMap` オブジェクトに見つからない場合、 `undefined` を返します。

例
-

### get() メソッドの使用

```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.get(window); // "foo" を返す
wm.get("baz"); // undefined を返す
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.get |

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

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

関連情報
----

* `WeakMap`
* `WeakMap.set()`
* `WeakMap.has()`


WeakMap.prototype.delete() - JavaScript

WeakMap.prototype.delete()
==========================

**`delete()`** メソッドは、 `WeakMap` オブジェクトから指定された要素を削除します。

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

構文
--
```

wm.delete(key);
```

### 引数

`key`

`WeakMap` オブジェクトから削除する要素のキーです。

### 返値

`WeakMap` オブジェクト内の要素を削除するのに成功した場合、`true` を返します。`WeakMap` 内でキーが見つからなかったり、キーがオブジェクトでなかったりした場合、`false` を返します。

例
-

### delete() メソッドの使用

```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.delete(window); // true を返す。削除に成功。

wm.has(window); // false を返す。 window はもう WeakMap に存在しない。
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.delete |

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

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

関連情報
----

* `WeakMap`


WeakMap.prototype.set() - JavaScript

WeakMap.prototype.set()
=======================

**`set()`** メソッドは、指定されたキーと値をもつ新しい要素を `WeakMap` オブジェクトへ追加します。

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

構文
--
```

wm.set(key, value);
```

### 引数

`key`

必須です。 `object` である必要があります。 `WeakMap` オブジェクトに追加する要素のキーです。

`value`

必須です。任意の値です。 `WeakMap` オブジェクトに追加する要素の値です。

### 返値

`WeakMap` オブジェクトです。

例
-

### set() メソッドの使用

```js
var wm = new WeakMap();
var obj = {};

// Add new elements to the WeakMap
wm.set(obj, "foo").set(window, "bar"); // chainable

// Update an element in the WeakMap
wm.set(obj, "baz");
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.set |

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

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

関連情報
----

* `WeakMap`
* `WeakMap.prototype.get()`
* `WeakMap.prototype.has()`


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

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

**`WeakMap()` コンストラクター**は、キーが弱く参照されている、キーと値の組のコレクションである `WeakMap` オブジェクトを生成します。キーはオブジェクトでなければならず、値は任意の値を指定することができます。

`WeakMap` については、キー付きコレクションの WeakMap オブジェクトの節を参照してください。

構文
--
```

new WeakMap([iterable])
```

### 引数

`iterable`

iterable は配列などの反復可能オブジェクトであり、その要素はキーと値の組 (2 要素の配列) となります。それぞれのキーと値の組は、新しい WeakMap に追加されます。 null は undefined として扱われます。

例
-

### WeakMap の使用

```js
const wm1 = new WeakMap(),
  wm2 = new WeakMap(),
  wm3 = new WeakMap();
const o1 = {},
  o2 = function () {},
  o3 = window;

wm1.set(o1, 37);
wm1.set(o2, "azerty");
wm2.set(o1, o2); // 値は何でもよく、オブジェクトでも関数でもよい
wm2.set(o3, undefined);
wm2.set(wm1, wm2); // キーと値はあらゆるオブジェクトになれる。 WeakMap も同様。

wm1.get(o2); // "azerty"
wm2.get(o2); // undefined、 o2 というキーが wm2 にないため
wm2.get(o3); // undefined、 設定された値がそうであるため

wm1.has(o2); // true
wm2.has(o2); // false
wm2.has(o3); // true (値自身が 'undefined' であっても)

wm3.set(o1, 37);
wm3.get(o1); // 37

wm1.has(o1); // true
wm1.delete(o1);
wm1.has(o1); // false
```

仕様書
---

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

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

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

関連情報
----

* `WeakMap` (JavaScript ガイド)
* Hiding Implementation Details with ECMAScript 6 WeakMaps
* `Map`
* `Set`
* `WeakSet`


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

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

**`Float64Array()`** は型付き配列のコンストラクターで、新しい `Float64Array` オブジェクト、すなわち 64 ビット浮動小数点数 (C 言語の `double` データ型に相当) の配列をプラットフォームのバイトオーダーで生成します。バイトオーダーを制御する必要がある場合は、代わりに `DataView` を使用してください。生成後は、オブジェクトのメソッドや、標準の配列の添字構文 (すなわち角括弧表記) を用いて配列の要素を参照することができます。

構文
--
```

new Float64Array(); // new in ES2017
new Float64Array(length);
new Float64Array(typedArray);
new Float64Array(object);
new Float64Array(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` の残りがビューとなります。

例
-

### Float64Array を生成するための様々な方法

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

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

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

// From an ArrayBuffer
var buffer = new ArrayBuffer(32);
var z = new Float64Array(buffer, 0, 4);

// From an iterable
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var float64 = new Float64Array(iterable);
// Float64Array[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 から、 `Float64Array` コンストラクターは `new` 演算子を使用して構築する必要があります。 `new` 演算子を使用せずに `Float64Array` コンストラクターを呼び出した場合、 `TypeError` が発生するようになりました。

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

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

関連情報
----

* JavaScript typed arrays
* `ArrayBuffer`
* `DataView`


Function.arguments - JavaScript

Function.arguments
==================

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

`***function*.arguments**` プロパティは、関数に渡される引数に対応する、配列風のオブジェクトです。より単純な `arguments` 変数を使用してください。このプロパティは厳格モードでは使用できません。

解説
--

`function.arguments` の構文は非推奨です。関数内で `arguments` オブジェクトにアクセスする方法としては、変数 `arguments` が利用できます。

再帰呼び出しの場合、すなわちコールスタックに関数 `f` が複数回現れる場合に、`f.arguments` はもっとも直近に実行された関数に対応する引数を表します。

実行中の関数の未処理の呼び出しがない (つまり、関数が呼び出された状態で返してない) 場合、 arguments プロパティの値は通常 null です。

例
-

### arguments オブジェクトの使用

```js
function f(n) {
  g(n - 1);
}

function g(n) {
  console.log("before: " + g.arguments[0]);
  if (n > 0) {
    f(n);
  }
  console.log("after: " + g.arguments[0]);
}

f(2);

console.log("returned: " + g.arguments);

// Output

// before: 1
// before: 0
// after: 0
// after: 1
// returned: null
```

仕様書
---

何れかの標準で定義されたものではありません。 ECMAScript 3 で `arguments` に置き換えられました。

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

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

関連情報
----

* `arguments` オブジェクト
* 関数と関数スコープ


Function.prototype.bind() - JavaScript

Function.prototype.bind()
=========================

**`bind()`** メソッドは新しい関数を生成し、これは呼び出された際に `this` キーワードに指定された値が設定されます。この値は新しい関数が呼び出されたとき、一連の引数の前に置かれます。

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

構文
--

```js
bind(thisArg)
bind(thisArg, arg1)
bind(thisArg, arg1, arg2)
bind(thisArg, arg1, arg2, /\* …, \*/ argN)
```

### 引数

`thisArg`

バインド済み関数が呼び出される際、 `this` 引数としてターゲット関数 `func` に渡される値です。関数が厳格モードでない場合、`null` と `undefined` はグローバルオブジェクトに置き換わり、プリミティブ値はオブジェクトに変換されます。バインド済み関数が `new` 演算子によって構築された場合、この引数は無視されます。

`arg1, …, argN` 省略可

`func` を呼び出す時、バインド済み関数に与えられる引数の前に付けて渡す引数。

### 返値

`this` の値と初期の引数（提供された場合）が指定された関数のコピーです。

解説
--

`bind()` 関数は新しい「バインド済み関数 (*bound function*)」を生成します。バインド済み関数を呼び出すと、通常はラップされた関数のほうが実行され、それは「ターゲット関数 (*target function*)」とも呼ばれます。バインド済み関数は、渡された引数、すなわち `this` の値と最初のいくつかの引数を内部の状態として格納します。これらの値は、呼び出し時に渡されるのではなく、あらかじめ格納されています。一般に、`const boundFn = fn.bind(thisArg, arg1, arg2)` は、`const boundFn = (...restArgs) => fn.call(thisArg, arg1, arg2, ...restArgs)` と呼ばれるのと同じだと考えてよいでしょう（ただし `boundFn` が構築されたときではなく、呼び出されたときに効果があります）。

バインド済み関数は、 `boundFn.bind(thisArg, /* その他の引数 */)` を呼び出すことでさらにバインドすることができ、別のバインド済み関数 `boundFn2` が作成されます。なぜなら、`boundFn2` の対象となる関数 `boundFn` はすでに `this` というバインド済み関数を持っているからです。`boundFn2` が呼ばれると、 `boundFn` を呼び出すことになり、それが `fn` を呼び出すことになります。最終的に `fn` が受け取る引数は、順に `boundFn` にバインドされた引数、 `boundFn2` にバインドされた引数、 `boundFn2` で受け取った引数になります。

```js
"use strict"; // `this` がラッパーオブジェクトの中に入ってしまうのを防ぐ

function log(...args) {
  console.log(this, ...args);
}
const boundLog = log.bind("this value", 1, 2);
const boundLog2 = boundLog.bind("new this value", 3, 4);
boundLog2(5, 6); // "this value", 1, 2, 3, 4, 5, 6
```

バインド済み関数は、そのターゲット関数が構築可能であれば、`new` 演算子を使用してオブジェクトを構築することもできます。これは、あたかもターゲット関数で構築されたかのように動作します。前置された引数は通常通りターゲット関数に提供されますが、指定された `this` 値は無視されます（コンストラクターは `Reflect.construct` の引数で見られるように、自分自身で `this` を用意するためです）。バインド済み関数が直接構築された場合、代わりに `new.target` がターゲット関数になります（つまり、バインドされた関数は `new.target` に対して透過的です）。

```js
class Base {
  constructor(...args) {
    console.log(new.target === Base);
    console.log(args);
  }
}

const BoundBase = Base.bind(null, 1, 2);

new BoundBase(3, 4); // true, [1, 2, 3, 4]
```

しかし、バインド済み関数は `prototype` プロパティを持たないので、 `extends` の基底クラスとして使用することはできません。

```js
class Derived extends class {}.bind(null) {}
// TypeError: Class extends value does not have valid prototype property undefined
```

バインド済み関数を `instanceof` の右辺として使用する場合、 `instanceof` はターゲット関数（これはバインド済み関数の内部に格納されています）に到達し、 代わりにその `prototype` を読み取ります。

```js
class Base {}
const BoundBase = Base.bind(null, 1, 2);
console.log(new Base() instanceof BoundBase); // true
```

バインド済み関数には以下のようなプロパティがあります。

`length`

ターゲット関数の `length` から、バインドされる引数の数（ `thisArg` 引数はカウントしない）を引いた値で、0が最小値になります。

`name`

対象となる関数の `name` に `"bound "` という接頭辞を加えたものです。

バインド済み関数は、ターゲット関数のプロトタイプチェーンも引き継ぎます。しかし、他にターゲット関数の独自のプロパティ（ターゲット関数がクラスの場合は静的プロパティなど）を持つことはありません。

例
-

### バインド済み関数の生成

最もシンプルな `bind()` の使い方は、どのように呼び出された場合でも特定の `this` 値を持つ関数を生成することです。

初心者の JavaScript プログラマーがよくやる間違いは、あるオブジェクトからメソッドを抽出し、後でその関数を呼び出すとき、その内側の `this` 値が元のオブジェクトになると考えてしまうことです（例えば、そのメソッドをコールバック関数に使う場合）。

特に配慮しなければ、ふつうは元のオブジェクトが見えなくなります。その関数に元々のオブジェクトを `bind()` してバインド済み関数を生成すれば、この問題をきちんと解決することができます。

```js
this.x = 9; // 'this' はここではブラウザーのグローバルな 'window' オブジェクト
const module = {
  x: 81,
  getX() {
    return this.x;
  },
};

console.log(module.getX()); // 81

const retrieveX = module.getX;
console.log(retrieveX()); // 9。この関数はグローバルスコープで呼び出されるためです。

// 'this' を module に結びつけた新しい関数を生成
// 初心者のプログラマーはグローバル変数の x と
// モジュールプロパティの x とを混同するかもしれません。
const boundGetX = retrieveX.bind(module);
console.log(boundGetX()); // 81
```

**メモ:** この例を厳格モードで呼び出すと（例えば ECMAScript モジュール内や `"use strict"` ディレクティブを通して）、グローバルな `this` 値は不定となり、 `retrieveX` 呼び出しに失敗する原因となります。

これを Node CommonJS モジュール内で実行すると、厳格モードかどうかに関わらず、最上位スコープの `this` は `globalThis` ではなく `module.exports` を指すようになります。しかし、関数内では、バインドされていない `this` の参照は、それでも「厳格モードでなければ `globalThis` 、厳格モードならば `undefined`」というルールに従います。したがって、厳格モードでない場合（既定）は、 `retrieveX` は `undefined` を返します。これは、 `this.x = 9` が、 `getX` が読んでいるオブジェクト (`globalThis`) とは異なるオブジェクト (`module.exports`) に書き込んでいるためです。

実際、いくつかの組み込みの「メソッド」はバインド済み関数を返すゲッターでもあります。注目すべき例は `Intl.NumberFormat.prototype.format()` で、アクセスすると、コールバックとして直接渡すことのできる、バインド済み関数を返します。

### 部分的に適用された関数

次のシンプルな `bind()` の使い方は、あらかじめ引数が指定された関数を生成することです。

これらの引数は（もしあれば）指定された `this` 値の後に続き、ターゲット関数に渡される引数の先頭に挿入され、その後に、バインドされた関数が呼ばれる際に渡される引数が続きます。

```js
function list(...args) {
  return args;
}

function addArguments(arg1, arg2) {
  return arg1 + arg2;
}

console.log(list(1, 2, 3)); // [1, 2, 3]

console.log(addArguments(1, 2)); // 3

// 先頭の引数が設定済みの関数を生成します。
const leadingThirtySevenList = list.bind(null, 37);

// 第一引数が設定済みの関数を生成します。
const addThirtySeven = addArguments.bind(null, 37);

console.log(leadingThirtySevenList()); // [37]
console.log(leadingThirtySevenList(1, 2, 3)); // [37, 1, 2, 3]
console.log(addThirtySeven(5)); // 42
console.log(addThirtySeven(5, 10)); // 42
// (最後の引数 10 は無視されます)
```

### setTimeout() での利用

既定では、 `setTimeout()` 内部の `this` キーワードは `globalThis`、すなわちブラウザーでは `window` に設定されます。暮らすメソッドを使用して `this` がクラスインスタンスを参照するようにする必要がある場合、インスタンスを保守するために、明示的に `this` をコールバック関数にバインドすることができます。

```js
class LateBloomer {
  constructor() {
    this.petalCount = Math.floor(Math.random() \* 12) + 1;
  }
  bloom() {
    // 1 秒間の遅延の後に開花を宣言
    setTimeout(this.declare.bind(this), 1000);
  }
  declare() {
    console.log(`わたしは花びらが ${this.petalCount} 枚の綺麗な花です！`);
  }
}

const flower = new LateBloomer();
flower.bloom();
// After 1 second, calls 'flower.declare()'
```

このためにアロー関数を使用することもできます。

```js
class LateBloomer {
  bloom() {
    // 1 秒間の遅延の後に開花を宣言
    setTimeout(() => this.declare(), 1000);
  }
}
```

### コンストラクターとして使用するバインド済み関数

バインド済み関数は自動的に、 `new` 演算子を使ってターゲット関数の新しいインスタンスを構築できるようになっています。新たな値を構築するためにバインド済み関数を使った場合、 `this` を与えても無視されます。しかし、同時に与える引数はコンストラクター呼び出しの先頭部分に挿入されます。

```js
function Point(x, y) {
  this.x = x;
  this.y = y;
}

Point.prototype.toString = function () {
  return `${this.x},${this.y}`;
};

const p = new Point(1, 2);
p.toString();
// '1,2'

// thisArg の値は無視されるため、重要ではない
const YAxisPoint = Point.bind(null, 0 /\*x\*/);

const axisPoint = new YAxisPoint(5);
axisPoint.toString(); // '0,5'

axisPoint instanceof Point; // true
axisPoint instanceof YAxisPoint; // true
new YAxisPoint(17, 42) instanceof Point; // true
```

`new`で使用するためのバインド済み関数を作成するために、特別なことをする必要はないことに注意してください。`new.target`, `instanceof`, `this` などはすべて期待通り、まるでこのコンストラクターがバインドされていないかのように処理されます。唯一の異なる形は、 `extends` には使用できなくなるということです。

このことから、たとえバインド済み関数が `new` を使用してのみ呼び出すことを要求したい場合でも、プレーンに呼び出される関数を作成することと比べて、特別なことをする必要はないことがわかります。 `new` を使わずに呼び出すと、バインドされた `this` は突然無視されなくなります。

```js
const emptyObj = {};
const YAxisPoint = Point.bind(emptyObj, 0 /\*x\*/);

// 普通の関数としても実行できます
// (あまり必要にはなりませんが)
YAxisPoint(13);

// これで `this` に対する変更が外から監視できるようになりました。
console.log(emptyObj); // { x: 0, y: 13 }
```

バインドされた関数が `new` でしか呼び出せないように制限したい場合、あるいは `new` なしでのみ呼び出せるようにしたい場合、ターゲット関数は `new.target !== undefined` を参照するか、代わりにクラスを使用して、その制限を実施しなければなりません。

### クラスのバインド

クラスに対して `bind()` を使用すると、そのクラスの意味づけはほとんど維持されますが、現在のクラスのすべての静的な自分自身のプロパティは失われます。しかし、プロトタイプチェーンは維持されるので、親クラスから継承された静的プロパティにアクセスすることは可能です。

```js
class Base {
  static baseProp = "base";
}

class Derived extends Base {
  static derivedProp = "derived";
}

const BoundDerived = Derived.bind(null);
console.log(BoundDerived.baseProp); // "base"
console.log(BoundDerived.derivedProp); // undefined
console.log(new BoundDerived() instanceof Derived); // true
```

### メソッドのユーティリティ関数への変換

`bind()` は特定の `this` 値を必要とするメソッドを、前回の `this` 引数を通常の引数として受け入れるプレーンなユーティリティ関数に変換したい場合にも役立ちます。これは、汎用的なユーティリティ関数の動作方法に似ています。 `array.map(callback)` を呼び出す代わりに、 `map(array, callback)` を使うと、 `Array.prototype` を変更することを避け、配列でない配列風オブジェクト（例えば `arguments` など）でも、 `map` が使用できるようになります。

例として、`Array.prototype.slice()` を取り上げます。この関数は、配列に似たオブジェクトを本物の配列へ変換するために使えます。まず、次のようにショートカットを作成するとします。

```js
const slice = Array.prototype.slice;

// ...

slice.call(arguments);
```

`slice.call` を保存して、普通の関数として呼び出すことはできないことに注意してください。なぜなら、 `call()` メソッドは、呼び出すべき関数である `this` の値も読み取るからです。この場合、 `bind()` を使用して、 `call()` に `this` の値をバインドすることができます。以下のコードでは、 `slice()` は `Function.prototype.call()` のバインド版で、 `this` の値は `Array.prototype.slice()` にバインドされます。これは、追加の `call()` 呼び出しを省くことができることを意味しています。

```js
// ひとつ前の例の "slice" と同じ
const unboundSlice = Array.prototype.slice;
const slice = Function.prototype.call.bind(unboundSlice);

// ...

slice(arguments);
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function.prototype.bind |

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

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

関連情報
----

* `Function.prototype.bind` のポリフィル (`core-js`)
* `Function.prototype.apply()`
* `Function.prototype.call()`
* 関数


Function.prototype.toString() - JavaScript

Function.prototype.toString()
=============================

**`toString()`** メソッドは、関数のソースコードを表す文字列を返します。

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

構文
--
```

function.toString()
```

### 返値

関数のソースコードを表す文字列です。

解説
--

`Function` オブジェクトは、 `Object` から継承した `toString` メソッドをオーバーライドします。つまり、 `Object.prototype.toString` を継承しません。 `Function` オブジェクトについて、 `toString` メソッドは関数宣言を表現するオブジェクトを表す文字列を返します。

`Function` を文字列値として表現するとき、JavaScript は自動的に `toString` メソッドを呼び出します。例えば、関数が文字列と連結されるときです。

`this` 値のオブジェクトが `Function` オブジェクトでない場合、 `toString()` メソッドは `TypeError` 例外 ("Function.prototype.toString called on incompatible object") を発生します。

```js
Function.prototype.toString.call("foo"); // TypeError
```

`toString()` メソッドが組込み関数オブジェクトや `Function.prototype.bind` 作成された関数に対して呼び出されると、 `toString()` は、次のような*ネイティブ関数文字列*を返します。

```js
"function () {\n [native code]\n}";
```

`toString()` メソッドが `Function` コンストラクターで生成された関数に対して呼び出されると、 `toString()` は "anonymous" という名前の関数宣言に、提供された引数と関数の本体を合成したソースコードを返します。

`+` 演算子を使用して、関数の文字列表現を明示的に取得することもできます。

```js
function foo() {
  return "bar";
}
console.log(foo + ""); // "function foo() { return 'bar' }"
```

例
-

### 実際のソースコードと toString の結果との比較

| Function | Function.prototype.toString の結果 |
| --- | --- |
|
```
function f(){}
```
 |
```
"function f(){}"
```
 |
|
```
class A { a(){} }
```
 |
```
"class A { a(){} }"
```
 |
|
```
function* g(){}
```
 |
```
"function* g(){}"
```
 |
|
```
a => a
```
 |
```
"a => a"
```
 |
|
```
({ a(){} }.a)
```
 |
```
"a(){}"
```
 |
|
```
({ *a(){} }.a)
```
 |
```
"*a(){}"
```
 |
|
```
({ [0](){} }[0])
```
 |
```
"[0](){}"
```
 |
|
```
Object.getOwnPropertyDescriptor({
    get a(){}
}, "a").get
```
 |
```
"get a(){}"
```
 |
|
```
Object.getOwnPropertyDescriptor({
    set a(x){}
}, "a").set
```
 |
```
"set a(x){}"
```
 |
|
```
Function.prototype.toString
```
 |
```
"function toString() { [native code] }"
```
 |
|
```
(function f(){}.bind(0))
```
 |
```
"function () { [native code] }"
```
 |
|
```
Function("a", "b")
```
 |
```
"function anonymous(a\n) {\nb\n}"
```
 |

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.toString()`


Function.length - JavaScript

Function.length
===============

**`length`** プロパティは、関数が期待する引数の数を示します。

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

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

解説
--

`length` は function オブジェクトのプロパティであり、関数が期待する引数の数、つまり形式上の引数の数を示します。この数に残余引数 (en-US)は含まれず、既定値を持つ引数が最初に登場する前までしか含みません。これに対し、 `arguments.length` は関数のローカルスコープ内で用いられ、関数が実際に受け取った引数の数、つまり実引数の数を参照するのに用いるものです。

### Function コンストラクターのデータプロパティ

`Function` コンストラクター自体は、`Function` オブジェクトです。この `length` データプロパティの値は 1 です。プロパティの属性は、 Writable: `false`、Enumerable: `false`、Configurable: `true` です。

### Function プロトタイプのオブジェクトのプロパティ

`Function` プロトタイプオブジェクトの length プロパティの値は 0 です。

例
-

### 関数の length の使用

```js
console.log(Function.length); /\* 1 \*/

console.log(function () {}.length); /\* 0 \*/
console.log(function (a) {}.length); /\* 1 \*/
console.log(function (a, b) {}.length); /\* 2 etc. \*/

console.log(function (...args) {}.length);
// 0, rest parameter は数に含まれない

console.log(function (a, b = 1, c) {}.length);
// 1, 既定値を持つ引数が最初に登場する前までの
// 引数だけが数に含まれる
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-instances-length |

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

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

関連情報
----

* `Function`


Function.caller - JavaScript

Function.caller
===============

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

**`function.caller`** プロパティは、指定した関数の呼び出し元の関数を返します。厳格モード、非同期関数、ジェネレーター関数の呼び出し元については `null` を返します。

解説
--

関数 `f` が最上位のコードで呼び出された場合、 `f.caller` の値は `null` に、それ以外の場合の値は `f` を呼び出した関数になります。厳格モード、非同期関数、ジェネレーター関数の呼び出し元についても `null` を返します。

このプロパティは、廃止された `arguments` オブジェクトの `arguments.caller` プロパティを置き換えます。

特殊プロパティである `__caller__` は呼び出し元の activation オブジェクトを返し、スタックの再現に利用できましたが、セキュリティ上の理由により削除されました。

### 注

再帰呼び出しの場合、このプロパティを用いてコールスタックを再現することはできません。以下について考えてみましょう。

```js
function f(n) {
  g(n - 1);
}
function g(n) {
  if (n > 0) {
    f(n);
  } else {
    stop();
  }
}
f(2);
```

`stop()` が呼び出された時点のコールスタックは以下のようになるでしょう。

```js
f(2) -> g(1) -> f(1) -> g(0) -> stop()
```

以下は真になります。

```js
stop.caller === g && f.caller === g && g.caller === f;
```

従って、`stop()` 関数のスタックトレースを以下のようにして取得するとします。

```js
var f = stop;
var stack = "Stack trace:";
while (f) {
  stack += "\n" + f.name;
  f = f.caller;
}
```

これは無限ループになります。

例
-

### 関数の caller プロパティの値を確認する

以下のコードは、関数の `caller` プロパティの値を確認します。

```js
function myFunc() {
  if (myFunc.caller == null) {
    return "The function was called from the top!";
  } else {
    return "This function's caller was " + myFunc.caller;
  }
}
```

仕様書
---

いずれの標準仕様でも定義されていません。

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

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

関連情報
----

* `Function.name`
* `arguments`


Function.displayName - JavaScript

Function.displayName
====================

**非標準:** この機能は標準ではなく、標準化の予定もありません。公開されているウェブサイトには使用しないでください。ユーザーによっては使用できないことがあります。実装ごとに大きな差があることもあり、将来は振る舞いが変わるかもしれません。

**`function.displayName`** プロパティは、関数の表示名を返します。

例
-

### displayName の設定

通常、コンソールやプロファイラーでは関数名を表示するのに `func.name` よりも好まれます。

以下のものをコンソールに入力すると、 "`function My Function()`" のように表示されます。

```js
var a = function () {};
a.displayName = "My Function";

a; // "function My Function()"
```

`displayName` プロパティが定義されると、関数の表示名が返されます。

```js
function doSomething() {}

console.log(doSomething.displayName); // "undefined"

var popup = function (content) {
  console.log(content);
};

popup.displayName = "Show Popup";

console.log(popup.displayName); // "Show Popup"
```

### 関数式の displayName の定義

関数式内で、関数と同時に表示名を定義できます。

```js
var object = {
  someMethod: function () {},
};

object.someMethod.displayName = "someMethod";

console.log(object.someMethod.displayName); // logs "someMethod"

try {
  someMethod;
} catch (e) {
  console.log(e);
}
// ReferenceError: someMethod is not defined
```

### 動的な displayName の変更

関数の `displayName` を動的に変更できます。

```js
var object = {
  // anonymous
  someMethod: function (value) {
    arguments.callee.displayName = "someMethod (" + value + ")";
  },
};

console.log(object.someMethod.displayName); // "undefined"

object.someMethod("123");
console.log(object.someMethod.displayName); // "someMethod (123)"
```

仕様書
---

どの仕様にも含まれていません。

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

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

関連情報
----

* `Function.name`


Function.name - JavaScript

Function.name
=============

`Function` オブジェクトの **`name`** プロパティは読み取り専用で、作成時に付けられた関数の名前、もしくは無名関数の場合は `anonymous` または `''` (空文字列) を返します。

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

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

**メモ:** 標準外であった ES2015 以前の実装では、`configurable` 属性も `false` であることに注意してください。

JavaScript の圧縮とミニファイ
--------------------

**警告:** `Function.name` を使用しているときに、 JavaScript の圧縮 (ミニファイ) や難読化のような変換を行う際には注意が必要です。これらのツールは JavaScript ビルドパイプラインの一部として、本番環境に設置する前にプログラムのサイズを縮小するためによく使用されます。それらの変換は、ビルド時に関数名を変更することがあります。

次のようなソースコードは、

```js
function Foo() {}
let foo = new Foo();

if (foo.constructor.name === "Foo") {
  console.log("'foo' は 'Foo' のインスタンスである");
} else {
  console.log("おおっと！");
}
```

このように圧縮されるかもしれません。

```js
function a() {}
let b = new a();
if (b.constructor.name === "Foo") {
  console.log("'foo' は 'Foo' のインスタンスである");
} else {
  console.log("おおっと！");
}
```

非圧縮版では、プログラムは真の方の分岐を実行し、「`'foo' は 'Foo' のインスタンスである`」と表示するのに対し、圧縮版は異なる振る舞いをし、偽の方の分岐を実行します。それゆえ、上述の例のように `Function.name` に依存するならば、ビルドパイプラインが関数名を変更しないようにするか、特定の関数名を想定しない構造にする必要があります。

例
-

### 関数文の名前

`name` プロパティは関数文の名前を返します。

```js
function doSomething() {}
doSomething.name; // "doSomething"
```

### Function コンストラクターの名前

構文 `new Function(...)` または単に `Function(...)` で関数を作成すると、 `Function` オブジェクトが作成され、その名前は "anonymous" になります。

```js
new Function().name; // "anonymous"
```

### 無名関数式

`function` キーワードを使用して生成された関数式またはアロー関数は、名前が `""` (空文字列) になっています。

```js
(function () {}).name; // ""
(() => {}).name; // ""
```

### 関数名の推測

変数とメソッドは、構文上の位置から無名関数の名前を推論できます (ECMAScript 2015 から)。

```js
let f = function () {};
let object = {
  someMethod: function () {},
};

console.log(f.name); // "f"
console.log(object.someMethod.name); // "someMethod"
```

関数式 で名前を持つ関数を定義することができます。

```js
let object = {
  someMethod: function object\_someMethod() {},
};
console.log(object.someMethod.name); // "object\_someMethod" と表示

try {
  object_someMethod;
} catch (e) {
  console.log(e);
}
// ReferenceError: object\_someMethod is not defined
```

name プロパティは読み取り専用であり、代入演算子で変更することはできません。

```js
let object = {
  // anonymous
  someMethod: function () {},
};

object.someMethod.name = "otherMethod";
console.log(object.someMethod.name); // someMethod
```

変更したければ、`Object.defineProperty()` を使ってください。

### 短縮メソッドの名前

```js
var o = {
  foo() {},
};
o.foo.name; // "foo";
```

### バインドされた関数の名前

`Function.bind()` が関数を作成する時、その名前は "bound " とその関数名を合わせたものとなります。

```js
function foo() {}
foo.bind({}).name; // "bound foo"
```

### ゲッターとセッターの関数名

`get` と `set` を使う時は、 "get" や "set" が関数名に含まれます。

```js
let o = {
  get foo() {},
  set foo(x) {},
};

var descriptor = Object.getOwnPropertyDescriptor(o, "foo");
descriptor.get.name; // "get foo"
descriptor.set.name; // "set foo";
```

### クラスでの関数名

`obj.constructor.name` でオブジェクトの「クラス」を知ることができます (ただし、下記の警告を確認してください)。

```js
function Foo() {} // ES2015 構文の場合: class Foo {}

var fooInstance = new Foo();
console.log(fooInstance.constructor.name); // "Foo" と表示
```

**警告:** スクリプトインタープリターは、関数が自身の *name* プロパティを持っていない場合に限り、組み込みの `Function.name` プロパティを設定します (9.11.2. of the ECMAScript2015 Language Specification セクションをご覧ください)。しかし ES2015 では、*static* キーワードを指定すると、その静的メソッドはクラスのコンストラクタ関数の OwnProperty として設定されます (ECMAScript2015, 14.5.14.21.b + 12.2.6.9)。

従って、`name()` という静的メソッドを持つクラスでは、事実上そのクラス名を取得することはできません:

```js
class Foo {
  constructor() {}
  static name() {}
}
```

`static name()` メソッドが存在する場合、`Foo.name` はクラス名ではなく、 `name()` 関数オブジェクトへの参照を持つことになります。Chrome や Firefox では、上記の ES2015 の構文によるクラス定義は、下記の ES5 構文のコードと同じような挙動をします:

```js
function Foo() {}
Object.defineProperty(Foo, "name", { writable: true });
Foo.name = function () {};
```

`fooInstance.constructor.name` で `fooInstance` のクラスを取得しようとしても、得られるのはクラス名ではなく静的メソッドへの参照です。例えば:

```js
let fooInstance = new Foo();
console.log(fooInstance.constructor.name); // 関数 name() を表示
```

先ほどの ES5 の構文の例では、Chrome や Firefox での `Foo.name` の静的な定義の際に *writable* を指定しています。このような独自の手法を用いなければ、デフォルトでは *read-only* となります:

```js
Foo.name = "Hello";
console.log(Foo.name); // Foo が static name() を持つ場合は "Hello"、そうでなければ "Foo" と表示する。
```

従って、`Function.name` プロパティが常にクラス名を保持しているとは考えないほうがいいでしょう。

### 関数名としての Symbol

`Symbol` を関数名として使用し、Symbol が description を持っている場合、関数名はブラケット `[ ]` 内の description となります。

```js
let sym1 = Symbol("foo");
let sym2 = Symbol();
let o = {
  [sym1]: function () {},
  [sym2]: function () {},
};

o[sym1].name; // "[foo]"
o[sym2].name; // ""
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-instances-name |

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

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

関連情報
----

* `Function`


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

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

**`Function` コンストラクター**は、新しい `Function` **オブジェクト**を生成します。コンストラクターを直接呼び出すと動的に関数を生成することができますが、セキュリティや、 `eval` (en-US) と似た性能の (ただし、はるかに重要性の低い) 問題を抱えます。ただし eval とは異なり、 `Function` コンストラクターはグローバルスコープで実行される関数のみを生成します。

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

構文
--
```

new Function([arg1 [, arg2 [, ...argN]] ,] functionBody)
```

### 引数

`arg1, arg2, ... argN`

仮引数の名前として関数で用いるための名前。各々は、妥当な JavaScript の識別子と一致する文字列か、カンマで区切られた文字列などのリストでなければなりません。例えば、 "`x`", "`theValue`", "`x,theValue`" などです。

`functionBody`

関数定義を形成する JavaScript の文を含む文字列。

解説
--

`Function` コンストラクターで生成された `Function` オブジェクトは、関数が作成されたときに解釈されます。これは、関数を関数式や関数文を使って定義してコード内で呼び出した場合に比べ、コードの他の部分と一緒に解釈されるため、効率が落ちます。

関数に渡されるすべての引数は、関数のパラメーター識別名として、渡される順番どおりに作成されます。引数を省略すると、その引数の値は `undefined` になります。

(`new` 演算子を用いずに) 関数として、`Function` コンストラクターを実行することは、コンストラクターとして実行することと同じです。

例
-

### Function コンストラクターに引数を指定する

以下のコードは二つの引数を取る `Function` オブジェクトを生成します。

```js
// この例は JavaScript コンソールで直接実行することができます

// 二つの引数を取り、その合計を返す関数を生成します
const adder = new Function("a", "b", "return a + b");

// 関数を呼び出します
adder(2, 6);
// 8
```

引数 "`a`" および "`b`" は関数の本体 "`return a + b`" の中で使用される形式的な引数名です。

仕様書
---

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

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

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

関連情報
----

* 関数と関数スコープ
* `function` 文
* `function` 式
* `function*` 文
* `function*` 式
* `AsyncFunction`
* `GeneratorFunction`


Function.prototype.call() - JavaScript

Function.prototype.call()
=========================

**`call()`** メソッドは、 `this` の値と、独立して提供された引数によって関数を呼び出します。

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

構文
--
```

func.call([thisArg[, arg1, arg2, ...argN]])
```

### 引数

`thisArg` 省略可

`func` が呼び出されたときに `this` として使用される値です。

**メモ:** 特定の場面では、 `thisArg` はメソッドから見える実際の値でない場合があります。

もし、そのメソッドが厳格モードの関数ではなかった場合、 `null` と `undefined` はグローバルオブジェクトで置き換えられ、プリミティブ値はオブジェクトに変換されます。

`arg1, arg2, ...argN` 省略可

呼び出し先の関数に渡される引数です。

### 返値

**`this`** の値と引数を指定して関数を呼び出した結果です。

解説
--

`call()` はあるオブジェクトに所属する関数やメソッドを、別なオブジェクトに割り当てて呼び出すことができます。

`call()` は関数やメソッドに `this` の新しい値を提供します。 `call()` によって、いったんメソッドを書いてから、新しいオブジェクトへメソッドを書き直さずに他のオブジェクトへと継承することができます。

**メモ:** このメソッドの構文は `apply()` とほぼ同じですが、基本的な違いは `call()` が**引数リスト**を受け取るのに対して、 `apply()` は**引数の単一の配列**を受け取る点です。

例
-

### call メソッドを使用してオブジェクトのコンストラクターを連鎖させる

`call` を使用して (Java と同様に) オブジェクトのコンストラクターを連鎖させることができます。

下記の例では、 `Product` オブジェクトのコンストラクターは `name` と `price` の二つの引数で定義されています。

他の `Food` と `Toy` の二つの関数は、 `Product` を呼び出して `this` と `name` と `price` を渡します。 `Product` は `name` と `price` プロパティを初期化し、どちらも特化した関数が `category` を定義します。

```js
function Product(name, price) {
  this.name = name;
  this.price = price;
}

function Food(name, price) {
  Product.call(this, name, price);
  this.category = "food";
}

function Toy(name, price) {
  Product.call(this, name, price);
  this.category = "toy";
}

const cheese = new Food("feta", 5);
const fun = new Toy("robot", 40);
```

### call メソッドを使用した無名関数の呼び出し

次の例では、無名関数を作成して `call` を使用して配列内の各オブジェクトに対して呼び出しを行います。

ここでの無名関数の主な目的は、 print 関数をすべてのオブジェクトに追加することで、配列内のオブジェクトの正しいインデックスを表示できるようにします。実際には `this` の値としてオブジェクトを渡す必要ありませんが、例示の目的で使用しています。

**メモ:** オブジェクトを `this` の値として渡すことは厳密には必要ではありませんが、説明のために使用しました。

```js
const animals = [
  { species: "Lion", name: "King" },
  { species: "Whale", name: "Fail" },
];

for (let i = 0; i < animals.length; i++) {
  (function (i) {
    this.print = function () {
      console.log("#" + i + " " + this.species + ": " + this.name);
    };
    this.print();
  }).call(animals[i], i);
}
```

### call を使用した関数を呼び出しと 'this' のコンテキストの指定

次の例では、`greet` メソッドを呼ぶとき、`this` の値を `obj` オブジェクトにバインドしています。

```js
function greet() {
  const reply = [
    this.animal,
    "typically sleep between",
    this.sleepDuration,
  ].join(" ");
  console.log(reply);
}

const obj = {
  animal: "cats",
  sleepDuration: "12 and 16 hours",
};

greet.call(obj); // cats typically sleep between 12 and 16 hours
```

### `call` を使用した最初の引数を指定しない関数の呼び出し

下記の例では、 `display` 関数を、最初の引数を渡さずに呼び出しています。最初の引数が渡されないと、 `this` の値はグローバルオブジェクトに結び付けられます。

```js
var sData = "Wisen";

function display() {
  console.log("sData value is %s ", this.sData);
}

display.call(); // sData value is Wisen
```

**メモ:** 厳格モードでは `this` の値は `undefined` になります。以下を参照してください。

```js
"use strict";

var sData = "Wisen";

function display() {
  console.log("sData value is %s ", this.sData);
}

display.call(); // undefined の 'sData' のプロパティは読めない
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function.prototype.call |

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

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

関連情報
----

* `Function.prototype.bind()`
* `Function.prototype.apply()`
* オブジェクト指向 JavaScript 入門


Function.prototype.apply() - JavaScript

Function.prototype.apply()
==========================

**`apply()`** メソッドは、 `this` 値を指定して関数を呼び出し、 `arguments` は配列 (または配列風オブジェクト) として提供します。

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

構文
--
```

func.apply(thisArg, [ argsArray])
```

### 引数

`thisArg`

`this` の値で、 `func` の呼び出しで提供されます。

このメソッドで指定した `this` が必ず呼び出したメソッドで参照されるわけではないことに注意してください。もし呼び出したメソッドが厳格モードではないコード内の関数であれば、ここで渡した値が `null` もしくは `undefined` であった場合はグローバルオブジェクトに置き換えられ、プリミティブ型の変数はボックス化されます。この引数は必須です。

`argsArray` 省略可

1 つの配列風のオブジェクトであり、 `func` 関数が呼ぶことになる引数を列挙したものです。関数に引数が渡されない場合は `null` または `undefined` となります。

ECMAScript 5 以降ではこれらの値は配列ではなく配列風のオブジェクトを用いる事になりました。後述のブラウザーの互換性を参照してください。

### 返値

指定した **`this`** と引数で関数を呼び出した結果が返ります。

解説
--

**メモ:** 関数の構文は `call()` メソッドとほぼ同じですが、根本的な違いは `call()` メソッドは**連続した引数のリスト**を受け取るのに対して、 `apply()` メソッドが**引数の配列を 1 つだけ**受け取るという点です。

**メモ:** 最初の引数が undefined または null の場合、配列のスプレッド構文を使用して同様の結果を得ることができます。

存在する関数を呼び出す時は通常と異なる `this` オブジェクトを渡すことができます。`this` はカレントオブジェクト、呼び出したオブジェクトを参照します。`apply` を用いることで、新たなオブジェクトのためにそのメソッドを書き直すことなく継承させることができます。

`apply` は、対応する引数の型を除けば `call()` によく似ています。引数のリストの代わりに引数の配列を用いることができます。`apply` は配列リテラルを引数に用いることもできます。例えば `func.apply(this, ['eat', 'bananas'])` のように利用でき、同様に配列オブジェクトを `func.apply(this, new Array('eat', 'bananas'))` のように利用できます。

`argsArray` で `arguments` を利用することもできます。`arguments` は関数内のローカル変数です。これは、呼び出されたオブジェクトの不特定の引数すべてに対して用いることができます。つまり、 `apply` メソッドを使うにあたって呼び出されたオブジェクトの引数について知る必要がないのです。`arguments` を利用することで、引数のすべてを呼び出されたオブジェクトに渡すことができます。引数の扱いは、呼び出されたオブジェクトが受け持ちます。

ECMAScript 第 5 版以降では、配列風のオブジェクトも使えます。具体的には、`length` プロパティとその範囲 (0 から length-1 まで) の整数の名称のプロパティを持った、あらゆる種類のオブジェクトの利用を認めています。例えば、`NodeList` や `{ 'length': 2, '0': 'eat', '1': 'bananas' }` のような独自のオブジェクトを利用できます。

**メモ:** Chrome 14 や Internet Explorer 9 などのブラウザーでは、配列風オブジェクトを扱えずに例外が発生します。

例
-

### apply で配列を別の配列に追加する

`push` で 1 つの要素を配列に追加できます。そして、`push` は可変長引数に対応しているので、複数の要素を一度に追加することもできます。

しかし `push` に配列を渡すと、配列の要素ごとにではなく配列全体を 1 つの要素として追加してしまいます。配列の中に配列が入るだけなのです。

それを望まない場合はどうすればいいのでしょう？ `concat` ならば望みの結果を得られます。しかし、*既存*の配列に追加するのではなく、新しい配列を生成して返します。

既存の配列に追加したいのに... では、どうすれば？ループ文を書きますか？おことわりですよね？

`apply` が救ってくれます！

```js
const array = ["a", "b"];
const elements = [0, 1, 2];
array.push.apply(array, elements);
console.info(array); // ["a", "b", 0, 1, 2]
```

### `apply` をビルトイン関数と共に利用する

`apply` を賢く使うと、本来なら配列のためにループ文を書かなくてはならないような処理に対して、ビルトイン関数をそのまま使えるようになります。

下記の例では、配列の最大値・最小値を求めるために `Math.max`/`Math.min` を使っています。

```js
// 最小値・最大値を求めたい配列
const numbers = [5, 6, 2, 3, 7];

// Math.min/Math.max と apply を使う
let max = Math.max.apply(null, numbers);
// これは右と同じ Math.max(numbers[0], ...)
// または Math.max(5, 6, ...)

let min = Math.min.apply(null, numbers);

// 対して、ループ文を使うとこうなる
(max = -Infinity), (min = +Infinity);

for (let i = 0; i < numbers.length; i++) {
  if (numbers[i] > max) {
    max = numbers[i];
  }
  if (numbers[i] < min) {
    min = numbers[i];
  }
}
```

しかし注意してください。この方法で `apply` を使う場合、 JavaScript エンジンの引数の長さ上限を超えてしまう危険があります。多すぎる (おおよそ数万個以上だと思って下さい) 引数を与えた結果は、その上限が特に決まっていない (本当に任意の巨大なデータのかたまりに対してさえ) ためエンジンによって (JavaScriptCore ライブラリでは引数の上限は 65536 であるとハードコーディングされています) 異なります。

これは、その限界 (実際には、過剰に大きなスタックの挙動の性質さえも) が不特定であるためです。例外を投げるエンジンも存在します。さらに酷い場合では、関数へ実際に渡す引数の数を勝手に制限するものもあります。後者について詳しく解説しますと、そのエンジンの引数の上限が 4 つの場合 (実際の上限値は当然もっと上です)、上の例では、完全な配列でなく `5, 6, 2, 3` が `apply` へ渡されたかのような動作をします。

もし実装しているコードで利用する配列の変数の数が数万を超えそうなときは、以下に示すように一度に apply に渡す配列を分割して利用する方法を併用すべきでしょう。

```js
function minOfArray(arr) {
  let min = Infinity;
  let QUANTUM = 32768;

  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
    var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len)));
    min = Math.min(submin, min);
  }

  return min;
}

let min = minOfArray([5, 6, 2, 3, 7]);
```

### apply を利用したコンストラクターチェーン

`apply` を利用して、Java のように `constructors` の連結を行なうことができます。

以下に示す例ではグローバルな `construct` という名称の `Function` オブジェクトを作成し、引数のリストの代わりに配列風オブジェクトをコンストラクターと共に利用できるようになります。

```js
Function.prototype.construct = function (aArgs) {
  let oNew = Object.create(this.prototype);
  this.apply(oNew, aArgs);
  return oNew;
};
```

**メモ:** 上記で使用している `Object.create()` メソッドは比較的新しいです。代わりの方法として、以下の例を検討してください。

`Object.prototype.__proto__` を利用:

```js
Function.prototype.construct = function (aArgs) {
  let oNew = {};
  oNew.__proto__ = this.prototype;
  this.apply(oNew, aArgs);
  return oNew;
};
```

クロージャを利用:

```js
Function.prototype.construct = function (aArgs) {
  let fConstructor = this,
    fNewConstr = function () {
      fConstructor.apply(this, aArgs);
    };
  fNewConstr.prototype = fConstructor.prototype;
  return new fNewConstr();
};
```

`Function` コンストラクターを利用:

```js
Function.prototype.construct = function (aArgs) {
  let fNewConstr = new Function("");
  fNewConstr.prototype = this.prototype;
  let oNew = new fNewConstr();
  this.apply(oNew, aArgs);
  return oNew;
};
```

使用例:

```js
function MyConstructor() {
  for (let nProp = 0; nProp < arguments.length; nProp++) {
    this["property" + nProp] = arguments[nProp];
  }
}

let myArray = [4, "Hello world!", false];
let myInstance = MyConstructor.construct(myArray);

console.log(myInstance.property1); // logs 'Hello world!'
console.log(myInstance instanceof MyConstructor); // logs 'true'
console.log(myInstance.constructor); // logs 'MyConstructor'
```

**メモ:** この非ネイティブな `Function.construct` メソッドはいくつかのネイティブ実装されたコンストラクタ (例えば `Date` のような物) と併用できません。このようなケースにおいては `Function.bind` メソッドを利用する必要があります。

例えば `[2012, 11, 4]` のような配列を `Date` コンストラクターに利用する事を考えてみてください。この場合では `new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()` のように書く必要があります。

いずれにせよこれは最適な選択肢とは言えず、実用上はいかなる状況でも用いるべきではないでしょう)

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function.prototype.apply |

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

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

関連情報
----

* `arguments` オブジェクト
* `Function.prototype.bind()`
* `Function.prototype.call()`
* 関数と関数スコープ
* `Reflect.apply()`
* スプレッド構文


Function.prototype[@@hasInstance]() - JavaScript

Function.prototype[@@hasInstance]()
===================================

`Function` インスタンスの **`[@@hasInstance]()`** メソッドは、コンストラクター関数がオブジェクトをそのコンストラクターのインスタンスの一つであると認識するかどうかを決定するデフォルトの手続きを定義します。これは、`instanceof` 演算子から呼ばれます。

構文
--

```js
func[Symbol.hasInstance](value)
```

### 引数

`value`

判定を行うオブジェクトです。プリミティブ値に対しては常に `false` を返します。

### 返値

`func.prototype` が `value` のプロトタイプチェーン内に存在する場合は `true` を返し、そうでない場合は `false` を返します。`value` がオブジェクトではないか、`this` が関数でない場合は、常に `false` を返します。`this` がバインド済み関数である場合は、`value` およびもとになったターゲット関数における `instanceof` 判定の結果を返します。

### 例外

`TypeError`

`this` がバインド済み関数ではなく、かつ `this.prototype` がオブジェクトではないとき投げられます。

説明
--

`instanceof` 演算子は、右辺の値に `[@@hasInstance]()` メソッドが存在する場合は、常にこのメソッドを呼びます。すべての関数はデフォルトで `Function.prototype` を継承しているので、それらはすべてこの `[@@hasInstance]()` メソッドを持ちます。そのため、ほとんどの場合、右辺が関数であれば `Function.prototype[@@hasInstance]` メソッドが `instanceof` の挙動を定義します。このメソッドは、`instanceof` 演算子のデフォルトの挙動 (`constructor` が `@@hasInstance` を持たないときと同じアルゴリズム) を実装します。

ほとんどのメソッドと違い、`Function.prototype[@@hasInstance]()` プロパティは設定不可能で、書込不可能です。これは、バインド済み関数のもとになったターゲット関数を取得されるのを防ぐためのセキュリティ機能です。例として、この StackOverflow での回答を参照してください。

例
-

### デフォルトの instanceof の挙動に戻す

このメソッドを直接呼ぶ必要が生じることはほとんどないでしょう。かわりに、このメソッドは `instanceof` 演算子から呼ばれます。以下の 2 種類の結果は通常等価であることを期待するべきです。

```js
class Foo {}
const foo = new Foo();
console.log(foo instanceof Foo === Foo[Symbol.hasInstance](foo)); // true
```

デフォルトの `instanceof` の挙動を呼び出したいが、コンストラクターにオーバーライドされた `[@@hasInstance]()` メソッドがあるかわからないとき、このメソッドを使いたくなるかもしれません。

```js
class Foo {
  static [Symbol.hasInstance](value) {
    // 独自の実装
    return false;
  }
}

const foo = new Foo();
console.log(foo instanceof Foo); // false
console.log(Function.prototype[Symbol.hasInstance].call(Foo, foo)); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function.prototype-@@hasinstance |

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

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

関連情報
----

* `instanceof`
* `Symbol.hasInstance`


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

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

**`SyntaxError`** オブジェクトは、文法的に無効なコードを解釈しようとしたときのエラーを表します。

構文
--
```

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

### 引数

`message` 省略可

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

`fileName` 省略可

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

`lineNumber` 省略可

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

例
-

### SyntaxError の捕捉

```js
try {
  eval("hoo bar");
} catch (e) {
  console.error(e instanceof SyntaxError);
  console.error(e.message);
  console.error(e.name);
  console.error(e.fileName);
  console.error(e.lineNumber);
  console.error(e.columnNumber);
  console.error(e.stack);
}
```

### SyntaxError の生成

```js
try {
  throw new SyntaxError("Hello", "someFile.js", 10);
} catch (e) {
  console.error(e instanceof SyntaxError); // true
  console.error(e.message); // Hello
  console.error(e.name); // SyntaxError
  console.error(e.fileName); // someFile.js
  console.error(e.lineNumber); // 10
  console.error(e.columnNumber); // 0
  console.error(e.stack); // @debugger eval code:3:9
}
```

仕様書
---

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

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

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

関連情報
----

* `Error`


AsyncIterator.prototype[@@asyncIterator]() - JavaScript

AsyncIterator.prototype[@@asyncIterator]()
==========================================

**`[@@asyncIterator]()`** は `AsyncIterator` インスタンスのメソッドで、非同期反復可能プロトコルを実装し、組み込みの非同期イテレーターを、 `for await...of` ループのような非同期反復可能オブジェクトを期待するほとんどの構文で利用できるようにします。これは `this` の値を返しますが、これは非同期イテレーターオブジェクトそのものです。

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

構文
--

```js
asyncIterator[Symbol.asyncIterator]()
```

### 引数

なし。

### 返値

`this` の値で、非同期イテレーターオブジェクトそのものです。

例
-

### for await...of ループを使用した反復処理

このメソッドを直接呼び出す必要はほとんどないことに注意してください。 `@@asyncIterator` メソッドが存在することで、すべての組み込み非同期イテレーターを非同期反復可能にすることができます、また、 `for await. ..of` ループなどの反復処理構文は、自動的にこのメソッドを呼び出し、ループ処理する非同期イテレーターを取得します。

```js
const asyncIterator = (async function\* () {
  yield 1;
  yield 2;
  yield 3;
})();
(async () => {
  for await (const value of asyncIterator) {
    console.log(value);
  }
})();
// ログ: 1, 2, 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-asynciteratorprototype-asynciterator |

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

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

関連情報
----

* `for await...of`


Atomics.exchange() - JavaScript

Atomics.exchange()
==================

静的な **`Atomics.exchange()`** メソッドは、指定された値を配列内の指定した位置に格納し、その値を返します。これは不可分操作で、古い値を読み取ってから新しい値を書き込むまでの間に他の物が書き込まないことを保証します。

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

構文
--

```js
Atomics.exchange(typedArray, index, value);
```

### 引数

`typedArray`

共有整数の型付き配列です。 `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array`, `Uint32Array` の何れかです。

`index`

`typedArray` で `value` と交換する位置です。

`value`

交換する数値です。

### 返値

指定された位置 (`typedArray[index]`) にあった古い値です。

### 例外

* `typedArray` が許可された整数型の何れでもない場合、`TypeError` が発生します。
* `index` が `typedArray` の範囲を超えている場合、 `RangeError` が発生します。
例
-

### exchange() の使用

```js
const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);

Atomics.exchange(ta, 0, 12); // 古い値である 0 を返す
Atomics.load(ta, 0); // 12
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.exchange |

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

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

関連情報
----

* `Atomics`
* `Atomics.compareExchange()`