recursal/MDN huggingface dataset:
SyntaxError: illegal character
==============================

JavaScript の例外 "illegal character" は、コード内のこの位置に属していない、無効または予期しないトークンがあった場合に発生します。

メッセージ
-----


```js
SyntaxError: Invalid character (Edge)
SyntaxError: illegal character (Firefox)
SyntaxError: Invalid or unexpected token (Chrome)
```

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

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

コードのこの位置に属していない、無効なトークンまたは予期しないトークンがあります。構文強調機能のあるエディターを使用して、マイナス記号 (`-`) とダッシュ (`–`) や、単純な引用符 (`"`) と標準外の引用符 (`“`) のようなミスがないか、コードを注意深くチェックしてください。

例
-

### 合わない文字

似たような文字でも、パーサーがコードの解釈に失敗するものがあります。有名な例としては、引用符、マイナス、セミコロンなどがあります (ギリシャ文字の疑問符 (U+37e) も同様です)。


```js
“This looks like a string”;  // SyntaxError: illegal character
                             // “ と ” は " ではありませんが、見た目が似ています

42 – 13;                     // SyntaxError: illegal character
                             // – は - ではありませんが、見た目が似ています

var foo = 'bar';             // SyntaxError: illegal character
                             // <37e> は ; ではありませんが、見た目が似ています
```


次のものは動作します。


```js
"This is actually a string";
42 - 13;
var foo = "bar";
```


エディターや IDE の中には、その旨を通知してくれたり、少なくとも若干異なる強調表示をしてくれるものもありますが、すべてではありません。自分のコードにこのようなことが起こり、問題の原因がわからない場合は、問題のある行を削除して再入力するのが最善の方法です。

### 文字の入れ忘れ

あちこちで文字を入れ忘れることがあります。


```js
var colors = ['#000', #333', '#666'];
// SyntaxError: illegal character
```


`'#333'` に付け忘れている引用符を追加してください。


```js
var colors = ["#000", "#333", "#666"];
```

### 隠れた文字

外部のソースをコピー＆ペーストすると、不正な文字が含まれていることがあります。気を付けて!


```js
var foo = "bar";
// SyntaxError: illegal character
```


Vim のようなエディターでこのコードを調査すると、実際には zero-width space (ZWSP) (U+200B) 文字があることが分かります。


```js
var foo = 'bar';<200b>
```

関連項目
----

* 字句文法
ReferenceError: invalid assignment left-hand side
=================================================

JavaScript の例外 "invalid assignment left-hand side" は、どこかで予想外の代入が行われたときに発生します。例えば、単一の "`=`" の記号が "`==`" や "`===`" の代わりに使用された場合です。

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


```js
ReferenceError: invalid assignment left-hand side
```

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

`ReferenceError`。

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

どこかに予想外の代入があります。たとえば、代入演算子と等値演算子が合っていないからかもしれません。 "`=`" 記号が 1 つの場合は変数に値を割り当てる一方、"`==`" か "`===`" 演算子は値を比較します。

例
-

### よくある無効な代入


```js
if (Math.PI = 3 || Math.PI = 4) {
  console.log('no way!');
}
// ReferenceError: invalid assignment left-hand side

var str = 'Hello, '
+= 'is it me '
+= 'you\'re looking for?';
// ReferenceError: invalid assignment left-hand side
```


`if` 文では、等価演算子 ("==") が必要ですし、文字連結にはプラス ("+") 演算子が必要です。


```js
if (Math.PI == 3 || Math.PI == 4) {
  console.log("no way!");
}

var str = "Hello, " + "from the " + "other side!";
```

関連項目
----

* 代入演算子
* 等値演算子
SyntaxError: redeclaration of formal parameter "x"
==================================================

JavaScript の例外 "redeclaration of formal parameter" は、関数の引数名としてある変数名が発生した後、関数本体内の `let` 代入文を使用して同じ変数名を再度宣言すると発生します。

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


```js
SyntaxError: Let/Const redeclaration (Edge)
SyntaxError: redeclaration of formal parameter "x" (Firefox)
SyntaxError: Identifier "x" has already been declared (Chrome)
```

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

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

関数の引数と同名の変数があり、関数内で再度 `let` 代入文を使用して再宣言しています。 JavaScript では、同じ関数内やブロックスコープ内で `let` を使用して同じ変数を再宣言できません。

例
-

### 再宣言した引数

この場合、変数 "arg" は、引数を再宣言しています。


```js
function f(arg) {
  let arg = "foo";
}

// SyntaxError: redeclaration of formal parameter "arg"
```


関数の本体内で "arg" の値を変更したい場合、これを行うことはできますが、再び同じ変数を宣言する必要はありません。言い換えれば、 `let` キーワードを省略することができます。新しい変数を生成する場合は、既存の関数の引数と競合するので、変数名を変更する必要があります。


```js
function f(arg) {
  arg = "foo";
}

function f(arg) {
  let bar = "foo";
}
```

関連情報
----

* `let`
* `const`
* `var`
* JavaScript ガイド 内の 宣言
InternalError: too much recursion
=================================

JavaScript の例外である "too much recursion" または "Maximum call stack size exceeded" は、関数の呼び出しが多すぎる場合や、関数に基礎ケースがない場合に発生します。

メッセージ
-----


```js
Error: Out of stack space (Edge)
InternalError: too much recursion (Firefox)
RangeError: Maximum call stack size exceeded (Chrome)
```

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

`InternalError`。

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

自分自身を呼び出す関数は*再帰関数*と呼ばれます。ある条件を満たすと、関数は自分自身を呼び出すのをやめます。これは*基礎ケース*と呼ばれます。

いくつかの点で、再帰はループに似ています。両方とも、同じコードを複数回実行し、 (無限ループまたは無限再帰を避けるために) 条件を必要とします。関数の再帰呼び出しが深すぎる場合、または関数が基礎ケースを欠いている場合、 JavaScript はこのエラーを発生します。

例
-

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


```js
function loop(x) {
  if (x >= 10) {
    // "x >= 10" は終了条件
    return;
  }
  // 何かを実行
  loop(x + 1); // 再帰呼び出し
}
loop(0);
```


この条件に、非常に大きい値を設定すると動作しません。


```js
function loop(x) {
  if (x >= 1000000000000) return;
  // 何かを実行
  loop(x + 1);
}
loop(0);

// InternalError: too much recursion
```


この再帰関数は基礎ケースを欠いています。脱出条件がないため、この関数は自分自身を無限に呼び出し続けます。


```js
function loop(x) {
  // The base case is missing

  loop(x + 1); // 再帰呼び出し
}

loop(0);

// InternalError: too much recursion
```

### Class error: too much recursion


```js
class Person {
  constructor() {}
  set name(name) {
    this.name = name; // 再帰呼び出し
  }
}

const tony = new Person();
tony.name = "Tonisha"; // InternalError: too much recursion
```


値がプロパティ name に代入されるとき (this.name = name;) JavaScript はプロパティを設定する必要があります。これが発生すると、セッター関数が呼び出されます。


```js
set name(name){
  this.name = name; // 再帰呼び出し
}
```


**メモ:** この例では、セッターが呼び出されたとき、同じことを再度行うように指示されます。\*つまり、処理しているのと同じプロパティに設定します。\*これにより、関数は何度も何度も自分自身を呼び出し、無限に再帰が行われます。

この問題は同じ変数がゲッターに使用される場合にも発生します。


```js
get name(){
  return this.name; // 再帰呼び出し
}
```


この問題を防ぐには、セッター関数の内部で代入しようとしているプロパティが、もともとセッターを起動したものと異なっていることを確認してください。同じことがゲッターにも言えます。


```js
class Person {
  constructor() {}
  set name(name) {
    this._name = name;
  }
  get name() {
    return this._name;
  }
}
const tony = new Person();
tony.name = "Tonisha";
console.log(tony);
```

関連情報
----

* 再帰
* 再帰関数
TypeError: "x" is read-only
===========================

JavaScript の strict モードのみの例外 "is read-only" は、代入されたグローバル変数またはオブジェクトプロパティが読み取り専用プロパティであった場合に発生します。

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


```js
TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)
TypeError: "x" is read-only (Firefox)
TypeError: 0 is read-only (Firefox)
TypeError: Cannot assign to read only property 'x' of #<Object> (Chrome)
TypeError: Cannot assign to read only property '0' of [object Array] (Chrome)
```

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

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

代入しようとしたグローバル変数、またはオブジェクトのプロパティが読み取り専用プロパティです。 (技術的には、 non-writable データプロパティです。)

このエラーは、 strict モードのコードにだけ発生します。 strict コードではない場合、割り当ては無視されるだけです。

例
-

### 無効な場合

読み取り専用プロパティはさほど一般的ではありませんが、 `Object.defineProperty()`、または `Object.freeze()` を使用して生成することができます。


```js
"use strict";
var obj = Object.freeze({ name: "Elsa", score: 157 });
obj.score = 0; // TypeError

("use strict");
Object.defineProperty(this, "LUNG\_COUNT", { value: 2, writable: false });
LUNG\_COUNT = 3; // TypeError

("use strict");
var frozenArray = Object.freeze([0, 1, 2]);
frozenArray[0]++; // TypeError
```


JavaScript の組み込みにも、いくつか読み取り専用プロパティがあります。数学的な定数を再定義しようとしたとします。


```js
"use strict";
Math.PI = 4; // TypeError
```


残念ながらできません。

グローバル変数の `undefined` も読み取り専用のため、このようにすると悪名高い "undefined is not a function" エラーが発生します。


```js
"use strict";
undefined = function () {}; // TypeError: "undefined" is read-only
```

### 有効な場合


```js
"use strict";
var obj = Object.freeze({ name: "Score", points: 157 });
obj = { name: obj.name, points: 0 }; // 新しいオブジェクトで置き換える

("use strict");
var LUNG\_COUNT = 2; // `var` が使われているので、読み取り専用ではない
LUNG\_COUNT = 3; // ok (解剖学的にはおかしいけれども)
```

関連情報
----

* `Object.defineProperty()`
* `Object.freeze()`
SyntaxError: applying the 'delete' operator to an unqualified name is deprecated
================================================================================

JavaScript の strict モード専用の例外 "applying the 'delete' operator to an unqualified name is deprecated" は、 `delete` 演算子を用いて変数を削除しようとしたときに発生します。

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


```js
SyntaxError: Calling delete on expression not allowed in strict mode (Edge)
SyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox)
SyntaxError: Delete of an unqualified identifier in strict mode. (Chrome)
```

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

strict モード でのみ `SyntaxError`。

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

JavaScript では、通常の変数を `delete` 演算子で削除できません。strict モードで、変数を削除しようとするとエラーが発生し、削除できません。

`delete` 演算子は、オブジェクトのプロパティのみ削除できます。オブジェクトプロパティは、設定可能な場合は "修飾" されます。

よくある予想とは異なり、 `delete` 演算子は直接的なメモリーの解放とは**関係ありません**。メモリー管理は、参照の解放によって間接的に行われます。メモリー管理ページと `delete` 演算子ページで詳細を確認してください。

このエラーは、strict mode モードでのみ発生します。非 strict モードでは、演算子はただ `false` を返します。

例
-

### 変数の内容の解放

JavaScript ではプレーンな変数を削除しようとすると動作せず、 strict モードだとエラーをスローします。


```js
"use strict";

var x;

// ...

delete x;

// SyntaxError: applying the 'delete' operator to an unqualified name
// is deprecated
```


変数のコンテンツを解放するには、`null` を設定してください。


```js
"use strict";

var x;

// ...

x = null;

// x can be garbage collected
```

関連項目
----

* `delete`
* メモリー管理
* TypeError: property "x" is non-configurable and can't be deleted
TypeError: setting getter-only property "x"
===========================================

JavaScript の strict モード専用の例外 "setting getter-only property" は、ゲッターのみが定義されているプロパティに新しい値を設定しようとした時に発生します。

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


```js
TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)
TypeError: setting getter-only property "x" (Firefox)
TypeError: Cannot set property "prop" of #<Object> which has only a getter (Chrome)
```

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

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

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

ゲッターのみが定義されているプロパティに、新しい値を設定しようとしています。非 strict モードでは暗黙裡に無視されるだけですが、 strict モードでは `TypeError` が発生します。

例
-

### セッターのないプロパティ

下記の例では、プロパティのゲッターの設定方法を示しています。セッターを指定していないため、 `temperature` プロパティに `30` を設定しようとすると、`TypeError` が発生します。詳細は `Object.defineProperty()` ページを見てください。


```js
"use strict";

function Archiver() {
  var temperature = null;
  Object.defineProperty(this, "temperature", {
    get: function () {
      console.log("get!");
      return temperature;
    },
  });
}

var arc = new Archiver();
arc.temperature; // 'get!'

arc.temperature = 30;
// TypeError: setting getter-only property "temperature"
```


このエラーを修正するには、 temperature プロパティに値を設定しようとしている 16 行目を取り除くか、次のようにセッターを実装します。


```js
"use strict";

function Archiver() {
  var temperature = null;
  var archive = [];

  Object.defineProperty(this, "temperature", {
    get: function () {
      console.log("get!");
      return temperature;
    },
    set: function (value) {
      temperature = value;
      archive.push({ val: temperature });
    },
  });

  this.getArchive = function () {
    return archive;
  };
}

var arc = new Archiver();
arc.temperature; // 'get!'
arc.temperature = 11;
arc.temperature = 13;
arc.getArchive(); // [{ val: 11 }, { val: 13 }]
```

関連項目
----

* `Object.defineProperty()`
* `Object.defineProperties()`
TypeError: "x" has no properties
================================

JavaScript の例外 "null (or undefined) has no properties" は、 `null` および `undefined` のプロパティにアクセスしようとしたときに発生します。これらはプロパティを何も持ちません。

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


```js
TypeError: Unable to get property {x} of undefined or null reference (Edge)
TypeError: null has no properties (Firefox)
TypeError: undefined has no properties (Firefox)
```

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

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

`null` と `undefined` に、アクセス可能なプロパティはありません。

例
-

### null と undefined にはプロパティがない


```js
null.foo;
// TypeError: null has no properties

undefined.bar;
// TypeError: undefined has no properties
```

関連項目
----

* `null`
* `undefined`
SyntaxError: missing } after function body
==========================================

JavaScript の例外 "missing } after function body" は、どこかで関数を作成するときに構文の間違いがある場合に発生します。閉じる中括弧や括弧が正しい順序で並んでいるか確認してください。

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


```js
SyntaxError: Expected '}' (Edge)
SyntaxError: missing } after function body (Firefox)
```

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

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

どこかで関数を生成するときに、構文上のミスをしています。また、括弧や中括弧の閉じが正しい順番かどうかを確認してください。コードをフォーマットしたり、インデントしたりすると、ジャングルを探すのに役立つと思います。

例
-

### 閉じ括弧忘れ

しばしば、関数コードで閉じ括弧を忘れることがあります。


```js
var charge = function() {
  if (sunny) {
    useSolarCells();
  } else {
    promptBikeRide();
};
```


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


```js
var charge = function () {
  if (sunny) {
    useSolarCells();
  } else {
    promptBikeRide();
  }
};
```


たとえば、 IIFE やクロージャ、そのほかのたくさんの中括弧や括弧を使用する構造を使用しているときは、さらに分かりにくくなります。


```js
(function() { if (true) { return false; } );
```


多くの場合、インデントを変えるか、インデントをダブルチェックすると、これらのエラーを特定するのに役立ちます。


```js
(function () {
  if (true) {
    return false;
  }
});
```

関連項目
----

* 関数
TypeError: "x" is not a non-null object
=======================================

JavaScript の例外 "is not a non-null object" は、ある場所でオブジェクトが期待されているのに提供されなかった場合に発生します。 `null` はオブジェクトではなく、動作しません。

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


```js
TypeError: Invalid descriptor for property {x} (Edge)
TypeError: "x" is not a non-null object (Firefox)
TypeError: Property description must be an object: "x" (Chrome)
TypeError: Invalid value used in weak set (Chrome)
```

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

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

ある場所でオブジェクトが期待されていますが、提供されませんでした。 `null` はオブジェクトではなく、動作しません。与えられた状況で適切なオブジェクトを提供しなければなりません。

例
-

プロパティ記述子が求められている場合
------------------

`Object.create()` メソッドや `Object.defineProperty()` メソッド、`Object.defineProperties()` メソッドを使用するとき、省略可能な記述子の引数として、プロパティ記述子オブジェクトが想定されます。 (ただの数値など) オブジェクト以外のものを提供すると、エラーが発生します。


```js
Object.defineProperty({}, "key", 1);
// TypeError: 1 is not a non-null object

Object.defineProperty({}, "key", null);
// TypeError: null is not a non-null object
```


有効なプロパティ記述子はこのようになります。


```js
Object.defineProperty({}, "key", { value: "foo", writable: false });
```

`WeakMap` および `WeakSet` オブジェクトにはオブジェクトキーが必要
-------------------------------------------

`WeakMap` および `WeakSet` オブジェクトはオブジェクトをキーとして保持します。そのほかの型をキーとして使用できません。


```js
var ws = new WeakSet();
ws.add("foo");
// TypeError: "foo" is not a non-null object
```


代わりにオブジェクトを使用してください。


```js
ws.add({ foo: "bar" });
ws.add(window);
```

関連項目
----

* `Object.create()`
* `Object.defineProperty()`, `Object.defineProperties()`
* `WeakMap`, `WeakSet`
ReferenceError: reference to undefined property "x"
===================================================

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

ReferenceError: reference to undefined property "x" (Firefox)
```

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

strict モード でのみ、`ReferenceError` の警告が出ます。

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

存在しないオブジェクトのプロパティにアクセスしようとしています。プロパティにアクセスする方法は 2 つあります。詳細については、メンバー演算子参照ページを見てください。

未定義プロパティを参照することによるエラーは、strict モードのコードでのみ発生します。非 strict コードでは、暗黙的に無視されます。

例
-

### 無効なケース

このケースでは、"bar" は未定義のプロパティです。


```js
"use strict";

var foo = {};
foo.bar; // ReferenceError: reference to undefined property "bar"
```

### 有効なケース

エラーを避けるには、"bar" プロパティを定義するか、使用する前に "bar" プロパティが存在するか確認する必要があります（たとえば、`Object.prototype.hasOwnProperty()` メソッドを使用します）。


```js
"use strict";

var foo = {};

foo.bar = "moon";
console.log(foo.bar); // "moon"

if (foo.hasOwnProperty("bar") {
  console.log(foo.bar);
}
```

関連項目
----

* Strict モード
TypeError: "x" is (not) "y"
===========================

JavaScript の例外 "*x* is (not) *y*" は、予期しない型があったときに発生します。よくあるのは、予期せず `undefined` または `null` の値があった場合です。

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


```js
TypeError: Unable to get property {x} of undefined or null reference (Edge)
TypeError: "x" is (not) "y" (Firefox)

例:
TypeError: "x" is undefined
TypeError: "x" is null
TypeError: "undefined" is not an object
TypeError: "x" is not an object or null
TypeError: "x" is not a symbol
```

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

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

予期しない型がありました。これは `undefined` または `null` の値でしばしば発生します。

また、`Object.create()` や `Symbol.keyFor()` のようなある種のメソッドは、特定の型を要求し、それを提供する必要があります。

例
-

### 無効な場合


```js
// undefined と null の場合、substring メソッドは動作しません。
var foo = undefined;
foo.substring(1); // TypeError: foo is undefined

var foo = null;
foo.substring(1); // TypeError: foo is null

// ある種のメソッドでは、特定の型が求められることがあります。
var foo = {};
Symbol.keyFor(foo); // TypeError: foo is not a symbol

var foo = "bar";
Object.create(foo); // TypeError: "foo" is not an object or null
```

### 問題の修正

null ポインターを `undefined` 値に修正するには、次のように typeof 演算子を用いて行うことができます。


```js
if (foo !== undefined) {
  // これで、 foo が定義されていることがわかるので、実行することができます。
}

if (typeof foo !== "undefined") {
  // 同じというのは良い考えですが、この実装を使わないでください。 - 本当の
  // undefined の値と未宣言の変数が混同されて問題が発生する可能性があります。
}
```

関連情報
----

* `undefined`
* `null`
RangeError: argument is not a valid code point
==============================================

JavaScript の例外 "Invalid code point" は、 `NaN` 値、負の整数 (-1)、 整数以外 (5.4)、 0x10FFFF より大きい数 (1114111) が `String.fromCodePoint()` で使用された場合に発生します。

メッセージ
-----


```js
RangeError: {0} is not a valid code point (Firefox)
RangeError: Invalid code point {0} (Chromium)
```

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

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

`String.fromCodePoint()` は、 `NaN` 値、負の整数 (-1)、 整数以外 (5.4)、 0x10FFFF より大きい数 (1114111) が渡されるとこのエラーを発生します。

コードポイントは、 Unicode 文字集合の値です。これは整数 `0` から `0x10FFFF` までの範囲です。

例
-

### 無効なケース


```js
String.fromCodePoint("\_"); // RangeError
String.fromCodePoint(Infinity); // RangeError
String.fromCodePoint(-1); // RangeError
String.fromCodePoint(3.14); // RangeError
String.fromCodePoint(3e-2); // RangeError
String.fromCodePoint(NaN); // RangeError
```

### 有効な場合


```js
String.fromCodePoint(42); // "\*"
String.fromCodePoint(65, 90); // "AZ"
String.fromCodePoint(0x404); // "\u0404"
String.fromCodePoint(0x2f804); // "\uD87E\uDC04"
String.fromCodePoint(194564); // "\uD87E\uDC04"
String.fromCodePoint(0x1d306, 0x61, 0x1d307); // "\uD834\uDF06a\uD834\uDF07"
```

関連情報
----

* `String.fromCodePoint()`
ReferenceError: deprecated caller or arguments usage
====================================================

JavaScript の strict モード独自の例外 "deprecated caller or arguments usage" は、非推奨の `Function.caller` または `Function.arguments` プロパティが使用されたときに発生します。

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


```js
TypeError: 'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context (Edge)
Warning: ReferenceError: deprecated caller usage (Firefox)
Warning: ReferenceError: deprecated arguments usage (Firefox)
TypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari)
```

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

strict モードでのみ、`ReferenceError` の警告が発生します。 JavaScript の実行は、停止しません。

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

strict モード で、 `Function.caller` または `Function.arguments` が使われていますが、それらは使用すべきではありません。呼び出し元を漏洩させること、標準外であること、最適化が困難になること、性能に悪影響を与える機能であるため、非推奨になりました。

例
-

### 非推奨の `function.caller` または `arguments.callee.caller`

`Function.caller` と `arguments.callee.caller` は非推奨です (詳細は参照記事を見てください)。


```js
"use strict";

function myFunc() {
  if (myFunc.caller == null) {
    return "The function was called from the top!";
  } else {
    return "This function's caller was " + myFunc.caller;
  }
}

myFunc();
// Warning: ReferenceError: deprecated caller usage
// "The function was called from the top!"
```

### `Function.arguments`

`Function.arguments` は非推奨です (詳細は参照記事を見てください)。


```js
"use strict";

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

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

f(2);

console.log("returned: " + g.arguments);
// Warning: ReferenceError: deprecated arguments usage
```

関連情報
----

* 非推奨の機能、廃止された機能
* Strict モード
* `Function.arguments`
* `Function.caller` と `arguments.callee.caller`
TypeError: cannot use 'in' operator to search for 'x' in 'y'
============================================================

JavaScript の例外 "right-hand side of 'in' should be an object" は、 `in` 演算子が文字列、数値、その他のプリミティブ型の中を検索するために使用された場合に発生します。これは、あるプロパティがオブジェクト内にあることをチェックする用途でしか使用することができません。

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


```js
TypeError: Invalid operand to 'in' (Edge)
TypeError: right-hand side of 'in' should be an object, got 'x' (Firefox)
TypeError: cannot use 'in' operator to search for 'x' in 'y' (Firefox, Chrome)
```

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

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

`in` 演算子はあるプロパティがオブジェクト内にあることをチェックする用途でしか使用することができません。文字列、数値、その他のプリミティブ型の中を検索することはできません。

例
-

### 文字列内の検索

他のプログラミング言語 (Python など) とは異なり、 `in` 演算子を使用して文字列の中を検索することはできません。


```js
"Hello" in "Hello World";
// TypeError: cannot use 'in' operator to search for 'Hello' in 'Hello World'
```


ここでは代わりに `String.prototype.indexOf()` を使う必要があります。


```js
"Hello World".indexOf("Hello") !== -1;
// true
```

### オペランドを null や undefined にすることはできない

調査対象のオブジェクトが実際に `null` や `undefined` になっていないことを確認してください。


```js
var foo = null;
"bar" in foo;
// TypeError: cannot use 'in' operator to search for 'bar' in 'foo' (Chrome)
// TypeError: right-hand side of 'in' should be an object, got null (Firefox)
```


`in` 演算子は常にオブジェクトを期待します。


```js
var foo = { baz: "bar" };
"bar" in foo; // false

"PI" in Math; // true
"pi" in Math; // false
```

### 配列の中の検索

`in` 演算子を使用して `Array` オブジェクトの中を検索するときは注意してください。 `in` 演算子は添字の数値をチェックするものであり、その位置の値をチェックするのではありません。


```js
var trees = ["redwood", "bay", "cedar", "oak", "maple"];
3 in trees; // true
"oak" in trees; // false
```

関連情報
----

* `in` 演算子
SyntaxError: missing } after property list
==========================================

JavaScript の例外 "missing } after property list" は、オブジェクト初期化子の構文のどこかに間違いがあった場合に発生します。実際に中括弧がない可能性もありますが、カンマを忘れている可能性もあります。

メッセージ
-----


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

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

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

オブジェクト初期化子の構文のどこかに誤りがあります。実際に中括弧を忘れているかもしれませんが、例えばコンマが不足している可能性もあります。また、閉じ中括弧や閉じ括弧が正しい順序になっているかも確認してください。インデントを付けたりコードを整形したりすると、多少見通しが良くなります。

例
-

### カンマ忘れ

多くの場合は、オブジェクト初期化子のコードでカンマを忘れています。


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


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


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

関連項目
----

* オブジェクト初期化子
TypeError: invalid 'instanceof' operand 'x'
===========================================

JavaScript の例外 "invalid 'instanceof' operand" は、 `instanceof` 演算子の右側のオペランドにコンストラクターオブジェクト、すなわち `prototype` を持ち呼び出すことができるものが使用されなかった場合に発生します。

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


```js
TypeError: invalid 'instanceof' operand "x" (Firefox)
TypeError: "x" is not a function (Firefox)
TypeError: Right-hand side of 'instanceof' is not an object (Chrome)
TypeError: Right-hand side of 'instanceof' is not callable (Chrome)
```

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

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

`instanceof` 演算子 は、右側のオペランドがコンストラクターオブジェクトであることを想定しています。つまり、右側のオペランドは `prototype` プロパティを持ち、呼び出し可能であるオブジェクトである必要があります。

例
-

### instanceof と typeof


```js
"test" instanceof ""; // TypeError: invalid 'instanceof' operand ""
42 instanceof 0; // TypeError: invalid 'instanceof' operand 0

function Foo() {}
var f = Foo(); // Foo() が呼び出されて undefined を返す
var x = new Foo();

x instanceof f; // TypeError: invalid 'instanceof' operand f
x instanceof x; // TypeError: x is not a function
```


これらのエラーを修正するには、`instanceof` 演算子 を `typeof` 演算子 に置き換えるか、評価結果の代わりに関数名を使用するようにしてください。


```js
typeof "test" == "string"; // true
typeof 42 == "number"; // true

function Foo() {}
var f = Foo; // Do not call Foo.
var x = new Foo();

x instanceof f; // true
x instanceof Foo; // true
```

関連項目
----

* `instanceof` 演算子
* `typeof` 演算子
SyntaxError: "x" is a reserved identifier
=========================================

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

SyntaxError: "x" is a reserved identifier (Firefox)
SyntaxError: Unexpected reserved word (Chrome)
```

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

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

予約語を識別子として使用した場合、エラーをスローします。これらは strict モードと通常モードの双方で予約されています:

* `enum`

次のものは strict モードのコードでのみ予約されています:

* `implements`
* `interface`
* `let`
* `package`
* `private`
* `protected`
* `public`
* `static`
例
-

### Strict モードと 非 Strict モードで予約されているキーワード

`enum` 識別子は全般的に予約されています。


```js
var enum = { RED: 0, GREEN: 1, BLUE: 2 };
// SyntaxError: enum is a reserved identifier
```


strict モードのコードでは、より多くの識別子が予約されています。


```js
"use strict";
var package = ["potatoes", "rice", "fries"];
// SyntaxError: package is a reserved identifier
```


これらの変数名を変更する必要があります。


```js
var colorEnum = { RED: 0, GREEN: 1, BLUE: 2 };
var list = ["potatoes", "rice", "fries"];
```

### 古いブラウザーを更新する

たとえば、`let` や `class` をまだ実装していない古いブラウザーを使用している場合、それらの新しい言語機能をサポートしているより新しいブラウザーにアップデートすべきです。


```js
"use strict";
class DocArchiver {}

// SyntaxError: class is a reserved identifier
// (たとえば、Firefox 44 以前の古いブラウザーはエラーをスローします)
```

関連項目
----

* Good variable names