recursal/MDN huggingface dataset:
名前付き後方参照: \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
============

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

構文
--


```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{...}
====================

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

構文
--


```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 の例外 "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 の例外 "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 のエラー "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 の例外 "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 の例外 "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 の例外 "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 の例外 "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);
```

関連項目
----

* 関数
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 の例外 "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 の例外 "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
=============================================================================

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

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 の例外 "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()`