recursal/MDN huggingface dataset:
SyntaxError: missing ] after element list
=========================================

JavaScript の例外 "missing ] after element list" は、配列の初期化構文のどこかにエラーがあった場合に発生します。閉じ括弧 ("`]`") やカンマ ("`,`") が抜けている可能性があります。

メッセージ
-----


```js
SyntaxError: missing ] after element list
```

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

`SyntaxError`。

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

どこかに配列初期化構文のエラーがあります。閉じ括弧 ("`]`") かカンマ ("`,`") が不足している可能性があります。

例
-

### 不完全な配列の初期化


```js
var list = [1, 2,

var instruments = [
  'Ukulele',
  'Guitar',
  'Piano'
};

var data = [{foo: 'bar'} {bar: 'foo'}];
```


修正すると次のようになります。


```js
var list = [1, 2];

var instruments = ["Ukulele", "Guitar", "Piano"];

var data = [{ foo: "bar" }, { bar: "foo" }];
```

関連情報
----

* `Array`
SyntaxError: test for equality (==) mistyped as assignment (=)?
===============================================================

JavaScript の警告 "test for equality (==) mistyped as assignment (=)?" は、代入 (`=`) が通常は等価性 (`==`) の検査をすべき場面にあった場合に発生します。

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


```js
Warning: SyntaxError: test for equality (==) mistyped as assignment (=)?
```

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

(Firefox のみ) `SyntaxError` の警告であり、 `javascript.options.strict` の設定が `true` に設定されていた場合に発生します。

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

代入 (`=`) が通常は等価性 (`==`) の検査をすべき場面にあった場合に発生します。デバッグを行いやすくするために、 JavaScript は (厳密な警告が有効な場合は) このパターンについて警告を出します。

例
-

### 条件式内での代入

(`if...else` のような) 条件式内では、単純な代入を行わないことをお勧めします。コードを一目見たときに、代入は等価と混同しやすいからです。たとえば、以下のコードは使用しないでください。


```js
if (x = y) {
  // 正しいことを実行する
}
```


条件式内で代入を行う必要がある場合、一般的には次のように、代入の周りに追加の括弧を置きます。


```js
if ((x = y)) {
  // 正しいことを実行する
}
```


または、本当は比較演算子 (`==` や `===` など) を使用しようとしたのかもしれません。


```js
if (x == y) {
  // 正しいことを実行する
}
```

関連項目
----

* `if...else`
* 等値演算子
TypeError: 'x' is not iterable
==============================

JavaScript の例外 "is not iterable" は、 for…of の右辺として与えられた値や、 `Promise.all` または `TypedArray.from` のような関数の引数として与えられた値が反復可能オブジェクトではなかった場合に発生します。

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


```js
TypeError: 'x' is not iterable (Firefox, Chrome)
TypeError: 'x' is not a function or its return value is not iterable (Chrome)
```

エラー種別
-----

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

for…of の右辺、 `Promise.all` や `TypedArray.from` などの引数として指定された値が反復可能オブジェクトではありません。反復可能なものは、`Array`、`String`、`Map` 等のような組み込み反復可能型や、ジェネレーターの結果、反復可能プロトコルを実装しているオブジェクトが成ることができます。

例
-

### オブジェクトのプロパティの反復処理

JavaScript では、 `Object` は反復可能プロトコルを実装していない限り反復処理できません。したがって、オブジェクトのプロパティを反復処理するために for…of を使用することはできません。


```js
var obj = { France: "Paris", England: "London" };
for (let p of obj) {
  // TypeError: obj is not iterable
  // …
}
```


代わりに、オブジェクトのプロパティを反復処理するためには `Object.keys` か `Object.entries` を使用してください。


```js
var obj = { France: "Paris", England: "London" };
// Iterate over the property names:
for (let country of Object.keys(obj)) {
  var capital = obj[country];
  console.log(country, capital);
}

for (const [country, capital] of Object.entries(obj))
  console.log(country, capital);
```


この使用例のそのほかの選択肢として、`Map` を使用することもできます。


```js
var map = new Map();
map.set("France", "Paris");
map.set("England", "London");
// Iterate over the property names:
for (let country of map.keys()) {
  let capital = map[country];
  console.log(country, capital);
}

for (let capital of map.values()) console.log(capital);

for (const [country, capital] of map.entries()) console.log(country, capital);
```

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

ジェネレーターは反復可能オブジェクトを生成するために呼び出す関数です。


```js
function\* generate(a, b) {
  yield a;
  yield b;
}

for (let x of generate) // TypeError: generate is not iterable
  console.log(x);
```


ジェネレーターを呼び出していないとき、ジェネレーターに対応した `Function` オブジェクトは呼び出し可能ですが、反復処理はできません。ジェネレーターを呼び出すと、ジェネレーターの実行中に生成された値を反復処理する反復可能オブジェクトが生成されます。


```js
function\* generate(a, b) {
  yield a;
  yield b;
}

for (let x of generate(1, 2)) console.log(x);
```

### 独自の反復可能オブジェクトでの反復処理

独自の反復可能オブジェクトは、 `Symbol.iterator` メソッドを実装することで作成することができます。 iterator メソッドはイテレーターであるオブジェクト、すなわち next メソッドを返す必要があります。


```js
const myEmptyIterable = {
  [Symbol.iterator]() {
    return []; // [] は反復可能ですが、イテレーターではありません。 -- next メソッドがないからです。
  },
};

Array.from(myEmptyIterable); // TypeError: myEmptyIterable is not iterable
```


こちらは正しい実装です。


```js
const myEmptyIterable = {
  [Symbol.iterator]() {
    return [][Symbol.iterator]();
  },
};

Array.from(myEmptyIterable); // []
```

関連情報
----

* 反復可能プロトコル
* `Object.keys`
* `Object.entries`
* `Map`
* ジェネレーター
* for…of
SyntaxError: missing = in const declaration
===========================================

JavaScript の例外 "missing = in const declaration" は、 const 宣言が同じ文内で値を与えられなかった場合 (`const RED_FLAG;` など) に発生します。値を設定する必要があります (`const RED_FLAG = '#ff0'`)。

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


```js
SyntaxError: Const must be initialized (Edge)
SyntaxError: missing = in const declaration (Firefox)
SyntaxError: Missing initializer in const declaration (Chrome)
```

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

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

定数は、通常の実行中にプログラムによって変更できない値です。これは、再代入で変更できず、再宣言もできません。 JavaScript では、定数は `const` キーワードで宣言します。定数の初期化子が必要です。つまり、宣言と同じ文で値を指定する必要があります (後で変更できないため、これには意味があります)。

例
-

### 定数の初期化子忘れ

`var` や `let` と異なり、`const` 宣言では値を指定する必要があります。エラーが発生する例です。


```js
const COLUMNS;
// SyntaxError: missing = in const declaration
```

### エラーの修正

このエラーを修正するには、複数の方法があります。定数で何をしようとしていたかを確認してください。

#### 定数値を追加する

宣言と同じ文で定数の値を指定します。


```js
const COLUMNS = 80;
```


#### `const` か `let` か `var` か

定数を宣言したいわけではない場合、`const` を使用しないでください。ブロックスコープの変数を `let` で宣言したいか、グローバル変数を `var` で宣言したいのかもしれません。双方ともに、初期値を必要としません。


```js
let columns;
```

関連項目
----

* `const`
* `let`
* `var`
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 の例外 "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 の例外 "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 の例外 "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 の例外 "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 の例外 "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 の警告 "-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
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 の例外 "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 の例外 "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 の例外 "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 の 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 の例外 "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 でエンコードしてからリカバリーできます。