AsyncGeneratorFunction - JavaScript

AsyncGeneratorFunction
======================

**`AsyncGeneratorFunction`** オブジェクトは、非同期ジェネレータ関数 のメソッドを提供します。 JavaScript で、すべての非同期ジェネレータ関数は実際には `AsyncGeneratorFunction` オブジェクトです。

なお、`AsyncGeneratorFunction` はグローバルオブジェクトではありません。以下のコードで取得できます。

```js
const AsyncGeneratorFunction = async function\* () {}.constructor;
```

`AsyncGeneratorFunction` は `Function` のサブクラスです。

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

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

`AsyncGeneratorFunction()`

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

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

*親である `Function` から継承したインスタンスプロパティもあります*。

これらのプロパティは `AsyncGeneratorFunction.prototype` で定義されており、すべての `AsyncGeneratorFunction` インスタンスで共有されます。

`AsyncGeneratorFunction.prototype.constructor`

このインスタンスオブジェクトを生成したコンストラクター関数です。 `AsyncGeneratorFunction` インスタンスにおいては、初期値は `AsyncGeneratorFunction` コンストラクターです。

`AsyncGeneratorFunction.prototype.prototype`

すべての非同期ジェネレータ関数は同じ `prototype` プロパティを共有していて、それは `AsyncGenerator.prototype` です。それぞれの非同期ジェネレーター関数のインスタンスは自分自身で `prototype` プロパティも持ちます。非同期ジェネレーター関数が呼び出されると、返される非同期ジェネレーターオブジェクトは非同期ジェネレーター関数の `prototype` プロパティを継承し、そのプロパティは `AsyncGeneratorFunction.prototype` を継承します。

`AsyncGeneratorFunction.prototype[@@toStringTag]`

`@@toStringTag` プロパティの初期値は文字列 `"AsyncGeneratorFunction"` です。このプロパティは `Object.prototype.toString()` で使用します。

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

*親である `Function` からインスタンスメソッドを継承しています*。

仕様書
---

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

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

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

関連情報
----

* `async function*` 宣言
* `async function*` 式
* `Function`
* `AsyncFunction`
* `GeneratorFunction`
* Functions


TypeError - JavaScript

TypeError
=========

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

`TypeError` は以下のような場合に発生します。

* 関数に渡されたオペランドや引数が、その演算子や関数で期待された型と互換性がなかった場合
* 変更できない値を変更しようとした場合
* 適切ではない方法で値を使用しようとした場合
コンストラクター
--------

`TypeError()`

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

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

`TypeError.prototype.message`

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

`TypeError.prototype.name`

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

`TypeError.prototype.fileName`

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

`TypeError.prototype.lineNumber`

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

`TypeError.prototype.columnNumber`

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

`TypeError.prototype.stack`

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

例
-

### TypeError のキャッチ

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

### TypeError の生成

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

仕様書
---

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

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

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

関連情報
----

* `Error`


BigInt64Array - JavaScript

BigInt64Array
=============

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

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

`BigInt64Array()`

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

静的プロパティ
-------

`BigInt64Array.BYTES_PER_ELEMENT`

要素の大きさを数値で返します。`BigInt64Array` の場合は `8` です。

`BigInt64Array.name`

コンストラクター名を文字列値で返します。`BigInt64Array` の場合、 "`BigInt64Array`" です。

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

`BigInt64Array.from()`

配列風オブジェクトまたは反復可能オブジェクトから新しい `BigInt64Array` オブジェクトを生成します。 `Array.from()` も参照してください。

`BigInt64Array.of()`

可変長引数で新しい `BigInt64Array` オブジェクトを生成します。`Array.of()` も参照してください。

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

`BigInt64Array.prototype.buffer`

`BigInt64Array` オブジェクトによって参照される `ArrayBuffer` を返します。構築時に固定され、**読み取り専用**です。

`BigInt64Array.prototype.byteLength`

`ArrayBuffer` の先頭からの `BigInt64Array` の長さを (バイト単位で) 返します。構築時に固定され、**読み取り専用**です。

`BigInt64Array.prototype.byteOffset`

`ArrayBuffer` の先頭からの `BigInt64Array` のオフセットを (バイト単位で) 返します。構築時に固定され、**読み取り専用**です。

`BigInt64Array.prototype.length`

`BigInt64Array` オブジェクト内に保持されている要素の数を返します。構築時に固定され、**読み取り専用**です。

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

`BigInt64Array.prototype.copyWithin()`

配列内で一連の配列要素をコピーします。`Array.prototype.copyWithin()` も参照してください。

`BigInt64Array.prototype.entries()`

配列内ですべての位置におけるキーと値の組を提供する新しい*配列イテレーター*を返します。`Array.prototype.entries()` も参照してください。

`BigInt64Array.prototype.every()`

配列内のすべての要素が関数によって提供されたテストに合格するかどうかテストを実行します。`Array.prototype.every()` も参照してください。

`BigInt64Array.prototype.fill()`

配列の先頭位置から末尾位置までのすべての要素を固定値に設定します。`Array.prototype.fill()` も参照してください。

`BigInt64Array.prototype.filter()`

この配列のすべての要素のうち、与えられたフィルタリング関数が `true` を返すものをもつ新しい配列を生成します。`Array.prototype.filter()` も参照してください。

`BigInt64Array.prototype.find()`

配列内の要素に与えられたテスト関数を満足するものがあったら、見つかった値を返します。見つからなければ `undefined` を返します。`Array.prototype.find()` も参照してください。

`BigInt64Array.prototype.findIndex()`

配列内の要素に与えられたテスト関数を満足するものがあったら、見つかった位置を返します。見つからなければ `-1` を返します。`Array.prototype.findIndex()` も参照してください。

`BigInt64Array.prototype.forEach()`

配列内のそれぞれの要素について関数を呼び出します。`Array.prototype.forEach()` も参照してください。

`BigInt64Array.prototype.includes()`

型付き配列に特定の要素があるかどうかを判断し、それに応じて `true` か `false`を返します。 `Array.prototype.includes()` も参照してください。

`BigInt64Array.prototype.indexOf()`

指定された値に等しい配列内の要素の最初の (最小の) 位置を返します。見つからなかった場合、 `-1` を返します。`Array.prototype.indexOf()` も参照してください。

`BigInt64Array.prototype.join()`

配列のすべての要素を 1 つの文字列に結合します。`Array.prototype.join()` も参照してください。

`BigInt64Array.prototype.keys()`

配列内ですべての位置におけるキーを提供する新しい*配列イテレーター*を返します。`Array.prototype.keys()` も参照してください。

`BigInt64Array.prototype.lastIndexOf()`

指定された値に等しい配列内の要素の最後の (最大の) 位置を返します。見つからなかった場合、 `-1` を返します。`Array.prototype.lastIndexOf()` も参照してください。

`BigInt64Array.prototype.map()`

この配列のすべての要素で与えられた関数を呼び出した結果をもつ新しい配列を生成します。`Array.prototype.map()` も参照してください。

`BigInt64Array.prototype.reduce()`

アキュムレーターとこの配列のそれぞれの値に対して (左から右へ) 関数を適用し、単一の値に還元します。`Array.prototype.reduce()` も参照してください。

`BigInt64Array.prototype.reduceRight()`

アキュムレーターとこの配列のそれぞれの値に対して (右から左へ) 関数を適用し、単一の値に還元します。`Array.prototype.reduceRight()` も参照してください。

`BigInt64Array.prototype.reverse()`

配列の要素の順番を反転させます。最初の要素は最後になり、最後の要素は最初になります。`Array.prototype.reverse()` も参照してください。

`BigInt64Array.prototype.set()`

入力値を指定した配列から読み込み、この型付き配列内に複数の値を格納します。

`BigInt64Array.prototype.slice()`

配列の一部を取り出して新しい配列を返します。`Array.prototype.slice()` も参照してください。

`BigInt64Array.prototype.some()`

この配列の 1 つ以上の要素が与えられたテスト関数を満たした場合に `true` を返します。`Array.prototype.some()` も参照してください。

`BigInt64Array.prototype.sort()`

配列の要素をその場で並べ替え、その配列を返します。`Array.prototype.sort()` も参照してください。

`BigInt64Array.prototype.subarray()`

指定された先頭と末尾の要素位置から新しい `BigInt64Array` を返します。

`BigInt64Array.prototype.values()`

配列内ですべての位置における値を提供する新しい*配列イテレーター*を返します。`Array.prototype.values()` も参照してください。

`BigInt64Array.prototype.toLocaleString()`

配列とその要素を表すローカライズされた文字列を返します。`Array.prototype.toLocaleString()` も参照してください。

`BigInt64Array.prototype.toString()`

配列とその要素を表す文字列を返します。`Array.prototype.toString()` も参照してください。

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

配列内ですべての位置における値を提供する新しい*配列イテレーター*を返します。

例
-

### 様々な方法で `BigInt64Array` を作成

```js
// 長さから
var bigint64 = new BigInt64Array(2);
bigint64[0] = 42n;
console.log(bigint64[0]); // 42n
console.log(bigint64.length); // 2
console.log(bigint64.BYTES\_PER\_ELEMENT); // 8

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

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

// ArrayBuffer から
var buffer = new ArrayBuffer(32);
var z = new BigInt64Array(buffer, 0, 4);

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

仕様書
---

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

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

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

関連情報
----

* JavaScript の型付き配列
* `BigUint64Array`
* `DataView`


Float32Array - JavaScript

Float32Array
============

**`Float32Array`** は型付き配列で、プラットフォームのバイト順による 32 ビット浮動小数点数 (C 言語の `float` データ型に相当) の配列を表します。バイト順の制御が必要な場合は、代わりに `DataView` を使用してください。中身は `0` で初期化されます。生成されると、配列内の要素はそのオブジェクトのメソッドを使用するか、配列の標準的な添字の構文 (すなわち、ブラケット記法) を使用するかして参照することができます。

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

`Float32Array()`

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

静的プロパティ
-------

`Float32Array.BYTES_PER_ELEMENT`

要素の大きさを数値で返します。`Float32Array` の場合は `4` です。

`Float32Array.name`

コンストラクター名を文字列値で返します。`Float32Array` の場合、 "`Float32Array`" です。

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

`Float32Array.from()`

配列風オブジェクトまたは反復可能オブジェクトから新しい `Float32Array` オブジェクトを生成します。 `Array.from()` も参照してください。

`Float32Array.of()`

可変長引数で新しい `Float32Array` オブジェクトを生成します。`Array.of()` も参照してください。

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

`Float32Array.prototype.buffer`

`Float32Array` オブジェクトによって参照される `ArrayBuffer` を返します。構築時に固定され、**読み取り専用**です。

`Float32Array.prototype.byteLength`

`Float32Array` の長さを (バイト単位で) 返します。構築時に固定され、**読み取り専用**です。

`Float32Array.prototype.byteOffset`

`ArrayBuffer` の先頭からの `Float32Array` のオフセットを (バイト単位で) 返します。構築時に固定され、**読み取り専用**です。

`Float32Array.prototype.length`

`Float32Array` オブジェクト内に保持されている要素の数を返します。構築時に固定され、**読み取り専用**です。

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

`Float32Array.prototype.copyWithin()`

配列内で一連の配列要素をコピーします。`Array.prototype.copyWithin()` も参照してください。

`Float32Array.prototype.entries()`

配列内ですべての位置におけるキーと値の組を提供する新しい*配列イテレーター*を返します。`Array.prototype.entries()` も参照してください。

`Float32Array.prototype.every()`

配列内のすべての要素が関数によって提供されたテストに合格するかどうかテストを実行します。`Array.prototype.every()` も参照してください。

`Float32Array.prototype.fill()`

配列の先頭位置から末尾位置までのすべての要素を固定値に設定します。`Array.prototype.fill()` も参照してください。

`Float32Array.prototype.filter()`

この配列のすべての要素のうち、与えられたフィルタリング関数が `true` を返すものをもつ新しい配列を生成します。`Array.prototype.filter()` も参照してください。

`Float32Array.prototype.find()`

配列内の要素に与えられたテスト関数を満足するものがあったら、見つかった値を返します。見つからなければ `undefined` を返します。`Array.prototype.find()` も参照してください。

`Float32Array.prototype.findIndex()`

配列内の要素に与えられたテスト関数を満足するものがあったら、見つかった位置を返します。見つからなければ `-1` を返します。`Array.prototype.findIndex()` も参照してください。

`Float32Array.prototype.forEach()`

配列内のそれぞれの要素について関数を呼び出します。`Array.prototype.forEach()` も参照してください。

`Float32Array.prototype.includes()`

型付き配列に特定の要素があるかどうかを判断し、それに応じて `true` か `false`を返します。 `Array.prototype.includes()` も参照してください。

`Float32Array.prototype.indexOf()`

指定された値に等しい配列内の要素の最初の (最小の) 位置を返します。見つからなかった場合、 `-1` を返します。`Array.prototype.indexOf()` も参照してください。

`Float32Array.prototype.join()`

配列のすべての要素を 1 つの文字列に結合します。`Array.prototype.join()` も参照してください。

`Float32Array.prototype.keys()`

配列内ですべての位置におけるキーを提供する新しい*配列イテレーター*を返します。`Array.prototype.keys()` も参照してください。

`Float32Array.prototype.lastIndexOf()`

指定された値に等しい配列内の要素の最後の (最大の) 位置を返します。見つからなかった場合、 `-1` を返します。`Array.prototype.lastIndexOf()` も参照してください。

`Float32Array.prototype.map()`

この配列のすべての要素で与えられた関数を呼び出した結果をもつ新しい配列を生成します。`Array.prototype.map()` も参照してください。

`Float32Array.prototype.reduce()`

アキュムレーターとこの配列のそれぞれの値に対して (左から右へ) 関数を適用し、単一の値に還元します。`Array.prototype.reduce()` も参照してください。

`Float32Array.prototype.reduceRight()`

アキュムレーターとこの配列のそれぞれの値に対して (右から左へ) 関数を適用し、単一の値に還元します。`Array.prototype.reduceRight()` も参照してください。

`Float32Array.prototype.reverse()`

配列の要素の順番を反転させます。最初の要素は最後になり、最後の要素は最初になります。`Array.prototype.reverse()` も参照してください。

`Float32Array.prototype.set()`

入力値を指定した配列から読み込み、この型付き配列内に複数の値を格納します。

`Float32Array.prototype.slice()`

配列の一部を取り出して新しい配列を返します。`Array.prototype.slice()` も参照してください。

`Float32Array.prototype.some()`

この配列の 1 つ以上の要素が与えられたテスト関数を満たした場合に `true` を返します。`Array.prototype.some()` も参照してください。

`Float32Array.prototype.sort()`

配列の要素をその場で並べ替え、その配列を返します。`Array.prototype.sort()` も参照してください。

`Float32Array.prototype.subarray()`

指定された先頭と末尾の要素位置から新しい `Float32Array` を返します。

`Float32Array.prototype.values()`

配列内ですべての位置における値を提供する新しい*配列イテレーター*を返します。`Array.prototype.values()` も参照してください。

`Float32Array.prototype.toLocaleString()`

配列とその要素を表すローカライズされた文字列を返します。`Array.prototype.toLocaleString()` も参照してください。

`Float32Array.prototype.toString()`

配列とその要素を表す文字列を返します。`Array.prototype.toString()` も参照してください。

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

配列内ですべての位置における値を提供する新しい*配列イテレーター*を返します。

例
-

### 様々な方法で `Float32Array` を作成

```js
// 長さから
var float32 = new Float32Array(2);
float32[0] = 42;
console.log(float32[0]); // 42
console.log(float32.length); // 2
console.log(float32.BYTES\_PER\_ELEMENT); // 4

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

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

// ArrayBuffer から
var buffer = new ArrayBuffer(16);
var z = new Float32Array(buffer, 0, 4);

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

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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

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

関連情報
----

* `Float32Array` のポリフィルが `core-js` で利用できます
* JavaScript の型付き配列
* `ArrayBuffer`
* `DataView`


DataView - JavaScript

DataView
========

**`DataView`** ビューは `ArrayBuffer` の多様な数値型を、プラットフォームのエンディアンに関係なく読み書きするための低水準インターフェイスを提供します。

解説
--

### エンディアン

多バイトの数値形式は、マシンアーキテクチャによってメモリー内での表現が異なります。説明はエンディアンを参照してください。 `DataView` のアクセサーは、プラットフォームアーキテクチャのエンディアンに関係なくデータにアクセスする方法を明確に制御する手段を提供します。

```js
var littleEndian = (function () {
  var buffer = new ArrayBuffer(2);
  new DataView(buffer).setInt16(0, 256, true /\* リトルエンディアン \*/);
  // Int16Array はプラットフォームのエンディアンを使用する
  return new Int16Array(buffer)[0] === 256;
})();
console.log(littleEndian); // true または false
```

### 64 ビット整数値

一部のブラウザーは `DataView.prototype.setBigInt64()` および `DataView.prototype.setBigUint64()` に対応していません。そのため、各ブラウザーで動作するコードで 64 ビット操作ができるようにするには、独自の `getUint64()` 関数を実装し、 `Number.MAX_SAFE_INTEGER` までの精度の値を受け取れるようにします。これで十分な場合もあるでしょう。

```js
function getUint64(dataview, byteOffset, littleEndian) {
  // 64 ビット数を 2 つの 32 ビット (4 バイト) の部分に分割する
  const left = dataview.getUint32(byteOffset, littleEndian);
  const right = dataview.getUint32(byteOffset + 4, littleEndian);

  // 2 つの 32 ビットの値を結合する
  const combined = littleEndian
    ? left + 2 \*\* 32 \* right
    : 2 \*\* 32 \* left + right;

  if (!Number.isSafeInteger(combined))
    console.warn(combined, "exceeds MAX\_SAFE\_INTEGER. Precision may be lost");

  return combined;
}
```

他にも、完全な 64 ビットの幅が必要な場合、`BigInt` を作成することもできます。さらに言えば、ネイティブの BigInt はユーザーランドライブラリーの同等品よりもはるかに速いのですが、JavaScript では BigInt は可変長であるという性質上、常に 32 ビット整数よりもはるかに遅くなります。

```js
const BigInt = window.BigInt,
  bigThirtyTwo = BigInt(32),
  bigZero = BigInt(0);
function getUint64BigInt(dataview, byteOffset, littleEndian) {
  // 64 ビット数を 2 つの 32 ビット (4 バイト) の部分に分割する
  const left = BigInt(dataview.getUint32(byteOffset | 0, !!littleEndian) >>> 0);
  const right = BigInt(
    dataview.getUint32(((byteOffset | 0) + 4) | 0, !!littleEndian) >>> 0,
  );

  // 2 つの 32 ビットの値を結合して返す
  return littleEndian
    ? (right << bigThirtyTwo) | left
    : (left << bigThirtyTwo) | right;
}
```

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

`DataView()`

新しい `DataView` オブジェクトを作成します。

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

`DataView.prototype.buffer`

このビューによって参照される `ArrayBuffer`。構築時に設定されるため、**読み取り専用**です。

`DataView.prototype.byteLength`

`ArrayBuffer` の開始位置からこのビューの (バイト単位の) 長さ。構築時に設定されるため、**読み取り専用**です。

`DataView.prototype.byteOffset`

`ArrayBuffer` の開始位置からこのビューの (バイト単位の) オフセット。構築時に設定されるため、**読み取り専用**です。

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

`DataView.prototype.getInt8()`

ビューの開始位置から指定されたバイト単位のオフセット位置にある符号付き 8 ビット整数値 (byte) を取得します。

`DataView.prototype.getUint8()`

ビューの開始位置から指定されたバイト単位のオフセット位置にある符号無し 8 ビット整数値 (unsigned byte) を取得します。

`DataView.prototype.getInt16()`

ビューの開始位置から指定されたバイト単位のオフセット位置にある符号付き 16 ビット整数値 (short) を取得します。

`DataView.prototype.getUint16()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号無し 16 ビット整数値 (unsigned short) を取得します。

`DataView.prototype.getInt32()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 32 ビット整数値 (long) を取得します。

`DataView.prototype.getUint32()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号無し 32 ビット整数値 (unsigned long) を取得します。

`DataView.prototype.getFloat32()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 32 ビット浮動小数点数 (float) を取得します。

`DataView.prototype.getFloat64()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 64 ビット浮動小数点数 (double) を取得します。

`DataView.prototype.getBigInt64()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 64 ビット整数値(long long) を取得します。

`DataView.prototype.getBigUint64()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号なし 64 ビット整数値 (unsigned long long) を取得します。

`DataView.prototype.setInt8()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 8 ビット整数値 (byte) を格納します。

`DataView.prototype.setUint8()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号なし 8 ビット整数値 (unsigned byte) を格納します。

`DataView.prototype.setInt16()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 16 ビット整数値 (short) を格納します。

`DataView.prototype.setUint16()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号無し 16 ビット整数値 (unsigned short) を格納します。

`DataView.prototype.setInt32()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 32 ビット整数値 (long) を格納します。

`DataView.prototype.setUint32()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号無し 32 ビット整数値 (unsigned long) を格納します。

`DataView.prototype.setFloat32()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 32 ビット浮動小数点数 (float) を格納します。

`DataView.prototype.setFloat64()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 64 ビット浮動小数点数 (double) を格納します。

`DataView.prototype.setBigInt64()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号あり 64 ビット整数値 (long long) を格納します。

`DataView.prototype.setBigUint64()`

ビューの開始位置からの指定されたバイト単位のオフセット位置にある符号なし 64 ビット整数値 (unsigned long long) を格納します。

例
-

### 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-objects |

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

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

関連情報
----

* `DataView` のポリフィルは `core-js` で利用できます
* jDataView: `DataView` API をすべてのブラウザーや Node.js に展開するポリフィルの JavaScript ライブラリー
* `ArrayBuffer`
* `SharedArrayBuffer`


globalThis - JavaScript

globalThis
==========

**`globalThis`** はグローバルプロパティで、グローバルオブジェクトと同等であるグローバルな `this` が格納されています。

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

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

解説
--

 従来、グローバルスコープにアクセスするには、JavaScript 環境ごとに異なる構文を必要としていました。ウェブ上では `window`, `self`, `frames` を使うことができます。しかし Web Worker は `self` のみを利用することができます。Node.js はこれらのいずれも利用できず、代わりに `global` を使用する必要があります。
 `this` キーワードは、strict でないモードで実行されている関数の中で使用することもできますが、strict モードで実行されているモジュールや関数の中では `undefined` になります。`Function('return this')()` を使用することもできますが、CSP などによって `eval()` (en-US) を無効にしている環境では、この方法でも `Function` の使用が抑制されます。

`globalThis` プロパティは、環境を越えてグローバルな `this` 値 (すなわちグローバルオブジェクト自身) にアクセスするための標準的な方法を提供します。`window` や `self` などの同様のプロパティとは異なり、これはウィンドウのコンテキストでも非ウィンドウのコンテキストでも動作することが保証されています。この方法では、コードがどの環境で実行されているのかを知らなくても、一貫した方法でグローバルオブジェクトにアクセスすることができます。名前を覚えやすくするために、グローバルスコープでは `this` の値は `globalThis` であることを忘れないでください。

### HTML と WindowProxy

多くのエンジンでは `globalThis` は実在のグローバルオブジェクトの参照になりますが、ウェブブラウザーにおいては、iframe およびウィンドウ間のセキュリティ上の配慮から、これは (直接アクセスできない) 実在のグローバルオブジェクトに関する `Proxy` になります。一般的な利用に関わることは稀ですが、認識しておくことは重要です。

### 命名

`self` や `global` のような他の一般的な名前の選択肢は、既存のコードとの互換性を損なう可能性があるため、候補から除外されました。詳しくは language proposal's "naming" document を参照してください。

例
-

### 異なる環境間でグローバルの検索

`globalThis` 以前は、その環境のグローバルオブジェクトを取得する信頼性の高い方法は `Function('return this')()` だけでした。ただし、これは設定によっては CSP 違反が発生するため、es6-shim では次のようなチェックを使用します。

```js
var getGlobal = function () {
  if (typeof self !== "undefined") {
    return self;
  }
  if (typeof window !== "undefined") {
    return window;
  }
  if (typeof global !== "undefined") {
    return global;
  }
  throw new Error("unable to locate global object");
};

var globals = getGlobal();

if (typeof globals.setTimeout !== "function") {
  // no setTimeout in this environment!
}
```

`globalThis` が利用可能になったため、異なる環境間でグローバルを追加で検索する必要がなくなりました。

```js
if (typeof globalThis.setTimeout !== "function") {
  // no setTimeout in this environment!
}
```

仕様
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-globalthis |

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

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

関連情報
----

* `this`


Reflect - JavaScript

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` オブジェクト


FinalizationRegistry - JavaScript

FinalizationRegistry
====================

**`FinalizationRegistry`** オブジェクトにより、オブジェクトがガベージコレクションで回収されるときにコールバックを要求することができます。

解説
--

`FinalizationRegistry` は、レジストリーに登録されているオブジェクトが*回収*される (ガベージコレクションされる) 時に*クリーンアップコールバック*を要求する方法を提供します。(クリーンアップコールバックは*ファイナライザー*と呼ばれることもあります。)

**メモ:** クリーンアップコールバックは、重要なプログラムロジックには使用しないでください。詳細は、クリーンアップコールバックに関する注意事項を参照してください。

コールバックで渡すレジストリーを作成します。

```js
const registry = new FinalizationRegistry((heldValue) => {
  // ....
});
```

次に、 `register` メソッドを呼び出して、クリーンアップコールバックを行いたいオブジェクトを登録し、そのオブジェクトと*保持値*を渡します。

```js
registry.register(theObject, "some value");
```

レジストリーがオブジェクトへの強い参照を保持すると、目的に反してしまうので、 (レジストリーが強い参照を保持していれば、そのオブジェクトは決して回収されない)、強い参照は保持はしません。

`theObject` が回収された場合、クリーンアップコールバックは、指定した*保持値* (上記の `"some value"`) で呼び出される可能性があります。保持値は、プリミティブでもオブジェクトでも、 `undefined` であっても構いません。保持値がオブジェクトの場合、レジストリーはその値への*強い*参照を保持します (これにより、後でクリーンアップコールバックに渡すことができます)。

オブジェクトの登録を解除したい場合は、三番目の値を渡します。 これは、後でレジストリのレジストリの `unregister` 関数を呼び出してオブジェクトの登録を解除する際に使用する*登録解除トークン*です。レジストリーは、登録解除トークンへの弱い参照のみを保持します。

よくオブジェクト自身が登録解除トークンとして使われ、これは良い結果になります。

```js
registry.register(theObject, "some value", theObject);
// ...some time later, if you don't care about `theObject` anymore...
registry.unregister(theObject);
```

ただし、同じオブジェクトである必要はありません。異なるものでも構いません。

```js
registry.register(theObject, "some value", tokenObject);
// ...some time later, if you don't care about `theObject` anymore...
registry.unregister(tokenObject);
```

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

`FinalizationRegistry()`

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

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

`FinalizationRegistry.prototype.register()`

オブジェクトをレジストリーに登録して、オブジェクトがガベージコレクションされたときにクリーンアップコールバックが実行できるようにします。

`FinalizationRegistry.prototype.unregister()`

オブジェクトをレジストリーから登録解除します。

できるだけ使用しない
----------

`FinalizationRegistry` を正しく使用するには慎重に検討する必要があるため、できるだけ使用しない方がいいでしょう。また、仕様で保証されていない特定の動作に依存しないようにすることも重要です。ガベージコレクションがいつ、どのように、どのように行われるかは、それぞれの JavaScript エンジンの実装に依存します。あるエンジンで観察された動作が、別のエンジンや同じエンジンの別のバージョンでは異なるかもしれませんし、同じエンジンの同じバージョンでも若干異なる状況になるかもしれません。ガベージコレクションは、 JavaScript エンジンの実装者がその解決策を常に改良し続けている難しい問題なのです。

ここでは、 `FinalizationRegistry` が含まれている WeakRef の提案の著者が、その説明文書に盛り込んだ具体的なポイントを紹介します。

>
> ガベージコレクター は複雑です。アプリケーションやライブラリーが、ガベージコレクターによる `FinalizationRegistry` のクリーンアップやファイナライザー [クリーンアップコールバック] の呼び出しをタイムリーに予測可能な方法で行うことに依存している場合、期待を裏切られる可能性があります。クリーンアップが予想よりもずっと遅く行われたり、まったく行われなかったりすることがあります。変化する原因には次のようなものがあります。
>
>
> * あるオブジェクトが他のオブジェクトよりも早くガベージコレクションされることがあります。これは、世代別コレクションなどにより、同時に到達できなくなったとしても同様です。
> * ガベージコレクションの作業は、差分技術やコンカレント技術を使って時間をかけて分割される可能性があります。
> * メモリ使用量や応答性のバランスをとるために、さまざまなランタイムヒューリスティックが使用されることがあります。
> * JavaScript エンジンは、 (クロージャやインラインキャッシュなどで) 到達できないように見えるものへの参照を保持することがあります。
> * JavaScript エンジンによっては、これらの処理が異なる場合がありますし、同じエンジンでもバージョンによってアルゴリズムが変わる場合があります。
> * 複雑な要因により、特定の API を使用する場合などに、オブジェクトが予想外の時間だけ保持されることがあります。
>
>
>

クリーンアップコールバックに関する注意点
--------------------

クリーンアップコールバックには、いくつかの注意点があります。

* 開発者は、重要なプログラムロジックをクリーンアップコールバックに頼るべきではありません。クリーンアップコールバックは、プログラムの途中でメモリー使用量を削減するのに役立つかもしれませんが、それ以外ではほとんど役に立ちません。
* 適合する JavaScript の実装は、たとえガベージコレクションを行うものであっても、クリーンアップコールバックを呼び出すとは限りません。いつ、どのように呼び出すかは、 JavaScript エンジンの実装に完全に依存します。登録されたオブジェクトが回収されたとき、そのオブジェクトのためのクリーンアップコールバックは、そのときに呼ばれるかもしれないし、しばらくしてから呼ばれるかもしれないし、まったく呼ばれないかもしれません。
* 多くの実装では、実行中のどこかの時点でクリーンアップコールバックが呼び出されると思われますが、それらの呼び出しは関連オブジェクトが再取得された後に実質的に行われるかもしれません。
* また、通常はクリーンアップコールバックを呼び出す実装であっても、状況によっては呼び出さない可能性もあります。
    + JavaScript プログラムが完全にシャットダウンされたとき (たとえば、ブラウザーのタブを閉じるなど)。
    + `FinalizationRegistry` インスタンス自体が JavaScript コードからアクセスできなくなったとき。
例
-

### 新しいレジストリーの生成

コールバックを渡すことでレジストリーを作成することができます。

```js
const registry = new FinalizationRegistry((heldValue) => {
  // ....
});
```

### クリーンアップのためにオブジェクトを登録

そして、クリーンアップコールバックを呼び出す任意のオブジェクトを登録するには、 `register` メソッドを呼び出して、そのオブジェクトと*保持値*を渡します。

```js
registry.register(theObject, "some value");
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-finalization-registry-objects |

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

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

関連情報
----

* `WeakRef`
* `WeakSet`
* `WeakMap`


Object - JavaScript

Object
======

**`Object`** クラスは JavaScript のデータ型の一つを表します。これは様々なキー付きコレクションとより複雑な実態を格納するために使用されます。 Object は `Object()` コンストラクターまたはオブジェクト初期化子/リテラル構文を使用して生成することができます。

解説
--

JavaScript のほぼすべてのオブジェクトが `Object` のインスタンスです。一般的なオブジェクトは、プロパティを (メソッドを含めて) `Object.prototype` から継承していますが、これらのプロパティはシャドウ化 (別名オーバーライド) されている場合があります。しかし、意図的にそうではない `Object` を生成したり (例えば `Object.create(null)` によって)、変更した結果そうではなくなる場合 (例えば `Object.setPrototypeOf`) もあります。

`Object` プロトタイプオブジェクトへの変更は、その変更の対象となるプロパティやメソッドがプロトタイプチェーンに沿ってさらにオーバーライドされない限り、プロトタイプチェーンを通して**すべての**オブジェクトに反映されます。これはとても強力ですが、オブジェクトの動作をオーバーライドしたり拡張したりするのは潜在的に危険をはらむ仕組みでもあります。

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

* 値が `null` または `undefined` である場合、空のオブジェクトを生成して返します。
* それ以外の場合は、与えられた値に関連する型のオブジェクトを返します。
* 値がすでにオブジェクトであった場合は、その値を返します。

コンストラクター以外のコンテキストで呼び出された場合、 `Object` は `new Object()` と同等に動作します。

オブジェクト初期化子/リテラル構文も参照してください。

### オブジェクトからのプロパティの削除

オブジェクト自体には、自身のプロパティを削除するメソッド (`Map.prototype.delete()` のようなもの) はありません。これを行うには、delete 演算子を使用する必要があります。

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

`Object()`

新しい `Object` オブジェクトを生成します。これは指定された値のラッパーです。

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

`Object.assign()`

1 個以上のソースオブジェクトから、自身の列挙可能なプロパティの値をすべてターゲットオブジェクトにコピーします。

`Object.create()`

指定されたプロトタイプオブジェクトとプロパティから、新しいオブジェクトを生成します。

`Object.defineProperty()`

指定された記述子で記述された名前付きプロパティをオブジェクトへ追加します。

`Object.defineProperties()`

指定された記述子で記述された複数の名前付きプロパティをオブジェクトへ追加します。

`Object.entries()`

指定されたオブジェクト**自身**の列挙可能な文字列プロパティのすべての `[key, value]` の組を含む配列を返します。

`Object.freeze()`

オブジェクトを凍結します。他のコードがプロパティを削除したり変更したりすることができなくなります。

`Object.fromEntries()`

反復可能な `[key, value]` の組から新しいオブジェクトを返します。(これは `Object.entries` の逆です。)

`Object.getOwnPropertyDescriptor()`

オブジェクトの名前付きプロパティに対応するプロパティ記述子を返します。

`Object.getOwnPropertyDescriptors()`

オブジェクト自身のすべてのプロパティの記述子を含むオブジェクトを返します。

`Object.getOwnPropertyNames()`

指定したオブジェクト**自身**の列挙可能および列挙不可なすべてのプロパティの名前を、配列として返します。

`Object.getOwnPropertySymbols()`

指定したオブジェクト上に直接存在するすべてのシンボルプロパティからなる配列を返します。

`Object.getPrototypeOf()`

指定されたオブジェクトのプロトタイプ (内部の `[[Prototype]]` プロパティ) を返します。

`Object.is()`

二つの値が同じ値であるかどうかを比較します。 `NaN` 値はすべて同じものとして扱われます (抽象的等価比較とも厳密等価比較とも異なります)。

`Object.isExtensible()`

オブジェクトの拡張が許可されているかどうかを判定します。

`Object.isFrozen()`

オブジェクトが凍結されているかどうかを判定します。

`Object.isSealed()`

オブジェクトが封印されているかどうかを判定します。

`Object.keys()`

指定されたオブジェクト**自身**の列挙可能なプロパティの名前をすべて含む配列を返します。

`Object.preventExtensions()`

オブジェクトのあらゆる拡張を抑止します。

`Object.seal()`

オブジェクトのプロパティを削除するほかのコードを抑止します。

`Object.setPrototypeOf()`

オブジェクトのプロトタイプ (内部の `[[Prototype]]` プロパティ) を設定します。

`Object.values()`

与えられたオブジェクト**自身**の列挙可能な文字列プロパティすべてに対応する値を含む配列を返します。

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

`Object.prototype.constructor`

オブジェクトのプロトタイプを生成する関数を指定します。

`Object.prototype.__proto__`

オブジェクトがインスタンス化されたとき、プロトタイプとして使用されたオブジェクトを指します。

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

`Object.prototype.__defineGetter__()`

関数をプロパティに関連付けます。そのプロパティにアクセスすると、その関数を実行して返値を返すようにします。

`Object.prototype.__defineSetter__()`

関数をプロパティに関連付け、設定されるとプロパティを変更する関数を実行するようにします。

`Object.prototype.__lookupGetter__()`

`Object.prototype.__defineGetter__()` メソッドによって特定のプロパティに関連付けされた関数を返します。

`Object.prototype.__lookupSetter__()`

`Object.prototype.__defineSetter__()` メソッドによって特定のプロパティに関連付けされた関数を返します。

`Object.prototype.hasOwnProperty()`

オブジェクトが、プロトタイプチェーンを通じて継承されたものではなくオブジェクトの直接のプロパティを持っているかどうかを示す論理値を返します。

`Object.prototype.isPrototypeOf()`

このメソッドが呼び出されたオブジェクトが、指定されたオブジェクトのプロトタイプチェーンにあるかどうかを示す論理値を返します。

`Object.prototype.propertyIsEnumerable()`

内部の ECMAScript [[Enumerable]] 属性が設定されているかどうかを表す論理値を返します。

`Object.prototype.toLocaleString()`

`toString()` を呼び出します。

`Object.prototype.toString()`

そのオブジェクトの文字列表現を返します。

`Object.prototype.valueOf()`

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

例
-

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

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

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

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

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

### `Object` を使用して `Boolean` オブジェクトを生成

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

```js
// o = new Boolean(true) と同じ
let o = new Object(true);
```

```js
// o = new Boolean(false) と同じ
let o = new Object(Boolean());
```

### オブジェクトのプロトタイプ

`Object.prototype` の既存のメソッドの動作を変更するには、既存のロジックの前または後で独自の拡張を囲む形でコードを挿入するようにしてください。例えば、この (テストされていない) コードは、組み込みロジックや誰かの拡張機能が実行される前に、条件付きで独自のロジックを実行します。

関数が呼び出されると、呼び出す引数は配列風の「変数」 arguments に保持されます。例えば `myFn(a, b, c)` の呼び出しでは、`myFn` の本体内での引数は `(a, b, c)` に対応する 3 つのの要素を含みます。

フックを使ってプロトタイプを変更する場合は、関数で `apply()` を呼び出すことで、 `this` と引数 (呼び出し状態) を現在の動作に渡します。このパターンは、`Node.prototype` や `Function.prototype` など、どんなプロトタイプにも使えます。

```js
var current = Object.prototype.valueOf;

// プロパティ "-prop-value" は横断的で、同じプロトタイプチェーン上に
// あるとは限らないので、 Object.prototype を修正したいと思います。
Object.prototype.valueOf = function () {
  if (this.hasOwnProperty("-prop-value")) {
    return this["-prop-value"];
  } else {
    // 私のオブジェクトのようには見えないので、現在の動作をできる限り再現して、
    // 既定の動作にフォールバックします。
    // apply は、他のいくつかの言語における "super" のような動作をします。
    // valueOf() は引数を取りませんが、他のフックによっては取るかもしれません。
    return current.apply(this, arguments);
  }
};
```

正確には JavaScript にはサブクラスのオブジェクトが存在しないので、プロトタイプは下記の例のように、オブジェクトとして動作する特定の関数の「基本クラス」オブジェクトを作るための有用な回避策となります。

```js
var Person = function (name) {
  this.name = name;
  this.canTalk = true;
};

Person.prototype.greet = function () {
  if (this.canTalk) {
    console.log("Hi, I am " + this.name);
  }
};

var Employee = function (name, title) {
  Person.call(this, name);
  this.title = title;
};

Employee.prototype = Object.create(Person.prototype);
Employee.prototype.constructor = Employee; // Object.prototype.constructor を Employee に設定しないと、
// Person (親) の prototype.constructor を取ってしまいます。
//それを避けるために prototype.constructor を Employee (子) に設定しています。

Employee.prototype.greet = function () {
  if (this.canTalk) {
    console.log("Hi, I am " + this.name + ", the " + this.title);
  }
};

var Customer = function (name) {
  Person.call(this, name);
};

Customer.prototype = Object.create(Person.prototype);
Customer.prototype.constructor = Customer; // Object.prototype.constructor を Customer に設定しないと、
// Person (親) の prototype.constructor を取ってしまいます。
//それを避けるために prototype.constructor を Employee (子) に設定しています。

var Mime = function (name) {
  Person.call(this, name);
  this.canTalk = false;
};

Mime.prototype = Object.create(Person.prototype);
Mime.prototype.constructor = Mime; // Object.prototype.constructor を Mime に設定しないと、
// Person (親) の prototype.constructor を取ってしまいます。
//それを避けるために prototype.constructor を Employee (子) に設定しています。

var bob = new Employee("Bob", "Builder");
var joe = new Customer("Joe");
var rg = new Employee("Red Green", "Handyman");
var mike = new Customer("Mike");
var mime = new Mime("Mime");

bob.greet();
// Hi, I am Bob, the Builder

joe.greet();
// Hi, I am Joe

rg.greet();
// Hi, I am Red Green, the Handyman

mike.greet();
// Hi, I am Mike

mime.greet();
```

仕様書
---

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

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

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

関連情報
----

* オブジェクト初期化子


Iterator - JavaScript

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

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

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

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


Boolean - JavaScript

Boolean
=======

**`Boolean`** オブジェクトは論理値（`true` または `false`）を表します。

解説
--

### 論理値プリミティブと Boolean オブジェクト

プリミティブの論理値である `true` や `false` を、 `true` や `false` の値を持った `Boolean` オブジェクトと混同しないでください。

`Boolean` オブジェクトの値が `false` である場合も含めて、オブジェクトは条件文に渡されると **すべて** `true` と評価されます。例えば、以下の `if` 文の条件は `true` と評価されます。

```js
const x = new Boolean(false);
if (x) {
  // このコードは実行されます。
}
```

この振る舞いは論理値プリミティブには適用されません。例えば、以下の `if` 文の条件は `false` に評価されます。

```js
const x = false;
if (x) {
  // このコードは実行されません
}
```

オブジェクトを論理値でない値から論理値へ変換するために `new` を使って `Boolean()` コンストラクターを使わないでください。代わりに、 `Boolean()` を関数として使ったり、二重否定を使用したりすることで同じことが行えます。

```js
const good = Boolean(expression); // これか、もしくは…
const good2 = !!expression; // 　…これを使ってください
const bad = new Boolean(expression); // これは使わないこと！！
```

`Boolean` オブジェクトの初期値として何らかのオブジェクトを指定した場合、それが値 `false` を持つ `Boolean` オブジェクトであっても、新しい `Boolean` オブジェクトは値 `true` を持ちます。

```js
const myFalse = new Boolean(false); // Booleanオブジェクト: false
const g = Boolean(myFalse); // true
const myString = new String("Hello"); // Stringオブジェクト
const s = Boolean(myString); // true
```

**警告:** コンストラクターとして `Boolean` を使うことは滅多にありません。

### 論理値への型強制

論理値を期待する多くの組み込み演算は、まず引数を論理値に型強制 (Type coercion)します。この変換は次のように要約されます。

* 論理値（boolean）はそのまま返されます。
* `undefined` は `false` に変換されます。
* `null` は `false` に変換されます。
* `0`, `-0`, `NaN` は `false` に、それ以外の数値は `true` に変換されます。
* `0n` は `false` に、その他の `BigInt` は `true` に変換されます。
* `Symbol` は `true` になります。
* すべてのオブジェクトは `true` になります。

**メモ:** 非推奨のプロパティ `document.all` はオブジェクトであるにもかかわらず、論理値に変換されると `false` になります。このプロパティはレガシーで非標準であるため、使用しないでください。

>
> **注意:** 文字列への型強制や数値への型強制などの他の型の変換とは異なり、論理値への型強制はオブジェクトからプリミティブに変換しようとするわけではありません。
>
>
>

言い換えれば、`false` に強制される値はほんの一握りで、これらは falsy (偽値) と呼ばれる値です。それ以外の値は truthy (真値) と呼ばれます。値が truthy (真値)であるかどうかは、論理演算子や条件文と共に使われるとき、あるいはあらゆる真偽値の文脈で使われるときに重要です。

JavaScriptで型強制と同じ効果を得るには、2つの方法があります。

* 二重否定: `!!x` は `x` を 2 回否定し、上記と同じアルゴリズムで `x` を論理値に変換します。
* `Boolean()`関数、つまり `Boolean(x)` は上記と同じアルゴリズムを用いて `x` を論理値に変換します。

なお、truthy / falsy であることは、論理値プリミティブ `true` や `false` と 緩く等しい (==) こととは異なることに注意してください。

```js
if ([]) {
  console.log("[] is truthy");
}
if ([] == false) {
  console.log("[] == false");
}
// [] is truthy
// [] == false
```

`[]` は truthy ですが、`false` と緩く等しいです。すべてのオブジェクトは truthy であるため、`[]` も truthy です。しかし、プリミティブである `false` と比較する場合、 `[]` も `Array.prototype.toString()` によって `""` というプリミティブに変換されます。文字列と論理値を比較すると、どちらも数値に変換され、どちらも `0` になるので、`[] == false` は `true` となります。一般に、falsy であることと `== false` は次のようなケースで異なります。

* `NaN`, `undefined`, `null` は falsy ですが、 `false` と緩く異なります。
* `"0"`（および `""` ではないが 0 に型強制される 他の文字列リテラル）は truthy ですが、`false` と緩く等しいです。
* オブジェクトは常に truthy ですが、そのプリミティブ表現は `false` と緩く等しくなる可能性があります。

truthy な値が `true` と緩く等しくなる可能性はさらに低いです。すべての値は truthy か falsy のどちらかですが、ほとんどの値は `true` と `false` のどちらとも緩く異なります。

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

`Boolean()`

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

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

`Boolean.prototype.toString()`

このオブジェクトの値に応じて、文字列で `true` または `false` のどちらかを返します。 `Object.prototype.toString()` メソッドを上書きします。

`Boolean.prototype.valueOf()`

`Boolean` オブジェクトのプリミティブ値を返します。 `Object.prototype.valueOf()` メソッドを上書きします。

例
-

### Boolean オブジェクトを初期値 false で生成

```js
const bNoParam = new Boolean();
const bZero = new Boolean(0);
const bNull = new Boolean(null);
const bEmptyString = new Boolean("");
const bfalse = new Boolean(false);
```

### Boolean オブジェクトを初期値 true で生成

```js
const btrue = new Boolean(true);
const btrueString = new Boolean("true");
const bfalseString = new Boolean("false");
const bSuLin = new Boolean("Su Lin");
const bArrayProto = new Boolean([]);
const bObjProto = new Boolean({});
```

仕様書
---

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

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

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

関連情報
----

* Boolean
* 論理値プリミティブ
* ブーリアン型 (Wikipedia)


WeakSet - JavaScript

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

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


RegExp - JavaScript

RegExp
======

**`RegExp`** オブジェクトは、テキストをパターンと照合するために使用します。

正規表現の入門記事は、 JavaScript ガイド の 正規表現 をお読みください。

解説
--

### リテラル記法とコンストラクター

`RegExp` オブジェクトを生成するには 2 通りの方法があります。*リテラル記法*と*コンストラクター*です。

* *リテラル記法* はパターンを 2 本のスラッシュで囲み、 2 本目のスラッシュの後にオプションでフラグが続きます。
* *コンストラクター関数* は文字列または `RegExp` オブジェクトを最初の引数として取り、オプションのフラグを文字列で 2 番目の引数として取ります。

以下の 3 つの式は、同じ正規表現オブジェクトを生成します。

```js
const re = /ab+c/i; // リテラル記法
const re = new RegExp("ab+c", "i"); // 最初の引数に文字列のパターンを渡したコンストラクター
const re = new RegExp(/ab+c/, "i"); // 最初の引数に正規表現リテラルを渡したコンストラクター
```

正規表現は使用できるようになる前に、コンパイルする必要があります。この処理によって、より効率的に一致を行うことができるようになります。この処理の詳細はドットネットのドキュメントに記載されています。

リテラル記法では、正規表現が評価されるときにコンパイルが行われます。一方、`RegExp` オブジェクトのコンストラクターである `new RegExp('ab+c')` は、実行時に正規表現をコンパイルすることになります。

動的な入力から正規表現を生成する場合には、 `RegExp()` コンストラクターの最初の引数として、文字列を使用してください。

### コンストラクターのフラグ

`new RegExp(/ab+c/, flags)` という式は、第 1 引数を最初の引数の元として使用し、第 2 引数を指定されたフラグとして使用して `RegExp` を生成します。

コンストラクター関数を使用する場合は、通常の文字エスケープ規則（文字列内に特殊文字が含まれるとき、前に `\` を付加する）が必須です。

例えば、以下 2 つの構文は同等です。

```js
const re = /\w+/;
// または
const re = new RegExp("\\w+");
```

### 正規表現の特殊な扱い

**メモ:** 何かが「正規表現」であるかどうかは、ダックタイピングになります。 `RegExp` である必要はありません。

いくつかの組み込みメソッドは、正規表現を特別に扱います。 `x` が正規表現であるかどうかを複数のステップを経て判断します。

1. `x` はオブジェクトでなければなりません（プリミティブではない）。
2. `x[Symbol.match]` が `undefined` でない場合、これが真値であるかどうかを調べます。
3. そうではない場合、 `x[Symbol.match]` が `undefined` であれば、 `x` が `RegExp` コンストラクターで作られたかどうかを調べます。（このステップが発生するのは稀です。 `x` が改ざんされていない `RegExp` オブジェクトであれば、 `Symbol.match` プロパティを持つはずだからです。）

ほとんどの場合、 `Symbol.match` のチェックを通ることに注意してください。これはつまり、次のようなことです。

* 実際の `RegExp` オブジェクトの `Symbol.match` プロパティの値が偽値であるが `undefined` ではなかった場合、（`exec` や `@@replace` のように他のすべてがそのままでも）、正規表現ではないかのように使用することができます。
* `RegExp` ではないオブジェクトが `Symbol.match` プロパティを持っていると、正規表現であるかのように扱われます。

この選択は `@@match` が照合に使用することを意図したプロパティであることを最もよく表しているからです。（`exec` も使用することができますが、シンボルのプロパティではないので、誤検出が多すぎるでしょう）。正規表現を特別扱いする場所は次のとおりです。

* `String.prototype.endsWith()`, `startsWith()`, `includes()` では、最初の引数が正規表現の場合は `TypeError` が発生します。
* `String.prototype.matchAll()` と `replaceAll()` は、最初の引数が正規表現である場合、 global フラグが `@@matchAll` または `@@replace` メソッドを呼び出す前に設定されます。
* `RegExp()` コンストラクターは、 `pattern` が（他のいくつかの条件を満たして）正規表現と判断された場合、 `pattern` を直接返します。 `pattern` が正規表現である場合、 `pattern` を文字列に変換するのではなく、 `source` と `flags` プロパティに問い合わせることになります。

例えば、 `String.prototype.endsWith()` はすべての入力値を文字列へと強制しますが、引数が正規表現の場合、この関数が文字列と照合するだけのために設計されており、正規表現を使用することは開発者の間違いと考えるため、例外を発生させます。

```js
"foobar".endsWith({ toString: () => "bar" }); // true
"foobar".endsWith(/bar/); // TypeError: First argument to String.prototype.endsWith must not be a regular expression
```

このチェックを回避するには、 `@@match` に `undefined` ではない偽値を設定してください。この場合、正規表現は `String.prototype.match()` には使用できませんが(`@@match` がなければ `match()` は `re.toString()` で追加したスラッシュ 2 本を持つ新しい `RegExp` オブジェクトを構築するので）、事実上他のすべてに使用することが可能です。

```js
const re = /bar/g;
re[Symbol.match] = false;
"/bar/g".endsWith(re); // true
re.exec("bar"); // [ 'bar', index: 0, input: 'bar', groups: undefined ]
"bar & bar".replace(re, "foo"); // 'foo & foo'
```

### Perl 風の RegExp プロパティ

`RegExp` のプロパティのいくつかは長い名前と短い（Perl 風の）名前があります。どちらの名前も同じ値を参照します。（Perl は JavaScript が正規表現をモデルにしたプログラミング言語です。）非推奨の `RegExp` のプロパティも参照してください。

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

`RegExp()`

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

静的プロパティ
-------

`get RegExp[@@species]`

派生オブジェクトを生成するために使用されるコンストラクター関数です。

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

`RegExp.prototype.flags`

`RegExp` オブジェクトのフラグから成る文字列です。

`RegExp.prototype.dotAll`

`.` を改行文字に一致させるかどうかのフラグです。

`RegExp.prototype.global`

対象文字列で一致する可能性があるすべてのものに対して正規表現をテストするか、それとも、最初に一致するものに対してのみテストするどうかのフラグです。

`RegExp.prototype.hasIndices`

正規表現の結果で、キャプチャした部分文字列の先頭と末尾の位置を出力するかどうかのフラグです。

`RegExp.prototype.ignoreCase`

文字列を照合する際に、大文字と小文字の違いを無視するかどうかのフラグです。

`RegExp.prototype.multiline`

複数行に渡って文字列を検索するかどうかのフラグです。

`RegExp.prototype.source`

パターンのテキストです。

`RegExp.prototype.sticky`

検索が先頭固定 (sticky) であるかどうかのフラグです。

`RegExp.prototype.unicode`

Unicode 機能が有効かどうかのフラグです。

`RegExp.prototype.lastIndex`

次の照合を開始する位置です。

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

`RegExp.prototype.compile()`
非推奨

スクリプトの実行中に正規表現を (再) コンパイルします。

`RegExp.prototype.exec()`

文字列引数の中で一致するものを検索します。

`RegExp.prototype.test()`

文字列引数で一致するものがあるかどうか検査します。

`RegExp.prototype.toString()`

指定されたオブジェクトを表す文字列を返します。 `Object.prototype.toString()` メソッドを上書きします。

`RegExp.prototype[@@match]()`

指定された文字列と照合を実行し、照合結果を返します。

`RegExp.prototype[@@matchAll]()`

文字列で正規表現に一致するものをすべて返します。

`RegExp.prototype[@@replace]()`

指定された文字列で一致する部分を新しい部分文字列で置き換えます。

`RegExp.prototype[@@search]()`

指定された文字列で一致する部分を検索し、その文字列で見つかったパターンの位置を返します。

`RegExp.prototype[@@split]()`

文字列を部分文字列に分割し、指定された文字列を配列に分割します。

例
-

### 正規表現を使用したデータ形式の変更

以下のスクリプトは、`String` インスタンスの `replace()` メソッドを使用して、 *名 姓* の形式の名前に一致させ、*姓, 名* の形式で出力します。

スクリプトでは、置換テキスト中で `$1` と `$2` を使用して、それぞれ対応する正規表現パターンで一致する括弧がキャプチャした結果を指定しています。

```js
const re = /(\w+)\s(\w+)/;
const str = "John Smith";
const newstr = str.replace(re, "$2, $1");
console.log(newstr);
```

これは、 `"Smith, John"` と表示します。

### 正規表現を使用したさまざまな行末/行の終端/改行での行の分割

既定の改行文字は、プラットフォーム (Unix、Windows など) によって異なります。この例で実行する行分割は、あらゆるプラットフォームで動作します。

```js
const text = "Some text\nAnd some more\r\nAnd yet\rThis is the end";
const lines = text.split(/\r\n|\r|\n/);
console.log(lines); // logs [ 'Some text', 'And some more', 'And yet', 'This is the end' ]
```

正規表現内のパターンの順序が重要であることに注意してください。

### 複数行で正規表現を使用する

```js
const s = "Please yes\nmake my day!";

s.match(/yes.\*day/);
// null を返す

s.match(/yes[^]\*day/);
// Returns ["yes\nmake my day"]
```

### sticky フラグ付きの正規表現の使用

`sticky` フラグは、正規表現の sticky 照合を実行することを示しており、対象文字列で `RegExp.prototype.lastIndex` の位置から照合を試みます。

```js
const str = "#foo#";
const regex = /foo/y;

regex.lastIndex = 1;
regex.test(str); // true
regex.lastIndex = 5;
regex.test(str); // false (sticky フラグがあるので lastIndex から始める)
regex.lastIndex; // 0 (照合に失敗した後はリセット)
```

### sticky フラグと global フラグの違い

sticky フラグ `y` を付けると、次の照合は `lastIndex` の位置で行われるのに対し、 global フラグ `g` を付けると、検索は `lastIndex` の位置から始められます。

```js
const re = /\d/y;
let r;
while ((r = re.exec("123 456"))) {
  console.log(r, "AND re.lastIndex", re.lastIndex);
}

// [ '1', index: 0, input: '123 456', groups: undefined ] AND re.lastIndex 1
// [ '2', index: 1, input: '123 456', groups: undefined ] AND re.lastIndex 2
// [ '3', index: 2, input: '123 456', groups: undefined ] AND re.lastIndex 3
// ... あとは一致しない
```

global フラグ `g` を付けると、 3 桁だけでなく、 6 桁すべてに一致します。

### 正規表現と Unicode 文字

上の表にもある通り、`\w` や `\W` は ASCII 基本文字にのみ一致します。具体的には `a` から `z` 、`A` から `Z` 、 `0` から `9` および `_` です。

キリル語やヘブライ語で使われるような非 ASCII 文字に一致させるには `\uhhhh` 形式 (`hhhh` の部分は 16 進表記の Unicode 値) を使ってください。

この例は、文字列全体から Unicode 文字列だけを抜き出す方法を示しています。

```js
const text = "Образец text на русском языке";
const regex = /[\u0400-\u04FF]+/g;

const match = regex.exec(text);
console.log(match[0]); // logs 'Образец'
console.log(regex.lastIndex); // '7' と出力

const match2 = regex.exec(text);
console.log(match2[0]); // logs 'на' ['text' は出力しない]
console.log(regex.lastIndex); // '15' と出力

// 以下同様
```

Unicode プロパティエスケープ機能は `\p{scx=Cyrl}` のように簡潔な表記ができるようにする解決策を導入しています。

### URL からのサブドメイン名の抽出

```js
const url = "http://xxx.domain.com";
console.log(/^https?:\/\/(.+?)\./.exec(url)[1]); // 'xxx' と出力
```

**メモ:** URL を解釈するには、正規表現を使用するより、 URL API におけるブラウザー内蔵の URL パーサーを使用することをお勧めします。

### 動的な入力からの正規表現の構築

```js
const breakfasts = ["bacon", "eggs", "oatmeal", "toast", "cereal"];
const order = "Let me get some bacon and eggs, please";

order.match(new RegExp(`\\b(${breakfasts.join("|")})\\b`, "g"));
// ['bacon', 'eggs'] を返す
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp-regular-expression-objects |

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

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

### Firefox 固有の注意事項

Firefox 34 より、量指定子を伴うキャプチャグループが動作を妨げている場合に、キャプチャグループに一致するテキストは空文字列ではなく `undefined` になりました。

```js
// Firefox 33 以前
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${JSON.stringify(group)}`);
});
// group: ""

// Firefox 34 以降
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${group}`);
});
// group: undefined
```

ウェブの互換性のため `RegExp.$N` は引き続き、 `undefined` ではなく空文字列を返します (bug 1053944)。

関連情報
----

* `RegExp` の新しい機能の多くのポリフィル (`dotAll`、`sticky` フラグ、名前付きキャプチャグループ、など (`core-js`) で利用できます。
* 正規表現の節（JavaScript ガイド内）
* `String.prototype.match()`
* `String.prototype.replace()`
* `String.prototype.split()`


Symbol (シンボル) - JavaScript

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

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

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

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

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

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


Date.prototype.setYear() - JavaScript

Date.prototype.setYear()
========================

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

古い **`setYear()`** メソッドは、指定された日付の年をローカル時間に従って設定します。

しかし、古い `setYear()` メソッドが年を設定する方法は、好ましい `setFullYear()` メソッドが年を設定する方法と異なり、いくつかのケースでは `new Date()` や `Date.parse()` が年の値を設定する方法とも異なっています。詳細度は、`22` や `61` のような 2 桁の数字が指定された場合、以下のようになります。

* `setYear()` は任意の 2 桁の数字を `1900` へのオフセットとして解釈します。したがって、 `date.setYear(22)` は年の値を `1922` に、 `date.setYear(61)` は年の値を `1961` に設定することになります（一方、 `new Date(61, 1)` は年の値を `1961` に設定しますが、 `new Date("2/1/22")` は年の値を `2022` に設定し、同様に `Date.parse()` も同じになります）。
* `setFullYear()` は特別な解釈をせず、 2 桁のリテラル値をそのまま使用して年を設定します。したがって、 `date.setFullYear(61)` は年の値を `0061` に、 `date.setFullYear(22)` は年の値を `0022` に設定する結果となります。

これらの動作の違いから、古いメソッドである `setYear()` はもう使用せず、代わりに推奨の `setFullYear()` メソッドを使用してください。

構文
--

```js
setYear(yearValue)
```

### 引数

`yearValue`

整数値。

### 返値

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

解説
--

`yearValue` が 0 から 99 までの値の場合、 `dateObj` の「年」には `1900 + yearValue` が設定されます。そうでない場合、`dateObj` の「年」には `yearValue` が設定されます。

例
-

### setYear() の使用

最初の 2 行は「年」を 1996 に設定します。3 行目は、「年」を 2000 に設定します。

```js
const theBigDay = new Date();

theBigDay.setYear(96);
theBigDay.setYear(1996);
theBigDay.setYear(2000);
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.setYear` のポリフィル (`core-js`)
* `Date.prototype.getFullYear()`
* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setFullYear()`
* `Date.prototype.setUTCFullYear()`


Date.prototype.setUTCHours() - JavaScript

Date.prototype.setUTCHours()
============================

**`setUTCHours()`** メソッドは、協定世界時に基づき、指定された日付の「時」を設定し、協定世界時 (UTC) 1970 年 1 月 1 日 00:00:00 から更新された `Date` インスタンスが表す時刻までの間のミリ秒単位の数値を返します。

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

構文
--

```js
setUTCHours(hoursValue)
setUTCHours(hoursValue, minutesValue)
setUTCHours(hoursValue, minutesValue, secondsValue)
setUTCHours(hoursValue, minutesValue, secondsValue, msValue)
```

### 引数

`hoursValue`

「時」を表す 0 から 23 までの間の整数値。

`minutesValue`

任意。「分」を表す 0 から 59 までの間の整数値。

`secondsValue`

任意。「秒」を表す 0 から 59 までの間の整数値。`secondsValue` 引数を指定した場合、`minutesValue` も指定しなければなりません。

`msValue`

任意。ミリ秒を表す 0 から 999 までの間の整数値。`msValue` 引数を指定した場合、`minutesValue` と `secondsValue` も指定しなければなりません。

### 返値

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

解説
--

`minutesValue`, `secondsValue` および `msValue` 引数を指定しない場合、`getUTCMinutes()` と `getUTCSeconds()`、`getUTCMilliseconds()` メソッドから返される値が使われます。

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

例
-

### setUTCHours() の使用

```js
const theBigDay = new Date();
theBigDay.setUTCHours(8);
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getUTCHours()`
* `Date.prototype.setHours()`


Date.prototype.getUTCFullYear() - JavaScript

Date.prototype.getUTCFullYear()
===============================

**`getUTCFullYear()`** メソッドは、協定世界時に基づき、指定された日時の「年」を返します。

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

構文
--

```js
getUTCFullYear()
```

### 返値

 数値です。
 `Date` オブジェクトが有効な日時を表している場合、指定された日時の西暦を世界時で表した整数を返します。
 それ以外の場合は、`Date` オブジェクトが有効な日時を表していなければ `NaN` が返されます。

解説
--

`getUTCFullYear()` が返す値は、 2000 年問題に対応した表記に従う絶対的な値、例えば 1995 などです。

例
-

### getUTCFullYear() の使用

次の例は、現在の年を表す 4 桁の値を変数 `year` に代入します。

```js
const today = new Date();
const year = today.getUTCFullYear();
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getFullYear()`
* `Date.prototype.setFullYear()`


Date.prototype.getTimezoneOffset() - JavaScript

Date.prototype.getTimezoneOffset()
==================================

**`getTimezoneOffset()`** メソッドは、（ホストシステム上における）現在のロケールから協定世界時 (UTC) までのタイムゾーンの差を分単位で返します。

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

構文
--

```js
getTimezoneOffset()
```

### 返値

UTC タイムゾーンで評価された日時とローカルタイムゾーンで評価された日時の差を分単位で表したもの。実際のローカルタイムアルゴリズムは実装で定義され、適切なデータがないランタイムでは返値が 0 になることが許容されます。

解説
--

`date.getTimezoneOffset()` は、 `date` が UTC タイムゾーンで評価されたものとローカルタイムゾーンで評価されたものの差を分単位で返します。つまり、（コードがブラウザーでウェブから実行された場合）ブラウザーを使用しているホストシステムのタイムゾーン、あるいは、コードが実行された JavaScript ランタイム（例えば Node.js 環境） のホストシステムのタイムゾーンです。

### 負の値と正の値

getTimezoneOffset()`が返す分の値は、ローカルのタイムゾーンが UTC よりも後の場合は正の値、先の場合は負の値になります。例えば、UTC+10 の場合、`-600` を返します。

| 現在のタイムゾーン | 返値 |
| --- | --- |
| UTC-8 | 480 |
| UTC | 0 |
| UTC+3 | -180 |

### 夏時間適用地域で変化する結果

毎年夏時間に移行する地域では、 `date` が変化すると、 `getTimezoneOffset()` を呼び出して返される分の値が一定でなくなる可能性があります。

**メモ:** `getTimezoneOffset()` の動作は、コードが実行された時間によって変わることはありません。同じ地域で実行した場合の動作は、常に一定です。結果に影響を与えるのは `date` の値のみです。

ほとんどの実装では、 IANA time zone database (tzdata) を使用して `date` の瞬間のローカルタイムゾーンのオフセットを正確に決定しています。しかし、そのような情報が得られない場合、実装は 0 を返すかもしれません。

例
-

### getTimezoneOffset() の使用

```js
// 現在の時刻を表す Date インスタンスを作成する
const currentLocalDate = new Date();
// 2016 年 5 月 1 日 03:24 GMT-0200 の Date インスタンスを作成する
const laborDay2016at0324GMTminus2 = new Date("2016-05-01T03:24:00-02:00");
currentLocalDate.getTimezoneOffset() ===
  laborDay2016at0324GMTminus2.getTimezoneOffset();
// 夏時間に毎年移行しないタイムゾーンでは常に true となります。
// 毎年夏時間に移行するあらゆるタイムゾーンは、 false になることがあります。
```

### getTimezoneOffset() と夏時間

夏時間が使用されている地域では、 `date` がある時期によって返値が変わることがあります。下記は、タイムゾーンが UTC-05:00 であるニューヨークでの実行時の出力結果です。

```js
const nyOffsetSummer = new Date("2022-02-01").getTimezoneOffset(); // 300
const nyOffsetWinter = new Date("2022-08-01").getTimezoneOffset(); // 240
```

### getTimezoneOffset() と歴史的なデータ

歴史的な理由により、ある地域が属するタイムゾーンが、夏時間によらなくても変化していることがあります。例えば、下記はタイムゾーンが UTC+08:00 である上海での実行時の出力です。

```js
const shModernOffset = new Date("2022-01-27").getTimezoneOffset(); // -480
const shHistoricalOffset = new Date("1943-01-27").getTimezoneOffset(); // -540
```

これは、日中戦争中で上海が日本の統制下にあった時、日本に合わせてタイムゾーンを UTC+09:00 に変更しており（実質的には「通年夏時間」）、そのことが IANA データベースに記録されていたためです。

仕様書
---

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

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

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

関連情報
----

* `Date`


Date.prototype.getTime() - JavaScript

Date.prototype.getTime()
========================

**`getTime()`** メソッドは、 ECMAScript 元期からの経過ミリ秒数を返します。

このメソッドは、日付と時刻を別の `Date` オブジェクトへ代入する助けとして使用できます。このメソッドは、`valueOf()` メソッドと機能的に同等です。

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

構文
--

```js
getTime()
```

### 返値

1970 年 1 月 1 日 00:00:00 UTC から指定した日時までの経過時間をミリ秒で表した数値。

時刻の低精度化
-------

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

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

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

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

例
-

### getTime() を使って日付をコピーする

同一の time 値を持つ date オブジェクトを構築します。

```js
// month は 0 を基点とするため、birthday は 1995 年 1 月 10 日になります
const birthday = new Date(1994, 12, 10);
const copy = new Date();
copy.setTime(birthday.getTime());
```

### 実行時間を計測する

新たに生成された `Date` オブジェクトでの、続く 2 個の `getTime()` の結果を減算して、これらの呼び出しと呼び出しの間の時間を得ます。これは、何らかの命令の実行時間を計測するために使用できます。不要な `Date` オブジェクトのインスタンス化を避けるため、`Date.now()` も参照してください。

```js
let end, start;

start = new Date();
for (let i = 0; i < 1000; i++) {
  Math.sqrt(i);
}
end = new Date();

console.log(`Operation took ${end.getTime() - start.getTime()} msec`);
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.setTime()`
* `Date.prototype.valueOf()`
* `Date.now()`


Date.UTC() - JavaScript

Date.UTC()
==========

**`Date.UTC()`** メソッドは、コンストラクターと同じ最も長い書式の引数を受け入れ、協定世界時 (UTC) 1970 年 1 月 1 日 00:00:00 からの経過時間を表す `Date` オブジェクトのミリ秒単位の数値を返します。

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

構文
--

```js
Date.UTC(year)
Date.UTC(year, month)
Date.UTC(year, month, day)
Date.UTC(year, month, day, hour)
Date.UTC(year, month, day, hour, minute)
Date.UTC(year, month, day, hour, minute, second)
Date.UTC(year, month, day, hour, minute, second, millisecond)
```

`year`

整数値で、年を表します。

`0` から `99` までの値は `1900` から `1999` までに対応付けられます。それ以外の値はすべて、実際の年を表します。
 例を参照してください。

`month` 省略可

`0` (1 月) から `11` (12 月) までの整数値で、月を表します。 ECMAScript 2017 以降では、省略時の既定値は `0` です。 *（ECMAScript 2016 までは、 `month` は必須の引数でした。 ES2017 では必須ではなくなりました。*

`day` 省略可

「日」を表す `1` から `31` までの整数値。省略された場合の既定値は `1` です。

`hour` 省略可

「時」を表す `0` から `23` までの整数値。省略された場合の既定値は `0` です。

`minute` 省略可

「分」を表す `0` から `59` までの整数値。省略された場合の既定値は `0` です。

`second` 省略可

「秒」を表す `0` から `59` までの整数値。省略された場合の既定値は `0` です。

`millisecond` 省略可

「ミリ秒」を表す `0` から `999` までの整数値。省略された場合の既定値は `0` です。

### 返値

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

解説
--

`UTC()` はカンマ区切りの日時の引数を取り、世界時の 1970 年 1 月 1 日 00:00:00 から指定した日時までの経過時間を表すミリ秒単位の数値を返します。

`0` から `99` までの年は、 20 世紀の年 `(1900 + year)` に変換されます。例えば、 `95` は 1995 年に変換されます。

この `UTC()` メソッドは `Date` コンストラクターと 2 つの点で異なります。

1. `Date.UTC()` は地方時ではなく、協定世界時を用います。
2. `Date.UTC()` は `Date` オブジェクトを生成せず、時刻値を整数で返します。

引数が日時に期待される範囲を超えている場合、 `UTC()` メソッドは指定した値を受け入れるよう他の引数を更新します。例えば `15` が `month` に使用された場合、年が 1 つ増加し `(year + 1)`、月には `3` が使われます。

`UTC()` は `Date` の静的メソッドなので、 `Date` インスタンスのメソッドとしてではなく、常に `Date.UTC()` のように使用してください。

例
-

### Date.UTC の使用

以下の文では、地方時の代わりに UTC を用いて `Date` オブジェクトを生成します。

```js
const utcDate = new Date(Date.UTC(2018, 11, 1, 0, 0, 0));
```

仕様書
---

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

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

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

### 互換性メモ

#### Date.UTC() の引数が 2 つ未満であった場合

`Date.UTC()` の引数が 2 つ未満の場合、 ECMAScript 2017 では `NaN` を返すよう要求しています。この動作に対応していなかったエンジンも対応済みです (bug 1050755, ecma-262 #642 を参照)。

```js
Date.UTC();
Date.UTC(1);

// Safari: NaN
// Chrome/Opera/V8: NaN

// Firefox <54: non-NaN
// Firefox 54+: NaN

// IE: non-NaN
// Edge: NaN
```

関連情報
----

* `Date.parse()`
* `Date`


Date.prototype.setTime() - JavaScript

Date.prototype.setTime()
========================

**`setTime()`** メソッドは、`Date` オブジェクトを協定世界時 (UTC) 1970 年 1 月 1 日 00:00:00 からの経過時間をミリ秒単位で表す時刻に設定します。

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

構文
--

```js
setTime(timeValue)
```

### 引数

`timeValue`

協定世界時 (UTC) 1970 年 1 月 1 日 00:00:00 からの経過時間をミリ秒単位で表す整数値。

### 返値

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

解説
--

`setTime()` メソッドは、日付と時刻を別の `Date` オブジェクトに代入するのに役立ちます。

例
-

### setTime() の使用

```js
const theBigDay = new Date("July 1, 1999");
const sameAsBigDay = new Date();
sameAsBigDay.setTime(theBigDay.getTime());
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getTime()`
* `Date.prototype.setUTCHours()`


Date.prototype.getMilliseconds() - JavaScript

Date.prototype.getMilliseconds()
================================

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

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

構文
--

```js
getMilliseconds()
```

### 返値

地方時に基づき、指定された日時の「ミリ秒」を表す 0 から 999 までの間の数値。

例
-

### getMilliseconds() の使用

次の例は、現在時刻のミリ秒部を変数 `milliseconds` に代入します。

```js
const today = new Date();
const milliseconds = today.getMilliseconds();
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getUTCMilliseconds()`
* `Date.prototype.setMilliseconds()`


Date.prototype.getSeconds() - JavaScript

Date.prototype.getSeconds()
===========================

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

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

構文
--

```js
getSeconds()
```

### 返値

地方時に基づき、与えた日付の「秒」を表す 0 から 59 までの間の整数値。

例
-

### getSeconds() の使用

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

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

console.log(seconds); // 30
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getUTCSeconds()`
* `Date.prototype.setSeconds()`


Date.prototype.getFullYear() - JavaScript

Date.prototype.getFullYear()
============================

**`getFullYear()`** メソッドは、地方時に基づき、指定された日時の年を返します。

`getYear()` メソッドの代わりに、このメソッドを使用してください。

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

構文
--

```js
getFullYear()
```

### 返値

地方時に基づき、与えた日付の年に相当する数値。

解説
--

`getFullYear()` が返す値は絶対的な値です。1000 年から 9999 年までの日付に対して、`getFullYear()` は 1995 のような 4 桁の数字を返します。 2000 年以降の年について正しい値を得るには、この関数を使用してください。

例
-

### getFullYear() の使用

以下の例は、変数 `year` に今年を表す 4 桁の数字を代入します。

```js
const today = new Date();
const year = today.getFullYear();
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setFullYear()`
* `Date.prototype.getYear()`


Date.prototype.setUTCMonth() - JavaScript

Date.prototype.setUTCMonth()
============================

**`setUTCMonth()`** メソッドは、協定世界時に基づき、指定された日時の「月」を設定します。

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

構文
--

```js
setUTCMonth(monthValue)
setUTCMonth(monthValue, dayValue)
```

### 引数

`monthValue`

1 月から 12 月を表す 0 から 11 までの間の整数値。

`dayValue`

任意。「日」を表す 1 から 31 までの間の整数値。

### 返値

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

解説
--

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

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

例
-

### setUTCMonth() の使用

```js
const theBigDay = new Date();
theBigDay.setUTCMonth(11);
```

仕様書
---

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

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

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

関連情報
----

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


Date.prototype.toUTCString() - JavaScript

Date.prototype.toUTCString()
============================

**`toUTCString()`** メソッドは、協定世界時 (UTC) のタイムゾーンに基づき、日付を文字列へ変換します。

rfc7231 と ECMA-262 toUTCString の改訂に基づくと、負の数が可能です。

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

構文
--

```js
toUTCString()
```

### 返値

UTC タイムゾーンに基づき、与えられた日付を表す文字列。

解説
--

`toUTCString()` から返される文字列は、 `Www, dd Mmm yyyy hh:mm:ss GMT` の形の文字列です。

| 書式文字列 | 説明 |
| --- | --- |
| `Www` | 曜日、3 文字で表す (例 Sun, Mon, ...) |
| `dd` | 日、必要に応じて先頭に 0 が付いた 2 桁の数字で表す |
| `Mmm` | 月、3 文字で表す (例 Jan, Feb, ...) |
| `yyyy` | 年、必要に応じて先頭に 0 が付いた 4 桁以上の数字で表す |
| `hh` | 時、必要に応じて先頭に 0 が付いた 2 桁の数字で表す |
| `mm` | 分、必要に応じて先頭に 0 が付いた 2 桁の数字で表す |
| `ss` | 秒、必要に応じて先頭に 0 が付いた 2 桁の数字で表す |

例
-

### toUTCString() の使用

```js
const today = new Date("Wed, 14 Jun 2017 00:00:00 PDT");
const UTCstring = today.toUTCString(); // Wed, 14 Jun 2017 07:00:00 GMT
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.toLocaleString()`
* `Date.prototype.toDateString()`
* `Date.prototype.toISOString()`


Date.prototype.getHours() - JavaScript

Date.prototype.getHours()
=========================

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

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

構文
--

```js
getHours()
```

### 返値

地方時に基づき、与えた日時の「時」を表す 0 から 23 の間の整数値。

例
-

### getHours() の使用

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

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

console.log(hours); // 23
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getUTCHours()`
* `Date.prototype.setHours()`


Date.prototype.setUTCMinutes() - JavaScript

Date.prototype.setUTCMinutes()
==============================

**`setUTCMinutes()`** メソッドは、協定世界時に基づき、指定された日時の「分」を設定します。

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

構文
--

```js
setUTCMinutes(minutesValue)
setUTCMinutes(minutesValue, secondsValue)
setUTCMinutes(minutesValue, secondsValue, msValue)
```

### 引数

`minutesValue`

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

`secondsValue`

任意。「秒」を表す 0 から 59 までの間の整数値。`secondsValue` 引数を指定した場合、`minutesValue` も指定しなければなりません。

`msValue`

任意。ミリ秒を表す 0 から 999 までの間の整数値。`msValue` 引数を指定した場合、`minutesValue` と `secondsValue` も指定しなければなりません。

### 返値

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

解説
--

`secondsValue` および `msValue` 引数を指定しない場合、`getUTCSeconds()` と `getUTCMilliseconds()` メソッドから返される値が使われます。

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

例
-

### setUTCMinutes() の使用

```js
const theBigDay = new Date();
theBigDay.setUTCMinutes(43);
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getUTCMinutes()`
* `Date.prototype.setMinutes()`


Date.prototype.toISOString() - JavaScript

Date.prototype.toISOString()
============================

**`toISOString()`** メソッドは、*簡潔な*拡張表記の ISO 形式 (ISO 8601) の文字列を返します。これは、常に 24 文字または 27 文字の長さになります（それぞれ、`YYYY-MM-DDTHH:mm:ss.sssZ` または `±YYYYYY-MM-DDTHH:mm:ss.sssZ`）。タイムゾーンは常に 0 UTC オフセットになり、接尾辞 `Z` で表記されます。

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

構文
--

```js
toISOString()
```

### 返値

協定世界時に基づき、与えられた日付を ISO 8601 形式で表す文字列。 `Date.parse()` で認識するために必要な形式と同じ形式です。

例
-

### toISOString() の使用

```js
const today = new Date("05 October 2011 14:48 UTC");

console.log(today.toISOString()); // 2011-10-05T14:48:00.000Z を返す
```

上記の例は、Mozilla 以外のブラウザーでは正しく解析されない、非標準の文字列値を解析するのに使います。

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.toLocaleDateString()`
* `Date.prototype.toTimeString()`
* `Date.prototype.toUTCString()`
* ポリフィル


Date.prototype.setMilliseconds() - JavaScript

Date.prototype.setMilliseconds()
================================

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

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

構文
--

```js
setMilliseconds(millisecondsValue)
```

### 引数

`millisecondsValue`

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

### 返値

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

解説
--

指定した値が期待される日付の範囲外の場合、それに応じて `Date` オブジェクトの日付情報の更新を試みます。例えば、1005 を指定した場合、秒の数値が 1 加算され、ミリ秒に 5 が使用されます。

例
-

### setMilliseconds() の使用

```js
const theBigDay = new Date();
theBigDay.setMilliseconds(100);
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getMilliseconds()`
* `Date.prototype.setUTCMilliseconds()`


Date.prototype.getYear() - JavaScript

Date.prototype.getYear()
========================

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

**`getYear()`** メソッドは、地方時に基づき、指定された日付の「年」を返します。`getYear()` は完全な桁数の値を返さないため（いわゆる「2000 年問題」）、使用されなくなり、`getFullYear()` メソッドに置き換えられました。

構文
--

```js
getYear()
```

### 返値

地方時に基づき、与えられた日付の「年」を表す数値から 1900 を引いたものを返します。

解説
--

* 2000 年以降の年について、`getYear()` が返す値は 100 以上です。例えば、 2026 年の場合、`getYear()` は 126 を返します。
* 1900 年から 1999 年について、`getYear()` が返す値は 0 から 99 の間です。例えば、 1976 年の場合、`getYear()` は 76 を返します。
* 1900 年以前の年について、`getYear()` が返す値は 0 未満です。例えば、 1800 年の場合、`getYear()` は -100 を返します。

2000 年以前と以降に対処するため、`getYear()` の代わりに、完全な桁数の値を返す `getFullYear()` を使用してください。

後方互換性
-----

### JavaScript 1.2 以前の動作

`getYear()` メソッドは、2 桁または 4 桁の年を返します。

* 1900 年から 1999 年の間の場合、`getYear()` が返す値は、year - 1900 です。例えば 1976 年の場合、戻り値は 76 です。
* 1900 年より前または 1999 年より後の場合、`getYear()` が返す値は 4 桁の年です。例えば、1856 年の場合、戻り値は 1856 です。2026 年の場合、戻り値は 2026 です。
例
-

### 1900 年から 1999 年の間の年

2 行目の文は、変数 `year` に 95 を代入します。

```js
const xmas = new Date("December 25, 1995 23:15:00");
const year = xmas.getYear(); // 95 を返す
```

### 1999 年より後の年

2 行目の文は、変数 `year` に 100 を代入します。

```js
const xmas = new Date("December 25, 2000 23:15:00");
const year = xmas.getYear(); // 100 を返す
```

### 1900 年より前の年

2 行目の文は、変数 `year` に -100 を代入します。

```js
const xmas = new Date("December 25, 1800 23:15:00");
const year = xmas.getYear(); // -100 を返す
```

### 1900 年から 1999 年の間の年の設定または取得

3 行目の文は、変数 `year` に 1995 年を表す 95 を代入します。

```js
const xmas = new Date("December 25, 2015 23:15:00");
xmas.setYear(95);
const year = xmas.getYear(); // 95 を返す
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getYear` のポリフィル (`core-js`)
* `Date.prototype.getFullYear()`
* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setYear()`


Date.prototype.getUTCSeconds() - JavaScript

Date.prototype.getUTCSeconds()
==============================

**`getUTCSeconds()`** メソッドは、協定世界時に基づき、指定された日時の「秒」を返します。

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

構文
--

```js
getUTCSeconds()
```

### 返値

 数値です。
 もし `Date` オブジェクトが有効な日時を表している場合は、0 から 59 までの整数で、指定された日時の世界時での秒の値を表します。
 それ以外の場合は、`Date` オブジェクトが有効な日時を表していなければ `NaN` が返されます。

例
-

### getUTCSeconds() の使用

次の例は、現在日時の「秒」部を変数 `seconds` に代入します。

```js
const today = new Date();
const seconds = today.getUTCSeconds();
```

仕様書
---

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

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

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

関連情報
----

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


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

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

**`Date()`** コンストラクターは `Date` のインスタンスを生成し、または現在時刻を表す文字列を返します。

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

構文
--

```js
new Date()
new Date(value)
new Date(dateString)
new Date(dateObject)

new Date(year, monthIndex)
new Date(year, monthIndex, day)
new Date(year, monthIndex, day, hours)
new Date(year, monthIndex, day, hours, minutes)
new Date(year, monthIndex, day, hours, minutes, seconds)
new Date(year, monthIndex, day, hours, minutes, seconds, milliseconds)

Date()
```

**メモ:** `Date()` は `new` ありでも `new` なしでも呼び出すことができますが、効果は異なります。返値を参照してください。

### 引数

`Date()` コンストラクターには 5 つの基本形があります。

#### 引数なし

引数が与えられなかった場合、新しく生成された `Date` オブジェクトはインスタンス化された時点の現在の日付と時刻を表します。

#### 時刻値またはタイムスタンプ値

`value`

世界協定時 (UTC) 1970 年 1 月 1 日午前 0 時 0 分 0 秒 (ECMAScript 元期、 UNIX 元期と等価) からのミリ秒数を整数値で表し、うるう秒は無視します。大部分の UNIX Timestamp 関数は秒単位の精度しかないことに注意してください。

#### 日付文字列

`dateString`

日付を表す文字列値で、 `Date.parse()` メソッドによって認識される形式で指定します。（ECMA262 仕様書は ISO 8601 の簡易版を定めていますが、実装がほかの形式を定義している場合があり、この多くが IETF 準拠の RFC 2822 タイムスタンプを含んでいます。）

**メモ:** `Date` コンストラクター（および `Date.parse` と同等）で日付文字列を解釈する際には、常に入力が ISO 8601 形式 (`YYYY-MM-DDTHH:mm:ss.sssZ`) であることを確認してください。他の形式で解釈した場合には、その挙動は実装によって定義されていて、すべてのブラウザーで動くとは限りません。 RFC 2822 書式の文字列の対応は慣習的に行われているだけです。多数の異なる形式に対応するためには、ライブラリーが役に立ちます。

日付のみの文字列（例: `"1970-01-01"`）は UTC として扱われ、日付時刻の文字列（例: `"1970-01-01T12:00"`）は ローカルとして扱われます。したがって、入力形式が 2 つの型の間で一貫していることを確認することも推奨されます。

#### Date オブジェクト

`dateObject`

既存の `Date` オブジェクトです。これは、既存の `Date` オブジェクトのコピーを、同じ日付と時刻で効率的に作成します。これは `new Date(dateObject.valueOf())` と同じですが、 `valueOf()` メソッドが呼び出されない点が異なります。

`Date()` コンストラクターに 1 つの引数が渡された場合、 `Date` インスタンスは特別に扱われます。他のすべての値はプリミティブに変換されます（`[@@toPrimitive]("default")`, `valueOf()`, `toString()` の順で呼び出されます）。もし結果が文字列であれば、それは日付の文字列として解釈されます。そうでない場合は、結果のプリミティブはさらに数値に強制され、タイムスタンプとして扱われます。

#### 独立した日付と時刻の成分の値

少なくとも年と月が指定された場合、この `Date()` の形式は `Date` オブジェクトを返します。その成分値（年、月、日、時、分、秒、ミリ秒）はすべて以下の引数から得られます。欠落しているフィールドには、使用可能な最小の値（`day` には `1`、他にもすべての成分には `0` ）が指定されます。引数の値はすべて、UTC ではなくローカルのタイムゾーンに対して評価されます。

いずれかの引数が定義された境界を超えた場合、「繰り上げ」が行われます。例えば、 `monthIndex` に `11` よりも大きな値が渡された場合、その月は年を増加させます。 `minutes` に `59` よりも大きな値が渡された場合、`hours` はそれに応じて増加します。したがって、 `new Date(1990, 12, 1)` は 1991 年 1 月 1 日を返し、 `new Date(2020, 5, 19, 25, 65)` は 2020 年 6 月 20 日の午前 2 時 5 分を返します。

同様に、何か引数がアンダーフローする場合は、上位の引数を「桁借り」します。例えば、`new Date(2020, 5, 0)` は、 2020 年 5 月 31 日を返します。

`year`

 年を表す整数値です。
 `0` から `99` までの値は、 `1900` から `1999` までの値にマッピングされます。他の値は実際の年になります。例をご覧ください。

`monthIndex`

月を表す整数値です。 `0` （1 月）から `11` （12 月）までの値です。

`day` 省略可

月内の日を表す整数値です。既定値は `1` です。

`hours` 省略可

`0` から `23` までの間の整数値で、 1 日の中の時を表します。既定値は `0` です。

`minutes` 省略可

整数値で、時刻の分の部分を表します。既定値は `0` 分を表します。

`seconds` 省略可

整数値で、時刻の秒の部分を表します。既定値は `0` 秒を表します。

`milliseconds` 省略可

整数値で、時刻のミリ秒の部分を表します。既定値は `0` ミリ秒です。

### 返値

`new Date()` （`Date()` コンストラクター）を呼び出すと、 `Date` オブジェクトを返します。日付として無効な文字列、または構築される日付が UNIX タイムスタンプの `-8,640,000,000,000,000` ミリ秒未満または `8,640,000,000,000,000` ミリ秒より大きくなる場合、 `Date` オブジェクトを返しますが、その `toString()` メソッドが `Invalid Date` という文字列を返します。

`Date()` 関数を（`new` キーワードなしで）呼び出すと、 `new Date().toString()` と全く同じように、現在の日付と時刻を文字列で表現したものを返します。 `Date()` 関数を（`new` キーワードなしで）呼び出す際に指定された引数は無視されます。無効な日付文字列で呼び出された場合でも、あるいは、任意のオブジェクトや他のプリミティブを引数として呼び出された場合でも、常に現在の日付と時刻を文字列で表現したものを返します。

例
-

### Date オブジェクトを生成するいくつかの方法

以下の例で、JavaScript の Date を生成するいくつかの方法を示します。

```js
const today = new Date();
const birthday = new Date("December 17, 1995 03:24:00"); // 非推奨: すべてのランタイムで動作するとは限りません
const birthday = new Date("1995-12-17T03:24:00"); // ISO-8601 互換であり、動作に信頼性があります
const birthday = new Date(1995, 11, 17); // 月は 0 から始まります
const birthday = new Date(1995, 11, 17, 3, 24, 0);
const birthday = new Date(628021800000); // 元期のタイムスタンプを渡す
```

### 日付でも文字列でも数値でもない値を渡す

もし、 `Date()` コンストラクターが `Date` インスタンスではない 1 つの引数で呼び出された場合、プリミティブに変換された後、文字列であるかどうかがチェックされます。例えば、 `new Date(undefined)` は `new Date()` とは異なります。

```js
console.log(new Date(undefined)); // Invalid Date
```

これは、 `undefined` は既にプリミティブであるものの、文字列ではないため、数値である `NaN` に変換され、タイムスタンプとして有効なものにならないからです。他にも、 `null` は `0` に変換されます。

```js
console.log(new Date(null)); // 1970-01-01T00:00:00.000Z
```

配列は `Array.prototype.toString()` によって文字列に強制され、要素はカンマで結合されます。しかし、複数の要素を持つ配列の結果の文字列は、有効な ISO 8601 日付文字列ではないため、その解釈の動作は実装依存となります。 **Date() コンストラクターに、配列を渡さないでください。**

```js
console.log(new Date(["2020-06-19", "17:13"]));
// Chrome では 2020-06-19T17:13:00.000Z になります。 "2020-06-19,17:13" と解釈されるからです。
// Firefox では "Invalid Date" となります。
```

仕様書
---

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

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

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

関連情報
----

* `Date`


Date.prototype.setMonth() - JavaScript

Date.prototype.setMonth()
=========================

**`setMonth()`** メソッドは、現在設定されている年に基づき、指定された日付の「月」を設定します。

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

構文
--

```js
setMonth(monthValue)
setMonth(monthValue, dayValue)
```

### 引数

`monthValue`

0 から始まる整数値で、年の始まりからの月のオフセットを表します。そのため、0 は 1 月を表し、 11 は 12 月を表し、 12 は次の年の 1 月を表します。

`dayValue`

任意。「日」を表す 1 から 31 までの間の整数値。

### 返値

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

解説
--

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

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

このメソッドの動作は、ある特定の月の日にちに影響を与えます。概念上は、その月の日数を、引数として与えた新しい月の初日に加え、新しい日付を返します。例えば、現在の値が 2016 年 8 月 31 日である場合、1 を引数として setMonth を呼び出すと 2016 年 3 月 2 日が返ってきます。これは、2016 年の 2 月が 29 日間しかないからです。

例
-

### setMonth() の使用

```js
const theBigDay = new Date();
theBigDay.setMonth(6);

//Watch out for end of month transitions
const endOfMonth = new Date(2016, 7, 31);
endOfMonth.setMonth(1);
console.log(endOfMonth); //Wed Mar 02 2016 00:00:00
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getMonth()`
* `Date.prototype.setUTCMonth()`


Date.prototype.valueOf() - JavaScript

Date.prototype.valueOf()
========================

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

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

構文
--

```js
valueOf()
```

### 返値

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

解説
--

`valueOf()` メソッドは、 `Date` オブジェクトのプリミティブ値を数値型で返します。これは、1970 年 1 月 1 日 00:00:00 (UTC) からのミリ秒単位の数値です。

このメソッドは、`Date.prototype.getTime()` メソッドと機能的に同等です。

このメソッドは、JavaScript によって内部的に呼ばれるものであり、コード内で明示的に呼ばれることはありません。

例
-

### valueOf() の使用

```js
const x = new Date(56, 6, 17);
const myVar = x.valueOf(); // myVar に -424713600000 を代入
```

仕様書
---

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

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

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

関連情報
----

* `Object.prototype.valueOf()`
* `Date.prototype.getTime()`


Date.prototype.getUTCDate() - JavaScript

Date.prototype.getUTCDate()
===========================

**`getUTCDate()`** メソッドは、協定世界時に基づき、指定された日時の月内の日（1 ～ 31）を返します。

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

構文
--

```js
getUTCDate()
```

### 返値

 数字です。
 `Date` オブジェクトが有効な日時を表している場合は、指定された日時の曜日を表す 1 から 31 までの整数値（世界標準時による）。
 それ以外の場合は、 `Date` オブジェクトが有効な日時を表していない場合は `NaN` を返します。

例
-

### getUTCDate() の使用

次の例は、現在日時の「日」の部分を変数 `dayOfMonth` に代入します。

```js
const today = new Date();
const dayOfMonth = today.getUTCDate();
```

仕様書
---

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

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

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

関連情報
----

* `Date.prototype.getUTCDate()`
* `Date.prototype.getDay()`
* `Date.prototype.setUTCDate()`