入力境界アサーション: ^, $ - JavaScript

入力境界アサーション: ^, $
================

**入力境界アサーション**は、文字列の減殺の位置が入力境界であるかどうかを検査します。入力境界は文字列の先頭または末尾です。`m` フラグが設定された場合は、行の先頭または末尾です。

構文
--

```regex
^
$
```

解説
--

`^` は現在の位置が入力の先頭であるかどうかを検査します。`$` は現在の位置が入力の末尾であるかどうかを検査します。どちらもアサーションであり、何も文字を消費しません。

より正確には、`^` は左側の文字が文字列の範囲外であることを、`$` は右側の文字が文字列の範囲外であることを表明します。`m` フラグが設定されている場合、`^` は左の文字が改行文字である場合にも一致し、`$` は右の文字が改行文字である場合にも一致します。

`m` フラグが設定されていない限り、`^` と `$` のアサーションはパターンの境界に配置したときのみ意味を持ちます。その左右に他の文字があるとアサーションが発生しなくなるからです。

`y` フラグはこれらのアサーションの意味を変えません。アンカー粘着フラグも参照してください。

例
-

### 末尾のスラッシュの除去

次の例は、URL 文字列から末尾のスラッシュを解除します。

```js
function removeTrailingSlash(url) {
  return url.replace(/\/$/, "");
}

removeTrailingSlash("https://example.com/"); // "https://example.com"
removeTrailingSlash("https://example.com/docs/"); // "https://example.com/docs"
```

### ファイル拡張子の照合

次の例は、常に文字列の最後に来るファイル拡張子を照合することで、ファイル型を調べます。

```js
function isImage(filename) {
  return /\.(?:png|jpe?g|webp|avif|gif)$/i.test(filename);
}

isImage("image.png"); // true
isImage("image.jpg"); // true
isImage("image.pdf"); // false
```

### 入力全体の照合

正規表現が入力の部分文字列だけでなく、入力全体と一致することを確認したい場合があります。例えば、文字列が有効な識別子かどうかを判定する場合、パターンの両端に入力境界のアサーションを追加することができます。

```js
function isValidIdentifier(str) {
  return /^[$\_\p{ID\_Start}][$\_\p{ID\_Continue}]\*$/u.test(str);
}

isValidIdentifier("foo"); // true
isValidIdentifier("$1"); // true
isValidIdentifier("1foo"); // false
isValidIdentifier(" foo "); // false
```

この関数は、codegen（コードを用いてコードを生成すること）を行う際に有益なものです。なぜなら、有効な識別子を、ドット記法をブラケット記法の代わりに用いるなど、他の文字列プロパティとは異なる形で使用することができるからです。

```js
const variables = ["foo", "foo:bar", " foo "];

function toAssignment(key) {
  if (isValidIdentifier(key)) {
    return `globalThis.${key} = undefined;`;
  }
  // JSON.stringify() escapes quotes and other special characters
  return `globalThis[${JSON.stringify(key)}] = undefined;`;
}

const statements = variables.map(toAssignment).join("\n");

console.log(statements);
// globalThis.foo = undefined;
// globalThis["foo:bar"] = undefined;
// globalThis[" foo "] = undefined;
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Assertion |

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

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

関連情報
----

* アサーション
* 正規表現リファレンス
* 単語境界アサーション: `\b`, `\B`
* 先読みアサーション: `(?=...)`, `(?!...)`
* 後読みアサーション: `(?<=...)`, `(?<!...)`


Unicode 文字クラスエスケープ: \p{...}, \P{...} - JavaScript

Unicode 文字クラスエスケープ: \p{...}, \P{...}
====================================

**Unicode 文字クラスエスケープ**は文字クラスエスケープの一種で、Unicode プロパティで指定された一連の文字に一致します。これは Unicode 対応モードでのみ対応しています。`v` フラグが有効である場合、有限長の文字列と照合するために使用することもできます。

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

構文
--

```regex
\p{loneProperty}
\P{loneProperty}

\p{property=value}
\P{property=value}
```

### 引数

`loneProperty`

単独の Unicode プロパティ名または値で、`value` と同じ構文に従います。`General_Category` プロパティの値、またはバイナリープロパティ名を指定します。`v` モードでは、文字列のバイナリー Unicode プロパティにもなります。

**メモ:** ICU 構文では `Script` プロパティ名も同様に省略することができますが、JavaScript では `Script` よりも `Script_Extensions` の方が有益な場合が多いため、対応していません。

`property`

Unicode プロパティ名。ASCII 文字 (`A-Z`, `a-z`) とアンダースコア (`_`) で構成され、バイナリー以外のプロパティ名のいずれかでなければなりません。

`value`

Unicode プロパティ値。ASCII 文字 (`A-Z`, `a-z`) とアンダースコア (`_`) と数字 (`0 - 9`) で構成され、`PropertyValueAliases.txt` に挙げられている対応値のいずれかでなければなりません。

解説
--

`\p` および `\P` は Unicode 対応モードでのみ対応しています。Unicode 非対応モードでは、これらは `p` または `P` の文字の ID エスケープです。

すべての Unicode 文字には、それを記述する一連のプロパティがあります。例えば、`a` という文字では、`General_Category` プロパティが `Lowercase_Letter` の値であり、`Script` プロパティが `Latn` の値です。エスケープシーケンス `\p` および `\P` を使用すると、そのプロパティに基づいて文字を照合することができます。例えば、`a` は `\p{`Lowercase\_Letter`}`（`General_Category` プロパティ名はオプション）と、`\p{Script=Latn}` によって一致させることができます。`\P` は、指定したプロパティを持たないコード ポイントからなる補集合クラスを生成します。

複数のプロパティを合成するには、`v` フラグで有効になる文字セット交差集合構文を使用してください。パターン差集合と交差集合を参照してください。

`v` モードでは、`\p` は Unicode で「文字列プロパティ」として定義されている一連のコードポイントと照合することができます。これは、複数のコードポイントで構成されることが多い絵文字に最も便利です。ただし、`\P` は文字プロパティの補集合しか作成できません。

**メモ:** 文字列プロパティ機能を `u` モードにも移植する計画があります。

例
-

### 一般カテゴリー

一般カテゴリーは、Unicode 文字を分類するために使用され、より詳細なカテゴリーを定義するためにサブカテゴリーを利用することができます。Unicode プロパティエスケープでは、短い形式と長い形式の両方を使用することができます。

これらは、文字、数字、記号、句読点、空白などを照合するために使用することができます。一般的なカテゴリーのより詳細なリストについては、Unicode 仕様書を参照してください。

```js
// この中のすべての文字を検索
const story = "It's the Cheshire Cat: now I shall have somebody to talk to.";

// 最も明示的な形式
story.match(/\p{General\_Category=Letter}/gu);

// 一般カテゴリーでは、プロパティ名を使用することが必須ではない
story.match(/\p{Letter}/gu);

// これも同等（短い別名）
story.match(/\p{L}/gu);

// これも同等（短い別名を使用したすべてのサブカテゴリーの結合）
story.match(/\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}/gu);
```

### 文字体系と文字体系拡張

言語によっては、その書法に別の文字体系を使用しているものもあります。例えば、英語とスペイン語はラテン文字を使用して書かれていますが、アラビア語とロシア語は他の文字（それぞれアラビア文字とキリル文字）を使用して書かれています。 Unicode の `Script` と `Script_Extensions` プロパティは、正規表現が、主に使用される文字体系 (`Script`) または文字体系の集合 (`Script_Extensions`) に従って文字と照合するようにするものです。

例えば、 `A` は `Latin` に、 `ε` は `Greek` に属します。

```js
const mixedCharacters = "aεЛ";

// この文字体系の正規の「長い」名前を使用
mixedCharacters.match(/\p{Script=Latin}/u); // a

// 文字体系に短い別名（ISO 15924 コード）を使用
mixedCharacters.match(/\p{Script=Grek}/u); // ε

// Script プロパティの短い名前 sc を使用
mixedCharacters.match(/\p{sc=Cyrillic}/u); // Л
```

より詳細には、Unicode 仕様書、ECMAScript 仕様書の文字体系一覧表、ISO 15924 文字体系コードのリストを参照してください。

ある文字が限られた文字体系で使用されている場合、`Script` プロパティは「主要な」使用されている文字体系に対してのみ一致します。もし、「主要ではない」文字体系に基づいて文字を照合したい場合には、 `Script_Extensions` プロパティ（`Scx` と略します）を使用することができます。

```js
// ٢ は、アラビア・インド語表記の数字の 2 であり、
// 主にアラビア文字体系で書かれるが、ターナ文字体系でも
// 使用することができます。

"٢".match(/\p{Script=Thaana}/u);
// ターナ文字体系は主要な文字体系ではないので null

"٢".match(/\p{Script\_Extensions=Thaana}/u);
// ["٢", index: 0, input: "٢", groups: undefined]
```

### Unicode プロパティエスケープと文字クラス

JavaScript の正規表現では、文字クラスで、特に `\w` や `\d` を使用して文字や数字に一致させることも可能です。しかし、このような形式は *ラテン* 文字体系の文字にしか一致しません（言い換えれば、 `a` から `z` と `A` から `Z` は `\w` に、`0` から `9` は `\d` に対応します）。この例に示すように、ラテン文字以外のテキストで作業するにはちょっと不便かもしれません。

Unicode プロパティエスケープのカテゴリーはより多くの文字を包含しており、 `\p{Letter}` や `\p{Number}` はどのような文字体系に対しても扱うことができます。

```js
// 範囲を使用して \w の制限を避けようとする

const nonEnglishText = "Приключения Алисы в Стране чудес";
const regexpBMPWord = /([\u0000-\u0019\u0021-\uFFFF])+/gu;
// BMP は U+0000 から U+FFFF だが、空白は U+0020

console.table(nonEnglishText.match(regexpBMPWord));

// Unicode プロパティエスケープを代わりに使用する
const regexpUPE = /\p{L}+/gu;
console.table(nonEnglishText.match(regexpUPE));
```

### 価格の照合

以下の例は、文字列中の価格に一致します。

```js
function getPrices(str) {
  // Sc は "currency symbol"（通貨記号）を表す。
  return [...str.matchAll(/\p{Sc}\s\*[\d.,]+/gu)].map((match) => match[0]);
}

const str = `California rolls $6.99
Crunchy rolls $8.49
Shrimp tempura $10.99`;
console.log(getPrices(str)); // ["$6.99", "$8.49", "$10.99"]

const str2 = `US store $19.99
Europe store €18.99
Japan store ¥2000`;
console.log(getPrices(str2)); // ["$19.99", "€18.99", "¥2000"]
```

### 文字列の照合

`v` フラグを付けると、`\p{…}` は文字列のプロパティを使用して、1 文字より長い可能性のある文字列と照合することができます。

```js
const flag = "🇺🇳";
console.log(flag.length); // 2
console.log(/\p{RGI\_Emoji\_Flag\_Sequence}/v.exec(flag)); // [ '🇺🇳' ]
```

ただし、`\P` を「プロパティを持たない文字列」と照合するために使うことはできません。何文字を消費するかが不明だからです。

```js
/\P{RGI\_Emoji\_Flag\_Sequence}/v; // Invalid regular expression: /\P{RGI\_Emoji\_Flag\_Sequence}/v: Invalid property name
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-CharacterClassEscape |

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

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

関連情報
----

* 文字クラス
* 正規表現リファレンス
* 文字クラス: `[...]`, `[^...]`
* 文字クラスエスケープ: `\d`, `\D`, `\w`, `\W`, `\s`, `\S`
* 文字エスケープ: `\n`, `\u{...}`
* 論理和: `|`
* Unicode character property (Wikipedia)
* ES2018: RegExp Unicode property escapes (Dr. Axel Rauschmayer, 2017)
* Unicode regular expressions § Properties (unicode.org)
* Unicode Utilities: UnicodeSet
* RegExp v flag with set notation and properties of strings (v8.dev, 2022)


後読みアサーション: (?<=...), (?<!...) - JavaScript

後読みアサーション: (?<=...), (?<!...)
=============================

**後読みアサーション**の「後読み」とは、それ以前の入力を指定されたパターンに照合しようとしますが、入力を消費することはありません。照合に成功した場合、入力の現在の位置はそのままです。パターン内のそれぞれのアトムは、逆順に照合します。

構文
--

```regex
(?<=pattern)
(?<!pattern)
```

### 引数

`pattern`

論理和を含む、正規表現リテラルで使用することができるあらゆるもので構成されるパターンです。

解説
--

正規表現は一般に左から右に照合します。これが先読みおよび後読みアサーションがこのように呼ばれる理由です。先読みアサーションは右にあるもの、後読みアサーションは左にあるものを表します。

`(?<=pattern)` アサーションが成功するためには、`pattern` が入力の現在の位置からみてすぐ左側ののテキストと一致しなければなりませんが、現在の位置は以降の入力と照合する前から変化しません。`(?<!pattern)` 形式はアサーションを否定します。`pattern` が入力の現在の位置のすぐ左側で一致しない場合に成功します。

後読みアサーションは、全般的には先読みと同じ意味づけを持ちます。 しかし、後読みアサーション内では、正規表現を逆順に照合します。例えば、次のようになります。

```js
/(?<=([ab]+)([bc]+))$/.exec("abc"); // ['', 'a', 'bc']
// Not ['', 'ab', 'c']
```

後読みで左から右に照合する場合は、最初に `[ab]+` に貪欲に照合して最初のグループが `"ab"` を捕捉し、残りの `"c"` は `[bc]+` に捕捉されるはずです。 しかし、ここでは `[bc]+` を最初に照合し、貪欲に `"bc"` を捕捉するため、`[ab]+` には `"a"` しか残りません。

この動作は妥当なものです。マッチャーはどこで照合を開始するかは分かりませんが（後読みが修正された長さでない可能性があるため）、どこで照合を終了するかは分かります（現在の位置です）。 したがって、現在の位置から開始し、逆方向に動作します（他の言語の正規表現では、この問題を避けるために固定長でない後読みを禁止しているものもあります）。

後読み内の量化されたキャプチャグループでは、逆順に照合されるため、入力文字列の右側ではなく、最も左側に一致するものがキャプチャされます。詳細はキャプチャグループのページを参照してください。後方参照は、逆順に照合されるため、参照するグループの左側に現れなければなりません。しかし、論理和は左から右へ試行されます。

例
-

### 消費せずに文字列を照合

先読みの場合と同様、後読みを使うと文字列を消費することなく文字列を照合し、有益な情報のみを抽出することができます。 例えば、次の例は価格ラベルの数字に一致する正規表現です。

```js
function getPrice(label) {
  return /(?<=\$)\d+(?:\.\d\*)?/.exec(label)?.[0];
}

getPrice("$10.53"); // "10.53"
getPrice("10.53"); // undefined
```

興味のある部分一致をキャプチャすることで、同様の効果が得られます。

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Assertion |

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

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

関連情報
----

* アサーション
* 正規表現リファレンス
* 入力境界アサーション: `^`, `$`
* 単語境界アサーション: `\b`, `\B`
* 先読みアサーション: `(?=...)`, `(?!...)`
* キャプチャグループ: `(...)`


論理和:

論理和: |
======

**論理和**は、複数の選択肢を指定します。いずれかの選択肢が入力に一致すると、その論理和全体が一致することになります。

構文
--

```regex
alternative1|alternative2
alternative1|alternative2|alternative3|…
```

### 引数

`alternativeN`

1 つの選択肢のパターンで、アトムとアサーションの並びで構成されます。いずれかの選択肢に一致した場合は、論理和全体に一致したと見なされます。

解説
--

正規表現の演算子 `|` は、2 つ以上の「選択肢」を区切ります。パターンは最初の選択肢との照合を試み、失敗すると 2 つ目に照合を試みます。例えば、次の例は `"ab"` ではなく `"a"` に一致します。

```js
/a|ab/.exec("abc"); // ['a']
```

`|` 演算子は正規表現の中では最も低い優先度になります。より大きなパターンの一部として論理和を使用したい場合は、グループ化する必要があります。

グループ化された論理和の後にさらに別の表現がある場合、照合は最初の選択肢を選択し、正規表現の残りの部分と照合しようとすることから始まります。正規表現の残りの部分が一致しなかった場合、マッチャーは代わりに次の選択肢を試みます。例えば、次のようになります、

```js
/(?:(a)|(ab))(?:(c)|(bc))/.exec("abc"); // ['abc', 'a', undefined, undefined, 'bc']
// Not ['abc', undefined, 'ab', 'c', undefined]
```

これは、最初の選択肢で `a` を選択することで、2 つ目の選択肢で `bc` を選択し、一致することが可能だからです。このプロセスは「バックトラッキング」と呼ばれ、マッチャーは最初に論理和を越え、その後の照合が失敗したときに論理和に戻ってくるからです。

また、一致しなかった選択肢の中に括弧を入れると、結果の配列に `undefined` が含まれることにも注意してください。

選択肢は空文字列であることもあり、その場合は空文字列に一致します（言い換えれば、常に一致します）。

選択肢は常に左から右に向けて試され、照合の方向には関係ありません（これは後読みで予約されています）。

例
-

### ファイル拡張子の照合

次の例は、入力境界アサーションの記事と同じコードを使用して、ファイル拡張子を照合します。

```js
function isImage(filename) {
  return /\.(?:png|jpe?g|webp|avif|gif)$/i.test(filename);
}

isImage("image.png"); // true
isImage("image.jpg"); // true
isImage("image.pdf"); // false
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Disjunction |

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

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

関連情報
----

* 文字クラス
* 正規表現リファレンス
* 修飾子: `*`, `+`, `?`, `{n}`, `{n,}`, `{n,m}`
* 文字クラス: `[...]`, `[^...]`


キャプチャグループ: (...) - JavaScript

キャプチャグループ: (...)
================

**キャプチャグループ**は、サブパターンをグループ化し、グループ全体に数量詞を適用したり、グループ内で論理和を使用したりすることができます。サブパターンの一致に関する情報を記憶しているので、後方参照で参照したり、照合結果からその情報にアクセスしたりすることができます。

サブパターンの照合結果が必要ない場合は、代わりに非キャプチャグループを使用することで、パフォーマンスが向上し、リファクタリングの危険を避けることができます。

構文
--

```regex
(pattern)
```

### 引数

`pattern`

正規表現リテラルで使用する何かのもの、例えば論理和などから構成されるパターンです。

解説
--

キャプチャグループは JavaScript の式におけるグループ化演算子のような役割を果たし、サブパターンを単一のアトムとして使用できるようにします。

キャプチャグループには、開始括弧の順番で番号が振られます。最初のキャプチャグループは `1`、2 つ目は `2`、といった具合に番号が振られます。名前付きキャプチャグループもキャプチャグループであり、他の（名前のない）キャプチャグループと一緒に番号が付けられます。キャプチャグループの一致に関する情報には、以下のようにしてアクセスできます。

* `RegExp.prototype.exec()`、`String.prototype.match()`、`String.prototype.matchAll()` の返値（配列）
* `String.prototype.replace()` および `String.prototype.replaceAll()` メソッドの `replacement` コールバック関数の `pN` 引数
* 同じパターン内の後方参照

**メモ:** `exec()` の結果の配列でも、キャプチャグループは `1`、`2` などの番号でアクセスされますが、これは要素 `0`` が一致するもの全体であるためです。`\0` は後方参照ではなく、NUL 文字の文字エスケープです。

正規表現コード内のキャプチャグループは、その結果と一対一に対応します。キャプチャグループが一致しない場合（例えば、それが論理和の一致しない選択肢に属する場合）、対応する結果は未定義です。

```js
/(ab)|(cd)/.exec("cd"); // ['cd', undefined, 'cd']
```

キャプチャグループは数量化できます。この場合、このグループに対応する一致情報は、そのグループで最後に一致したものとなります。

```js
/([ab])+/.exec("abc"); // ['ab', 'b']; because "b" comes after "a", this result overwrites the previous one
```

キャプチャグループは、先読みおよび後読みアサーションで使用できます。後読みアサーションはアトムを逆方向に一致させるので、 このグループに対応する最終的な一致は文字列の左端に現れるものになります。ただし、一致するグループのインデックスは、正規表現ソース内の相対位置に対応します。

```js
/c(?=(ab))/.exec("cab"); // ['c', 'ab']
/(?<=(a)(b))c/.exec("abc"); // ['c', 'a', 'b']
/(?<=([ab])+)c/.exec("abc"); // ['c', 'a']; because "a" is seen by the lookbehind after the lookbehind has seen "b"
```

キャプチャグループは入れ子にすることができ、その場合、開き括弧によって順序付けされるため、外側のグループが最初に番号付けされ、次に内側のグループが番号付けされます。入れ子になったグループが数量詞によって繰り返される場合、そのグループが一致するたびにサブグループの結果はすべて上書きされ、場合によっては `undefined` になります。

```js
/((a+)?(b+)?(c))\*/.exec("aacbbbcac"); // ['aacbbbcac', 'ac', 'a', undefined, 'c']
```

上の例では、外側のグループは 3 回一致します。

1. `"aac"` に一致。サブグループは `"aa"`、`undefined`、`"c"`。
2. `"bbbc"` に一致。サブグループは `undefined`、`"bbb"`、`"c"`。
3. `"ac"` に一致。サブグループは `"a"`、`undefined`、`"c"`。

2 回目の一致で得られた `"bbb"` の結果は保存されません。3 つ目の一致で `undefined` で上書きされるからです。

`d` フラグを用いることで、入力文字列中の各キャプチャグループの開始と終わりのインデックスを取得することができます。これは、`exec()` が返す配列に `indices` プロパティを作成します。

オプションでキャプチャグループに名前を指定することができ、グループの位置やインデックス関連の落とし穴を避けるのに役立ちます。詳細は、名前付きキャプチャグループを参照してください。

括弧は、異なる正規表現構文において他の目的もあります。例えば、先読みアサーションや後読みアサーションも括弧で囲みます。これらの構文はすべて `?` で始まり、`?` は `(` の直後には置くことができない数量詞なので、曖昧さにはつながりません。

例
-

### 日付の照合

次の例は `YYYY-MM-DD` という形式の日付に一致します。

```js
function parseDate(input) {
  const parts = /^(\d{4})-(\d{2})-(\d{2})$/.exec(input);
  if (!parts) {
    return null;
  }
  return parts.slice(1).map((p) => parseInt(p, 10));
}

parseDate("2019-01-01"); // [2019, 1, 1]
parseDate("2019-06-19"); // [2019, 6, 19]
```

### 引用符のペアリング

以下の関数は文字列中の `title='xxx'` と `title="xxx"` のパターンを照合します。引用符が確実に一致するように、後方参照を使用して最初の引用符を参照します。2 つ目のキャプチャグループ (`[2]`) にアクセスすると、一致する引用符の間の文字列を返します。

```js
function parseTitle(metastring) {
  return metastring.match(/title=(["'])(.\*?)\1/)[2];
}

parseTitle('title="foo"'); // 'foo'
parseTitle("title='foo' lang='en'"); // 'foo'
parseTitle('title="Named capturing groups\' advantages"'); // "Named capturing groups' advantages"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-Atom |

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

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

関連情報
----

* グループと後方参照
* 正規表現リファレンス
* 非キャプチャグループ: `(?:...)`
* 名前付きキャプチャグループ: `(?<name>...)`
* 後方参照: `\1`, `\2`


文字クラスエスケープ: \d, \D, \w, \W, \s, \S - JavaScript

文字クラスエスケープ: \d, \D, \w, \W, \s, \S
==================================

**文字クラスエスケープ**は、文字の集合を表すエスケープシーケンスです。

構文
--

```regex
\d, \D
\s, \S
\w, \W
```

**メモ:** `,` is not part of the syntax.

解説
--

文字エスケープとは異なり、文字クラスエスケープは、文字クラスのように、事前に定義された文字の集合を表します。以下の文字クラスに対応しています。

`\d`

いずれかの数字に一致します。`[0-9]` と同等です。

`\w`

任意の単語文字に一致します。単語文字には文字 (A-Z, a-z)、数字 (0-9)、アンダースコア (\_) が含まれます。正規表現が Unicode 対応で `i` フラグが設定されている場合、大文字小文字の折りたたみによって上記の文字のいずれかに正規化される他の Unicode 文字にも一致します。

`\s`

任意のホワイトスペースまたは改行文字に一致します。

大文字形式の `\D`、`\W`、`\S` は、それぞれ `\d`、`\w`、`\s` の補集合文字クラスを作成します。これらは、小文字形式が一致する文字の集合にない任意の文字に一致します。

Unicode 文字クラスエスケープは˶`\p` および `\P`で始まりますが、Unicode 対応モードでのみ対応しています。Unicode 非対応モードでは、これらは `p` または `P` 文字の識別子エスケープです。

文字クラスエスケープは文字クラスで使用することができます。しかし、文字範囲の境界として使用することはできません。これはウェブの互換性のための非推奨構文としてのみ認められており、頼ってはいけません。

例
-

### ホワイトスペースでの分割

次の例は、文字列を単語の配列に分割します。すべての種類のホワイトスペース区切り文字に対応しています。

```js
function splitWords(str) {
  return str.split(/\s+/);
}

splitWords(`Look at the stars
Look how they\tshine for you`);
// ['Look', 'at', 'the', 'stars', 'Look', 'how', 'they', 'shine', 'for', 'you']
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-CharacterClassEscape |

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

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

関連情報
----

* 文字クラス
* 正規表現リファレンス
* 文字クラス: `[...]`, `[^...]`
* Unicode 文字クラスエスケープ: `\p{...}`, `\P{...}`
* 文字エスケープ: `\n`, `\u{...}`
* 論理和: `|`


名前付き後方参照: \k<name> - JavaScript

名前付き後方参照: \k<name>
==================

**名前付き後方参照**は、以前の[名前付きキャプチャグループ]の一致部分を参照し、そのグループと同じテキストに一致します。名前なしキャプチャグループの場合は、通常の後方参照構文を使用する必要があります。

構文
--

```regex
\k<name>
```

### 引数

`name`

グループの名前です。有効な識別子であり、存在する名前付きキャプチャグループを参照する必要があります。

解説
--

名前付き後方参照は、通常の後方参照とよく似ています。キャプチャグループによって照合されたテキストを参照し、同じテキストに一致します。異なる点は、キャプチャグループを番号ではなく名前で参照することです。これにより、正規表現がより読み取りやすくなり、 リファクタリングや保守が簡単になります。

Unicode 非対応モードでは、正規表現が少なくとも 1 つの名前付きキャプチャグループを格納している場合にのみ、シーケンス `\k` は名前付き後方参照を開始します。それ以外の場合、これは ID エスケープであり、リテラル文字 `k`` と同じです。これはウェブの互換性のための非推奨構文としてのみ認められており、頼ってはいけません。

```js
/\k/.test("k"); // true
```

例
-

### 引用符のペアリング

以下の関数は、文字列中の `title='xxx'` と `title="xxx"` のパターンと一致します。 引用符が確実に一致するように、後方参照を使用して最初の引用符を参照します。 2 つ目のキャプチャグループ (`[2]`) にアクセスすると、一致した引用符の間の文字列を返します。

```js
function parseTitle(metastring) {
  return metastring.match(/title=(?<quote>["'])(.\*?)\k<quote>/)[2];
}

parseTitle('title="foo"'); // 'foo'
parseTitle("title='foo' lang='en'"); // 'foo'
parseTitle('title="Named capturing groups\' advantages"'); // "Named capturing groups' advantages"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-AtomEscape |

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

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

関連情報
----

* グループと後方参照
* 正規表現リファレンス
* キャプチャグループ: `(...)`
* 名前付きキャプチャグループ: `(?<name>...)`
* 後方参照: `\1`, `\2`


リテラル文字: a, b - JavaScript

リテラル文字: a, b
============

**リテラル文字**は、入力テキスト内で一致するもの自体を示します。

構文
--

```regex
c
```

### 引数

`c`

下記で記述する構文文字以外の単一の文字です。

解説
--

正規表現では、ほとんどの文字が文字通り現れます。これらは通常、パターンの最も基本的な構成要素です。例えば、HTML タグの削除の例からのパターンです。

```js
const pattern = /<.+?>/g;
```

この例では、`.`、`+`、`?` は構文文字と呼ばれます。これらは正規表現において特別な意味を持っています。パターンの残りの文字（`<` と `>`）はリテラル文字です。これらは入力されたテキスト、つまり左と右の山括弧に一致します。

以下は正規表現における構文文字であり、リテラル文字として現れることはありません。

* `^`, `$`
* `\`
* `*`, `+`, `?`, `{`, `}`
* `(`, `)`
* `[`, `]`
* `|`

文字クラスの中では、より多くの文字を文字通り記述することができます。詳しい情報は文字クラスのページを参照してください。例えば `\.` と `[.]` はどちらもリテラル `.` に一致します。しかし、`v` モード文字クラス では、構文文字として予約されている文字の異なる集合があります。包括的に言うと、下記は別の ASCII 文字と、それらが様々なコンテキストでエスケープまたはアンエスケープされて現れるかどうかの表です。"✅" はその文字自身を表し、"❌" は構文エラーを発生し、"⚠" はその文字が有効であるが、それ自身以外の何かを意味していることを意味します。

| 文字 | `u` または `v` モードにおける文字クラス外の文字 | `u` モードの文字クラス | `v` モードの文字クラス |
| --- | --- | --- | --- |
| エスケープなし | エスケープあり | エスケープなし | エスケープあり | エスケープなし | エスケープあり |
| `123456789 "'ACEFGHIJKLMNOPQRTUVXYZ_aceghijklmopquxyz` | ✅ | ❌ | ✅ | ❌ | ✅ | ❌ |
| `!#%&,:;<=>@`~` | ✅ | ❌ | ✅ | ❌ | ✅ | ✅ |
| `]` | ❌ | ✅ | ❌ | ✅ | ❌ | ✅ |
| `()[{}` | ❌ | ✅ | ✅ | ✅ | ❌ | ✅ |
| `*+?` | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ |
| `/` | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ |
| `0DSWbdfnrstvw` | ✅ | ⚠ | ✅ | ⚠ | ✅ | ⚠ |
| `B` | ✅ | ⚠ | ✅ | ❌ | ✅ | ❌ |
| `$.` | ⚠ | ✅ | ✅ | ✅ | ✅ | ✅ |
| `|` | ⚠ | ✅ | ✅ | ✅ | ❌ | ✅ |
| `-` | ✅ | ❌ | ✅⚠ | ✅ | ❌⚠ | ✅ |
| `^` | ⚠ | ✅ | ✅⚠ | ✅ | ✅⚠ | ✅ |
| `\` | ❌⚠ | ✅ | ❌⚠ | ✅ | ❌⚠ | ✅ |

**メモ:** `v` モード文字クラスでエスケープとアンエスケープの両方が可能な文字は、まさに「二重記号」として禁止されている文字です。詳しくは`v`モード文字クラスを参照してください。

構文文字を文字通りに照合したい場合は、バックスラッシュ (`\`) でエスケープする必要があります。例えば、パターン中のリテラル文字 `*` と照合するには、パターンに `\*` と書く必要があります。構文文字をリテラル文字として使用すると、予期しない結果になるか、構文エラーが発生します。例えば、 `/*/` は正規表現として有効ではありません。Unicode 非対応モードでは、`]`、`{`、`}` は文字クラスの終わりや数量詞の区切りとして解釈できない場合、文字通りに現れることがあります。これはウェブ互換性のために非推奨ですので、頼ってはいけません。

正規表現リテラルは、特定の非構文リテラル文字を指定することはできません。`/` はリテラル自体の区切り文字として使用されるため、リテラル `/` と照合したい場合は `\/` としてエスケープする必要があります。リテラルは複数の行にまたがることができないので、改行文字も正規表現リテラルでリテラル文字として使用することはできません。代わりに `\n` のような文字エスケープを使用する必要があります。`RegExp()` コンストラクターを使用する場合は、このような制限はありませんが、文字列リテラルには自分自身でエスケープするルールがあります（例えば、`"\\"` は実際には単一のバックスラッシュ文字を表すので、`new RegExp("\\*")` と `/\*/` は等価です）。

Unicode 非対応モードでは、パターンは UTF-16 コード単位の並びとして解釈されます。これはサロゲートペアが実際には 2 つのリテラル文字を表していることを意味しています。これは、他の機能とペアになったときに予期せぬ動作が発生します。

```js
/^[😄]$/.test("😄"); // false。このパターンは /^[\ud83d\udc04]$/ と解釈されるため
/^😄+$/.test("😄😄"); // false。このパターンは /^\ud83d\udc04+$/ と解釈されるため
```

Unicode 対応モードでは、パターンは Unicode コードポイントの並びとして解釈され、サロゲートペアは分割されません。できれば常に `u` フラグを使用しましょう。

例
-

### リテラル文字の使用

次の例は文字エスケープからコピーしたものです。`a` と `b` はパターン内のリテラル文字で、`\n` は正規表現リテラルでは文字通りに現れないのでエスケープされた文字です。

```js
const pattern = /a\nb/;
const string = `a
b`;
console.log(pattern.test(string)); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-PatternCharacter |

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

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

関連情報
----

* 文字クラス
* 正規表現リファレンス
* 文字エスケープ: `\n`, `\u{...}`


文字エスケープ: \n, \u{...} - JavaScript

文字エスケープ: \n, \u{...}
====================

**文字エスケープ**は、リテラルの形ではうまく表現できない文字を表します。

構文
--

```regex
\f, \n, \r, \t, \v
\cA, \cB, …, \cz
\0
\^, \$, \\, \., \\*, \+, \?, \(, \), \[, \], {, }, \|, \/

\xHH
\uHHHH
\u{HHH}
```

**メモ:** `,` は構文の一部ではありません。

### 引数

`HHH`

文字の Unicode コードポイントを表す 16 進数です。`xHH` 形式の場合は 16 進数 2 桁、`uHHHH` 形式の場合は 4 桁、`\u{HHH}` 形式の場合は 16 進数 1 桁から 6 桁を持つことができます。

解説
--

以下の文字エスケープが正規表現内で認識されます。

`\f`, `\n`, `\r`, `\t`, `\v`

文字リテラルのものと同じですが、`\b` は単語境界となります（文字クラスでない限り）。

`\c` に `A` から `Z` または `a` から `z` が続いたもの

32 で割った余りに等しい値の制御文字を表します。例えば、`J` のコードポイントは 74 であり、74 を 32 で割ると改行のコードポイントである 10 であるため、`cJ` は改行 (`\n`) を表します。大文字と小文字の形式は 32 だけ異なるので、`\cJ` と `\cj` は等価です。この形で 1 から 26 までの制御文字を表すことができます。

`\0`

U+0000 NUL 文字を表します。数字を続けてはいけまません（古い 8 進数エスケープシーケンスになります）。

`\^`, `\$`, `\\`, `\.` `\*`, `\+`, `\?`, `\(`, `\)`, `\[`, `\]`, `{`, `}`, `\|`, `\/`

文字自体を表します。例えば、`\\` はバックスラッシュを表し、`\(` は左括弧を表します。これらは正規表現内（`/` は正規表現リテラルの区切り文字です）では構文文字であるため、文字クラス内でない場合はエスケープする必要があります。

`\xHH`

指定された Unicode コードポイントを持つ文字を表します。16 進数は正確に 2 桁でなければなりません。

`\uHHHH`

指定された Unicode コードポイントを持つ文字を表します。16 進数は正確に 4 桁でなければなりません。このようなエスケープシーケンス 2 つで、Unicode 対応モードではサロゲートペアを表すのに使用することができます。（Unicode 非対応モードでは常に 2 つの別個の文字になります。）

`\u{HHH}`

（Unicode 対応モードのみ）指定された Unicode コードポイントを持つ文字を表します。16 進数は 1 桁から 6 桁までです。

Unicode 非対応モードでは、上記のいずれでもないエスケープシーケンスは識別エスケープになります。これらはバックスラッシュに続く文字を表します。例えば、`\a` は文字 `a` を表します。この動作は後方互換性の問題を発生させることなく新しいエスケープシーケンスを導入す る能力を制限するため、Unicode 対応モードでは禁止されています。

Unicode 非対応モードでは、`]`、`{`、`}` は文字クラスの末尾や数量詞の区切り文字として解釈できない場合、文字通りに現れることがあります。これはウェブの互換性のために非推奨です。

Unicode 非対応モードでは、文字クラス内の `\cX` という形のエスケープシーケンスで、`X` が数字または `_` である場合、ASCII 文字と同じようにデコードされます。`\c0` は 32 で割った余りを取って `\cP` と同じになります。さらに、`\cX` に遭遇したとき `X` が認識された文字の一つでなかった場合、バックスラッシュはリテラル文字として扱われます。これらの構文も非推奨です。

```js
/[\c0]/.test("\x10"); // true
/[\c_]/.test("\x1f"); // true
/[\c\*]/.test("\\"); // true
/\c/.test("\\c"); // true
/\c0/.test("\\c0"); // true （\c0 文字は文字クラス内でのみ対応しています）
```

例
-

### 文字エスケープの使用

文字エスケープは、リテラル形式では表しにくい文字と照合したいときに有益です。例えば、正規表現リテラルでは改行は使用できないので、文字エスケープを使用しなければなりません。

```js
const pattern = /a\nb/;
const string = `a
b`;
console.log(pattern.test(string)); // true
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # prod-CharacterEscape |

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

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

関連情報
----

* 文字クラス
* 正規表現リファレンス
* 文字クラス: `[...]`, `[^...]`
* 文字クラスエスケープ: `\d`, `\D`, `\w`, `\W`, `\s`, `\S`
* リテラル文字: `a`, `b`
* Unicode 文字クラスエスケープ: `\p{...}`, `\P{...}`
* 後方参照: `\1`, `\2`
* 名前付き後方参照: `\k<name>)`
* 単語境界アサーション: `\b`, `\B`


TypeError: invalid Array.prototype.sort argument - JavaScript

TypeError: invalid Array.prototype.sort argument
================================================

JavaScript の例外 "invalid Array.prototype.sort argument" は、 `Array.prototype.sort()` の引数が `undefined` でもオペランドを比較する関数でもない場合に発生します。

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

TypeError: argument is not a function object (Edge)
TypeError: invalid Array.prototype.sort argument (Firefox)
```

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

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

`Array.prototype.sort()` の引数には、`undefined` かオペランドを比較する関数のいずれかが求められれます。

例
-

### 無効な場合

```js
[1, 3, 2].sort(5); // TypeError

var cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };
[1, 3, 2].sort(cmp[this.key] || "asc"); // TypeError
```

### 有効な場合

```js
[1, 3, 2].sort(); // [1, 2, 3]

var cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };
[1, 3, 2].sort(cmp[this.key || "asc"]); // [1, 2, 3]
```

関連情報
----

* `Array.prototype.sort()`


SyntaxError: Unexpected token - JavaScript

SyntaxError: Unexpected token
=============================

JavaScript の例外 "unexpected token" は、特定の言語構造が期待されているのに、それ以外のものが提供されている場合に発生します。単純なタイプミスかもしれません。

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

```js
SyntaxError: expected expression, got "x"
SyntaxError: expected property name, got "x"
SyntaxError: expected target, got "x"
SyntaxError: expected rest argument name, got "x"
SyntaxError: expected closing parenthesis, got "x"
SyntaxError: expected '=>' after argument list, got "x"
```

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

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

特定の言語構造が予想されている箇所に、ほかのものが提供されています。これは単純なタイプミスの可能性があります。

例
-

### 式が期待される

たとえば関数を呼び出すとき、末尾のカンマは許可されていません。

```js
for (let i = 0; i < 5,; ++i) {
  console.log(i);
}
// SyntaxError: expected expression, got ')'
```

正しくは、カンマを省略するか、他の式を追加するかしてください。

```js
for (let i = 0; i < 5; ++i) {
  console.log(i);
}
```

### 括弧の不足

時々、 `if` 文を囲む括弧を忘れることがあります。

```js
function round(n, upperBound, lowerBound){
  if(n > upperBound) || (n < lowerBound){
    throw 'Number ' + String(n) + ' is more than ' + String(upperBound) + ' or less than ' + String(lowerBound);
  }else if(n < ((upperBound + lowerBound)/2)){
    return lowerBound;
  }else{
    return upperBound;
  }
} // SyntaxError: expected expression, got '||'
```

最初は括弧が正しく見えますが、 `||` が括弧の外にあることに注意してください。 `||` の周囲を括弧で囲むように修正してください。

```js
function round(n, upperBound, lowerBound) {
  if (n > upperBound || n < lowerBound) {
    throw (
      "Number " +
      String(n) +
      " is more than " +
      String(upperBound) +
      " or less than " +
      String(lowerBound)
    );
  } else if (n < (upperBound + lowerBound) / 2) {
    return lowerBound;
  } else {
    return upperBound;
  }
}
```

関連情報
----

* `SyntaxError`


SyntaxError: unterminated string literal - JavaScript

SyntaxError: unterminated string literal
========================================

JavaScript のエラー "unterminated string literal" は、どこかに終了していない文字列リテラルがあった場合に発生します。文字列リテラルは単一引用符 (`'`) または二重引用符 (`"`) で囲む必要があります。

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

```js
SyntaxError: Unterminated string constant (Edge)
SyntaxError: unterminated string literal (Firefox)
```

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

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

どこかに終端されていない文字列リテラルがあります。文字列リテラルは単一引用符 (`'`) または二重引用符 (`"`) で囲む必要があります。JavaScript は、単一引用符の文字列と二重引用符の文字列を区別しません。エスケープシーケンス は単一引用符と二重引用符、どちらの文字列でも動作します。このエラーを修正するためには、次の点をチェックしてください。

* 文字列リテラルのために、単一引用符または二重引用符の開始と終了を行っている。
* 文字列リテラルを正しくエスケープしている。
* 文字列リテラルが複数行に分けられていない。
例
-

### 複数行

JavaScript では、次のように複数行にまたがる文字列を分割できません。

```js
var longString = 'This is a very long string which needs
                  to wrap across multiple lines because
                  otherwise my code is unreadable.';
// SyntaxError: unterminated string literal
```

代わりに、+ 演算子 かバックスラッシュ、テンプレートリテラル を使用します。`+` 演算子の場合、次のようになります。

```js
var longString =
  "This is a very long string which needs " +
  "to wrap across multiple lines because " +
  "otherwise my code is unreadable.";
```

または、文字列が次のように続くことを示すために、各行の終わりにバックスラッシュ文字（"\"）を使用することもできます。バックスラッシュの後に、 (改行を除いて) スペースや文字、インデントを入れないようにしてください。そうしないと動作しません。バックスラッシュの場合、次のようになります。

```js
var longString =
  "This is a very long string which needs \
to wrap across multiple lines because \
otherwise my code is unreadable.";
```

ECMAScript 2015 環境でサポートされているテンプレートリテラルを使っても改行可能です。

```js
var longString = `This is a very long string which needs
 to wrap across multiple lines because
 otherwise my code is unreadable.`;
```

関連情報
----

* 文字列リテラル
* テンプレートリテラル


SyntaxError: identifier starts immediately after numeric literal - JavaScript

SyntaxError: identifier starts immediately after numeric literal
================================================================

JavaScript の例外 "identifier starts immediately after numeric literal" は、識別子が数字で始まっているときに発生します。識別子の先頭は英字、アンダースコア (\_)、ドル記号 ($) しか使うことができません。

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

```js
SyntaxError: Unexpected identifier after numeric literal (Edge)
SyntaxError: identifier starts immediately after numeric literal (Firefox)
SyntaxError: Unexpected number (Chrome)
```

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

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

変数の名前、いわゆる識別子は特定のルールに従う必要があり、それに反しています。

JavaScript の識別子は文字かアンダースコア (\_)、ドル記号 ($) で始まる必要があります。数値からは始められません。 2 文字目以降でのみ、数値 (0-9) を使用することができます。

例
-

### 数字から始まる変数名

JavaScript は変数名を数字から始めることはできません。次の例は失敗します。

```js
var 1life = 'foo';
// SyntaxError: identifier starts immediately after numeric literal

var foo = 1life;
// SyntaxError: identifier starts immediately after numeric literal

alert(1.foo);
// SyntaxError: identifier starts immediately after numeric literal
```

数値始まりにならないように、変数名を変更する必要があります。

```js
var life1 = "foo";
var foo = life1;
```

関連項目
----

* 字句文法
* JavaScript ガイドの変数


TypeError: "x" is not a constructor - JavaScript

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

JavaScript の例外 "is not a constructor" は、オブジェクトや変数をコンストラクターとして使用しようとしたものの、そのオブジェクトや変数がコンストラクターではなかった場合に発生します。

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

```js
TypeError: Object doesn't support this action (Edge)
TypeError: "x" is not a constructor

TypeError: Math is not a constructor
TypeError: JSON is not a constructor
TypeError: Symbol is not a constructor
TypeError: Reflect is not a constructor
TypeError: Intl is not a constructor
TypeError: Atomics is not a constructor
```

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

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

オブジェクトや変数をコンストラクターとして使おうとしていますが、それらがコンストラクターではありません。コンストラクターとは何かについては、コンストラクターまたは `new` 演算子を参照してください。

`String` や `Array` のような、 `new` を使用して生成できる数多くのグローバルオブジェクトがあります。しかし、いくつかのグローバルオブジェクトはそうではなく、それらのプロパティやメソッドは静的です。次の JavaScript 標準組み込みオブジェクトのうち、 `Math`、`JSON`、`Symbol`、`Reflect`、`Intl`、`Atomics` はコンストラクターではありません。

ジェネレーター関数も、コンストラクターとして使用することはできません。

例
-

### 無効な場合

```js
var Car = 1;
new Car();
// TypeError: Car is not a constructor

new Math();
// TypeError: Math is not a constructor

new Symbol();
// TypeError: Symbol is not a constructor

function\* f() {}
var obj = new f();
// TypeError: f is not a constructor
```

### car コンストラクター

自動車のためのオブジェクト型を作成するとします。このオブジェクト型を `Car` と呼び、 make, model, year の各プロパティを持つようにしたいとします。これを実現するには、次のような関数を定義します。

```js
function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}
```

次のようにして `mycar` というオブジェクトを生成できるようになりました。

```js
var mycar = new Car("Eagle", "Talon TSi", 1993);
```

### プロミスの場合

ただちに解決するか拒否されるプロミスを返す場合は、 *new Promise(...)* を生成して操作する必要はありません。

これは正しくなく (Promise コンストラクターが正しく呼び出されません)、 `TypeError: this is not a constructor` 例外が発生します。

```js
return new Promise.resolve(true);
```

 代わりに、 Promise.resolve() または
 Promise.reject() の静的メソッドを使用してください。

```js
// This is legal, but unnecessarily long:
return new Promise((resolve, reject) => { resolve(true); })

// Instead, return the static method:
return Promise.resolve(true);
return Promise.reject(false);
```

関連情報
----

* コンストラクター
* `new` 演算子


TypeError: can't define property "x": "obj" is not extensible - JavaScript

TypeError: can't define property "x": "obj" is not extensible
=============================================================

JavaScript の例外 "can't define property "x": "obj" is not extensible" は `Object.preventExtensions()` でオブジェクトが拡張可能ではなくなったため、その時点で存在していたプロパティを設定できなかった際に発生します。

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

```js
TypeError: Cannot create property for a non-extensible object (Edge)
TypeError: can't define property "x": "obj" is not extensible (Firefox)
TypeError: Cannot define property: "x", object is not extensible. (Chrome)
```

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

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

通常、オブジェクトは拡張可能で、新しいプロパティを追加できます。しかしこの場合は、`Object.preventExtensions()` がオブジェクトをもはや拡張できないものに設定しているため、拡張不可のマークが付けられたときにあったプロパティ以上のプロパティを追加できません。

例
-

### Adding new properties to a non-extensible objects

strict モードでは、拡張不可のオブジェクトに新しいプロパティを追加しようとすると `TypeError` が発生します。非 strict モードでは、"x" プロパティの追加は暗黙的に無視されます。

```js
"use strict";

var obj = {};
Object.preventExtensions(obj);

obj.x = "foo";
// TypeError: can't define property "x": "obj" is not extensible
```

strict モードと非 strict モード共に、拡張不可のオブジェクトに新しいプロパティを追加しようとして `Object.defineProperty()` を呼び出すと、例外が発生します。

```js
var obj = {};
Object.preventExtensions(obj);

Object.defineProperty(obj, "x", { value: "foo" });
// TypeError: can't define property "x": "obj" is not extensible
```

このエラーを修正するには、`Object.preventExtensions()` の呼び出しを削除するか、オブジェクトが拡張不可とマークされる前にプロパティを追加するように移動する必要があります。もちろん、必要がないのであれば、追加しようとしているプロパティを削除しても構いません。

```js
"use strict";

var obj = {};
obj.x = "foo"; // プロパティを追加してから拡張不可にする

Object.preventExtensions(obj);
```

関連情報
----

* `Object.preventExtensions()`


TypeError: More arguments needed - JavaScript

TypeError: More arguments needed
================================

JavaScript の例外 "more arguments needed" は、関数の呼び出し方にエラーがあった場合に発生します。もっと多くの引数が必要です。

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

```js
TypeError: argument is not an Object and is not null (Edge)
TypeError: Object.create requires at least 1 argument, but only 0 were passed
TypeError: Object.setPrototypeOf requires at least 2 arguments, but only 0 were passed
TypeError: Object.defineProperties requires at least 1 argument, but only 0 were passed
```

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

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

関数の呼び出し方にエラーがあります。より多くの引数を提供する必要があります。

例
-

### 必要な引数が足りない

`Object.create()` メソッドは、少なくとも 1 つは引数が必要です。また、`Object.setPrototypeOf()` メソッドは少なくとも 2 つ引数が必要です。

```js
var obj = Object.create();
// TypeError: Object.create requires at least 1 argument, but only 0 were passed

var obj = Object.setPrototypeOf({});
// TypeError: Object.setPrototypeOf requires at least 2 arguments, but only 1 were passed
```

たとえば、`null` を prototype として設定することで修正できます。

```js
var obj = Object.create(null);

var obj = Object.setPrototypeOf({}, null);
```

関連項目
----

* 関数


SyntaxError: JSON.parse: bad parsing - JavaScript

SyntaxError: JSON.parse: bad parsing
====================================

JavaScript の例外で、 `JSON.parse()` が文字列を JSON として解釈するのに失敗した場合に発生します。

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

```js
SyntaxError: JSON.parse: unterminated string literal
SyntaxError: JSON.parse: bad control character in string literal
SyntaxError: JSON.parse: bad character in string literal
SyntaxError: JSON.parse: bad Unicode escape
SyntaxError: JSON.parse: bad escape character
SyntaxError: JSON.parse: unterminated string
SyntaxError: JSON.parse: no number after minus sign
SyntaxError: JSON.parse: unexpected non-digit
SyntaxError: JSON.parse: missing digits after decimal point
SyntaxError: JSON.parse: unterminated fractional number
SyntaxError: JSON.parse: missing digits after exponent indicator
SyntaxError: JSON.parse: missing digits after exponent sign
SyntaxError: JSON.parse: exponent part is missing a number
SyntaxError: JSON.parse: unexpected end of data
SyntaxError: JSON.parse: unexpected keyword
SyntaxError: JSON.parse: unexpected character
SyntaxError: JSON.parse: end of data while reading object contents
SyntaxError: JSON.parse: expected property name or '}'
SyntaxError: JSON.parse: end of data when ',' or ']' was expected
SyntaxError: JSON.parse: expected ',' or ']' after array element
SyntaxError: JSON.parse: end of data when property name was expected
SyntaxError: JSON.parse: expected double-quoted property name
SyntaxError: JSON.parse: end of data after property name when ':' was expected
SyntaxError: JSON.parse: expected ':' after property name in object
SyntaxError: JSON.parse: end of data after property value in object
SyntaxError: JSON.parse: expected ',' or '}' after property value in object
SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal
SyntaxError: JSON.parse: property names must be double-quoted strings
SyntaxError: JSON.parse: expected property name or '}'
SyntaxError: JSON.parse: unexpected character
SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data
SyntaxError: JSON.parse Error: Invalid character at position {0} (Edge)
```

エラー種別
-----

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

`JSON.parse()` は文字列を JSON として解釈します。この文字列は妥当な JSON であるべきであり、不正確な構文に出会った場合、このエラーが発生します。

例
-

### `JSON.parse()` は末尾のカンマを許容しない

どちらの行でも SyntaxError が発生します。

```js
JSON.parse("[1, 2, 3, 4,]");
JSON.parse('{"foo": 1,}');
// SyntaxError JSON.parse: unexpected character
// at line 1 column 14 of the JSON data
```

末尾のカンマを省略すると、正しく JSON として解釈します。

```js
JSON.parse("[1, 2, 3, 4]");
JSON.parse('{"foo": 1}');
```

### プロパティ名は二重引用符で囲んだ文字列でなければならない

プロパティを囲むのに、たとえば 'foo' のように単一引用符を使用してはいけません。

```js
JSON.parse("{'foo': 1}");
// SyntaxError: JSON.parse: expected property name or '}'
// at line 1 column 2 of the JSON data
```

代わりに "foo" と書いてください。

```js
JSON.parse('{"foo": 1}');
```

### 先頭のゼロと小数点

01 のような先頭の 0 は使用できません。また、小数点の後には少なくとも 1 桁以上が続かなければなりません。

```js
JSON.parse('{"foo": 01}');
// SyntaxError: JSON.parse: expected ',' or '}' after property value
// in object at line 1 column 2 of the JSON data

JSON.parse('{"foo": 1.}');
// SyntaxError: JSON.parse: unterminated fractional number
// at line 1 column 2 of the JSON data
```

0 を除いて 1 だけを書いてください。また、小数点の後には少なくとも 1 桁の数字を置いてください。

```js
JSON.parse('{"foo": 1}');
JSON.parse('{"foo": 1.0}');
```

関連情報
----

* `JSON`
* `JSON.parse()`
* `JSON.stringify()`


Warning: unreachable code after return statement - JavaScript

Warning: unreachable code after return statement
================================================

JavaScript の警告 "unreachable code after return statement" は、 `return` 文の後で式を使用したり、セミコロンのない return 文を使用して、その直後に式を置いたりした場合に発生します。

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

```js
Warning: unreachable code after return statement (Firefox)
```

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

警告

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

unreachable code after a return statement は、以下のような場合に発生することがあります。

* `return` 文の後で式を使用している場合
* セミコロンがない return 文の直後に式を置いている場合

有効な `return` 文の後に式がある場合、警告は `return` 文の後のコードには到達しない、つまり決して実行されないことを表します。

`return` 文の後にセミコロンをつけるべきなのはなぜでしょうか。セミコロンがない `return` 文の場合、開発者が次の行にある文を返そうとしているのか、処理を停止して戻ろうとしているのかが不明確になってしまいます。この警告は、 `return` 文の書かれ方にあいまいさがあることを示しています。

以下の文の場合、セミコロンがない場合の return の警告は表示されません。

* `throw`
* `break`
* `var`
* `function`
例
-

### 無効な場合

```js
function f() {
  var x = 3;
  x += 4;
  return x; // return は直ちに関数を終了します。
  x -= 3; // そのため、この行は実行されません。到達不可能です。
}

function f() {
  return // これは `return;` のように扱われます。
    3 + 4; // そのため、関数を抜け出し、この行には決して到達しません。
}
```

### 妥当な場合

```js
function f() {
  var x = 3;
  x += 4;
  x -= 3;
  return x; // OK: すべての式の後に return があります。
}

function f() {
  return 3 + 4; // OK: 同じ行に式があるセミコロンなしの return です。
}
```

関連情報
----

* 自動セミコロン挿入


TypeError: can't delete non-configurable array element - JavaScript

TypeError: can't delete non-configurable array element
======================================================

JavaScript の例外 "can't delete non-configurable array element" は、配列を短縮しようとしたときに配列の要素の 1 つが設定不可であった場合に発生します。

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

```js
TypeError: can't delete non-configurable array element (Firefox)
TypeError: Cannot delete property '2' of [object Array] (Chrome)
```

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

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

配列を短縮しようとしていますが、配列の要素が変更不可です。配列の短縮をするとき、新しい配列の長さを超える要素は削除されますが、このシチュエーションでは失敗します。

`configurable` 属性はプロパティをオブジェクトから削除できるかどうか、および (`writable` 以外の) 変更できるかどうかを制御します。

通常、配列初期化子で生成されたオブジェクトのプロパティは変更可能です。しかし、たとえば `Object.defineProperty()` が使用された場合、既定でプロパティを変更できません。

例
-

### `Object.defineProperty` で生成した変更不可能なプロパティ

プロパティを変更できないように指定する場合、`Object.defineProperty()` は既定で変更できないプロパティを生成します。

```js
"use strict";
var arr = [];
Object.defineProperty(arr, 0, { value: 0 });
Object.defineProperty(arr, 1, { value: "1" });

arr.length = 1;
// TypeError: can't delete non-configurable array element
```

配列を短縮したい場合、要素を変更可能に設定する必要があります。

```js
"use strict";
var arr = [];
Object.defineProperty(arr, 0, { value: 0, configurable: true });
Object.defineProperty(arr, 1, { value: "1", configurable: true });

arr.length = 1;
```

### 封印された配列

`Object.seal()` 関数はすべての存在する要素を設定不可にします。

```js
"use strict";
var arr = [1, 2, 3];
Object.seal(arr);

arr.length = 1;
// TypeError: can't delete non-configurable array element
```

`Object.seal()` の呼び出しを削除するか、配列のコピーを取る必要があります。コピーの場合、コピーした配列の短縮は元の配列の長さに影響しません。

```js
"use strict";
var arr = [1, 2, 3];
Object.seal(arr);

// Copy the initial array to shorten the copy
var copy = Array.from(arr);
copy.length = 1;
// arr.length == 3
```

関連項目
----

* [[Configurable]]
* `Array.length`
* `Object.defineProperty()`
* `Object.seal()`


TypeError: Reduce of empty array with no initial value - JavaScript

TypeError: Reduce of empty array with no initial value
======================================================

JavaScript の例外 "reduce of empty array with no initial value" は、 reduce 関数が使用されたときに発生します。

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

```js
TypeError: reduce of empty array with no initial value
```

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

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

JavaScript には、複数の reduce 関数があります。

* `Array.prototype.reduce()`、`Array.prototype.reduceRight()` と
* `TypedArray.prototype.reduce()`、`TypedArray.prototype.reduceRight()`)。

これらの関数は、オプションとして (最初に `callback` が呼び出される際の最初の引数として使用される) `initialValue` を受け取ります。しかし、初期値を提供しない場合は、`Array` や `TypedArray` の最初の要素が初期値として使用されます。空の配列が提供されて初期値を取得できない場合にこのエラーが発生します。

例
-

### 無効なケース

この問題は、しばしばリストのすべての要素を取り除くフィルター (`Array.prototype.filter()`、`TypedArray.prototype.filter()`) で結合した際に発生します。したがって、初期値がないまま使用することになります。

```js
var ints = [0, -1, -2, -3, -4, -5];
ints
  .filter((x) => x > 0) // removes all elements
  .reduce((x, y) => x + y); // no more elements to use for the initial value.
```

似たようなケースとして、セレクターに typo がある場合やリストに予想外の数の要素がある場合に同様の問題が発生します:

```js
var names = document.getElementsByClassName("names");
var name_list = Array.prototype.reduce.call(
  names,
  (acc, name) => acc + ", " + name,
);
```

### 有効な場合

これらの問題は、2 つの異なる方法で解決できます。

1 つ目の方法は、`initialValue` を提供することです; 加算の場合には 0、乗算の場合には 1、文字連結の場合は空文字など、その操作にとって自然な値を指定します。

```js
var ints = [0, -1, -2, -3, -4, -5];
ints
  .filter((x) => x < 0) // removes all elements
  .reduce((x, y) => x + y, 0); // the initial value is the neutral element of the addition
```

もう 1 つの方法は、`reduce` を呼び出す前、または予期しないダミーの初期値を追加した後にコールバックで空のケースを処理する方法です。

```js
var names = document.getElementsByClassName("names");

var name_list1 = "";
if (names1.length >= 1)
  name_list1 = Array.prototype.reduce.call(
    names,
    (acc, name) => acc + ", " + name,
  );
// name\_list1 == "" when names is empty.

var name_list2 = Array.prototype.reduce.call(
  names,
  (acc, name) => {
    if (acc == "")
      // initial value
      return name;
    return acc + ", " + name;
  },
  "",
);
// name\_list2 == "" when names is empty.
```

関連項目
----

* `Array.prototype.reduce()`
* `Array.prototype.reduceRight()`
* `TypedArray.prototype.reduce()`
* `TypedArray.prototype.reduceRight()`
* `Array`
* `TypedArray`
* `Array.prototype.filter()`
* `TypedArray.prototype.filter()`


SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated - JavaScript

SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated
=============================================================================

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

SyntaxError:
"0"-prefixed octal literals and octal escape sequences are deprecated;
for octal literals use the \"0o\" prefix instead
```

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

strict モードでのみ `SyntaxError`。

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

8 進文字と 8 進エスケープシーケンスは非推奨で、strict モードでは `SyntaxError` をスローします。ECMAScript 2015 以降では、標準文法として 0 から始まり大文字、または小文字のラテン文字 "O" (`0o` or `0O)` が続く文法を使用します。

例
-

### "0" 接頭辞付きの 8 進文字

```js
"use strict";

03;

// SyntaxError: "0"-prefixed octal literals and octal escape sequences
// are deprecated
```

### 8 進エスケープシーケンス

```js
"use strict";

"\251";

// SyntaxError: "0"-prefixed octal literals and octal escape sequences
// are deprecated
```

### 有効な 8 進数

0 に "o" か "O" が続くものを使用します:

```js
0o3;
```

8 進エスケープシーケンスの代わりに、16 進エスケープシーケンスを使用できます:

```js
"\xA9";
```

関連項目
----

* 字句文法
* Warning: 08/09 is not a legal ECMA-262 octal constant


RangeError: repeat count must be non-negative - JavaScript

RangeError: repeat count must be non-negative
=============================================

JavaScript の例外 "repeat count must be non-negative" は、 `String.prototype.repeat()` メソッドに `count` 引数が指定され、その値が負の数であった場合に発生します。

メッセージ
-----

```js
RangeError: argument out of range
RangeError: repeat count must be non-negative (Firefox)
RangeError: Invalid count value (Chrome)
```

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

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

`String.prototype.repeat()` メソッドを使用しています。 `count` 引数は、文字列の繰り返し回数を指定します。 これは 0 から正の `Infinity` 未満の値である必要があり、負の数は使用できません。 有効値の範囲は [0, +∞) のように説明できます。

例
-

### 無効なケース

```js
"abc".repeat(-1); // RangeError
```

### 有効な場合

```js
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(2); // 'abcabc'
"abc".repeat(3.5); // 'abcabcabc' (count は整数に変換されます)
```

関連情報
----

* `String.prototype.repeat()`


ReferenceError: assignment to undeclared variable "x" - JavaScript

ReferenceError: assignment to undeclared variable "x"
=====================================================

JavaScript の strict モード独自の例外 "Assignment to undeclated variable" は、値が宣言されていない変数に代入されたときに発生します。

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

```js
ReferenceError: assignment to undeclared variable "x" (Firefox)
ReferenceError: "x" is not defined (Chrome)
ReferenceError: Variable undefined in strict mode (Edge)
```

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

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

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

宣言していない変数に値を代入しています。つまり、 `var` キーワードを使用せずに代入をしています。宣言した変数と宣言していない変数の間には、予想外の結果を招くいくつかの違いがあります。それが、 strict モードで JavaScript がエラーを発生させる理由です。

宣言した変数と宣言していない変数について、3 つの注意点があります。

* 宣言した変数は、それが宣言された実行コンテキストに制限されます。宣言していない変数は常にグローバルです。
* 宣言した変数は、コードが実行される前に生成されます。宣言していない変数は、それに割り当てるコードが実行されるまで存在しません。
* 宣言した変数は、その実行コンテキスト (関数かグローバル) で設定不可能なプロパティです。 宣言していない変数は、設定可能です (たとえば、削除できます)。

詳細や具体例は、`var` 参照ページを見てください。

strict モードのコード でのみ、宣言していない変数割り当てエラーが発生します。非 strict コードでは、それらは暗黙裡に無視されます。

例
-

### 無効なケース

このケースでは、変数 "bar" は宣言していない変数です。

```js
function foo() {
  "use strict";
  bar = true;
}
foo(); // ReferenceError: assignment to undeclared variable bar
```

### 有効な場合

"bar" を宣言済みの変数にするために、その前に `var` キーワードを追加します。

```js
function foo() {
  "use strict";
  var bar = true;
}
foo();
```

関連情報
----

* Strict モード


SyntaxError: missing name after . operator - JavaScript

SyntaxError: missing name after . operator
==========================================

JavaScript の例外 "missing name after . operator" は、プロパティアクセスのためのドット演算子 (`.`) の使い方に問題があった場合に発生します。

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

```js
SyntaxError: missing name after . operator
```

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

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

メンバー演算子に対して、ドット演算子 (`.`) が使われました。アクセスしたいプロパティ名を指定しなければなりません。計算されたプロパティアクセスのためには、プロパティアクセスをドットを使用したものから角括弧を使用したものに変更する必要があります。それにより、式を計算できるようになります。そうではなく、連結しようとしましたか? その場合は、プラス演算子 (`+`) を代わりに使用してください。以下の例をご覧ください。

例
-

### プロパティアクセス

JavaScript のメンバー演算子は、ドット (.) か角括弧 (`[]`) を使用しますが、両方は使いません。角括弧で計算されたプロパティアクセスができます。

```js
var obj = { foo: { bar: "baz", bar2: "baz2" } };
var i = 2;

obj.[foo].[bar]
// SyntaxError: missing name after . operator

obj.foo."bar"+i;
// SyntaxError: missing name after . operator
```

このコードを修正するには、次のようにオブジェクトにアクセスする必要があります。

```js
obj.foo.bar; // "baz"
// or alternatively
obj["foo"]["bar"]; // "baz"

// computed properties require square brackets
obj.foo["bar" + i]; // "baz2"
```

### プロパティアクセスと連結

(PHP のような) ほかの言語から来た人なら、ドット演算子 (`.`) と連結演算子 (`+`) を混同しがちです。

```js
console.log("Hello" . "world");

// SyntaxError: missing name after . operator
```

連結のためにはプラス記号を使用してください。

```js
console.log("Hello" + "World");
```

関連項目
----

* メンバー演算子


SyntaxError: "use strict" not allowed in function with non-simple parameters - JavaScript

SyntaxError: "use strict" not allowed in function with non-simple parameters
============================================================================

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

Firefox:
SyntaxError: "use strict" not allowed in function with default parameter
SyntaxError: "use strict" not allowed in function with rest parameter
SyntaxError: "use strict" not allowed in function with destructuring parameter

Chrome:
SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list
```

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

`SyntaxError`。

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

次の引数のうちいずれかを持つ関数の先頭に `"use strict"` ディレクティブが書かれています:

* Default parameters
* Rest parameters
* Destructuring parameters

ECMAScript 仕様に則って、このような関数の先頭では `"use strict"` を使用できません。

例
-

### Function ステートメント

このケースでは、関数 `sum` は既定値を持つ引数 `a=1` と `b=2` を持っています:

```js
function sum(a=1, b=2) {
  // SyntaxError: "use strict" not allowed in function with default parameter
  "use strict";
  return a + b;
}
```

関数を strict モードにしたい、かつスクリプト全体、またはエンクロージャー関数が strict モードになってもよいなら、`"use strict"` ディレクティブを関数の外側に移動できます:

```js
"use strict";
function sum(a = 1, b = 2) {
  return a + b;
}
```

### Function 式

function 式では、別の回避策をとることができます:

```js
var sum = function sum([a, b]) {
  // SyntaxError: "use strict" not allowed in function with destructuring parameter
  "use strict";
  return a + b;
};
```

これは、次の式に変換できます:

```js
var sum = (function () {
  "use strict";
  return function sum([a, b]) {
    return a + b;
  };
})();
```

### アロー関数

アロー関数が `this` 変数にアクセスする必要がある場合、アロー関数をエンクロージャー関数として使用できます:

```js
var callback = (...args) => {
  // SyntaxError: "use strict" not allowed in function with rest parameter
  "use strict";
  return this.run(args);
};
```

これは、次の式に変換できます:

```js
var callback = (() => {
  "use strict";
  return (...args) => {
    return this.run(args);
  };
})();
```

関連項目
----

* Strict mode
* function statement
* function expression
* Default parameters
* Rest parameters
* Destructuring parameters


SyntaxError: missing variable name - JavaScript

SyntaxError: missing variable name
==================================

JavaScript の例外 "missing variable name" は、開発者がよく経験するエラーです。入力間違いや変数名を忘れた場合によく発生します。

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

```js
SyntaxError: missing variable name (Firefox)
SyntaxError: Unexpected token = (Chrome)
```

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

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

変数の名前がありません。原因は、タイプミスや変数名の忘れがほとんどです。変数名が `=` 記号の前に記載されていることを確認してください。

複数の変数を同時に宣言する場合は、前の行/宣言がセミコロンではなくカンマで終わっていないことを確認してください。

例
-

### 変数名を忘れている

```js
var = "foo";
```

分かりやすい変数名を考えることは、ほとんどの開発者にとって難しいことです。しかし、時間が経てば簡単になります。

```js
var description = "foo";
```

### 予約語は変数名にできない

いくつか予約語である変数名があります。使用できません。ごめんね:(

```js
var debugger = "whoop";
// SyntaxError: missing variable name
```

### 複数の変数宣言

複数の変数を宣言するときは、カンマに特別な注意を払ってください。余分なカンマがありませんか?誤ってセミコロンの代わりにカンマを加えていませんか?

```js
var x, y = "foo",
var x, = "foo"

var first = document.getElementById('one'),
var second = document.getElementById('two'),

// SyntaxError: missing variable name
```

修正版は次の通りです。

```js
var x,
  y = "foo";
var x = "foo";

var first = document.getElementById("one");
var second = document.getElementById("two");
```

### 配列

JavaScript の `Array` リテラルは、値を角括弧で囲む必要があります。これは動作しません。

```js
var arr = 1,2,3,4,5;
// SyntaxError: missing variable name
```

正しくは次の通りです。

```js
var arr = [1, 2, 3, 4, 5];
```

関連情報
----

* 良い変数名
* `var`
* JavaScript ガイドの変数の宣言


RangeError: invalid array length - JavaScript

RangeError: invalid array length
================================

JavaScript の例外 "Invalid array length" は、配列の長さが負の数か、プラットフォームで対応している最大値を超える値に設定しようとしたとき (すなわち、 `Array` または `ArrayBuffer` を生成しようとしたとき、または `Array.length` を設定しようとしたとき) に発生します。

配列の長さに許されている最大値は、プラットフォームとブラウザーとそのバージョンに依存します。 `Array` については、最大長は 2GB-1 (2^32-1) です。 `ArrayBuffer` については、最大値は 32 ビットシステムで 2GB-1 (2^32-1) です。 Firefox バージョン 89 から、 `ArrayBuffer` の最大値は 64 ビットシステムでは 8GB (2^33) です。

**メモ:** `Array` と `ArrayBuffer` は別個のデータ構造です (一方の実装がもう一方には影響しません)。

メッセージ
-----

```js
RangeError: invalid array length (Firefox)
RangeError: Invalid array length (Chromium-based)
RangeError: Array buffer allocation failed (Chromium-based)
```

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

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

配列の長さが不正になるのは、以下のような場合です。

* `Array` や `ArrayBuffer` を、負の数の長さで生成しようとしたか、 `Array.length` プロパティに負の数を設定しようとした。
* 2GB-1 (2^32-1) よりも大きな `Array` を生成しようとしたか、 `Array.length` プロパティに設定しようとした。
* 32 ビットシステムで 2GB-1 (2^32-1)、 64 ビットシステムで 8GB (2^33) を超える `ArrayBuffer` を生成しようとした。
* Firefox 89 以前: 2GB-1 (2^32-1) より大きな `ArrayBuffer` を生成しようとした。

コンストラクターを使用して `Array` を生成すると、最初の引数が `Array` の長さとして解釈されるので、代わりにリテラル表記を使った方が良いかもしれません。

そうでない場合は、 length プロパティを設定する前、またはコンストラクターの引数として使用する前に、長さを制限しておくとよいでしょう。

例
-

### 不正なケース

```js
new Array(Math.pow(2, 40));
new Array(-1);
new ArrayBuffer(Math.pow(2, 32)); //32 ビットシステム
new ArrayBuffer(-1);

let a = [];
a.length = a.length - 1; // length プロパティに -1 を設定

let b = new Array(Math.pow(2, 32) - 1);
b.length = b.length + 1; // length プロパティに 2^32 を設定
```

### 有効な場合

```js
[Math.pow(2, 40)]; // [ 1099511627776 ]
[-1]; // [ -1 ]
new ArrayBuffer(Math.pow(2, 32) - 1);
new ArrayBuffer(Math.pow(2, 33)); // 64 ビットシステム、 Firefox 89 以降
new ArrayBuffer(0);

let a = [];
a.length = Math.max(0, a.length - 1);

let b = new Array(Math.pow(2, 32) - 1);
b.length = Math.min(0xffffffff, b.length + 1);

// 0xffffffff は 2^32 - 1 の 16 進表記です。
// (-1 >>> 0) と書くこともできます。
```

関連情報
----

* `Array`
* `Array.length`
* `ArrayBuffer`


ReferenceError: "x" is not defined - JavaScript

ReferenceError: "x" is not defined
==================================

JavaScript の例外 "*variable* is not defined" は、どこかで参照している変数が存在しない場合に発生します。

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

```js
ReferenceError: "x" is not defined
```

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

`ReferenceError`.

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

どこかで存在しない変数を参照しています。この変数を宣言しておくか、現在のスクリプトまたはスコープで利用可能であることを確認する必要があります。

**メモ:** ライブラリ (jQuery など) を読み込むとき、ライブラリの変数、例えば "$" にアクセスする前に読み込みが行われるかを確認してください。ライブラリを読み込む `<script>` 要素は、それを使用するコードよりも前に置いてください。

例
-

### 宣言されていない変数

```js
foo.substring(1); // ReferenceError: foo is not defined
```

"foo" と言う変数はどこにも宣言されていません。これは文字列である必要があり、それならば `String.prototype.substring()` メソッドが動作します。

```js
var foo = "bar";
foo.substring(1); // "ar"
```

### スコープの間違い

変数は現在の実行コンテキストで利用可能である必要があります。関数の中で定義された変数は、その関数のスコープ内でしか定義されていないので、関数の外のどこからもアクセスできません。

```js
function numbers() {
  var num1 = 2,
    num2 = 3;
  return num1 + num2;
}

console.log(num1); // ReferenceError num1 is not defined.
```

しかし、関数はそれが定義されたスコープ内で定義されたすべての変数と関数にアクセスすることができます。言い換えれば、グローバルスコープで定義された関数は、グローバルスコープ内で定義されたすべての変数にアクセスすることができます。/p>

```js
var num1 = 2,
  num2 = 3;

function numbers() {
  return num1 + num2;
}

console.log(numbers()); // 5
```

関連情報
----

* スコープ
* 変数の宣言 (JavaScript ガイド)
* 関数のスコープ (JavaScript ガイド)


SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead - JavaScript

SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead
===================================================================================

JavaScript の警告 "Using `//@` to indicate sourceURL pragmas is deprecated. Use `//#` instead" は、 JavaScript の非推奨のソースマップ構文があったときに発生します。

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

Warning: SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead

Warning: SyntaxError: Using //@ to indicate sourceMappingURL pragmas is deprecated. Use //# instead
```

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

`SyntaxError` が発生したという警告です。 JavaScript の実行は停止しません。

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

JavaScript のソースに非推奨のソースマップ構文があることです。

通常 JavaScript ソースは、サーバーからの提供を効率化するために、結合と最小化が行われます。ソースマップがあると、デバッガーが実行中のコードを元のソースファイルに対応付けすることができます。

IE の JScript エンジンは、`//@cc_on` の後でページが見つかると、条件付きコンパイルの有効化とみなします。 この IE での競合のために、ソースマップの仕様の構文が変更されました。IE の @cc\_on 文 はあまり知られていない機能ですが、jQuery やそのほかのライブラリのソースマップを破壊します。

例
-

### 非推奨の構文

"@" 記号による構文は非推奨です。

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

### 標準の構文

代わりに "#" 記号を使用してください。

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

あるいは、JavaScript ファイルに `SourceMap` ヘッダーを設定して、コメントを全く表示しないようにすることもできます。

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

関連情報
----

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


TypeError: property "x" is non-configurable and can't be deleted - JavaScript

TypeError: property "x" is non-configurable and can't be deleted
================================================================

JavaScript の例外 "property is non-configurable and can't be deleted" は、プロパティを削除しようとしたが、そのプロパティが構成不可である場合に発生します。

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

```js
TypeError: Calling delete on 'x' is not allowed in strict mode (Edge)
TypeError: property "x" is non-configurable and can't be deleted. (Firefox)
TypeError: Cannot delete property 'x' of #<Object> (Chrome)
```

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

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

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

プロパティを削除しようとしましたが、プロパティが non-configurable でした。`configurable` 属性は、オブジェクトからプロパティを削除できるかどうか、および (`writable` を除く) 属性を変更できるかどうかを制御します。

このエラーは、strict モードのコード でのみ発生します。非 strict コードでは、この操作は `false` を返します。

例
-

### 構成不可のプロパティに対する削除の試み

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

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

("use strict");
var obj = {};
Object.defineProperty(obj, "foo", { value: 2, configurable: false });
delete obj.foo; // TypeError

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

JavaScript に組み込まれた、少数の構成不可プロパティもあります。もしかしたら、Math の定数を削除しようとしたのかもしれません。

```js
"use strict";
delete Math.PI; // TypeError
```

関連情報
----

* delete
* `Object.defineProperty()`
* `Object.freeze()`


SyntaxError: missing ) after condition - JavaScript

SyntaxError: missing ) after condition
======================================

JavaScript の例外 "missing ) after condition" は、 `if` 文の条件の書き方にエラーがあった場合に発生します。 `if` キーワードの後には括弧が必要です。

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

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

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

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

`if` 条件の書き方にエラーがあります。どのプログラミング言語でも、コードは様々な入力に応じて決定を行い、アクションを実行する必要があります。if 文は指定した条件を満たす場合、処理を実行します。JavaScript では次のように、この条件は `if` キーワードの後に括弧を付ける必要があります。

```js
if (condition) {
  // do something if the condition is true
}
```

例
-

### 括弧の欠落

ちょっとした見落としかもしれないので、慎重にコード内のすべての括弧をチェックしてください。

```js
if (3 > Math.PI {
  console.log("wait what?");
}

// SyntaxError: missing ) after condition
```

このコードを修正するには、条件を閉じる括弧を追加する必要があります。

```js
if (3 > Math.PI) {
  console.log("wait what?");
}
```

### `is` キーワードの誤用

他の言語から来た人ならば、 JavaScript で同じ意味を持たないキーワードや意味のないキーワードを追加してしまいがちです。

```js
if (done is true) {
 console.log("we are done!");
}

// SyntaxError: missing ) after condition
```

代わりに、正しい比較演算子を使うべきです。例を示します。

```js
if (done === true) {
  console.log("we are done!");
}
```

関連項目
----

* `if...else`
* 比較演算子
* コードでの意思決定 — 条件文


RangeError: repeat count must be less than infinity - JavaScript

RangeError: repeat count must be less than infinity
===================================================

JavaScript の例外 "repeat count must be less than infinity" は、 `String.prototype.repeat()` メソッドが使用され、 `count` 引数が無限大である場合に発生します。

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

```js
RangeError: argument out of range (Edge)
RangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox)
RangeError: Invalid count value (Chrome)
```

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

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

`String.prototype.repeat()` メソッドを使用しています。`count` 引数は、文字列の繰り返し回数を指定します。 これは 0 から正の `Infinity` 未満の値である必要があり、負の数は使用できません。有効値の範囲は [0, +∞) のように表現することができます。

結果の文字列は、文字列サイズの最大値以上にはできません。これは JavaScript エンジンによって異なります。 Firefox (SpiderMonkey) の最大文字列数は、 228 -1 （`0xFFFFFFF）`です。

例
-

### 無効なケース

```js
"abc".repeat(Infinity); // RangeError
"a".repeat(2 \*\* 28); // RangeError
```

### 有効な場合

```js
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(2); // 'abcabc'
"abc".repeat(3.5); // 'abcabcabc' (count は整数に変換されます)
```

関連情報
----

* `String.prototype.repeat()`


ReferenceError: can't access lexical declaration`X' before initialization - JavaScript

ReferenceError: can't access lexical declaration`X' before initialization
=========================================================================

 JavaScript の例外 "can't access lexical declaration `*variable*' before
 initialization" は、語彙変数が初期化前にアクセスされたときに発生します。これはブロック文内で、 `let` または `const` 宣言が定義される前にアクセスされたときに発生します。

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

```js
ReferenceError: Use before delaration (Edge)
ReferenceError: can't access lexical declaration `X' before initialization (Firefox)
ReferenceError: 'x' is not defined (Chrome)
```

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

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

初期化前に語彙変数にアクセスしました。これはブロックステートメント内で、定義される前に`let` か `const` 宣言にアクセスすると発生します。

例
-

### 不正な場合

この場合、変数 "foo" はブロックステートメント内で `let` を使用して再宣言されています。

```js
function test() {
  let foo = 33;
  if (true) {
    let foo = foo + 55;
    // ReferenceError: can't access lexical
    // declaration `foo' before initialization
  }
}
test();
```

### 有効な場合

"foo" を if ステートメント内に変更するには、再宣言の原因となる `let` を取り除きます。

```js
function test() {
  let foo = 33;
  if (true) {
    foo = foo + 55;
  }
}
test();
```

関連情報
----

* let における一時的なデッドゾーンとエラー


TypeError: can't assign to property "x" on "y": not an object - JavaScript

TypeError: can't assign to property "x" on "y": not an object
=============================================================

JavaScript の strict モードの例外 "can't assign to property" は、プリミティブ値、例えばシンボル、文字列、数値、論理値などにプロパティを作成しようとしたときに発生します。プリミティブ値はいかなるプロパティを持つこともできません。

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

```js
TypeError: can't assign to property "x" on {y}: not an object (Firefox)
TypeError: Cannot create property 'x' on {y} (Chrome)
```

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

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

Strict モードでは、 `TypeError` はプリミティブ値、例えばシンボル、文字列、数値、論理値などにプロパティを作成しようとしたときに発生します。プリミティブ値はいかなるプロパティを持つこともできません。

想定外の場所に想定外の値が流れてきたり、 `String` や `Number` のオブジェクトバリアントが想定されていたりすることが問題となることがあります。

例
-

### 無効な場合

```js
"use strict";

var foo = "my string";
// 次の行は strict モードでない場合は何もしません。
foo.bar = {}; // TypeError: can't assign to property "bar" on "my string": not an object
```

### 問題の修正

このような場所でプリミティブ値を使用しないようにコードを修正するか、 `Object` と同等のオブジェクトを生成して問題を修正するかします。

```js
"use strict";

var foo = new String("my string");
foo.bar = {};
```

関連情報
----

* Strict モード
* プリミティブ


TypeError: invalid assignment to const "x" - JavaScript

TypeError: invalid assignment to const "x"
==========================================

JavaScript の例外 "invalid assignment to const" は、定数を変更しようとしたときに発生します。 JavaScript の `const` で宣言すると、再代入や再宣言を行うことができません。

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

```js
TypeError: invalid assignment to const "x" (Firefox)
TypeError: Assignment to constant variable. (Chrome)
TypeError: Assignment to const (Edge)
TypeError: Redeclaration of const 'x' (IE)
```

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

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

定数は、通常の実行中にプログラムによって変更できない値です。再代入も再宣言もできません。JavaScript では、定数を `const` キーワードで宣言します。

例
-

### 無効な再宣言

同じブロックスコープで同じ定数名に値を代入すると、エラーが発生します。

```js
const COLUMNS = 80;

// ...

COLUMNS = 120; // TypeError: invalid assignment to const `COLUMNS'
```

### エラーの修正

エラーを修正するには、複数の選択肢があります。問題となっている定数で、達成しようとしていたことを確認してください。

#### 名前の変更

ほかの定数を宣言しようとしていたのであれば、ほかの名前を選んで名前を変更してください。この定数名は、すでにこのスコープで使用されています。

```js
const COLUMNS = 80;
const WIDE\_COLUMNS = 120;
```

#### `const`、`let`、`var`

定数を宣言するつもりがなかったのであれば、 const を使用しないでください。ブロックスコープの変数であれば `let` で、グローバルスコープの変数であれば `var` で宣言してください。

```js
let columns = 80;

// ...

let columns = 120;
```

#### スコープ

正しいスコープにあるか確認してください。たとえば、この定数はこのスコープにあるべきなのでしょうか。それとも関数にあるべきなのでしょうか。

```js
const COLUMNS = 80;

function setupBigScreenEnvironment() {
  const COLUMNS = 120;
}
```

### `const` と不変性

`const` 宣言は、値への読み取り専用の参照を作成します。それが保持している値が不変であることを意味するものでは**なく**、変数識別子に再代入できないだけです。たとえば、コンテンツがオブジェクトである場合、オブジェクト自体はまだ変更可能であることを意味します。 つまり、変数に格納されている値を変更することはできないということです。

```js
const obj = { foo: "bar" };
obj = { foo: "baz" }; // TypeError: invalid assignment to const `obj'
```

しかし、変数内のプロパティは変更することができます。

```js
obj.foo = "baz";
obj; // Object { foo: "baz" }
```

関連項目
----

* `const`
* `let`
* `var`


SyntaxError: a declaration in the head of a for-of loop can't have an initializer - JavaScript

SyntaxError: a declaration in the head of a for-of loop can't have an initializer
=================================================================================

JavaScript の例外 "a declaration in the head of a for-of loop can't have an initializer" は、 for...of ループの先頭に |`for (var i = 0 of iterable)`| のように初期化子が含まれている場合に発生します。これは for-of ループでは許可されていません。

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

```js
SyntaxError: for-of loop head declarations cannot have an initializer (Edge)
SyntaxError: a declaration in the head of a for-of loop can't have an initializer (Firefox)
SyntaxError: for-of loop variable declaration may not have an initializer. (Chrome)
```

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

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

for...of ループの先頭に初期化式が含まれています。つまり、 |`for (var i = 0 of iterable)`| のように変数が宣言され、値が代入されています。これは、 for-of ループでは許可されていません。初期化できる `for` ループを使用した方が良いかもしれません。

例
-

### 不正な `for-of` ループ

```js
let iterable = [10, 20, 30];

for (let value = 50 of iterable) {
  console.log(value);
}

// SyntaxError: a declaration in the head of a for-of loop can't
// have an initializer
```

### 有効な `for-of` ループ

`for-of` ループのヘッダーから初期化子 (`value = 50`) を取り除く必要があります。おそらく、50 をオフセット値にしようとしているのでしょうから、たとえばループのボディー内で 50 を加えられます。

```js
let iterable = [10, 20, 30];

for (let value of iterable) {
  value += 50;
  console.log(value);
}
// 60
// 70
// 80
```

関連項目
----

* `for...of`
* `for...in` – strict モードでは同様に初期化できない (SyntaxError: for-in loop head declarations may not have initializers)
* `for` – 反復時に初期化子を許可している


SyntaxError: missing formal parameter - JavaScript

SyntaxError: missing formal parameter
=====================================

```js
SyntaxError: missing formal parameter (Firefox)
```

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

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

"Formal parameter" とは「関数の引数」のことです。関数宣言で、有効な引数を忘れています。関数定義において、引数は識別子でなければならず、数字や文字列、オブジェクトのような値であってはいけません。関数の宣言と関数の呼び出しは、異なる 2 つのステップです。宣言時には引数として識別子が求められ、関数を呼び出すときだけ、関数が使用する値を提供します。

JavaScript では、識別子はアルファベット文字 (または "$" か "\_") だけを含めることができ、数値から始められません。文字列はデータですが、識別子はコードの一部です。そのため、識別子と**文字列**は異なるものです。

例
-

### 関数の正しい引数を提供する

関数を定義するとき、関数の引数は識別子でなければなりません。引数として値を提供しているため、これらの関数宣言はすべて失敗します。

```js
function square(3) {
  return number \* number;
};
// SyntaxError: missing formal parameter

function greet("Howdy") {
  return greeting;
};
// SyntaxError: missing formal parameter

function log({ obj: "value"}) {
  console.log(arg)
};
// SyntaxError: missing formal parameter
```

関数宣言では、識別子を使用しなければなりません。

```js
function square(number) {
  return number \* number;
}

function greet(greeting) {
  return greeting;
}

function log(arg) {
  console.log(arg);
}
```

次に、好きな引数を渡してこれらの関数を呼び出すことができます。

```js
square(2); // 4

greet("Howdy"); // "Howdy"

log({ obj: "value" }); // Object { obj: "value" }
```

関連項目
----

* 形式的な引数に関係するその他のエラー:
    + SyntaxError: Malformed formal parameter
    + SyntaxError: redeclaration of formal parameter "x"


SyntaxError: missing : after property id - JavaScript

SyntaxError: missing : after property id
========================================

JavaScript の例外 "missing : after property id" は、オブジェクトがオブジェクト初期化子の構文を使用して生成されたときに発生します。コロン (`:`) はオブジェクトのプロパティのキーと値を区切ります。おそらく、このコロンがないか場所が間違っているかです。

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

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

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

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

オブジェクト初期化子構文でオブジェクトを生成する場合、オブジェクトのプロパティのキーと値をコロン (`:`) で区切ります。

```js
var obj = { propertyKey: "value" };
```

例
-

### コロンと代入記号

この方法で代入記号をオブジェクト初期化子構文として使用できないため、このコードは失敗します。

```js
var obj = { propertyKey = 'value' };
// SyntaxError: missing : after property id
```

正しくはコロンを使用するか、オブジェクトを生成した後に角括弧を使用して新しいプロパティを割り当てます。

```js
var obj = { propertyKey: "value" };

// または

var obj = {};
obj["propertyKey"] = "value";
```

### 空のプロパティ

次のような方法では、プロパティを生成することができません。

```js
var obj = { propertyKey; };
// SyntaxError: missing : after property id
```

値がないプロパティを定義する必要がある場合、値として `null` を使用することができます。

```js
var obj = { propertyKey: null };
```

### 計算されたプロパティ

式からプロパティキーを生成する場合、角括弧を使用してください。そうしなければ、プロパティ名を計算することができません。

```js
var obj = { 'b'+'ar': 'foo' };
// SyntaxError: missing : after property id
```

式を括弧 `[]` に入れてください。

```js
var obj = { ["b" + "ar"]: "foo" };
```

関連項目
----

* オブジェクト初期化子


Error: Permission denied to access property "x" - JavaScript

Error: Permission denied to access property "x"
===============================================

JavaScript の例外 "Permission denied to access property" は、権限がない状態でオブジェクトへのアクセスの試行があった場合に発生します。

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

```js
Error: Permission denied to access property "x"
```

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

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

権限がない状態でオブジェクトへのアクセスの試行がありました。これは異なるドメインから読み込んだ `<iframe>` 要素が同一オリジンポリシーに違反する場合などです。

例
-

### 文書にアクセスする権限がない

```html
<!doctype html>
<html>
  <head>
    <iframe
 id="myframe"
 src="http://www1.w3c-test.org/common/blank.html"></iframe>
    <script>
 onload = function () {
 console.log(frames[0].document);
 // Error: Permission denied to access property "document"
 };
 </script>
  </head>
  <body></body>
</html>
```

関連情報
----

* `<iframe>`
* 同一オリジンポリシー


SyntaxError: illegal character - JavaScript

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


SyntaxError: missing ] after element list - JavaScript

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

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

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

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`