TypeError: can't redefine non-configurable property "x" - JavaScript

TypeError: can't redefine non-configurable property "x"
=======================================================

メッセージ
-----
```

TypeError: can't redefine non-configurable property "x" (Firefox)
TypeError: Cannot redefine property: "x" (Chrome)
```

エラータイプ
------

`TypeError`何がうまくいかなかったのか？
--------------

プロパティを再定義しようとしましたが、そのプロパティは設定不可です。`configurable` 属性は、プロパティをオブジェクトから削除できるかどうか、および (`writable` 以外で) 変更できるかどうかを制御します。通常、オブジェクト初期化子で生成されたオブジェクトのプロパティは、変更可能です。しかし、`Object.defineProperty()` を使用した場合などは、既定でプロパティを修正できません。

例
-

### `Object.defineProperty` で生成された設定不可のプロパティ

設定可能にしたくない場合、`Object.defineProperty()` は設定不可のプロパティを生成します。

```js
var obj = Object.create({});
Object.defineProperty(obj, "foo", { value: "bar" });

Object.defineProperty(obj, "foo", { value: "baz" });
// TypeError: can't redefine non-configurable property "foo"
```

後のコードで再定義するためには、"foo" プロパティを設定可能にする必要があります。

```js
var obj = Object.create({});
Object.defineProperty(obj, "foo", { value: "bar", configurable: true });
Object.defineProperty(obj, "foo", { value: "baz", configurable: true });
```

関連項目
----

* [[Configurable]]
* `Object.defineProperty()`


RangeError: precision is out of range - JavaScript

RangeError: precision is out of range
=====================================

JavaScript の例外 "precision is out of range" は、 `toFixed` または `toPrecision` に 0 から 20 (または 21) までの範囲外の数値が渡された場合に発生します。

エラーメッセージ
--------

```js
RangeError: The number of fractional digits is out of range (Edge)
RangeError: The precision is out of range (Edge)
RangeError: precision {0} out of range (Firefox)
RangeError: toExponential() argument must be between 0 and 20 (Chrome)
RangeError: toFixed() digits argument must be between 0 and 20 (Chrome)
RangeError: toPrecision() argument must be between 1 and 21 (Chrome)
```

エラーの種類
------

`RangeError`エラーの原因
------

これらのメソッドのいずれかで、 範囲外の精度を引数を使用しています。

* `Number.prototype.toExponential()`
* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`

これらのメソッドで許可されている範囲は、通常 0 と 20（または 21）の間です。しかし、ECMAScript 仕様では、この範囲の拡張が認められています。

| メソッド | Firefox (SpiderMonkey) | Chrome, Opera (V8) |
| --- | --- | --- |
| `Number.prototype.toExponential()` | 0 から 100 | 0 から 20 |
| `Number.prototype.toFixed()` | -20 から 100 | 0 から 20 |
| `Number.prototype.toPrecision()` | 1 から 100 | 1 から 21 |

例
-

### 無効なケース

```js
(77.1234).toExponential(-1); // RangeError
(77.1234).toExponential(101); // RangeError

(2.34).toFixed(-100); // RangeError
(2.34).toFixed(1001); // RangeError

(1234.5).toPrecision(-1); // RangeError
(1234.5).toPrecision(101); // RangeError
```

### 有効な場合

```js
(77.1234).toExponential(4); // 7.7123e+1
(77.1234).toExponential(2); // 7.71e+1

(2.34).toFixed(1); // 2.3
(2.35).toFixed(1); // 2.4 （この場合は丸めが発生することに注意してください）

(5.123456).toPrecision(5); // 5.1235
(5.123456).toPrecision(2); // 5.1
(5.123456).toPrecision(1); // 5
```

関連情報
----

* `Number.prototype.toExponential()`
* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`


SyntaxError: missing ; before statement - JavaScript

SyntaxError: missing ; before statement
=======================================

JavaScript の例外 "missing ; before statement" は、どこかでセミコロンが欠けており、 自動セミコロン挿入 (ASI) によって追加できない場合に発生します。 JavaScript がソースコードを正しく解釈するためには、セミコロンを置く必要があります。

メッセージ
-----

```js
SyntaxError: Expected ';' (Edge)
SyntaxError: missing ; before statement (Firefox)
```

エラーの種類
------

`SyntaxError`エラーの原因
------

どこかでセミコロン (`;`) を忘れています。JavaScript の文はセミコロンで終えなければなりません。一部は、自動セミコロン挿入 (ASI) の影響を受けますが、この場合に JavaScript がソースコードを正確に解釈するためには、セミコロンを置く必要があります。

しかし、多くの場合、このエラーは、文字列の不適切なエスケープや `var` の誤った使用など、その他のエラーの結果として発生します。また、どこかで括弧が多すぎるかもしれません。このエラーが発生した場合は、注意深く構文をチェックしてください。

例
-

### エスケープされていない文字列

このエラーは、次のように、適切に文字列をエスケープしておらず、文字列がすでに終了していると JavaScript エンジンが予測したときによく発生します。

```js
var foo = 'Tom's bar';
// SyntaxError: missing ; before statement
```

二重引用符を使用するか、アポストロフィをエスケープするかしてください。

```js
var foo = "Tom's bar";
var foo = 'Tom\'s bar';
```

### var を使用したプロパティ宣言

オブジェクトや配列のプロパティを `var` を使って宣言することは**できません**。

```js
var obj = {};
var obj.foo = 'hi'; // SyntaxError missing ; before statement

var array = [];
var array[0] = 'there'; // SyntaxError missing ; before statement
```

`var` キーワードを省略してください。

```js
var obj = {};
obj.foo = "hi";

var array = [];
array[0] = "there";
```

### 誤ったキーワード

他のプログラミング言語から来た人は、 JavaScript では同じ意味を持たない、あるいはまったく意味を持たないキーワードを使ってしまうこともよくあります。

```js
def print(info){
  console.log(info);
}; // SyntaxError missing ; before statement
```

`function` を `def` の代わりに使用してください。

```js
function print(info) {
  console.log(info);
}
```

関連情報
----

* 自動セミコロン挿入 (ASI)
* JavaScript 文


RangeError: radix must be an integer - JavaScript

RangeError: radix must be an integer
====================================

JavaScript の例外 "radix must be an integer at least 2 and no greater than 36" は、 `Number.prototype.toString()` メソッドまたは `BigInt.prototype.toString()` メソッドのオプションの `radix` 引数が指定されたものの、 2 から 36 までの範囲になかったときに発生します。

エラーメッセージ
--------

```js
RangeError: invalid argument (Edge)
RangeError: radix must be an integer at least 2 and no greater than 36 (Firefox)
RangeError: toString() radix argument must be between 2 and 36 (Chrome)
```

エラーの種類
------

`RangeError`エラーの原因
------

`Number.prototype.toString()` メソッドまたは `BigInt.prototype.toString()` メソッドのオプションの `radix` 引数が指定されています。この引数は、数値を表すために使用する基数を指定する 2 から 36 の整数 (数) でなければなりません。例えば、 10 進数の数値 169 は 16 進数では A9 と表現されます。

なぜ上限が 36 なのでしょうか？ 10 よりも大きい基数の場合は、アルファベットが数値として用いられます。したがって、 (英語およびほかの多くの言語で用いられる) ラテン文字のアルファベットは 26 文字しかないため、基数は 36 以上にすることができません。

一般的な基数には、次のものがあります。

* 二進法のための 2、
* 八進法のための 8、
* 十進法のための 10、
* 十六進法のための 16。
例
-

### 無効な場合

```js
(42).toString(0);
(42).toString(1);
(42).toString(37);
(42).toString(150);
// フォーマットのために、このような文字列は使用できません。
(12071989).toString("MM-dd-yyyy");
```

### 有効な場合

```js
(42).toString(2); // "101010" (二進法)
(13).toString(8); // "15" (八進法)
(0x42).toString(10); // "66" (十進法)
(100000).toString(16); // "186a0" (十六進法)
```

関連情報
----

* `Number.prototype.toString()`
* `BigInt.prototype.toString()`


TypeError: X.prototype.y called on incompatible type - JavaScript

TypeError: X.prototype.y called on incompatible type
====================================================

JavaScript の例外 "called on incompatible target (or object)" は、関数が (与えられたオブジェクト上で) 呼び出されたときに、関数が期待する型に対応していない `this` を使用して呼び出された場合に発生します。

エラーメッセージ
--------

```js
TypeError: 'this' is not a Set object (Edge)
TypeError: Function.prototype.toString called on incompatible object (Firefox)
TypeError: Function.prototype.bind called on incompatible target (Firefox)
TypeError: Method Set.prototype.add called on incompatible receiver undefined (Chrome)
TypeError: Bind must be called on a function (Chrome)
```

エラーの種類
------

`TypeError`エラーの原因
------

このエラーが発生する場合、(指定されたオブジェクト上の) 関数が、関数が予期する型に対応していない `this` と共に呼び出されています。

この問題は `Function.prototype.call()` メソッドか `Function.prototype.apply()` メソッドを使用して、予期していない型の `this` 引数を渡した場合に発生します。

この問題は、オブジェクトのプロパティとして格納されている関数を他の関数の引数として提供する場合にも発生します。この場合、関数を格納しているオブジェクトは、他の関数から呼び出されたときに、その関数の `this` のターゲットにはなりません。この問題を回避するには、呼び出しを行っているラムダを提供するか、 `Function.prototype.bind()` 関数を使用して `this` 引数を期待されるオブジェクトに強制的に渡す必要があります。

例
-

### 無効な場合

```js
var mySet = new Set();
["bar", "baz"].forEach(mySet.add);
// mySet.add is a function, but "mySet" is not captured as this.

var myFun = function () {
  console.log(this);
};
["bar", "baz"].forEach(myFun.bind);
// myFun.bind is a function, but "myFun" is not captured as this.
```

### 妥当な場合

```js
var mySet = new Set();
["bar", "baz"].forEach(mySet.add.bind(mySet));
// This works due to binding "mySet" as this.

var myFun = function () {
  console.log(this);
};
["bar", "baz"].forEach((x) => myFun.bind(x));
// This works using the "bind" function. It creates a lambda forwarding the argument.
```

関連情報
----

* `Function.prototype.call()`
* `Function.prototype.apply()`
* `Function.prototype.bind()`


SyntaxError: return not in function - JavaScript

SyntaxError: return not in function
===================================

JavaScript の例外 "return (or yield) not in function" は、 `return` 文または `yield` 文が関数の外側で呼び出されたときに発生します。

エラーメッセージ
--------

```js
SyntaxError: 'return' statement outside of function (Edge)
SyntaxError: return not in function (Firefox)
SyntaxError: yield not in function (Firefox)
```

エラーの種類
------

`SyntaxError`エラーの原因
------

`return` 文か `yield` 文が 関数 の外側で呼び出されました。どこかで、中括弧を忘れたのかもしれません。 `return` 文と `yield` 文は、関数内で使用しなければなりません。これらの文は、関数の実行を終了 (または、停止や再開) し、関数の呼び出し元に返す値を指定するからです。

例
-

### 中括弧がない場合

```js
var cheer = function(score) {
  if (score === 147)
    return 'Maximum!';
  };
  if (score > 100) {
    return 'Century!';
  }
}

// SyntaxError: return not in function
```

一見すると、中括弧は正しく見えますが、このコードスニペットでは、最初の `if` 文の後の `{` を忘れています。正しくは以下のようにします。

```js
var cheer = function (score) {
  if (score === 147) {
    return "Maximum!";
  }
  if (score > 100) {
    return "Century!";
  }
};
```

関連情報
----

* `return`
* `yield`


Warning: -file- is being assigned a //# sourceMappingURL, but already has one - JavaScript

Warning: -file- is being assigned a //# sourceMappingURL, but already has one
=============================================================================

JavaScript の警告 "-file- is being assigned a //# sourceMappingURL, but already has one." は、ある JavaScript ソースに対してソースマップが 2 回以上指定されている場合に発生します。

エラーメッセージ
--------

```html
Warning: -file- is being assigned a //# sourceMappingURL, but already has one.
```

エラーの種類
------

警告です。 JavaScript の実行が停止されることはありません。

エラーの原因
------

JavaScript ソースに対して、ソースマップが複数回指定されています。

より効率的にサーバから配信するため、しばしば JavaScript ソースの結合や縮小が行われます。 ソースマップを使用すると、デバッガーは実行されているコードと元のソースファイルを対応付けできます。ソースマップを割り当てるには、コメントを使用するか JavaScript ファイルにヘッダーを設定するかの 2 つの方法があります。

例
-

### ソースマップの設定

ファイル内でコメントを使用してソースマップを設定します。

```js
//# sourceMappingURL=http://example.com/path/to/your/sourcemap.map
```

あるいは、JavaScript ファイルにヘッダーを設定することもできます。

```js
X-SourceMap: /path/to/file.js.map
```

関連情報
----

* ソースマップを使用する – Firefox ツールドキュメント
* Introduction to source maps – HTML5 rocks


TypeError: "x" is not a function - JavaScript

TypeError: "x" is not a function
================================

JavaScript の例外 "is not a function" は、値を関数として呼び出そうとしたが、その値が実際には関数ではなかった場合に発生します。

エラーメッセージ
--------

```js
TypeError: Object doesn't support property or method {x} (Edge)
TypeError: "x" is not a function
```

エラーの種類
------

`TypeError`エラーの原因
------

関数でないものを、関数呼び出ししようとした際に発生するエラーです。また適切な関数が定義されていることを期待されているが、定義されていない場合も発生します。

関数名のタイプミスをしていないか確認してみましょう。また、呼び出そうとしてるオブジェクトがそのメソッドを持っているかどうかも確認してみてください。配列オブジェクトが持っている `map` 関数を、それを持たない通常のオブジェクトに対して呼び出そうとしている場合が、後者の例になります。

多くの組み込み関数はコールバック関数を必要とします。これらのメソッドを正しく呼び出すためには、関数を引数に指定する必要があります。

* `Array` もしくは `TypedArray` オブジェクトを操作する場合:
    + `Array.prototype.every()`, `Array.prototype.some()`, `Array.prototype.forEach()`, `Array.prototype.map()`, `Array.prototype.filter()`, `Array.prototype.reduce()`, `Array.prototype.reduceRight()`, `Array.prototype.find()`
* `Map` もしくは `Set` を操作する場合:
    + `Map.prototype.forEach()`, `Set.prototype.forEach()`
例
-

### 関数名のタイプミス

次のように関数名を間違えている場合に発生します。なおこのミスは非常に多く発生します。

```js
let x = document.getElementByID("foo");
// TypeError: document.getElementByID is not a function
```

正しい関数名は `getElementById` です。

```js
let x = document.getElementById("foo");
```

### 間違ったオブジェクトに対する関数呼び出し

いくつかのメソッドは、引数に関数が指定されていることを期待していて、しかも特定のオブジェクトの上でのみ正しく動作するものがあります。この典型例が `Array.prototype.map()` で、これは `Array` オブジェクトでのみ正しく動作します。

```js
let obj = { a: 13, b: 37, c: 42 };

obj.map(function (num) {
  return num \* 2;
});

// TypeError: obj.map is not a function
```

オブジェクトではなく、配列を利用しましょう。

```js
let numbers = [1, 4, 9];

numbers.map(function (num) {
  return num \* 2;
});

// Array [2, 8, 18]
```

### すでに存在するプロパティと名前を共有する関数

クラスを作るとき、プロパティと関数が同じ名前になることがあります。関数を呼び出すと、コンパイラーは関数が存在するのをやめたように考えます。

```js
var Dog = function () {
  this.age = 11;
  this.color = "black";
  this.name = "Ralph";
  return this;
};

Dog.prototype.name = function (name) {
  this.name = name;
  return this;
};

var myNewDog = new Dog();
myNewDog.name("Cassidy"); //Uncaught TypeError: myNewDog.name is not a function
```

代わりに異なるプロパティ名を使ってください。

```js
var Dog = function () {
  this.age = 11;
  this.color = "black";
  this.dogName = "Ralph"; //Using this.dogName instead of .name
  return this;
};

Dog.prototype.name = function (name) {
  this.dogName = name;
  return this;
};

var myNewDog = new Dog();
myNewDog.name("Cassidy"); //Dog { age: 11, color: 'black', dogName: 'Cassidy' }
```

### 乗算での括弧の使用

数学では、 2 × (3 + 5) を 2\*(3 + 5) または単に 2(3 + 5) と書くことができます。

後者を使用するとエラーが発生します。

```js
const sixteen = 2(3 + 5);
alert("2 x (3 + 5) is " + String(sixteen));
//Uncaught TypeError: 2 is not a function
```

このコードは `*` 演算子を追加すると修正できます。

```js
const sixteen = 2 \* (3 + 5);
alert("2 x (3 + 5) is " + String(sixteen));
//2 x (3 + 5) is 16
```

### 正しくエクスポートされたモジュールをインポートする

正しくモジュールをインポートしていることを確認してください。

helpers ライブラリーの例 (`helpers.js`)

```js
let helpers = function () {};

helpers.groupBy = function (objectArray, property) {
  return objectArray.reduce(function (acc, obj) {
    var key = obj[property];
    if (!acc[key]) {
      acc[key] = [];
    }
    acc[key].push(obj);
    return acc;
  }, {});
};

export default helpers;
```

正しい import の使い方 (`App.js`):
```

import helpers from './helpers'
```

関連情報
----

* 関数


SyntaxError: missing ) after argument list - JavaScript

SyntaxError: missing ) after argument list
==========================================

JavaScript の例外 "missing ) after argument list" は、関数の呼び出し方にエラーがあった場合に発生します。これは入力ミス、演算子の欠落、文字列のエスケープ忘れなどの可能性があります。

エラーメッセージ
--------

```js
SyntaxError: Expected ')' (Edge)
SyntaxError: missing ) after argument list (Firefox)
```

エラーの種類
------

`SyntaxError`エラーの原因
------

関数の呼び出し方にエラーがあります。たとえば、入力ミスや演算子の記述忘れ、文字列のエスケープ忘れの可能性が考えられます。

例
-

文字列を連結する "+" 演算子がないため、JavaScript は `log` 関数の引数として、 `"PI: "` だけを想定します。この場合、閉じ括弧で終了する必要があります。

```js
console.log('PI: ' Math.PI);
// SyntaxError: missing ) after argument list
```

"`+`" 演算子を追加することで、`log` の呼び出しを修正できます。

```js
console.log("PI: " + Math.PI);
// "PI: 3.141592653589793"
```

### 終了していない文字列

```js
console.log('"Java" + "Script" = \"' + 'Java' + 'Script\");
// SyntaxError: missing ) after argument list
```

ここで、 JavaScript は `);` が文字列の中にあると誤解して無視し、結局、 `);` が `console.log` の末尾に入っていることを知らないままになってしまいます。これを修正するには、 `'` を "Script" の文字列の後に入れます。

```js
console.log('"Java" + "Script" = "' + "Java" + 'Script"');
// '"Java" + "Script" = "JavaScript"'
```

関連情報
----

* 関数


SyntaxError: function statement requires a name - JavaScript

SyntaxError: function statement requires a name
===============================================

JavaScript の例外 "function statement requires a name" は、名前が必要な関数文がコードの中にあった場合に発生します。

エラーメッセージ
--------

```js
Syntax Error: Expected identifier (Edge)
SyntaxError: function statement requires a name [Firefox]
SyntaxError: Unexpected token ( [Chrome]
```

エラーの種類
------

`SyntaxError`何がうまくいかなかったのか？
--------------

コードに名前が必要な関数文があります。関数がどのように定義されているか、関数の名前を指定する必要があるかどうか、または問題の関数が関数式、IIFE である必要があるかどうか、 コードがこのコンテクストに正しく置かれているかどうかを確認する必要があります。

例
-

### 文と式

*function 文* (または *function 宣言*) では名前が必要であり、次のものは動作しません。

```js
function () {
  return 'Hello world';
}
// SyntaxError: function statement requires a name
```

代わりに、function 式 (代入) を使用することができます。

```js
var greet = function () {
  return "Hello world";
};
```

または、定義するとすぐに実行される IIFE (即時実行関数式) を定義しようとしているのかもしれません。その場合は、もう少々括弧が必要です。

```js
(function () {})();
```

### ラベル付けされた関数

関数 label を使用している場合、`function` キーワードの後に関数名を指定する必要があります。これは動作しません:

```js
function Greeter() {
  german: function () {
    return "Moin";
  }
}
// SyntaxError: function statement requires a name
```

たとえば、これは動作します。

```js
function Greeter() {
  german: function g() {
    return "Moin";
  }
}
```

### オブジェクトのメソッド

オブジェクトのメソッドを作るならば、オブジェクトを作る必要があります。その場合、`function` キーワードの後に名前がない次の構文は有効です。

```js
var greeter = {
  german: function () {
    return "Moin";
  },
};
```

### コールバック構文

コールバックを使用するときの構文もチェックします。大括弧とカンマが混同しやすいです。

```js
promise.then(
  function() {
    console.log("success");
  });
  function() {
    console.log("error");
}
// SyntaxError: function statement requires a name
```

正しくは、次の通りです。

```json
promise.then(
  function() {
    console.log("success");
  },
  function() {
    console.log("error");
  }
);
```

関連項目
----

* 関数 (JavaScript ガイド)
* 関数文
* 関数式
* IIFE
* label


RangeError: invalid date - JavaScript

RangeError: invalid date
========================

JavaScript の例外 "invalid date" は、無効な日付を示す文字列が `Date` または `Date.parse()` に与えらえた場合に発生します。

メッセージ
-----

```js
RangeError: invalid date (Edge)
RangeError: invalid date (Firefox)
RangeError: invalid time value (Chrome)
RangeError: Provided date is not in valid range (Chrome)
```

エラー種別
-----

`RangeError`エラーの原因
------

無効な日付を示す文字列が `Date` または `Date.parse()` に渡されたことです。

例
-

### 無効なケース

認識できない文字列や、 ISO フォーマットの文字列に不正な要素の値を含む日付の場合は、通常 `NaN` を返します。しかし実装によっては、 Firefox における次のケースのように、不適合な ISO フォーマットの文字列で `RangeError: invalid date` が発生することもあります。

```js
new Date("foo-bar 2014");
new Date("2014-25-23").toISOString();
new Date("foo-bar 2014").toString();
```

一方、これは Firefox で `NaN` を返します。

```js
Date.parse("foo-bar 2014"); // NaN
```

詳細は `Date.parse()` のドキュメントをご覧ください。

### 有効な場合

```js
new Date("05 October 2011 14:48 UTC");
new Date(1317826080); // Unix Time Stamp for 05 October 2011 14:48:00 UTC
```

関連情報
----

* `Date`
* `Date.prototype.parse()`
* `Date.prototype.toISOString()`


SyntaxError: invalid regular expression flag "x" - JavaScript

SyntaxError: invalid regular expression flag "x"
================================================

JavaScript の例外 "invalid regular expression flag" は、正規表現リテラルにおいて 2 番目のスラッシュの後に定義されたフラグが、 `g`, `i`, `m`, `s`, `u`, `y` のどれでもないときに発生します。

エラーメッセージ
--------

```js
SyntaxError: Syntax error in regular expression (Edge)
SyntaxError: invalid regular expression flag "x" (Firefox)
SyntaxError: Invalid regular expression flags (Chrome)
```

エラーの種類
------

`SyntaxError`エラーの原因
------

コード内に、不正な正規表現フラグがあります。スラッシュで囲まれたパターンで構成される正規表現リテラルでは、フラグは 2 番目のフラグの後に定義されます。 `RegExp` オブジェクトのコンストラクター関数 (2 つ目の引数) で定義することもできます。正規表現フラグは個別に使うこともできれば、好きな順序で複数使うこともできますが、 ECMAScript では 6 つしかありません。

正規表現にフラグを含めるには、次の構文を使用します。

```js
var re = /pattern/flags;
```

または、

```js
var re = new RegExp("pattern", "flags");
```

| フラグ | 説明 |
| --- | --- |
| `g` | グローバル検索 |
| i | 大文字小文字を区別した検索 |
| m | 複数行検索 |
| s | `.` で改行文字に一致できるようにする (ECMAScript 2018 で追加) |
| u | Unicode。パターンを Unicode コードポイントの並びとして扱う。 |
| y | 対象の文字列の現在の位置から一致を探す "sticky" 検索。 `sticky` を見てください。 |

例
-

有効な正規表現フラグは 6 つしかありません。

```js
/foo/bar;

// SyntaxError: invalid regular expression flag "b"
```

正規表現を生成するつもりでなくても、 2 つのスラッシュを含む式は正規表現リテラルとして解釈されます。

```js
let obj = {
  url: /docs/Web
};

// SyntaxError: invalid regular expression flag "W"
```

文字列を生成する場合、文字列リテラルを生成するためには単一引用符、または二重引用符を追加します。

```js
let obj = {
  url: "/docs/Web",
};
```

### 有効な正規表現フラグ

JavaScript で使用できる 6 つの正規表現フラグについては、上述の表を見てください。

```js
/foo/g;
/foo/gims;
/foo/uy;
```

関連情報
----

* 正規表現
* XRegEx flags – regular expression library that provides four new flags (`n`, `s`, `x`, `A`)


SyntaxError: for-in loop head declarations may not have initializers - JavaScript

SyntaxError: for-in loop head declarations may not have initializers
====================================================================

JavaScript の strict モード専用の例外である "for-in loop head declarations may not have initializers" は、 for...in の先頭に初期化構文が含まれていた場合、例えば |`for (var i = 0 in obj)`| のような場合に発生します。これは strict モードの for-in ループでは許可されていません。

エラーメッセージ
--------

```js
SyntaxError: for-in loop head declarations cannot have an initializer (Edge)
SyntaxError: for-in loop head declarations may not have initializers (Firefox)
SyntaxError: for-in loop variable declaration may not have an initializer. (Chrome)
```

エラータイプ
------

strict モードでのみ、`SyntaxError`。

何がうまくいかなかったのか？
--------------

for...in ループの先頭に初期化式が含まれています。つまり、 |`for (var i = 0 in obj)`| のように変数を宣言して値を代入しています。 strict モードでない場合は、このヘッダー宣言は暗黙に無視され、`|for (var i in obj)|` のように動作します。しかし、strict モードでは `SyntaxError` が発生します。

例
-

この例では `SyntaxError` が発生します。

```js
"use strict";

var obj = {a: 1, b: 2, c: 3 };

for (var i = 0 in obj) {
  console.log(obj[i]);
}

// SyntaxError: for-in loop head declarations may not have initializers
```

### 有効な for-in ループ

for-in ループのヘッダーから初期化子 (`i = 0`) を削除してください。

```js
"use strict";

var obj = { a: 1, b: 2, c: 3 };

for (var i in obj) {
  console.log(obj[i]);
}
```

### Array の反復処理

for...in ループは Array の反復処理で使用すべきではありません。 `Array` を反復するのに、 `for` ループを `for-in` ループの代わりに使うつもりだったのでしょうか。 `for` ループならば、初期化子を設定することができます。

```js
var arr = ["a", "b", "c"];

for (var i = 2; i < arr.length; i++) {
  console.log(arr[i]);
}

// "c"
```

関連項目
----

* `for...in`
* `for...of` – こちらも strict モードであろうとなかろうと初期化子が使用できない。
* `for` – 配列の反復処理に向いており、初期化子を定義できる。


TypeError: cyclic object value - JavaScript

TypeError: cyclic object value
==============================

JavaScript の例外 "cyclic object value" は、 JSON の中にオブジェクトの参照が見つかったときに発生します。 `JSON.stringify()` はこれを解決しようとせず、これによって失敗します。

メッセージ
-----
```

TypeError: cyclic object value (Firefox)
TypeError: Converting circular structure to JSON (Chrome and Opera)
TypeError: Circular reference in value argument not supported (Edge)
```

エラーの種類
------

`TypeError`エラーの原因
------

JSON 形式はオブジェクト参照に対応していません (IETF の草案はありますが)。したがって `JSON.stringify()` はこれを解決しようとせず、これによって失敗します。

例
-

### 循環参照

次のような循環構造体では、

```js
var circularReference = { otherData: 123 };
circularReference.myself = circularReference;
```

`JSON.stringify()` は失敗します。

```js
JSON.stringify(circularReference);
// TypeError: cyclic object value
```

循環参照をシリアライズするには、それに対応したライブラリ (例えば cycle.js) を使用したり、自分自身で循環参照を探してシリアライズ可能な値に置き換える (または削除する) ことを求める解決策を実装することもできます。

次のスニペットは、 `JSON.stringify()` の `replacer` 引数を使用して循環参照を検索してフィルタリングする方法を示しています (これによりデータ損失が発生します)。

```js
const getCircularReplacer = () => {
  const seen = new WeakSet();
  return (key, value) => {
    if (typeof value === "object" && value !== null) {
      if (seen.has(value)) {
        return;
      }
      seen.add(value);
    }
    return value;
  };
};

JSON.stringify(circularReference, getCircularReplacer());
// {"otherData":123}
```

関連情報
----

* `JSON.stringify`
* cycle.js – `JSON.decycle` と `JSON.retrocycle` という 2 つの関数を導入し、循環構造と dag を JSON でエンコードしてからリカバリーできます。


URIError: malformed URI sequence - JavaScript

URIError: malformed URI sequence
================================

JavaScript の例外 "malformed URI sequence" は、 URI エンコードまたはデコードに失敗したときに発生します。

エラーメッセージ
--------

```js
URIError: The URI to be encoded contains invalid character (Edge)
URIError: malformed URI sequence (Firefox)
URIError: URI malformed (Chrome)
```

エラータイプ
------

`URIError`何がうまくいかなかったのか？
--------------

URI エンコードまたはデコードが成功しませんでした。`decodeURI` か `encodeURI`、`encodeURIComponent`、`decodeURIComponent` 関数の引数が無効のため、関数は適切にエンコード、またはデコードできませんでした。

例
-

### エンコード

エンコードは、特定の文字インスタンスをそれぞれ、文字の UTF-8 エンコーディングを表す 1 から 4 つの並びに置き換えます。高低ペアの一部ではないサロゲートをエンコードしようとした場合、次のように `URIError` が発生します。

```js
encodeURI("\uD800");
// "URIError: malformed URI sequence"

encodeURI("\uDFFF");
// "URIError: malformed URI sequence"
```

高低ペアが正しい場合の例です。

```js
encodeURI("\uD800\uDFFF");
// "%F0%90%8F%BF"
```

### デコード

デコードでは、エンコードされた URI の部分に含まれるそれぞれのエスケープシーケンスを、それを表す文字に置き換えます。そのような文字がない場合、エラーが発生します。

```js
decodeURIComponent("%E0%A4%A");
// "URIError: malformed URI sequence"
```

適切な入力を行うと、通常は次のようになります。

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

関連項目
----

* `URIError`
* `decodeURI`
* `encodeURI`
* `encodeURIComponent`
* `decodeURIComponent`


Error - JavaScript

Error
=====

`Error` オブジェクトは、実行時エラーが発生した時に発生します。 `Error` オブジェクトは、ユーザー定義の例外の基底オブジェクトとして使用することもできます。標準の組み込みエラー型については下記を参照してください。

解説
--

実行時エラーが発生すると、新しい `Error` オブジェクトが生成されスローされます。

### エラーの型

JavaScript には、一般的な `Error` コンストラクターの他に、中核となる 7 つのエラーコンストラクターがあります。クライアント側の例外については、例外処理文を参照してください。

`EvalError`

グローバル関数 `eval()` (en-US) に関して発生するエラーを表すインスタンスを生成します。

`InternalError`

"too much recursion" (深すぎる再帰) など、JavaScript エンジンで内部エラーが発生した時に発生するエラーを表すインスタンスを生成します。

`RangeError`

数値変数または引数が、その有効範囲外である場合に発生するエラーを表すインスタンスを生成します。

`ReferenceError`

不正な参照から参照先の値を取得した時に発生するエラーを表すインスタンスを生成します。

`SyntaxError`

構文エラーを表すインスタンスを生成します。

`TypeError`

変数または引数の型が有効でない場合に発生するエラーを表すインスタンスを生成します。

`URIError`

`encodeURI()` または `decodeURI()` に不正な引数が渡された時に発生するエラーを表すインスタンスを生成します。

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

`Error()`

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

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

`Error.captureStackTrace()`

標準外の **V8** の関数で、 Error インスタンスに `stack` プロパティを生成します。

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

`Error.prototype.message`

エラーメッセージ。

`Error.prototype.name`

エラーの名称。

`Error.prototype.description`

標準外の Microsoft のプロパティで、エラーの説明です。 `message` と似ています。

`Error.prototype.number`

標準外の Microsoft のプロパティで、エラー番号です。

`Error.prototype.fileName`

標準外の Mozilla のプロパティで、このエラーが発生したファイルへのパスです。

`Error.prototype.lineNumber`

標準外の Mozilla のプロパティで、このエラーが発生したファイル内の行番号です。

`Error.prototype.columnNumber`

標準外の Mozilla のプロパティで、このエラーが発生した行内の桁番号です。

`Error.prototype.stack`

標準外の Mozilla プロパティで、スタックトレースです。

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

`Error.prototype.toString()`

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

例
-

### 一般的なエラーを発生させる

通常、`throw` キーワードを使い意図的にエラーを発生させて `Error` オブジェクトを生成します。 `try...catch` 構文を使用してエラーを処理してください:

```js
try {
  throw new Error("Whoops!");
} catch (e) {
  console.error(e.name + ": " + e.message);
}
```

### 特定のエラーを処理する

エラーの `constructor` プロパティでエラー型をテストすることにより、特定のエラー型だけを選んで処理できます。または、最近の JavaScript エンジン向けに書いているのであれば、`instanceof` キーワードが使えます:

```js
try {
  foo.bar();
} catch (e) {
  if (e instanceof EvalError) {
    console.error(e.name + ": " + e.message);
  } else if (e instanceof RangeError) {
    console.error(e.name + ": " + e.message);
  }
  // ... etc
}
```

### 独自のエラー型

`Error` から派生した独自のエラー型を定義して `throw new CustomError()` ができるようにし、`instanceof CustomError` で例外ハンドラー内のエラーの種類を確認したいでしょう。これを行う一般的な方法の実例を以下に示します。

StackOverflow の突っ込んだ議論、 "What's a good way to extend Error in JavaScript?" も参照してください。

#### ES6 独自のエラークラス

**警告:** Babel 7 以前では独自のエラークラスのメソッドを使用することができますが、 Object.defineProperty() で宣言された場合に限定されます。 そうでない場合、古い Babel やそれ以外のトランスパイラは、下記のコードを正しく処理するために追加の設定を必要とします。

**メモ:** ES2015 クラスを使用した場合、一部のブラウザのスタックトレース上に、 CustomError コンストラクタが含まれます。

```js
class CustomError extends Error {
  constructor(foo = "bar", ...params) {
    // Pass remaining arguments (including vendor specific ones) to parent constructor
    super(...params);

    // Maintains proper stack trace for where our error was thrown (only available on V8)
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, CustomError);
    }

    this.name = "CustomError";
    // Custom debugging information
    this.foo = foo;
    this.date = new Date();
  }
}

try {
  throw new CustomError("baz", "bazMessage");
} catch (e) {
  console.error(e.name); //CustomError
  console.error(e.foo); //baz
  console.error(e.message); //bazMessage
  console.error(e.stack); //stacktrace
}
```

#### ES5 独自のエラーオブジェクト

**警告:** **すべて**のブラウザーのスタックトレース上に、 `CustomError` コンストラクターが含まれます。

```js
function CustomError(foo, message, fileName, lineNumber) {
  var instance = new Error(message, fileName, lineNumber);
  instance.name = "CustomError";
  instance.foo = foo;
  Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
  if (Error.captureStackTrace) {
    Error.captureStackTrace(instance, CustomError);
  }
  return instance;
}

CustomError.prototype = Object.create(Error.prototype, {
  constructor: {
    value: Error,
    enumerable: false,
    writable: true,
    configurable: true,
  },
});

if (Object.setPrototypeOf) {
  Object.setPrototypeOf(CustomError, Error);
} else {
  CustomError.__proto__ = Error;
}

try {
  throw new CustomError("baz", "bazMessage");
} catch (e) {
  console.error(e.name); //CustomError
  console.error(e.foo); //baz
  console.error(e.message); //bazMessage
}
```

仕様書
---

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

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

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

関連情報
----

* `throw`
* `try...catch`


isNaN() - JavaScript

isNaN()
=======

**`isNaN()`** 関数は引数が `NaN` (非数) かどうかを判定します。`isNaN` 関数の型強制は意外なものになる可能性があるため、他の `Number.isNaN()` を使用した方が良いかもしれません。

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

構文
--

```js
isNaN(value);
```

### 引数

`value`

テストされる値。

### 返値

渡された値が `NaN` である場合は **`true`** を返し, そうでなければ **`false`** を返します。

解説
--

### isNaN 関数の必要性

JavaScript のその他すべての値とは違い、等値性評価演算子（== と ===）を `NaN` に対して使用してその値が `NaN` であるかどうかを判定することはできません。 `NaN == NaN` と `NaN === NaN` はどちらも `false` と評価されるからです。そこで、`isNaN` が必要となります。

### NaN 値の生成条件

`NaN` の値は、算術演算の結果が*未定義*または*表現不可能*な値となった時に生成されます。こうした値が常にオーバーフロー状態を表現するとは限りません。`NaN` はプリミティブな数値が利用不可能といった、非数値を数値へと型強制した結果として生成されることもあります。

例えば、ゼロをゼロで除算した場合の結果は `NaN` になりますが、その他の数をゼロで除算した場合は異なります。

### 特殊な場合における厄介な動作

`isNaN` 関数の定義はごく初期のバージョン以降、数値ではない引数における振る舞いが分かりにくいものとなっていました。 `isNaN` 関数の引数が数値型ではない場合、その値はまず数へと型強制されます。その結果の値はその後 `NaN` かどうかがテストされます。このようにして、数値型に型強制される際に結果が NaN ではない数値となる非数値 (とりわけ型強制されると 0 や 1 の値になる空文字列や論理値プリミティブ) に対しては、予想外なことに "false" が返されます。無論、例えば空文字列は「数ではありません」。この混乱は、 "not a number" (数ではない) というこの用語が IEEE-754 浮動小数点数定義で表現された数においては特別な意味を持っていることに起因しています。この関数は、「この値を数値型に型強制した場合、IEEE-754 における 'Not A Number' という値になりますか？」という質問に答えるものとして解釈すべきです。

ECMAScript 2015 では `Number.isNaN()` 関数が存在します。`Number.isNaN(x)` は `x` が `NaN` かどうかをテストする確実な方法です。しかしながら `Number.isNaN` においても、`NaN` の意味は明確な数値的意味を持つ "not a number" のままです。`Number.isNaN` が利用できない場合、`x` が `NaN` かどうかを確実にテストする代わりの方法として `(x != x)` という式があります。この式の結果は信頼性のない `isNaN` が引き起こす誤検出の影響を受けません。

`isNaN` のポリフィルは以下のようになります (このポリフィルは `NaN` が自分自身と常に等しくならないという特徴を利用しています)。

```js
const isNaN = function (value) {
  const n = Number(value);
  return n !== n;
};
```

例
-

```js
isNaN(NaN); // true
isNaN(undefined); // true
isNaN({}); // true

isNaN(true); // false
isNaN(null); // false
isNaN(37); // false

// strings
isNaN("37"); // false: "37" は非数でない数値 37 に変換される
isNaN("37.37"); // false: "37.37" は非数でない数値 37.37 に変換される
isNaN("37,5"); // true
isNaN("123ABC"); // true: parseInt("123ABC") の結果は 123、しかし Number("123ABC") の結果は NaN
isNaN(""); // false: 空文字列は非数でない 0 に変換される
isNaN(" "); // false: 半角スペースからなる文字列は非数でない 0 に変換される

// dates
isNaN(new Date()); // false
isNaN(new Date().toString()); // true

// isNaN が信頼性に欠ける理由となる誤検出の例
isNaN("blabla"); // true: "blabla" が数値に変換される。
// 数値への変換が失敗し NaN が返される。
```

### 特殊な場合における便利な動作

`isNaN()` のふるまいを考慮した別の使用方法があります。`isNaN(x)` が `false` を返す場合、`NaN` を返すことなく算術式内で `x` を使用できます。`true` を返す場合、`x` を使用すると全ての算術式で `NaN` を返すことになります。これはつまり、JavaScript において `isNaN(x) == true` という式は、`x - 0` という式が `NaN` を返すかどうか、というケースと同等である（JavaScript では `x - 0 == NaN` は常に false を返すため、このことを確認できませんが）ということです。実際、`isNaN(x)`、`isNaN(x - 0)`、`isNaN(Number(x))`、`Number.isNaN(x - 0)`、そして `Number.isNaN(Number(x))` は常に同じ値を返し、JavaScript では `isNaN(x)` がこれらの条件を表す最も短い形式となります。

例えばこの動作を使って、ある関数への引数が算術処理可能か (数値として利用できるか) どうかをテストするのに利用し、そうでない場合は既定値などを与えるようにできます。この方法によりコンテキスト次第で値を暗黙的に変換する汎用性の高い JavaScript 関数を作成できます。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-isnan-number |

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

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

関連情報
----

* `NaN`
* `Number.isNaN()`


AsyncGenerator - JavaScript

AsyncGenerator
==============

**`AsyncGenerator`** オブジェクトは非同期ジェネレーター関数から返されるもので、非同期反復可能プロトコルと非同期イテレータープロトコルの両方を満たすものです。

非同期ジェネレーターメソッドは、常に `Promise` オブジェクトを生成します。

`AsyncGenerator` は隠しクラスの `AsyncIterator` のサブクラスです。

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

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

`AsyncGenerator` コンストラクターはグローバルには利用できません。`AsyncGenerator` のインスタンスは、非同期ジェネレーター関数から返される必要があります。

```js
async function\* createAsyncGenerator() {
  yield await Promise.resolve(1);
  yield await Promise.resolve(2);
  yield await Promise.resolve(3);
}
const asyncGen = createAsyncGenerator();
asyncGen.next().then((res) => console.log(res.value)); // 1
asyncGen.next().then((res) => console.log(res.value)); // 2
asyncGen.next().then((res) => console.log(res.value)); // 3
```

実際、`AsyncGenerator`コンストラクターに対応するJavaScriptのエンティティはありません。非同期ジェネレーター関数によって生成されるすべてのオブジェクトによって共有されるプロトタイプオブジェクトである隠しオブジェクトがあるだけです。このオブジェクトはクラスのように見せるために `AsyncGenerator.prototype` というスタイルで呼ばれることが多いのですが、`AsyncGeneratorFunction.prototype.prototype` と呼ぶほうが適切でしょう。なぜなら `AsyncGeneratorFunction` は実際の JavaScript エンティティであるからです。

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

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

`AsyncGenerator.prototype.constructor`

インスタンスオブジェクトを作成したコンストラクター関数。`AsyncGenerator` インスタンスの場合、初期値は `AsyncGeneratorFunction.prototype` です。

**メモ:** `AsyncGenerator` は生成した非同期ジェネレーター関数を格納しているわけではありません。

`AsyncGenerator.prototype[@@toStringTag]`

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

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

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

`AsyncGenerator.prototype.next()`

`Promise` を返します。これは、`yield` 式で返された指定された値で解決されます。

`AsyncGenerator.prototype.return()`

ジェネレータ本体に現在の停止位置に `return` 文を挿入したかのように動作します。`try...finally` ブロックと組み合わせるとジェネレーターを終了し、クリーンアップタスクを実行することができます。

`AsyncGenerator.prototype.throw()`

ジェネレーター本体の現在の停止位置に `throw` 文が挿入されたかのように動作します。これは、ジェネレーターにエラー状態を通知し、エラーを処理するか、クリーンアップを実行して自身を終了させることができます。

例
-

### 非同期ジェネレーターの反復処理

次の例では、非同期ジェネレーターを反復処理し、時間間隔が短くなるごとに 1～6 の値をコンソールに出力しています。時刻が変わるたびにプロミスが生成されますが、それは `for await...of` ループの中で自動的に解決されることに注意してください。

```js
// 非同期タスクです。実際にはもっと有益なことを使用していることを
// 想定してください。
function delayedValue(time, value) {
  return new Promise((resolve /\*, reject\*/) => {
    setTimeout(() => resolve(value), time);
  });
}

async function\* generate() {
  yield delayedValue(2000, 1);
  yield delayedValue(100, 2);
  yield delayedValue(500, 3);
  yield delayedValue(250, 4);
  yield delayedValue(125, 5);
  yield delayedValue(50, 6);
  console.log("All done!");
}

async function main() {
  for await (const value of generate()) {
    console.log("value", value);
  }
}

main().catch((e) => console.error(e));
```

仕様書
---

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

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

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

関連情報
----

* function\*
* async function\*
* `function*` 式
* Generator Function
* Async Generator Function
* イテレーターとジェネレーター


BigInt - JavaScript

BigInt
======

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since September 2020.

* Learn more
* See full compatibility
* Report feedback
**`BigInt`** は、大きすぎて `number` プリミティブで表すことができない数を表現します。

解説
--

**BigInt 値**は、単に **BigInt** と呼ばれることもありますが、`bigint` プリミティブです。整数リテラルの末尾に `n` を追加するか、`BigInt()` コンストラクターを呼び出し、整数値または文字列値を与えることで生成することができます（ただし `new` 演算子なしで）。

```js
const previouslyMaxSafeInteger = 9007199254740991n;

const alsoHuge = BigInt(9007199254740991);
// 9007199254740991n

const hugeString = BigInt("9007199254740991");
// 9007199254740991n

const hugeHex = BigInt("0x1fffffffffffff");
// 9007199254740991n

const hugeOctal = BigInt("0o377777777777777777");
// 9007199254740991n

const hugeBin = BigInt(
  "0b11111111111111111111111111111111111111111111111111111",
);
// 9007199254740991n
```

BigInt はいくつかの点で Number と似ていますが、重要ないくつかの点が異なります。組み込みの `Math` オブジェクト内のメソッドでは利用できず、演算で Number の値と混ぜることができません。同じ型に統一する必要があります。ただし、BigInt を Number へ変換する際には精度が落ちることがあるので、相互に変換する場合には注意が必要です。

### 型情報

`typeof` の BigInt 値 (`bigint` プリミティブ) に対する評価値は、`"bigint"` となります。

```js
typeof 1n === "bigint"; // true
typeof BigInt("1") === "bigint"; // true
```

BigInt 値は `Object` でラップすることができます。

```js
typeof Object(1n) === "object"; // true
```

### 演算子

以下の演算子は BigInt 値またはオブジェクトでラップした BigInt 値で使用することができます。
```

+ * - % **
```

ビット操作演算子も同様に利用できますが、`>>>`（論理的右シフト）は BigInt が常に符号付きなので除外されます。

同様に、asm.js を壊さないようにするため単項演算子（`+`）にも対応していません。

```js
const previousMaxSafe = BigInt(Number.MAX\_SAFE\_INTEGER);
// 9007199254740991n

const maxPlusOne = previousMaxSafe + 1n;
// 9007199254740992n

const theFuture = previousMaxSafe + 2n;
// 9007199254740993n, this works now!

const multi = previousMaxSafe \* 2n;
// 18014398509481982n

const subtr = multi - 10n;
// 18014398509481972n

const mod = multi % 10n;
// 2n

const bigN = 2n \*\* 54n;
// 18014398509481984n

bigN \* -1n;
// -18014398509481984n
```

`/` 演算子もすべての数値に対して、期待される通りに動作します。ただし、小数の結果をもつ演算では BigInt 値と演算する際に小数が切り捨てられます。小数点以下の桁数は返されません。

```js
const expected = 4n / 2n;
// 2n

const truncated = 5n / 2n;
// 2n, not 2.5n
```

### 比較演算

BigInt 値は Number 値と厳密等価ではありませんが、*等価*にはなります。

```js
0n === 0; // false
0n == 0; // true
```

Number 値と BigInt 値は通常通り比較できます。

```js
1n < 2; // true
2n > 1; // true
2 > 2; // false
2n > 2; // false
2n >= 2; // true
```

BigInt 値と Number 値は配列内に混在させて並べ替えることができます。

```js
const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
// [4n, 6, -12n, 10, 4, 0, 0n]

mixed.sort(); // 既定の並べ替えの動作
// [ -12n, 0, 0n, 10, 4n, 4, 6 ]

mixed.sort((a, b) => a - b);
// 型が混在した減算はできないので動作しない
// TypeError: can't convert BigInt value to Number value

// 適切な数値比較関数を使用した並べ替え
mixed.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
// [ -12n, 0, 0n, 4n, 4, 6, 10 ]
```

なお、`Object` にラップされた BigInt は他のオブジェクトと同様の振る舞いをします。同じインスタンス同士が比較された場合にのみ等価となります。

```js
0n === Object(0n); // false
Object(0n) === Object(0n); // false

const o = Object(0n);
o === o; // true
```

Number 値と BigInt 値の型変換は精度が落ちる可能性があるため、次のことを推奨します。

* BigInt 値は、値が 253 を超えることが合理的に予想される場合にのみ使用する。
* BigInt 値と Number 値の間で型変換を行わない。
### 条件式

BigInt 値は次のような場合は Number 値のように動作します。

* `Boolean` へ変換される場合（`Boolean` 関数を使用して）
* 論理演算子の `||`、`&&`、`!` と一緒に使用された場合
* または `if` 文のような条件式の中で使用された場合

つまり、`0n` のみが偽値で、他のすべては真値となります。

```js
if (0n) {
  console.log("Hello from the if!");
} else {
  console.log("Hello from the else!");
}
// "Hello from the else!"

0n || 12n; // 12n
0n && 12n; // 0n
Boolean(0n); // false
Boolean(12n); // true
!12n; // false
!0n; // true
```

### 暗号処理

BigInt で対応している演算は、実行時間が一定ではないので、タイミング攻撃を受ける可能性があります。したがって、緩和要因がなければ JavaScript の BigInt を暗号処理で使うのは危険な可能性があります。非常に一般的な例として、攻撃者は `101n ** 65537n` と `17n ** 9999n` の時間差を計測し、経過時間にもとづいて秘密鍵のような秘匿情報の大きさを推定することができます。もしそれでも BigInt を使用しなければならない場合は、この問題に関する一般的なアドバイスが掲載されているタイミング攻撃のFAQをご覧ください。

### JSON での使用

`JSON.stringify()` を BigInt 値に対して使用すると `TypeError` が発生します。 BigInt 値は既定で JSON のシリアライズに対応していないためです。ただし、`JSON.stringify()` は特別に BigInt 値に対する裏口を残しており、 BigInt の `toJSON()` メソッドを呼び出そうとします（他のプリミティブ値に対してはそうしません）。したがって、自身で `toJSON()` メソッドを実装することができます（組み込みにオブジェクトにパッチを当てることが明確に抑止されていない数少ない例の一つ）。

```js
BigInt.prototype.toJSON = function () {
  return this.toString();
};
```

エラーを発生させるかわりに、`JSON.stringify()` は次のような文字列を生成します。

```js
console.log(JSON.stringify({ a: 1n }));
// {"a":"1"}
```

もし `BigInt.prototype` にパッチを当てたくない場合は、 BigInt 値のシリアライズに `JSON.stringify()` の `replacer` 引数を使うことができます。

```js
const replacer = (key, value) =>
  typeof value === "bigint" ? value.toString() : value;

const data = {
  number: 1,
  big: 18014398509481982n,
};
const stringified = JSON.stringify(data, replacer);

console.log(stringified);
// {"number":1,"big":"18014398509481982"}
```

長整数になることがわかっている値を含む JSON データがある場合は、`JSON.parse` の `reviver` 引数を使って対処することができます。

```js
const reviver = (key, value) => (key === "big" ? BigInt(value) : value);

const payload = '{"number":1,"big":"18014398509481982"}';
const parsed = JSON.parse(payload, reviver);

console.log(parsed);
// { number: 1, big: 18014398509481982n }
```

**メモ:** `JSON.stringify()` の replacer を汎用的にし、すべてのオブジェクトに対して BigInt 値を適切にシリアライズをすることが可能であるのに対し、`JSON.parse()` の reviver は期待するペイロードの形に特化していなければなりません。というのも、シリアライズは*非可逆的*だからです。つまり BigInt を表現する文字列と通常の文字列を区別することはできません。

### BigInt の変換

BigInt を期待する多くの組み込み演算は、まず引数を BigInt に変換します。演算は以下のように要約できます。

* BigInt はそのまま返される。
* `undefined` と `null` は `TypeError` を発生させる。
* `true` は `1n` になり、 `false` は `0n` になる。
* 文字列は整数リテラルを含むかのように解析され、変換される。解析に失敗すると `SyntaxError` が発生する。
* 数値は `TypeError` を発生させ、精度の低下を引き起こす意図しない暗黙の変換を防ぐ。
* シンボルは `TypeError` を発生させる。
* オブジェクトはまず、`[@@toPrimitive]()` （`"number"` をヒントに指定）、`valueOf()`、`toString()` の順にメソッドを呼び出してプリミティブ変換される。その結果のプリミティブは BigInt に変換される。

JavaScript でほぼ同じ効果を得る最良の方法は、`BigInt()` 関数を使うことです。`BigInt(x)` は同じアルゴリズムを使って `x` を変換しますが、数値が `TypeError` を発生させず、整数であれば BigInt に変換される点が異なります。

BigInt を期待する組み込み演算は、変換後に BigInt を固定幅に切り詰めることが多いことに注意してください。これは `BigInt.asIntN()` と `BigInt.asUintN()` 、および `BigInt64Array` と `BigUint64Array` のメソッドも含みます。

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

`BigInt()`

新しい BigInt 値を生成します。

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

`BigInt.asIntN()`

BigInt 値を符号付き整数値に丸め、その値を返します。

`BigInt.asUintN()`

BigInt 値を符号なし整数値に丸め、その値を返します。

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

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

`BigInt.prototype.constructor`

インスタンスオブジェクトを作成したコンストラクター関数。`BigInt` インスタンスの場合、初期値は `BigInt` コンストラクターです。

`BigInt.prototype[@@toStringTag]`

`@@toStringTag` プロパティの初期値は文字列 `"BigInt"` です。このプロパティは `Object.prototype.toString()` で使われます。ただし、 `BigInt` も独自の `toString()` メソッドをもつので、`thisArg` として BigInt を指定して `Object.prototype.toString.call()` を呼び出さないかぎりこのプロパティは使われません。

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

`BigInt.prototype.toLocaleString()`

この BigInt 値の言語に合わせた表現の文字列を返します。`Object.prototype.toLocaleString()` メソッドを上書きします。

`BigInt.prototype.toString()`

この BigInt 値を指定された基数で表現した文字列を返します。`Object.prototype.toString()` メソッドを上書きします。

`BigInt.prototype.valueOf()`

この BigInt 値を返します。`Object.prototype.valueOf()` メソッドを上書きします。

例
-

### 素数の計算

```js
// 渡された BigInt が素数であった場合は true を返します
function isPrime(p) {
  for (let i = 2n; i \* i <= p; i++) {
    if (p % i === 0n) return false;
  }
  return true;
}

// 引数として BigInt 値を取り、 nth 番目の素数を BigInt 値として返します。
function nthPrime(nth) {
  let maybePrime = 2n;
  let prime = 0n;

  while (nth >= 0n) {
    if (isPrime(maybePrime)) {
      nth--;
      prime = maybePrime;
    }
    maybePrime++;
  }

  return prime;
}

nthPrime(20n);
// 73n
```

仕様書
---

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

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

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

関連情報
----

* `Number`
* `Number.MAX_SAFE_INTEGER`


encodeURI() - JavaScript

encodeURI()
===========

**`encodeURI()`** 関数は、URI (Uniform Resource Identifier; 統一資源識別子) をエンコードし、各文字のインスタンスをそれぞれ UTF-8 符号の文字を表す 1 個から 4 個のエスケープシーケンスに置き換えます (サロゲート文字のペアのみ 4 個のエスケープシーケンスになります)。

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

構文
--
```

encodeURI(URI)
```

### 引数

`URI`

完全 URI です。

### 返値

URI (Uniform Resource Identifier) としてエンコードされた指定された文字列を表す新しい文字列です。

解説
--

`encodeURI()` 関数では、 URI において特別な意味を持つ文字 (予約文字) はエンコードされません。下記の例は URI "scheme" に含まれる可能性がある全ての箇所を示しています。特定の文字がどのように特殊な意味を表すために使われているかに注意してください。
```

http://username:password@www.example.com:80/path/to/file.php?foo=316&bar=this+has+spaces#anchor
```

したがって、 `encodeURI()` は完全な URI を表すのに必要な文字はエンコード**しません**。また、 `encodeURI()` は "unreserved marks" (予約されていないが "そのまま" URI に使用できる) 文字をエンコード**しません**。 (RFC2396 を確認してください。)

`encodeURI()` は下記**以外**の全ての文字をエスケープします。
```

エスケープされないもの:

    A-Z a-z 0-9 ; , / ? : @ & = + $ - _ . ! ~ * ' ( ) #
```

例
-

### encodeURI と encodeURIComponent

`encodeURI()` は以下のように `encodeURIComponent()` とは異なります。

```js
var set1 = ";,/?:@&=+$#"; // 予約文字
var set2 = "-\_.!~\*'()"; // 予約されていない記号
var set3 = "ABC abc 123"; // 英数字 + 空白

console.log(encodeURI(set1)); // ;,/?:@&=+$#
console.log(encodeURI(set2)); // -\_.!~\*'()
console.log(encodeURI(set3)); // ABC%20abc%20123 (空白は %20 にエンコードされる)

console.log(encodeURIComponent(set1)); // %3B%2C%2F%3F%3A%40%26%3D%2B%24%23
console.log(encodeURIComponent(set2)); // -\_.!~\*'()
console.log(encodeURIComponent(set3)); // ABC%20abc%20123 (空白は %20 にエンコードされる)
```

なお、`encodeURI()` のみでは、 HTTP の `GET` および `POST` リクエストを `XMLHttpRequest` のように適切に構成できません。なぜなら、 "`&`", "`+`", "`=`" は `GET` および `POST` リクエストにおいて特別な文字であり、それらがエンコードされないからです。 `encodeURIComponent()` の場合、それらがエンコードされます。

### 単独のサロゲート文字のエンコード

サロゲートペアになっていない 1 個のサロゲート文字をエンコードしようとすると `URIError` が発生することに注意してください。例えば、

```js
// サロゲートペアは OK
console.log(encodeURI("\uD800\uDFFF"));

// 上位サロゲートのみだと "URIError: malformed URI sequence" エラーが発生
console.log(encodeURI("\uD800"));

// 下位サロゲートのみだと "URIError: malformed URI sequence" エラーが発生
console.log(encodeURI("\uDFFF"));
```

### IPv6 のエンコード

また、 URL 記述のために最近の RFC3986 仕様に従おうとする場合、角括弧 `[]` は (IPv6 用の) 予約文字となっているため、角括弧が (ホスト名など) URL の一部を形成している場合はエンコードされていないほうがよいでしょう。そういう場合は以下のコードが役に立ちます。

```js
function fixedEncodeURI(str) {
  return encodeURI(str).replace(/%5B/g, "[").replace(/%5D/g, "]");
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-encodeuri-uri |

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

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

関連情報
----

* `decodeURI()`
* `encodeURIComponent()`
* `decodeURIComponent()`


Array - JavaScript

Array
=====

**`Array`** オブジェクトは、他のプログラミング言語の配列と同様に、複数の項目の集合を単一の変数名の下に格納することができ、共通の配列操作を行うためのメンバーを持っています。

解説
--

JavaScript では、配列はプリミティブではなく、主に次のような性質を持つ `Array` オブジェクトです。

* **JavaScript の配列はリサイズ可能**であり、**異なるデータ型を交ぜて格納することができます**。（これらの性質が望ましくない場合は、代わりに型付き配列を使用してください）。
* **JavaScript の配列は連想配列ではありません**。配列の要素はインデックスとして任意の文字列を使用してアクセスすることができません。非負の整数（またはそれぞれの文字列表現）をインデックスとして使用してアクセスする必要があります。
* **JavaScript の配列はゼロオリジンです**。配列の最初の要素は `0` の位置にあり、 2 番目の要素は `1` の位置にあるといった具合です。そして、最後の要素は配列の `length` プロパティの値から `1` を引いた位置になります。
* **JavaScript の配列コピー操作はシャローコピーを生成します**。（JavaScript オブジェクトに対するすべての標準組み込みコピー操作は、ディープコピーではなく、シャローコピーを作成します）。
### 配列のインデックス

`Array` オブジェクトは要素のインデックスとして任意の文字列を（連想配列のように）使用することはできません。非負の整数（またはその文字列形式）を使用しなければなりません。整数以外の値で設定したりアクセスしたりすると、配列のリスト自体の要素を設定したり取り出したりすることはできませんが、その配列のオブジェクトプロパティの集合に関連する変数を設定したりアクセスしたりすることができます。配列のオブジェクトプロパティと配列要素のリストは別個のものであり、配列の探索や変更操作はこれらの名前付きプロパティに適用することができません。

`toString` が一つのプロパティであるのと同様に（ただし厳密には `toString()` はメソッドですが）、配列における配列要素はオブジェクトのプロパティです。しかし、次のように配列にアクセスしようとすると、プロパティ名が妥当でないため、構文エラーが発生します。

```js
arr.0; // 構文エラー
```

JavaScript の構文では、数字で始まるプロパティにはブラケット記法を使う必要があり、ドット記法を使うことはできません。また、配列のインデックスを引用符で囲むことができますが（`years[2]` の代わりに `years['2']` のように）、ふつうはそうする必要はありません。

`years[2]` の `2` は最終的に、JavaScript エンジンが内部的に `toString` メソッドで型変換することで文字列にされます。これは '2' と '02' が `years` オブジェクトの異なる場所を指すようにするためでです。このため、以下の例は `true` がログ出力されます。

```js
console.log(years["2"] !== years["02"]);
```

`years['2']` だけが実際の配列のインデックスです。 `years['02']` は自由な文字列のプロパティであり、配列の反復処理では処理されません。

### length と数値プロパティとの関係

JavaScript の配列の `length` プロパティと数値プロパティは関連しています。

配列の一部の組込みメソッド（例えば `join()`, `slice()`, `indexOf()`, など）は、配列の `length` プロパティの値はメソッドの呼び出し時の値を考慮します。

他にも（例えば `push()`, `splice()`, など）、結果として配列の `length` プロパティを更新するメソッドがあります。

```js
const fruits = [];
fruits.push("バナナ", "りんご", "もも");
console.log(fruits.length); // 3
```

JavaScript の配列で、配列のインデックスとして妥当なプロパティであり、かつ現在の配列の範囲の外にあるインデックスを設定すると、エンジンは配列の `length` プロパティを更新します。

```js
fruits[5] = "マンゴー";
console.log(fruits[5]); // "マンゴー"
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 6
```

`length` を増やすと、 `undefined` でもなく、新しい要素を作成せずに空のスロットを追加して配列を拡張します。

```js
fruits.length = 10;
console.log(fruits); // ['バナナ', 'りんご', 'もも', 空 x 2, 'マンゴー', 空 x 4]
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 10
console.log(fruits[8]); // undefined
```

一方、 `length` プロパティの数を減らすと、要素が削除されます。

```js
fruits.length = 2;
console.log(Object.keys(fruits)); // ['0', '1']
console.log(fruits.length); // 2
```

これらについては `Array/length` のページで詳しく解説します。

### 配列メソッドと空のスロット

疎配列において空のスロットは、配列のメソッド間で一貫性のない動作をします。一般に、古いメソッドは空のスロットをスキップしますが、新しいメソッドはそれを `undefined` として扱う傾向があります。

複数の要素を反復処理するメソッドのうち、以下のものはインデックスにアクセスする前に `in` によるチェックを行い、空のスロットと `undefined` を混同しないようにします。

* `concat()`
* `copyWithin()`
* `every()`
* `filter()`
* `flat()`
* `flatMap()`
* `forEach()`
* `indexOf()`
* `lastIndexOf()`
* `map()`
* `reduce()`
* `reduceRight()`
* `reverse()`
* `slice()`
* `some()`
* `sort()`
* `splice()`

空のスロットを具体的にどのように扱うかについては、各メソッドのページを参照してください。

以下のメソッドは、空のスロットを `undefined` であるかのように扱います。

* `entries()`
* `fill()`
* `find()`
* `findIndex()`
* `findLast()`
* `findLastIndex()`
* `includes()`
* `join()`
* `keys()`
* `toLocaleString()`
* `values()`
### コピーメソッドと変更メソッド

メソッドの中には、呼び出された既存の配列を変更せずに新しい配列を返すものもあります。その場合は、まず新しい配列を作成し、そこに要素を代入します。コピーは常にシャローコピーで行われ、メソッドは最初に作成された配列以外をコピーすることはありません。元の配列の要素は、次のように新しい配列にコピーされます。

* オブジェクトの場合は、オブジェクトの参照が新しい配列にコピーされます。元の配列と新しい配列の両方が同じオブジェクトを参照します。つまり、参照するオブジェクトが変更された場合、その変更は新しい配列と元の配列の両方に反映されます。
* 文字列、数値、論理値などのプリミティブ型（`String`, `Number`, `Boolean` オブジェクトではないもの）の場合、値は新しい配列へコピーされます。

他にも、メソッドが呼び出された配列を変更するメソッドがあります。この場合、メソッドによって返値が異なります。あるものは同じ配列への参照を、あるものは新しい配列の長さを返します。

以下のメソッドは、 `this.constructor[Symbol.species]` にアクセスして使用するコンストラクターを決定し、新しい配列を作成します。

* `concat()`
* `filter()`
* `flat()`
* `flatMap()`
* `map()`
* `slice()`
* `splice()`（返される要素を取り除いた配列を構成するため）

以下のメソッドは常に `Array` ベースのコンストラクターで新しい配列を作成します。

* `toReversed()`
* `toSorted()`
* `toSpliced()`
* `with()`

以下の表は、元の配列を変更メソッドと、それに対応する変更しない代替メソッドの一覧です。

| 変更メソッド | 変更しない代替メソッド |
| --- | --- |
| `copyWithin()` | 代替メソッドなし |
| `fill()` | 代替メソッドなし |
| `pop()` | `slice(0, -1)` |
| `push(v1, v2)` | `concat([v1, v2])` |
| `reverse()` | `toReversed()` |
| `shift()` | `slice(1)` |
| `sort()` | `toSorted()` |
| `splice()` | `toSpliced()` |
| `unshift(v1, v2)` | `toSpliced(0, 0, v1, v2)` |

変更メソッドを変更しない代替メソッドに変更する簡単な方法は、スプレッド構文 や `slice()` を使って最初にコピーを作成することです。

```js
arr.copyWithin(0, 1, 2); // arr を変更
const arr2 = arr.slice().copyWithin(0, 1, 2); // arr を変更しない
const arr3 = [...arr].copyWithin(0, 1, 2); // arr を変更しない
```

### 反復処理メソッド

多くの配列メソッドは、コールバック関数を引数にとります。コールバック関数は配列のそれぞれの要素に対して順次、最大1回呼び出され、コールバック関数の返値はメソッドの返値を決定するために使用されます。これらはすべて同じ形式です。

```js
method(callbackFn, thisArg)
```

`callbackFn` は 3 つの引数を取ります。

`element`

配列の中で現在処理されている要素。

`index`

配列の中で、現在処理中の要素のインデックス。

`array`

メソッドが呼び出された配列。

`callbackFn` が何を返すかは、呼び出された配列メソッドによって異なります。

引数 `thisArg` （既定値は `undefined`）は、`callbackFn` を呼び出す際に `this` 値として使用されます。`callbackFn` から最終的に見える `this` 値は、通常のルールに従って決定します。もし `callbackFn` が厳格モードではないのであれば、`this` の値がプリミティブ型であった場合はオブジェクトにラップされ、`undefined`/`null` の場合は `globalThis` に置き換わります。`callbackFn` がアロー関数で定義されていた場合は、`thisArg` 引数は関係ありません。アロー関数には自分自身の `this` のバインディングがないためです。

すべての反復可能オブジェクトはコピー可能で汎用性がありますが、空のスロットでは異なる形で動作します。

以下のメソッドは反復可能です。

* `every()`
* `filter()`
* `find()`
* `findIndex()`
* `findLast()`
* `findLastIndex()`
* `flatMap()`
* `forEach()`
* `map()`
* `some()`

具体的には、`every()`, `find()`, `findIndex()`, `findLast()`, `findLastIndex()`, `some()` は常にすべての要素に対して `callbackFn` を呼び出すわけではなく、返値が決定するとすぐに反復処理を停止します。

他にもコールバック関数を受け取り、配列のそれぞれの要素に対して最大1回実行するメソッドが2種類ありますが、一般的な反復処理メソッドとは少し異なる形式を持っています（`thisArg` を受け入れないなど）。

* `reduce()`
* `reduceRight()`

`sort()` メソッドもコールバック関数を取りますが、反復処理するメソッドではありません。配列の配置を変更し、`thisArg` を受け入れず、1 つのインデックスに対して複数回コールバックを呼び出すことがあります。

### 汎用的な配列メソッド

配列メソッドは常に汎用的であり、配列オブジェクトの内部データにはアクセスしません。配列の要素には `length` プロパティを通してアクセスし、インデックスの要素にはアクセスするだけです。つまり、配列風のオブジェクトに対しても呼び出すことができます。

```js
const arrayLike = {
  0: "a",
  1: "b",
  length: 2,
};
console.log(Array.prototype.join.call(arrayLike, "+")); // 'a+b'
```

#### length プロパティの正規化

`length` プロパティは数値に変換され、0 から 253 - 1 までの範囲に収められます。`NaN` は `0` となるので、`length` が存在しないか `undefined` であっても `0` という値を持つものとして扱われます。

言語は `length` を安全でない整数に設定することを避けます。もし `length` が 253 - 1 より大きい数に設定されると、すべての組み込みメソッドは `TypeError` を発生させます。しかし、配列の `length` プロパティは、232 - 1 より大きい値に設定されるとエラーが発生するので、メソッドが非配列オブジェクトで呼び出されない限り、安全な整数のしきい値に達することは通常ありません。

```js
Array.prototype.flat.call({}); // []
```

配列メソッドの中には、配列オブジェクトの `length` プロパティを設定するものがあります。これらのメソッドは常に正規化後の値を設定するので、`length` は常に整数値になります。

```js
const a = { length: 0.7 };
Array.prototype.push.call(a);
console.log(a.length); // 0
```

#### 配列風オブジェクト

配列風オブジェクトとは、上記の `length` の処理で例外が発生しないオブジェクトのことです。具体的に言うと、このようなオブジェクトには実際に `length` プロパティがあり、`0` から `length - 1` までのインデックスつき要素を持つことが期待されます（すべてのインデックスが存在するわけではない場合は、機能的に疎配列と同等となります）。配列メソッドが配列風オブジェクトを処理するとき、 0 より小さいか `length - 1` より大きい整数インデックスは無視されます。

多くの DOM オブジェクトは、例えば `NodeList` や `HTMLCollection` は配列風です。また、`arguments` オブジェクトも配列風です。自分自身に配列メソッドがなくても、その配列メソッドを呼び出すことができます。

```js
function f() {
  console.log(Array.prototype.join.call(arguments, "+"));
}

f("a", "b"); // 'a+b'
```

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

`Array()`

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

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

`Array[@@species]`

`Array` コンストラクターを返します。

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

`Array.from()`

新しい `Array` インスタンスを反復可能 (iterable) または配列風 (array-like) オブジェクトから生成します。

`Array.fromAsync()`

非同期反復可能、反復可能、配列風オブジェクトを元に、新しい `Array` インスタンスを作成します。

`Array.isArray()`

配列であれば `true` を、配列でなければ `false` を返します。

`Array.of()`

可変個の引数から、引数の個数や型に関わらず、新しい `Array` インスタンスを生成します。

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

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

`Array.prototype.constructor`

このインスタンスオブジェクトを作成したコンストラクター関数です。 `Array` インスタンスの場合、初期値は `Array` コンストラクターです。

`Array.prototype[@@unscopables]`

ES2015 版以前の ECMAScript 標準に含まれておらず、 `with` による文のバインドの目的には無視されるプロパティ名を含みます。

これらのプロパティはそれぞれの `Array` インスタンスが自分自身で持つプロパティです。

`length`

配列内の要素数を反映します。

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

`Array.prototype.at()`

指定された位置にある配列の項目を返します。負の整数も指定可能で、末尾の項目から戻ります。

`Array.prototype.concat()`

この配列に他の配列や値を結合して新しい配列を返します。

`Array.prototype.copyWithin()`

配列内で配列内の連続した要素を複写します。

`Array.prototype.entries()`

新しい*配列イテレーター*オブジェクトを返します。このオブジェクトは、配列中のそれぞれの位置に対するキー/値の組を保持しています。

`Array.prototype.every()`

指定したテスト関数を配列中のすべての要素が満たした場合に `true` を返します。

`Array.prototype.fill()`

配列内の指定した開始位置から終了位置までの要素を固定値で埋めます。

`Array.prototype.filter()`

指定したフィルタリング関数が `true` を返す、配列中の要素を格納した新しい配列を生成します。

`Array.prototype.find()`

指定されたたテスト関数を満たす、配列の最初の要素の値を返します。適切な要素が見つからなかった場合は `undefined` を返します。

`Array.prototype.findIndex()`

指定されたテスト関数を満たす、配列の最初の要素のインデックスを返します。適切な要素が見つからなかった場合は `-1` を返します。

`Array.prototype.findLast()`

指定されたたテスト関数を満たす、配列の最後の要素の値を返します。適切な要素が見つからなかった場合は `undefined` を返します。

`Array.prototype.findLastIndex()`

指定されたテスト関数を満たす、配列の最後の要素のインデックスを返します。適切な要素が見つからなかった場合は `-1` を返します。

`Array.prototype.flat()`

すべての部分配列の要素を指定された深さまで再帰的に連結した新しい配列を返します。

`Array.prototype.flatMap()`

コールバック関数を呼び出し元の配列の各要素に適用し、その結果を一段階平坦化した新しい配列を返します。

`Array.prototype.forEach()`

配列中のそれぞれの要素について関数を呼び出します。

`Array.prototype.includes()`

この配列が特定の要素を含むかどうか判定し、その結果を `true` または `false` で返します。

`Array.prototype.indexOf()`

指定された値と等しい値を持つ最初の（インデックスの一番小さい）要素のインデックスを返します。見つからない場合、`-1` を返します。

`Array.prototype.join()`

配列のすべての要素を結合した文字列を返します。

`Array.prototype.keys()`

新しい*配列イテレーター*を返します。このオブジェクトは配列中の各インデックスのキーを保持します。

`Array.prototype.lastIndexOf()`

指定された値と等しい値を持つ最後の (インデックスの一番大きい) 要素のインデックスを返します。見つからない場合、`-1` を返します。

`Array.prototype.map()`

配列内のすべての要素に対して与えられた関数を呼び出し、その結果を格納した新しい配列を生成します。

`Array.prototype.pop()`

配列から最後の要素を取り除き、返値として返します。

`Array.prototype.push()`

配列の最後に 1 個以上の要素を追加し、新しい配列の `length` を返します。

`Array.prototype.reduce()`

アキュムレーターと配列内のすべての要素に対して (左から右の順で) 関数を適用し、単一の値に還元します。

`Array.prototype.reduceRight()`

アキュムレーターと配列内のすべての要素に対して (右から左の順で) 関数を適用し、単一の値に還元します。

`Array.prototype.reverse()`

配列の要素の順番を逆転させます (最初の要素は最後に、最後の要素は最初になります)。

`Array.prototype.shift()`

配列から最初の要素を取り除き、その要素を返します。

`Array.prototype.slice()`

配列の一部を取り出して新しい配列として返します。

`Array.prototype.some()`

指定したテスト関数を配列中の少なくとも 1 個の要素が満たした場合に `true` を返します。

`Array.prototype.sort()`

配列内で要素を整列し、配列を返します。

`Array.prototype.splice()`

配列に対して複数の要素を追加したり取り除いたりします。

`Array.prototype.toLocaleString()`

配列とその要素を表すロケールに従った文字列を返します。`Object.prototype.toLocaleString()` メソッドを上書きします。

`Array.prototype.toReversed()`

元の配列を変更せずに、要素を逆順に並べた新しい配列を返します。

`Array.prototype.toSorted()`

元の配列を変更せずに、要素を昇順に並べた新しい配列を返します。

`Array.prototype.toSpliced()`

元配列を変更することなく、指定された位置の要素を除去または置き換えた新しい配列を返します。

`Array.prototype.toString()`

配列とその要素を表す文字列を返します。`Object.prototype.toString()` メソッドを上書きしています。

`Array.prototype.unshift()`

配列の最初に 1 個以上の要素を追加し、配列の変更後の `length` を返します。

`Array.prototype.values()`

新しい*配列イテレーター*オブジェクトを返します。このオブジェクトは、配列中の各インデックスの値を保持します。

`Array.prototype.with()`

指定された位置の要素を指定された値で置き換えた新しい配列を、元の配列に変更を加えることなく返します。

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

既定では `values()` 関数を返します。

例
-

この節では、 JavaScript で一般的な配列操作の例をいくつか紹介します。

**メモ:** まだ配列の基本に慣れていない場合は、最初に JavaScript の第一歩: 配列 の配列とは何かの説明、およびよくある配列の操作の他の例を読んでみてください。

### 配列の作成

ここでは、新しい配列を作る 3 通りの方法を示しています。最初のものは配列リテラル記法を使用したもので、次は `Array()` コンストラクターを使用して、最後は `String.prototype.split()` を使用して文字列から配列を構築しています。

```js
// 'fruits' 配列が配列リテラル記法で作成されています。
const fruits = ["りんご", "バナナ"];
console.log(fruits.length);
// 2

// 'fruits2' 配列が Array() コンストラクターで作成されています。
const fruits2 = new Array("りんご", "バナナ");
console.log(fruits2.length);
// 2

// 'fruits3' 配列が String.prototype.split() を使用して作成されています。
const fruits3 = "りんご, バナナ".split(", ");
console.log(fruits3.length);
// 2
```

### 配列から文字列を生成

この例では `join()` メソッドを使用して、配列 `fruits` から文字列を生成しています。

```js
const fruits = ["りんご", "バナナ"];
const fruitsString = fruits.join(", ");
console.log(fruitsString);
// "りんご, バナナ"
```

### インデックスによる配列の要素へのアクセス

この例では配列 `fruits` 内の項目に、配列内の位置を示すインデックスを指定することでアクセスする方法を示しています。

```js
const fruits = ["りんご", "バナナ"];

// 配列の最初の要素のインデックスは必ず 0 です。
fruits[0]; // りんご

// 配列の 2 番目の要素のインデックスは必ず 1 です。
fruits[1]; // バナナ

// 配列の末尾の要素のインデックスは、常に配列の長さよりも
// 1 だけ小さいものです。
fruits[fruits.length - 1]; // バナナ

// 配列の長さよりも大きなインデックスを使用すると、
// 'undefined' が返されます。
fruits[99]; // undefined
```

### 配列内の項目のインデックスを検索

この例では `indexOf()` メソッドを使用して、文字列 `"バナナ"` の位置（インデックス）を配列 `fruits` の中から探します。

```js
const fruits = ["りんご", "バナナ"];
console.log(fruits.indexOf("バナナ"));
// 1
```

### 配列内に特定の項目があるかどうかを検査

この例では、配列 `fruits` が `"バナナ"` と `"さくらんぼ"` を含んでいるかどうかを確認する 2 つの方法を示しています。最初は `includes()` メソッドで、次に `indexOf()` メソッドで、インデックスの値が `-1` でないことを確認します。

```js
const fruits = ["りんご", "バナナ"];

fruits.includes("バナナ"); // true
fruits.includes("さくらんぼ"); // false

// indexOf() が -1 を返さない場合、その配列はその項目を持っています。
fruits.indexOf("バナナ") !== -1; // true
fruits.indexOf("さくらんぼ") !== -1; // false
```

### 配列に項目を追加

この例では、 `push()` メソッドを使用して新しい文字列を配列 `fruits` に追加しています。

```js
const fruits = ["りんご", "バナナ"];
const newLength = fruits.push("みかん");
console.log(fruits);
// ["りんご", "バナナ", "みかん"]
console.log(newLength);
// 3
```

### 配列から最後の項目を取り除く

この例では、 `pop()` メソッドを使用して配列 `fruits` から最後の項目を取り除いています。

```js
const fruits = ["りんご", "バナナ", "みかん"];
const removedItem = fruits.pop();
console.log(fruits);
// ["りんご", "バナナ"]
console.log(removedItem);
// みかん
```

**メモ:** `pop()` は配列の最後の項目を削除するためだけに使用できます。配列の最後にある複数の項目を削除したい場合は、次の例を参照してください。

### 配列の最後から複数の項目を取り除く

この例では `splice()` メソッドを使用して、配列 `fruits` から最後の 3 つの項目を取り除いています。

```js
const fruits = ["りんご", "バナナ", "いちご", "マンゴー", "さくらんぼ"];
const start = -3;
const removedItems = fruits.splice(start);
console.log(fruits);
// ["りんご", "バナナ"]
console.log(removedItems);
// ["いちご", "マンゴー", "さくらんぼ"]
```

### 配列を最初の *N* 項目ちょうどに切り詰める

この例では `splice()` メソッドはを使用して、配列 `fruits` を最初の 2 項目ちょうどに切り詰めます。

```js
const fruits = ["りんご", "バナナ", "いちご", "マンゴー", "さくらんぼ"];
const start = 2;
const removedItems = fruits.splice(start);
console.log(fruits);
// ["りんご", "バナナ"]
console.log(removedItems);
// ["いちご", "マンゴー", "さくらんぼ"]
```

### 配列の最初から項目を取り除く

この例では `shift()` メソッドを使用して、最初の項目を配列 `fruits` から取り除きます。

```js
const fruits = ["りんご", "バナナ"];
const removedItem = fruits.shift();
console.log(fruits);
// ["バナナ"]
console.log(removedItem);
// りんご
```

**メモ:** `shift()` は最初の項目を配列から取り除く場合にのみ使用できます。複数の項目を配列の先頭から取り除く場合は、次の例を参照してください。

### 配列の先頭から複数の項目を取り除く

この例では `splice()` メソッドを使用して、配列 `fruits` から先頭の 3 項目を取り除きます。

```js
const fruits = ["りんご", "いちご", "さくらんぼ", "バナナ", "マンゴー"];
const start = 0;
const deleteCount = 3;
const removedItems = fruits.splice(start, deleteCount);
console.log(fruits);
// ["バナナ", "マンゴー"]
console.log(removedItems);
// ["りんご", "いちご", "さくらんぼ"]
```

### 配列に最初の項目を追加

この例では `unshift()` メソッドを使用して、配列 `fruits` のインデックス `0` に新しい項目を追加します。これを配列の新しい先頭の項目にします。

```js
const fruits = ["バナナ", "マンゴー"];
const newLength = fruits.unshift("いちご");
console.log(fruits);
// ["いちご", "バナナ", "マンゴー"]
console.log(newLength);
// 3
```

### インデックスを指定して単一の項目を取り除く

この例では `splice()` メソッドを使用して、文字列 `"バナナ"` を配列 `fruits` から取り除きます。 `"バナナ"` の位置のインデックスを指定します。

```js
const fruits = ["いちご", "バナナ", "マンゴー"];
const start = fruits.indexOf("バナナ");
const deleteCount = 1;
const removedItems = fruits.splice(start, deleteCount);
console.log(fruits);
// ["いちご", "マンゴー"]
console.log(removedItems);
// ["バナナ"]
```

### インデックスを指定して複数の項目を取り除く

この例では `splice()` メソッドを使用して、文字列 `"バナナ"` および `"いちご"` を配列 `fruits` から取り除きます。 `"バナナ"` の位置のインデックスと共に、取り除く項目の総数を指定します。

```js
const fruits = ["りんご", "バナナ", "いちご", "マンゴー"];
const start = 1;
const deleteCount = 2;
const removedItems = fruits.splice(start, deleteCount);
console.log(fruits);
// ["りんご", "マンゴー"]
console.log(removedItems);
// ["バナナ", "いちご"]
```

### 配列の複数の項目を置換

この例では `splice()` メソッドを使用して、配列 `fruits` 内の 2 つの項目を置き換えます。

```js
const fruits = ["りんご", "バナナ", "いちご"];
const start = -2;
const deleteCount = 2;
const removedItems = fruits.splice(
  start,
  deleteCount,
  "マンゴー",
  "さくらんぼ",
);
console.log(fruits);
// ["りんご", "マンゴー", "さくらんぼ"]
console.log(removedItems);
// ["バナナ", "いちご"]
```

### 配列の走査

この例では `for...of` ループを使用して配列 `fruits` を走査し、それぞれの項目をコンソールへログ出力します。

```js
const fruits = ["りんご", "マンゴー", "さくらんぼ"];
for (const fruit of fruits) {
  console.log(fruit);
}
// りんご
// マンゴー
// さくらんぼ
```

ただし `for...of` は配列を走査する数々の方法の一つにすぎません。他の方法はループと反復処理を参照したり、 `every()`, `filter()`, `flatMap()`, `map()`, `reduce()`, `reduceRight()` の各メソッドのドキュメントを参照したり、また `forEach()` メソッドを使用している次の例を参照したりしてください。

### 配列のそれぞれの要素に対して関数を呼び出す

この例では `forEach()` メソッドを使用して、配列 `fruits` のそれぞれの要素に対して関数を呼び出しています。この関数ではそれぞれの項目を、その項目のインデックスの番号と共にコンソールへログ出力します。

```js
const fruits = ["りんご", "マンゴー", "さくらんぼ"];
fruits.forEach((item, index, array) => {
  console.log(item, index);
});
// りんご 0
// マンゴー 1
// さくらんぼ 2
```

### 複数の配列を結合

この例では `concat()` メソッドを使用して、配列 `fruits` を配列 `moreFruits` と結合子、新しい配列 `combinedFruits` を生成します。 `fruits` と `moreFruits` は変更されないことに注意してください。

```js
const fruits = ["りんご", "バナナ", "いちご"];
const moreFruits = ["マンゴー", "さくらんぼ"];
const combinedFruits = fruits.concat(moreFruits);
console.log(combinedFruits);
// ["りんご", "バナナ", "いちご", "マンゴー", "さくらんぼ"]

// 配列 'fruits' は変更されないままです。
console.log(fruits);
// ["りんご", "バナナ", "いちご"]

// 配列 'moreFruits' も変更されないままです。
console.log(moreFruits);
// ["マンゴー", "さくらんぼ"]
```

### 配列のコピー

この例では、既存の配列 `fruits` から新しい配列を生成する方法を 3 通り示します。最初のものはスプレッド構文を使用するもので、次は `from()` メソッドを使用するもの、その次は `slice()` メソッドを使用するものです。

```js
const fruits = ["いちご", "マンゴー"];

// スプレッド構文でコピーを作成します。
const fruitsCopy = [...fruits];
// ["いちご", "マンゴー"]

// from() メソッドでコピーを作成します。
const fruitsCopy2 = Array.from(fruits);
// ["いちご", "マンゴー"]

// slice() メソッドでコピーを作成します。
const fruitsCopy3 = fruits.slice();
// ["いちご", "マンゴー"]
```

組み込みの配列コピー操作（スプレッド構文, `Array.from()`, `Array.prototype.slice()`, `Array.prototype.concat()`）はすべて、シャローコピーを生成します。配列のディープコピーを得る場合は、 `JSON.stringify()` で配列を JSON 文字列に変換し、 `JSON.parse()` でその文字列を新しい配列に戻せば、元の配列から完全に独立した新しい配列ができます。

```js
const fruitsDeepCopy = JSON.parse(JSON.stringify(fruits));
```

また、 `structuredClone()` メソッドを使用してディープコピーを作成することもできます。これは、ソース内の移譲可能オブジェクトを、コピーするのではなく、新しいコピーに移譲できる利点があります。

最後に、既存の配列を新しい変数に代入しても、配列やその要素のコピーは作成されないことを理解することが重要です。つまり、元の配列の名前と新しい変数の名前は、まったく同じオブジェクトの名前に過ぎません（したがって、常に厳密等価であると評価されます）。したがって、元の配列の値や新しい変数の値に何らかの変更を加えると、もう片方も変更されます。

```js
const fruits = ["いちご", "マンゴー"];
const fruitsAlias = fruits;
// 'fruits' と 'fruitsAlias' は同じオブジェクトとなり、厳密等価になります。
fruits === fruitsAlias; // true
// 配列 'fruits' を変更すると、 'fruitsAlias' も変化します。
fruits.unshift("りんご", "バナナ");
console.log(fruits);
// ['りんご', 'バナナ', 'いちご', 'マンゴー']
console.log(fruitsAlias);
// ['りんご', 'バナナ', 'いちご', 'マンゴー']
```

### 二次元配列の生成

以下では、文字列の二次元配列としてチェス盤を生成しています。最初の動きは `'p'` を `board[6][4]` から `board[4][4]` にコピーすることで行います。古い位置 `[6][4]` は空白にします。

```js
const board = [
  ["R", "N", "B", "Q", "K", "B", "N", "R"],
  ["P", "P", "P", "P", "P", "P", "P", "P"],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  ["p", "p", "p", "p", "p", "p", "p", "p"],
  ["r", "n", "b", "q", "k", "b", "n", "r"],
];

console.log(`${board.join("\n")}\n\n`);

// キングの前のポーンを 2 つ前へ移動
board[4][4] = board[6][4];
board[6][4] = " ";
console.log(board.join("\n"));
```

出力を示します。
```

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , ,
 , , , , , , ,
 , , , , , , ,
 , , , , , , ,
p,p,p,p,p,p,p,p
r,n,b,q,k,b,n,r

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , ,
 , , , , , , ,
 , , , ,p, , ,
 , , , , , , ,
p,p,p,p, ,p,p,p
r,n,b,q,k,b,n,r
```

### 配列を使って値のセットを表にする

```js
const values = [];
for (let x = 0; x < 10; x++) {
  values.push([2 \*\* x, 2 \* x \*\* 2]);
}
console.table(values);
```

結果は次のようになります。
```

// 最初の列はインデックスです
0  1    0
1  2    2
2  4    8
3  8    18
4  16   32
5  32   50
6  64   72
7  128  98
8  256  128
9  512  162
```

### 照合結果を使用して配列を作成

正規表現 (`RegExp`) と文字列の照合結果から配列を生成することができます。この配列には、プロパティと、一致したものに関する情報を提供する要素を持ちます。このような配列は `RegExp.prototype.exec()` や `String.prototype.match()` から返されます。

例えば、次のようになります。

```js
// 1 文字の d と、続く 1 文字以上の b と、続く 1 文字の d に一致します
// 一致した b およびそれに続く d を記憶します
// 大文字小文字は区別しません

const myRe = /d(b+)(d)/i;
const execResult = myRe.exec("cdbBdbsbz");

console.log(execResult.input); // 'cdbBdbsbz'
console.log(execResult.index); // 1
console.log(execResult); // [ "dbBd", "bB", "d" ]
```

照合結果についての詳しい情報は、 `RegExp.prototype.exec()` および `String.prototype.match()` のページを参照してください。

仕様書
---

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

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

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

関連情報
----

* インデックス付きコレクションガイド
* `TypedArray`
* `ArrayBuffer`


Int32Array - JavaScript

Int32Array
==========

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

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

`Int32Array()`

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

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

`Int32Array.BYTES_PER_ELEMENT`

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

`Int32Array.name`

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

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

`Int32Array.from()`

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

`Int32Array.of()`

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

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

`Int32Array.prototype.buffer`

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

`Int32Array.prototype.byteLength`

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

`Int32Array.prototype.byteOffset`

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

`Int32Array.prototype.length`

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

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

`Int32Array.prototype.copyWithin()`

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

`Int32Array.prototype.entries()`

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

`Int32Array.prototype.every()`

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

`Int32Array.prototype.fill()`

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

`Int32Array.prototype.filter()`

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

`Int32Array.prototype.find()`

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

`Int32Array.prototype.findIndex()`

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

`Int32Array.prototype.forEach()`

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

`Int32Array.prototype.includes()`

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

`Int32Array.prototype.indexOf()`

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

`Int32Array.prototype.join()`

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

`Int32Array.prototype.keys()`

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

`Int32Array.prototype.lastIndexOf()`

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

`Int32Array.prototype.map()`

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

`Int32Array.prototype.reduce()`

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

`Int32Array.prototype.reduceRight()`

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

`Int32Array.prototype.reverse()`

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

`Int32Array.prototype.set()`

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

`Int32Array.prototype.slice()`

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

`Int32Array.prototype.some()`

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

`Int32Array.prototype.sort()`

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

`Int32Array.prototype.subarray()`

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

`Int32Array.prototype.values()`

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

`Int32Array.prototype.toLocaleString()`

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

`Int32Array.prototype.toString()`

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

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

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

例
-

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

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

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

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

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

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

仕様書
---

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

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

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

関連情報
----

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


undefined - JavaScript

undefined
=========

グローバルの **`undefined`** プロパティはプリミティブ値の `undefined` を表します。これは JavaScript におけるプリミティブ型の一つです。

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

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

構文
--

```js
undefined;
```

解説
--

`undefined` は、*グローバルオブジェクト*のプロパティです。すなわちグローバルスコープ内の変数です。 `undefined` の初期値はプリミティブ値である `undefined` です。

最近のブラウザー (JavaScript 1.8.5 / Firefox 4 以降) での `undefined` は、 ECMAScript 5 仕様により、設定不可、書込不可のプロパティとなります。 (そうでない場合でも、上書きは避けてください。)

まだ値が代入されていない変数は `undefined` 型となります。評価しようとしている変数に値が代入されていない場合、メソッドや文も `undefined` を返します。値を `return` しない関数も `undefined` を返します。

**メモ:** グローバルスコープ以外のスコープでは `undefined` を識別子 (変数名) として使うことができますが (`undefined` は予約語でないため)、コードの管理やデバッグが困難になるためおすすめできません。

```js
//こんなことはしないこと！

// "foo string" をログ出力する
(function () {
  var undefined = "foo";
  console.log(undefined, typeof undefined);
})();

// "foo string" をログ出力する
(function (undefined) {
  console.log(undefined, typeof undefined);
})("foo");
```

例
-

### 厳密等価と undefined

`undefined` と厳密等価・非等価演算子を使って、変数に値があるか調べることができます。次のコードでは、変数 `x` が定義されていないため、 `if` 文は true に評価されます。

```js
var x;
if (x === undefined) {
  // ここの文は実行される
} else {
  // ここの文は実行されない
}
```

**メモ:** ここでは、標準の等価演算子ではなく厳密等価演算子を使わないといけません。厳密等価演算子とは違い、 `x == undefined` は、 `x` が `null` であるかどうかもチェックするからです。 `null` は `undefined` と等しくありません。

詳しくは、比較演算子を参照してください。

### typeof 演算子と undefined

代わりに、 `typeof` を使用することができます。

```js
var x;
if (typeof x === "undefined") {
  // ここの文は実行される
}
```

`typeof` を使う理由の一つとして、こちらは変数が宣言されていなくてもエラーにはなりません。

```js
// 直前まで x は宣言されていない
if (typeof x === "undefined") {
  // エラーなしで true と評価される
  // ここの文は実行される
}

if (x === undefined) {
  // ReferenceError が発生
}
```

しかし、もう一つの選択肢があります。 JavaScript は静的にスコープされた言語なので、変数が宣言されているかどうかを知るには、それが含まれるコンテキストで宣言されているかどうかを見ることで読み取ることができます。

グローバルスコープはグローバルオブジェクトに結びつけられているので、グローバルコンテキストに変数が存在するかどうかのチェックは、*グローバルオブジェクト*にプロパティが存在することを、 `in` 演算子を使用してチェックすることで行うことができます。

```js
if ("x" in window) {
  // x がグローバルに定義されている場合のみ、ここの文を実行
}
```

### void 演算子と undefined

3 つ目の方法として、`void` 演算子があります。

```js
var x;
if (x === void 0) {
  // ここの文は実行される
}

// 直前まで y は宣言されていない
if (y === void 0) {
  // ReferenceError: y is not defined が発生
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-undefined |

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

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

関連情報
----

* JavaScript の プリミティブ型
* `null`


WeakMap - JavaScript

WeakMap
=======

**`WeakMap`** オブジェクトは、キーが弱く参照されるキーと値の組のコレクションです。キーはオブジェクトでなければならず、値は任意の値を取ることができます。

`WeakMap` については、 WeakMap オブジェクトのガイド (キー付きコレクション内) でより詳しく解説しています。

解説
--

WeakMap のキーは `Object` に限ります。プリミティブ型 はキーとして使えません（例えば `Symbol` は `WeakMap` のキーとして使えません）。

### なぜ *Weak*Map なのか?

map API は、4 つの API メソッドから共有される 2 つの配列 (1 つはキー用、もう 1 つは値用) を用いることで、JavaScript で実装*できます*。このマップに要素を設定すると、それぞれの配列の最後に同時にキーと値を追加することになります。その結果、両方の配列でキーと値のインデックスは対応がとれています。マップから値を取得するには、すべてのキーを操作して一致するものを見つけ、見つかったキーのインデックスを使用して値の配列から対応する値を取り出します。

そうした実装では、主に 2 つの不都合が生じることとなります。

1. 第一に、設定や探索の計算量が `O(n)` となること (*n* はマップ中におけるキーの数) で、どちらの操作も一致する値を見つけるためにキーのリストを反復しなければならないからです。
2. 第二の不都合は、配列が各キーと各値への参照を無期限に維持することを保証しているため、メモリリークが発生することです。これらの参照は、オブジェクトへの他の参照がない場合でも、キーがガベージコレクションされるのを防ぎます。これにより、対応する値がガベージコレクションされるのを防ぐことにもなります。

これに対して、ネイティブの `WeakMap` では、キーとなるオブジェクトに対しては"弱い"参照が保持されます。これにより、キーとなったオブジェクトへの参照が他に存在しない場合に、そのオブジェクトはガベージコレクションの対象に含まれるようになります。ネイティブの WeakMap はキーとそのキーに関する情報をマッピングする場合に、キーがガベージコレクションされていないときにだけ意味があるため特に有用な構造です。

**弱い参照を用いるため、`WeakMap` のキーは列挙できません。** キーの一覧を取得するメソッドは存在しません。もし、可能であれば、キーの一覧はガベージコレクションに依存することになり、非決定性が生まれます。キーの一覧が必要な場合は、`Map`を使うことになります。

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

`WeakMap()`

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

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

`WeakMap.prototype.delete(key)`

`key` に関連した値を削除します。その後 `WeakMap.prototype.has(key)` は `false` を返します。

`WeakMap.prototype.get(key)`

`key` に関連した値を返します。見つからない場合、`undefined` を返します。

`WeakMap.prototype.has(key)`

`WeakMap` オブジェクト内に `key` に関連した値があるかどうか示す Boolean を返します。

`WeakMap.prototype.set(key, value)`

`WeakMap` オブジェクト内に `key` に対する値を設定し、`WeakMap` オブジェクトを返します。

例
-

### WeakMap の使用

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

wm1.set(o1, 37);
wm1.set(o2, "azerty");
wm2.set(o1, o2); // 値は（オブジェクトまたは関数を含む）何であってもかまいません
wm2.set(o3, undefined);
wm2.set(wm1, wm2); // キーも値もどんなオブジェクトでもかまいません。 WeakMap であってもよいのです！

wm1.get(o2); // "azerty"
wm2.get(o2); // wm2 には o2 に関連付けられた値が無い為、undefined が返ってきます
wm2.get(o3); // 値が undefined と関連付けられている為、undefined が返ってきます

wm1.has(o2); // true
wm2.has(o2); // false
wm2.has(o3); // true (値が関連付けられているならば、たとえ値が 'undefined' であっても true となります)

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

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

### .clear() メソッドを持つ WeakMap 風のクラスの実装

```js
class ClearableWeakMap {
  constructor(init) {
    this._wm = new WeakMap(init);
  }
  clear() {
    this._wm = new WeakMap();
  }
  delete(k) {
    return this._wm.delete(k);
  }
  get(k) {
    return this._wm.get(k);
  }
  has(k) {
    return this._wm.has(k);
  }
  set(k, v) {
    this._wm.set(k, v);
    return this;
  }
}
```

仕様書
---

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

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

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

関連情報
----

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


Uint32Array - JavaScript

Uint32Array
===========

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

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

`Uint32Array()`

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

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

`Uint32Array.BYTES_PER_ELEMENT`

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

`Uint32Array.name`

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

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

`Uint32Array.from()`

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

`Uint32Array.of()`

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

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

`Uint32Array.prototype.buffer`

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

`Uint32Array.prototype.byteLength`

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

`Uint32Array.prototype.byteOffset`

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

`Uint32Array.prototype.length`

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

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

`Uint32Array.prototype.copyWithin()`

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

`Uint32Array.prototype.entries()`

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

`Uint32Array.prototype.every()`

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

`Uint32Array.prototype.fill()`

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

`Uint32Array.prototype.filter()`

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

`Uint32Array.prototype.find()`

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

`Uint32Array.prototype.findIndex()`

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

`Uint32Array.prototype.forEach()`

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

`Uint32Array.prototype.includes()`

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

`Uint32Array.prototype.indexOf()`

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

`Uint32Array.prototype.join()`

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

`Uint32Array.prototype.keys()`

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

`Uint32Array.prototype.lastIndexOf()`

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

`Uint32Array.prototype.map()`

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

`Uint32Array.prototype.reduce()`

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

`Uint32Array.prototype.reduceRight()`

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

`Uint32Array.prototype.reverse()`

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

`Uint32Array.prototype.set()`

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

`Uint32Array.prototype.slice()`

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

`Uint32Array.prototype.some()`

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

`Uint32Array.prototype.sort()`

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

`Uint32Array.prototype.subarray()`

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

`Uint32Array.prototype.values()`

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

`Uint32Array.prototype.toLocaleString()`

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

`Uint32Array.prototype.toString()`

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

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

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

例
-

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

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

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

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

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

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

仕様書
---

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

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

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

関連情報
----

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


parseFloat() - JavaScript

parseFloat()
============

**`parseFloat()`** 関数は、引数を (必要に応じてまず文字列に変換してから) 解釈し、浮動小数点値を返します。

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

構文
--
```

parseFloat(string)
```

### 引数

`string`

解釈する値。この引数が文字列でない場合、抽象操作 `ToString` を用いて文字列に変換されます。この引数では先頭のホワイトスペースは無視されます。

### 返値

指定された `string` を解釈した浮動小数点値です。

または、最初のホワイトスペース以外の文字が数値に変換できなかった場合は `NaN` です。

解説
--

`parseFloat` は最上位関数であり、どのオブジェクトのメソッドでもありません。

* `parseFloat` が正の符号 (`+`)、負の符号 (`-` U+002D HYPHEN-MINUS)、数値 (`0`–`9`)、小数点 (`.`)、指数記号 (`e` または `E`) 以外の文字に遭遇したら、その文字の前までの値を返し、無効な文字とそれ以降の文字を無視します。
* *2 番目*の小数点に遭遇した場合も、解析を停止します (その位置より前までの文字は解析されます)。
* 引数にある前後の空白は無視されます。
* 引数の最初の文字が数値に変換できない場合 (上記のいずれでもない場合), `parseFloat` は `NaN` を返します。
* `parseFloat` は `Infinity` を解析し、返すことができます。
* `parseFloat` は `BigInt` の構文を `Numbers` に変換し、精度は下がります。これは最後の `n` の文字が破棄されるからです。

より厳密な構文解析には `Number(value)` を検討してください。これは、引数のどこかに無効な文字があると `NaN` に変換します。

`parseFloat` は `toString` または `valueOf` メソッドが定義されているオブジェクトを解析することもできます。返値は `parseFloat` がこれらのメソッドの返値で呼び出された場合と同じです。

例
-

### 数値を返す `parseFloat`

以下の例はすべて `3.14` を返します。

```js
parseFloat(3.14);
parseFloat("3.14");
parseFloat(" 3.14 ");
parseFloat("314e-2");
parseFloat("0.0314E+2");
parseFloat("3.14some non-digit characters");
parseFloat({
  toString: function () {
    return "3.14";
  },
});
```

### `NaN` を返す `parseFloat`

以下の例は `NaN` を返します。

```js
parseFloat("FF2");
```

### `parseFloat` と `BigInt`

以下の例はどちらも `900719925474099300` を返します。 float として表現できないほど整数が大きいので、精度が失われます。

```js
parseFloat(900719925474099267n);
parseFloat("900719925474099267n");
```

仕様書
---

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

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

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

関連情報
----

* `parseInt()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `Number.toFixed()`
* `isNaN()`


BigUint64Array - JavaScript

BigUint64Array
==============

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

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

`BigUint64Array()`

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

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

`BigUint64Array.BYTES_PER_ELEMENT`

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

`BigUint64Array.name`

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

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

`BigUint64Array.from()`

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

`BigUint64Array.of()`

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

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

`BigUint64Array.prototype.buffer`

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

`BigUint64Array.prototype.byteLength`

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

`BigUint64Array.prototype.byteOffset`

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

`BigUint64Array.prototype.length`

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

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

`BigUint64Array.prototype.copyWithin()`

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

`BigUint64Array.prototype.entries()`

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

`BigUint64Array.prototype.every()`

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

`BigUint64Array.prototype.fill()`

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

`BigUint64Array.prototype.filter()`

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

`BigUint64Array.prototype.find()`

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

`BigUint64Array.prototype.findIndex()`

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

`BigUint64Array.prototype.forEach()`

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

`BigUint64Array.prototype.includes()`

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

`BigUint64Array.prototype.indexOf()`

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

`BigUint64Array.prototype.join()`

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

`BigUint64Array.prototype.keys()`

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

`BigUint64Array.prototype.lastIndexOf()`

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

`BigUint64Array.prototype.map()`

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

`BigUint64Array.prototype.reduce()`

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

`BigUint64Array.prototype.reduceRight()`

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

`BigUint64Array.prototype.reverse()`

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

`BigUint64Array.prototype.set()`

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

`BigUint64Array.prototype.slice()`

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

`BigUint64Array.prototype.some()`

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

`BigUint64Array.prototype.sort()`

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

`BigUint64Array.prototype.subarray()`

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

`BigUint64Array.prototype.values()`

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

`BigUint64Array.prototype.toLocaleString()`

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

`BigUint64Array.prototype.toString()`

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

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

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

例
-

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

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

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

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

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

// 反復可能オブジェクトから
var iterable = (function\* () {
  yield\* [1n, 2n, 3n];
})();
var biguint64 = new BigUint64Array(iterable);
// BigUint64Array[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 の型付き配列
* `BigInt64Array`
* `DataView`