recursal/MDN huggingface dataset:
Reflect
=======

**`Reflect`** は、JavaScript 操作を受け付けるためのメソッドを提供する組み込みオブジェクトです。メソッドはプロキシーハンドラーのメソッドと同じです。`Reflect` は関数オブジェクトではありませんので、構築することはできません。

解説
--

他の多くのグローバルオブジェクトとは異なり、`Reflect` はコンストラクターではありません。`new` 演算子で使用したり、 `Reflect` オブジェクトを関数として呼び出したりすることはできません。 `Reflect` のすべてのプロパティとメソッドは (`Math` オブジェクトと同様に) 静的です。

`Reflect` オブジェクトはプロキシーハンドラーのメソッドと同じ名前をもつ、下記の関数を提供します。

これらのメソッドの一部は `Object` の対応するメソッドとも同じですが、これらの間にはいくらか微妙な違いがあります。

静的メソッド
------

`Reflect.apply(target, thisArgument, argumentsList)`

`target` 関数を、引数 `argumentsList` で指定された引数で呼び出します。 `Function.prototype.apply()` も参照してください。

`Reflect.construct(target, argumentsList[, newTarget])`

関数としての `new` 演算子です。 `new target(...argumentsList)` を呼び出すのと等価です。別なプロトタイプを指定するためにオプションを指定することもできます。

`Reflect.defineProperty(target, propertyKey, attributes)`

`Object.defineProperty()` と同様です。返値は論理値で、プロパティが定義できた場合は `true` を返します。

`Reflect.deleteProperty(target, propertyKey)`

関数としての `delete` 演算子です。 `delete target[propertyKey]` を呼び出すのと等価です。

`Reflect.get(target, propertyKey[, receiver])`

このプロパティの値を返します。オブジェクトからのプロパティの取得 (`target[propertyKey]`) を関数にしたようなものです。

`Reflect.getOwnPropertyDescriptor(target, propertyKey)`

`Object.getOwnPropertyDescriptor()` に似ています。指定したプロパティが存在する場合にプロパティ記述子を返し、存在しない場合は `undefined` を返します。

`Reflect.getPrototypeOf(target)`

`Object.getPrototypeOf()` と同じです。

`Reflect.has(target, propertyKey)`

論理値で、対象がそのプロパティを持っているかどうかを返します。固有の場合も継承の場合も含みます。 `in` 演算子を関数にしたものです。

`Reflect.isExtensible(target)`

`Object.isExtensible()` と同じです。論理値を返し、 `true` ならば対象が拡張可能です。

`Reflect.ownKeys(target)`

独自の (継承されているものではない) プロパティのキーをもつ文字列の配列を返します。

`Reflect.preventExtensions(target)`

`Object.preventExtensions()` に似ています。論理値を返し、 `true` は更新に成功した場合です。

`Reflect.set(target, propertyKey, value[, receiver])`

値をプロパティに割り当てる関数です。更新に成功したら `true` となる論理値を返します。

`Reflect.setPrototypeOf(target, prototype)`

オブジェクトのプロトタイプを設定する関数です。論理値を返し、 `true` ならば成功です。

例
-

### オブジェクトが特定のプロパティを持っているかどうかを検出


```js
const duck = {
  name: "Maurice",
  color: "white",
  greeting: function () {
    console.log(`Quaaaack! My name is ${this.name}`);
  },
};

Reflect.has(duck, "color");
// true
Reflect.has(duck, "haircut");
// false
```

### オブジェクトが所有するキーの返却


```js
Reflect.ownKeys(duck);
// [ "name", "color", "greeting" ]
```

### オブジェクトへの新しいプロパティの追加


```js
Reflect.set(duck, "eyes", "black");
// 成功した場合は "true" を返します。
// "duck" には "eyes: 'black'" プロパティが設定されました。
```

仕様書
---

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

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

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

関連情報
----

* `Proxy` グローバルオブジェクト
* `handler` オブジェクト
Iterator
========

**`Iterator`** オブジェクトは、イテレーターの結果オブジェクトを返す `next()` メソッドを提供することで、イテレータープロトコルに準拠したオブジェクトです。`Iterator.prototype` オブジェクトは、すべての組み込みイテレーターが継承する、隠れたグローバルオブジェクトです。これは、イテレーターオブジェクト自身を返す `@@iterator` メソッドを提供し、イテレーターを反復可能にしています。

なお、`Iterator` はグローバルオブジェクトではありませんが、将来的にはイテレーターヘルパーの提案でグローバルオブジェクトになる予定です。すべての組み込みイテレーターに共通する `Iterator.prototype` オブジェクトは、以下のコードで得ることができます。


```js
const IteratorPrototype = Object.getPrototypeOf(
  Object.getPrototypeOf([].values()),
);
```

解説
--

以下のものは、すべて JavaScript の組み込みイテレーターです。

* 配列イテレーター: `Array.prototype.values()`、`Array.prototype.keys()`、`Array.prototype.entries()`、`Array.prototype[@@iterator]()`、`TypedArray.prototype.values()`、`TypedArray.prototype.keys()`、`TypedArray.prototype.entries()`、`TypedArray.prototype[@@iterator]()`、`arguments[@@iterator]()` で返されます。
* String イテレーター: `String.prototype[@@iterator]()` で返されます。
* Map イテレーター: `Map.prototype.values()`、`Map.prototype.keys()`、`Map.prototype.entries()`、`Map.prototype[@@iterator]()` で返されます。
* Set イテレーター: `Set.prototype.values()`、`Set.prototype.keys()`、`Set.prototype.entries()`、`Set.prototype[@@iterator]()` で返されます。
* RegExp String イテレーター: `RegExp.prototype[@@matchAll]()`、`String.prototype.matchAll()` で返されます。
* `Generator` オブジェクト: ジェネレーター関数で返されます。
* Segments イテレーター: `Intl.Segmenter.prototype.segment()` で返される `Segments` オブジェクトの `[@@iterator]()` メソッドで返されます。

これらのイテレーターはそれぞれ個別のプロトタイプオブジェクトを持っており、特定のイテレーターが使用する `next()` メソッドを定義しています。例えば、すべての String イテレーターオブジェクトは、隠しオブジェクトである `StringIteratorPrototype` を継承しており、このオブジェクトは、その文字列をコードポイントごとに反復処理する `next()` メソッドを持っています。また、 `StringIteratorPrototype` は `@toStringTag` プロパティを持っており、初期値は文字列 `"String Iterator"` となります。このプロパティは `Object.prototype.toString()` で使用します。同様に、他のイテレータープロトタイプも自分自身で `@@toStringTag` の値を持ち、それは上で指定された名前と同じです。

これらのプロトタイプオブジェクトはすべて `Iterator.prototype` を継承しており、イテレーターオブジェクト自身を返す `@@iterator` メソッドを提供し、イテレーターを反復可能にもしています。

インスタンスメソッド
----------

`Iterator.prototype[@@iterator]()`

イテレーターオブジェクト自身を返します。これにより、イテレータオブジェクトが反復可能にもなります。

例
-

### イテレーターを反復可能オブジェクトとして使用

すべての組み込みイテレーターは反復可能でもあるので、`for...of` ループの中で使うことができます。


```js
const arrIterator = [1, 2, 3].values();
for (const value of arrIterator) {
  console.log(value);
}
// Logs: 1, 2, 3
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%iteratorprototype%-object |

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

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

関連情報
----

* `function*`
* イテレータープロトコル
decodeURIComponent()
====================

**`decodeURIComponent()`** 関数は、`encodeURIComponent()` 関数あるいは同様のルーチンによって事前に作成された URI (Uniform Resource Identifier; 統一資源識別子) の構成要素をデコードします。

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

構文
--
```

decodeURIComponent(encodedURI)
```

### 引数

`encodedURI`

エンコードされた URI の構成要素です。

### 返値

エンコードされた統一資源識別子 (URI) の構成要素をデコードしたものを表す新しい文字列です。

### 例外

不正に利用された場合は `URIError` ("malformed URI sequence") 例外が発生します。

解説
--

エンコードされた URI の構成要素のエスケープシーケンスを、それぞれが表す文字に置き換えます。

例
-

### キリル文字の URL の構成要素をデコード


```js
decodeURIComponent("JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
// "JavaScript\_шеллы"
```

### エラーの捕捉


```js
try {
  var a = decodeURIComponent("%E0%A4%A");
} catch (e) {
  console.error(e);
}

// URIError: malformed URI sequence
```

### URL からのクエリパラメータのデコード

decodeURIComponent は、URL からのクエリパラメータを解析するために直接使用することはできません。少し準備が必要です。


```js
function decodeQueryParam(p) {
  return decodeURIComponent(p.replace(/\+/g, " "));
}

decodeQueryParam("search+query%20%28correct%29");
// 'search query (correct)'
```

仕様
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-decodeuricomponent-encodeduricomponent |

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

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

関連情報
----

* `decodeURI`
* `encodeURI`
* `encodeURIComponent`
SyntaxError
===========

**`SyntaxError`** オブジェクトは、構文的に不正なコードを解釈しようとした場合のエラーを表します。これは、 JavaScript エンジンが、コードを解析中に言語の構文に従わないトークンまたはトークンの順序に遭遇した場合に発生します。

コンストラクター
--------

`SyntaxError()`

新しい `SyntaxError` オブジェクトを生成します。

インスタンスプロパティ
-----------

`SyntaxError.prototype.message`

エラーメッセージです。 ECMA-262 において `SyntaxError` は自身の `message` プロパティを提供するべきとされていますが、 SpiderMonkey では `Error.prototype.message` を継承しています。

`SyntaxError.prototype.name`

エラー名です。 `Error` から継承しています。

`SyntaxError.prototype.fileName`

このエラーが発生したファイルのパスです。 `Error` から継承しています。

`SyntaxError.prototype.lineNumber`

このエラーが発生したファイル内の行番号です。 `Error` から継承しています。

`SyntaxError.prototype.columnNumber`

このエラーが発生した行内の桁数です。 `Error` から継承しています。

`SyntaxError.prototype.stack`

スタックトレースです。 `Error` から継承しています。

例
-

### 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-native-error-types-used-in-this-standard-syntaxerror |

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

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

関連情報
----

* `Error`
RangeError
==========

**`RangeError`** オブジェクトは、値が配列内に存在しない、または値が許容範囲にない場合のエラーを表します。

解説
--

`RangeError`は、関数に対して引数として許容されない範囲の数値を渡そうとした場合に発生します。

これは次のような場合に発生します。

* 許容されない文字を含む文字列を `String.prototype.normalize()` に渡した場合
* `Array` コンストラクターで不正な長さの配列を作ろうとした場合
* 数値に関するメソッド `Number.prototype.toExponential()`, `Number.prototype.toFixed()`, `Number.prototype.toPrecision()` に不適切な値を渡した場合
コンストラクター
--------

`RangeError()`

新しい `RangeError` オブジェクトを生成します。

インスタンスプロパティ
-----------

`RangeError.prototype.message`

エラーメッセージ。 ECMA-262 は `RangeError` 自身が `message` プロパティを提供するべきであると規定しているにもかかわらず、 SpiderMonkey では `Error.prototype.message` が継承される。

`RangeError.prototype.name`

エラー名。 `Error` から継承。

`RangeError.prototype.fileName`

エラーが発生したファイルへのパス。 `Error` から継承。

`RangeError.prototype.lineNumber`

エラーが発生したファイルの行番号。 `Error` から継承。

`RangeError.prototype.columnNumber`

エラーが発生したファイルの列番号。 `Error` から継承。

`RangeError.prototype.stack`

スタックトレース。`Error`から継承。

例
-

### 数値に対する RangeError の使用


```js
function check(n) {
  if (!(n >= -500 && n <= 500)) {
    throw new RangeError("The argument must be between -500 and 500.");
  }
}

try {
  check(2000);
} catch (error) {
  if (error instanceof RangeError) {
    // Handle the error
  }
}
```

### RangeError の使用 (数値以外に対して)


```js
function check(value) {
  if (["apple", "banana", "carrot"].includes(value) === false) {
    throw new RangeError(
      'The argument must be an "apple", "banana", or "carrot".',
    );
  }
}

try {
  check("cabbage");
} catch (error) {
  if (error instanceof RangeError) {
    // Handle the error
  }
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-rangeerror |

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

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

関連情報
----

* `Error`
* `Array`
* `Number.toExponential()`
* `Number.toFixed()`
* `Number.toPrecision()`
* `String.prototype.normalize()`
WeakSet
=======

**`WeakSet`** オブジェクトは、コレクションに弱く参照された*オブジェクト*を格納することができます。

解説
--

`WeakSet` オブジェクトはコレクションオブジェクトです。 `Set` と同様に、 `WeakSet` 内の各オブジェクトは一度だけ存在します。すなわち、 `WeakSet` コレクション内で固有になります。

`Set` オブジェクトとの主な違いは下記の通りです。

* `WeakSet` は**オブジェクトのみ**のコレクションです。 `Set` のように、任意の型の自由な値を入れることはできません。
* `WeakSet` は*弱い参照*です。コレクション内のオブジェクトへの*弱い参照*で保持されます。 `WeakSet` 内に格納されているオブジェクトへの参照が他にない場合、ガベージコレクションにより削除されます。

**メモ:** これは、このコレクションに格納されているオブジェクトの現在のリストが存在しないことを意味します。 `WeakSets` は列挙可能ではありません。
### 使用例: 循環参照の検出

自分自身を再帰的に呼び出す関数は、どのオブジェクトが処理済みであるかを追跡することで、循環したデータ構造を防ぐ必要があります。

`WeakSet` はこの目的に理想的です。


```js
// Execute a callback on everything stored inside an object
function execRecursively(fn, subject, \_refs = null) {
  if (!_refs) _refs = new WeakSet();

  // Avoid infinite recursion
  if (_refs.has(subject)) return;

  fn(subject);
  if ("object" === typeof subject) {
    _refs.add(subject);
    for (let key in subject) execRecursively(fn, subject[key], _refs);
  }
}

const foo = {
  foo: "Foo",
  bar: {
    bar: "Bar",
  },
};

foo.bar.baz = foo; // Circular reference!
execRecursively((obj) => console.log(obj), foo);
```


ここで、 `WeakSet` は最初の実行時に作成され、その後の関数呼び出しのたびに (内部の `_refs` 引数を使用して) 渡されます。

オブジェクトの数や探索順序は重要ではないので、オブジェクトの参照を追跡するには `WeakSet` のほうが `Set` よりも、特に巨大な数のオブジェクトを処理する場合にはよりふさわしい (そして性能もよい) ものです。

コンストラクター
--------

`WeakSet()`

新しい`WeakSet`オブジェクトを生成します。

インスタンスメソッド
----------

`WeakSet.prototype.add(value)`

`value` を `WeakSet` オブジェクトに追加します。

`WeakSet.prototype.delete(value)`

`value` を `WeakSet` オブジェクトから削除します。削除後、 `WeakSet.prototype.has(value)` は `false` を返します。

`WeakSet.prototype.has(value)`

`value` が `WeakSet` オブジェクト内の要素に含まれているかどうかを示す論理値を返します。

例
-

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


```js
const ws = new WeakSet();
const foo = {};
const bar = {};

ws.add(foo);
ws.add(bar);

ws.has(foo); // true
ws.has(bar); // true

ws.delete(foo); // foo を set から削除
ws.has(foo); // false, foo は削除済み
ws.has(bar); // true, bar は残っている
```


`foo !== bar` であることに注意してください。これらは似たオブジェクトですが、***まったく同じオブジェクト**ではありません*。したがって、両方のオブジェクトが set に追加されます。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset-objects |

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

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

関連情報
----

* `Map`
* `Set`
* `WeakMap`
InternalError
=============

**非標準:** この機能は標準ではなく、標準化の予定もありません。公開されているウェブサイトには使用しないでください。ユーザーによっては使用できないことがあります。実装ごとに大きな差があることもあり、将来は振る舞いが変わるかもしれません。

**`InternalError` オブジェクト** は、 JavaScript エンジンで内部的に発生したエラーを示します。

これは、以下のように何かが大きすぎる時に発生します。

* "switch case が多すぎる"、
* "正規表現内の括弧が多すぎる"、
* "配列の初期化子が大きすぎる"、
* "再帰が深すぎる"。
コンストラクター
--------

`InternalError()`

新しい `InternalError` オブジェクトを生成します。

インスタンスプロパティ
-----------

`InternalError.prototype.message`

エラーメッセージです。 `Error.prototype.message` から継承しています。

`InternalError.prototype.name`

エラー名です。 `Error` から継承しています。

`InternalError.prototype.fileName`

このエラーが発生したファイルのパスです。 `Error` から継承しています。

`InternalError.prototype.lineNumber`

このエラーが発生したファイル内の行番号です。 `Error` から継承しています。

`InternalError.prototype.columnNumber`

このエラーが発生した行内の桁番号です。 `Error` から継承しています。

`InternalError.prototype.stack`

スタックトレースです。 `Error` から継承しています。

例
-

### 深すぎる再帰

この再帰関数は終了条件によって、10 回実行されます。


```js
function loop(x) {
  if (x >= 10) {
    // "x >= 10" is the exit condition
    return;
  }
  // do stuff
  loop(x + 1); // the recursive call
}
loop(0);
```


この条件を非常に大きな値に設定した場合、動作しなくなります。


```js
function loop(x) {
  if (x >= 1000000000000) return;
  // do stuff
  loop(x + 1);
}
loop(0);

// InternalError: too much recursion
```


詳しくは、 InternalError: too much recursion. を参照してください。

仕様書
---

仕様の一部ではありません。

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

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

関連情報
----

* `Error`
* InternalError: too much recursion
Symbol (シンボル)
=============

JavaScript では、シンボルはプリミティブ値です。

**Symbol** データ型を持つ値は「シンボル値」として見ることができます。 JavaScript の実行時環境では、シンボル値は `Symbol` 関数を呼び出すことで生成され、動的に無名の一意の値を生み出します。シンボルはオブジェクトプロパティとして使用されることがあります。

Symbol は任意で説明文を持つことができますが、これはデバッグ目的のみに利用されます。

**Symbol** 値は固有の識別子を表します。例えば以下のように使用します。


```js
// 2 つのシンボルを同じ説明文で使用
let Sym1 = Symbol("Sym");
let Sym2 = Symbol("Sym");

console.log(Sym1 === Sym2); // "false" を返す
// シンボルは固有であることが保証されます。
// 同じ説明文でたくさんのシンボルが生成されても、
// 異なる値を持ちます。
```


**メモ:** Ruby (または他の言語) の *"symbols"* と呼ばれる機能をよくご存知であれば、間違えないでください。 JavaScript のシンボルは異なります。

*Symbol* 型は ECMAScript 2015 の新機能であり、 ECMAScript 5 にはシンボルに相当するものはありません。

プログラミング言語によっては、シンボルデータ型は「アトム」と呼ばれています。

### シンボルは文字列に「自動変換」されない

JavaScript の大部分の値は文字列への暗黙的な変換に対応しています。例えば `alert` はほぼすべての値で表示することができ、動作します。シンボルは特殊です。自動変換は行われません。

例を示します。


```js
let Sym = Symbol("Sym");
alert(Sym); // TypeError: Cannot convert a Symbol value to a string
```


これは混合しないための「言語ガード」で、これは文字列とシンボルが根本的に異なるため、そして他の型に変換するべきものではないためです。

本当にシンボルを表示したいのであれば、 `.toString()` を呼び出す必要があります。


```js
let Sym = Symbol("Sym");
alert(Sym.toString()); // Symbol(Sym), now it works
```


または、 `symbol.description` プロパティを使用して、説明文を取得することができます。


```js
let _Sym = Symbol("Sym");

alert(_Sym.description); // Sym
```

### Well-known symbol

`Symbol` クラスには、 *well-known symbols* と呼ばれる定数があります。これらのシンボルによって、 JavaScript がオブジェクトをどのように扱うかを、プロパティキーとして使用することで構成することができます。

well-known symbol の例としては、配列風オブジェクトのための `Symbol.iterator`、文字列オブジェクトのための `Symbol.search` などがあります。

仕様書の Well-known symbol の表に挙げられているものは次の通りです。

* `Symbol.hasInstance`
* `Symbol.isConcatSpreadable`
* `Symbol.iterator`
* `Symbol.toPrimitive`
* …など。
### グローバルシンボルレジストリー

グローバルシンボルレジストリーを扱うメソッドは `Symbol.for()` および `Symbol.keyFor()` があります。これらは、グローバルシンボルテーブル（または「レジストリー」）と実行時環境の間を仲介します。シンボルレジストリーは、主に JavaScript コンパイラーインフラストラクチャが構築しており、その中のシンボルの内容は、 JavaScript 実行時インフラストラクチャでは上記のメソッド以外で扱えません。

`Symbol.for(tokenString)` メソッドはレジストリー内のシンボル値を返し、 `Symbol.keyFor(symbolValue)` メソッドはレジストリーからトークンの文字列を返します。この二つは対照的で、下記の結果は `true` です。


```js
Symbol.keyFor(Symbol.for("tokenString")) === "tokenString"; // true
```

関連情報
----

* Wikipedia の Symbol (programming) (英語)
* JavaScript データ型とデータ構造
* Symbols in ECMAScript 6
* `Symbol` （MDN JS リファレンス）
* `Object.getOwnPropertySymbols()`
* MDN Web Docs 用語集
    + JavaScript
    + Primitive
Function
========

JavaScript の関数は、実際にはすべて `Function` オブジェクトです。これは、 `(function(){}).constructor === Function` というコードが true を返すことで確認することができます。

コンストラクター
--------

`Function()`

新しい `Function` オブジェクトを生成します。コンストラクターを直接呼び出すと関数を動的に生成することができますが、セキュリティや、 `eval` (en-US) と似た性能の (ただし、はるかに重要性の低い) 問題を抱えます。ただし eval とは異なり、 `Function` コンストラクターはグローバルスコープで実行される関数のみを生成します。

インスタンスプロパティ
-----------

`Function.arguments`

 関数に渡した引数に対応する配列です。
 これは `Function` オブジェクトのプロパティとしては非推奨です。代わりに関数内に用意されている `arguments` オブジェクト (関数内で使用可能) を使用してください。


`Function.caller`

 現在実行している関数を呼び出した関数を返します。
 このプロパティは非推奨であり、一部の厳格モードではない関数でのみ機能します。


`Function.displayName`

関数の表示名です。

`Function.length`

関数によって期待される引数の数を指定します。

`Function.name`

関数の名前です。

インスタンスメソッド
----------

`Function.prototype.apply(thisArg [, argsArray])`

関数を呼び出し、 `this` を提供された `thisArg` に設定します。引数は `Array` として渡すことができます。

`Function.prototype.bind(thisArg[, arg1[, arg2[, ...argN]]])`

新しい関数を作成し、呼び出されたときに、 `this` を提供された `thisArg` に設定します。任意で、指定された一連の引数が、新しく結びつけられた関数が呼び出されたときに与えられた引数の前に付加されます。

`Function.prototype.call(thisArg[, arg1, arg2, ...argN])`

関数を呼び出して、 `this` に提供した値を設定します。引数は、指定するオブジェクトのものとして渡すことができます。

`Function.prototype.toString()`

 関数のソースコードを表す文字列を返します。
 `Object.prototype.toString` メソッドを上書きします。


例
-

### Funciton コンストラクターと関数宣言の違い

`Function` コンストラクターで生成された関数は、生成コンテキストにクロージャを作りません。つまり常にグローバルスコープで生成されます。これを実行すると、 `Function` コンストラクターの呼び出し元のスコープは入らず、自身のローカル変数とグローバル変数だけにアクセスできます。これは関数式のコードに `eval` (en-US) を使うのとは異なります。


```js
var x = 10;

function createFunction1() {
  var x = 20;
  return new Function("return x;"); // この |x| はグローバルの |x| を表す
}

function createFunction2() {
  var x = 20;
  function f() {
    return x; // この |x| は上記のローカルの |x| を表す
  }
  return f;
}

var f1 = createFunction1();
console.log(f1()); // 10
var f2 = createFunction2();
console.log(f2()); // 20
```


このコードはウェブブラウザーでは動作しますが、 Node.js では `f1()` で `ReferenceError` が発生します。 `x` が見つからないためです。これは Node の最上位のスコープがグローバルスコープではなく、 `x` はモジュールのローカルになるからです。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-objects |

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

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

関連情報
----

* 関数と関数スコープ
* `function` 文
* `function` 式
* `function*` 文
* `function*` 式
* `AsyncFunction`
* `GeneratorFunction`
escape()
========

**警告:** `escape()` は厳密には (「ウェブ標準から削除された」という意味で) 非推奨ではありませんが、ECMA-262 標準の Annex B で定義されており、その導入部には次のように書かれています。

> 
> 
>  … この付録で規定されているすべての言語機能と動作は、 1 つ以上の望ましくない特性を持ち、レガシーな使用例がない場合は、この仕様から削除されます。…
>  … プログラマーは、新しい ECMAScript のコードを書くときに、これらの機能や動作の存在を使用したり、仮定したりしてはいけません。…
>  
> 
> 
> 

The **`escape()`** 関数は、特定の文字を 16 進数のエスケープシーケンスで置き換えた新しい文字列を計算します。

**メモ:** この関数は、主に URL クエリー (URL の `?` に続く部分) に使われていました。 — "`\xHH`" の形式を使用して、ふつうの文字列リテラルをエスケープするためのものでは*ありません*。 (HH は 2 桁の 16 進数であり、より高い面の Unicode 文字には「\xHH\xHHxHH」という形式が使われます。)

文字列リテラル内のエスケープされた文字は、 `\x` を `%` に置き換えてから、 `decodeURIComponent()` 関数を使用することで展開することができます。

構文
--


```js
escape(str);
```

### 引数

`str`

エンコードする文字列。

### 返値

特定の文字がエスケープされた新しい文字列。

解説
--

`escape` 関数は*グローバルオブジェクト*のプロパティです。特殊文字は `@*_+-./` 以外の文字が符号化されます。

文字の 16 進数形式として、文字コードの値が `0xFF` 以下になる文字は 2 桁のエスケープシーケンス `%xx` が、それ以上の場合は 4 桁のエスケープシーケンス `%uxxxx` が使われます。

例
-

### escape の使用


```js
escape("abc123"); // "abc123"
escape("äöü"); // "%E4%F6%FC"
escape("ć"); // "%u0107"

// 特殊文字
escape("@\*\_+-./"); // "@\*\_+-./"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-escape-string |

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

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

関連情報
----

* `encodeURI`
* `encodeURIComponent`
* `unescape`
Date.now()
==========

**`Date.now()`** メソッドは、UTC (協定世界時) での 1970 年 1 月 1 日 0 時 0 分 0 秒 から現在までの経過時間をミリ秒単位で返します。

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

構文
--


```js
Date.now()
```

### 返値

ECMAScript 元期からの経過時間をミリ秒単位で表す数値です。

例
-

### 時刻の低精度化

 ブラウザーの設定によっては、タイミング攻撃とフィンガープリンティングに対する保護を提供するために `Date.now()` の精度が落とされていることがあります。
 Firefox では、`privacy.reduceTimerPrecision` が既定で有効になっています。既定値は Firefox 59 では 20 マイクロ秒で、 Firefox 60 では 2 ミリ秒です。


```js
// Firefox 60 での時刻の精度の低下（2 ミリ秒）
Date.now();
// 1519211809934
// 1519211810362
// 1519211811670
// …

// `privacy.resistFingerprinting` が有効な場合の時刻の精度の低下
Date.now();
// 1519129853500
// 1519129858900
// 1519129864400
// …
```


Firefox では、 `privacy.resistFingerprinting` も有効にできます。この場合、精度は 100 ミリ秒と `privacy.resistFingerprinting.reduceTimerPrecision.microseconds` 値のうち大きい方になります。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.now |

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

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

関連情報
----

* `Date.now` のポリフィル (`core-js`)
* `Performance.now()` — ウェブページのパフォーマンス測定のための、ミリ秒以下の分解能を持つタイムスタンプを提供
* `console.time()` / `console.timeEnd()`
Date.prototype.getMonth()
=========================

**`getMonth()`** メソッドは、地方時に基づき、指定された日付の「月」を表す 0 を基点とした値（すなわち 0 が年の最初の月を示す）を返します。

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

構文
--


```js
getMonth()
```

### 返値

地方時に基づき、与えた日付の「月」を表す 0 から 11 までの間の整数値。0 は 1 月、1 は 2 月、11 は 12 月に対応します。

例
-

### getMonth() の使用

以下の 2 行目の文は、`Date` オブジェクトである `xmas95` の値に基づき、変数 `month` に 11 という値を代入します。


```js
const xmas95 = new Date("December 25, 1995 23:15:30");
const month = xmas95.getMonth();

console.log(month); // 11
```


**メモ:** 必要に応じて、月の完全な名前（例えば `January` ）は `Intl.DateTimeFormat()` に `options` 引数を付けることで取得することができます。このメソッドを使用すれば、国際化がより簡単になります。


```js
const options = { month: "long" };
console.log(new Intl.DateTimeFormat("en-US", options).format(Xmas95));
// December
console.log(new Intl.DateTimeFormat("de-DE", options).format(Xmas95));
// Dezember
```


仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getmonth |

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

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

関連情報
----

* `Date.prototype.getUTCMonth()`
* `Date.prototype.setMonth()`
Date.prototype.setSeconds()
===========================

**`setSeconds()`** メソッドは、地方時に基づき、指定された日時の「秒」を設定します。

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

構文
--


```js
setSeconds(secondsValue)
setSeconds(secondsValue, msValue)
```

### 引数

`secondsValue`

日付の「秒」を表す 0 から 59 までの間の整数値。

`msValue` 省略可

日付の「ミリ秒」を表す 0 から 999 までの間の整数。

### 返値

協定世界時 (UTC) 1970 年 1 月 1 日 00:00:00 から更新された日時までの間のミリ秒単位の数値。

解説
--

`msValue` 引数を指定しなかった場合、`getMilliseconds()` メソッドから返される値が使われます。

指定した値が期待される日付の範囲外の場合、それに応じて `setSeconds()` が `Date` オブジェクトの日付情報の更新を試みます。例えば、 `secondsValue` に 100 を指定した場合、分に 1 が加算され、秒が 40 になります。

例
-

### setSeconds() の使用


```js
const theBigDay = new Date();
theBigDay.setSeconds(30);
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.setseconds |

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

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

関連情報
----

* `Date.prototype.getSeconds()`
* `Date.prototype.setUTCSeconds()`