recursal/MDN huggingface dataset:
URIError: malformed URI sequence
================================

错误提示
----
```

URIError: malformed URI sequence (Firefox)
URIError: URI malformed (Chrome)
```

错误类型
----

`URIError`哪里出错了？
------

URI 编码和解码不成功。传递给 `decodeURI`、`encodeURI`、`encodeURIComponent` 或者 `decodeURIComponent` 这些函数的参数不合法，导致函数无法正确对其进行编解码。

示例
--

### 编码

编码操作会将每一个字符实例替换为一到四个相对应的 UTF-8 编码形式的转义序列。如果试图编码一个非高 - 低位完整的代理字符，将会抛出一个 `URIError` 错误，例如：


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

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


高 - 低位完整的代理字符是没问题的，例如：


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

### 解码

解码操作则是将已经经过编码的 URL 片段中的每一个转义序列替换为相对应的字符。如果相应的字符不存在，就会抛出错误：


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


输入没问题的话，通常是下面这样：


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

相关内容
----

* `URIError`
* `decodeURI`
* `encodeURI`
* `encodeURIComponent`
* `decodeURIComponent`
SyntaxError: missing } after function body
==========================================

错误提示
----
```

SyntaxError: missing } after function body
```

错误类型
----

`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;
  }
});
```

相关内容
----

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

Message
-------
```

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

Error type
----------

`SyntaxError`What went wrong?
----------------

变量名叫identifiers，它符合某些规则，而你打破了这些规则！

一个 JavaScript 标识符必须以字母开头，下划线（\_）或美元符号（$）。他们不能以数字开头。只有后续字符可以是数字（0-9）。

Examples
--------

### Variable names starting with numeric literals

Variable names can't start with numbers in JavaScript. The following fails:


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

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


You will need to rename your variable to avoid the leading number.


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

See also
--------

* Lexical grammar
* Variables in the JavaScript Guide
TypeError: "x" is read-only
===========================

报错消息
----
```

TypeError: "x" is read-only (Firefox) //格式错误："x"只读。(x 可以代表任意值)
TypeError: 0 is read-only (Firefox)
TypeError: Cannot assign to read only property 'x' of #<Object> (Chrome)
//格式错误：对象的 x 属性是只读的不能设置（chrome）
TypeError: Cannot assign to read only property '0' of [object Array] (Chrome)
```

错误格式
----

`TypeError`哪里出错了？
------

全局变量或对象属性被设置为只读 (专业点讲，就是这条数据属性禁止写入.)

这条错误值发生在strict mode code(俗称严格模式). 正常情况下，是没有报错的。

例如
--

### 无效例子（也就是下面这么做会导致报这种错）

只读属性不能直接创建，但我们可以通过`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 内置属性。如果你尝试修改一个常量。

"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; //
LUNG\_COUNT = 3; //
```

参见
--

* `Object.defineProperty()`
* `Object.freeze()`
* "Which animals have three lungs?" on answers.com
* Klingons (another answer to that query)
RangeError: precision is out of range
=====================================

描述
--
```

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

错误类型
----

`RangeError`什么地方出错了？
--------

以下的某个方法传入了一个超出精度范围的参数：

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

通常这些方法允许的参数范围介于 0 和 20（或 21）之间。需要注意的是，ECMAScript 标准是允许扩展这个范围的。

| Method | Firefox (SpiderMonkey) | Chrome, Opera (V8) |
| --- | --- | --- |
| `Number.prototype.toExponential()` | 0 to 100 | 0 to 20 |
| `Number.prototype.toFixed()` | -20 to 100 | 0 to 20 |
| `Number.prototype.toPrecision()` | 1 to 100 | 1 to 21 |

示例
--

### 错误的示例


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

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

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

### 正确的示例


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

(2.34).toFixed(1); // 2.3
(2.35).toFixed(1); // 2.4 (note that it rounds up in this case)

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

相关页面
----

* `Number.prototype.toExponential()`
* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()`
TypeError: invalid assignment to const "x"
==========================================

错误提示
----
```

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

错误类型
----

`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` or `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`
TypeError: 'x' is not iterable
==============================

错误信息
----
```

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`, 一个 generator 生成结果，或者一个实现了 可迭代协议 的对象

示例
--

### Iterating over Object properties

在 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" };
// 迭代属性名称：
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);
```


这次 case 的另外一个选择是使用 `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);
```

### Iterating over a generator

生成器是用来生成可迭代对象的函数。


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

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


当它没有被调用，这个 `Function` 相应的是可调用的，但是不可迭代。调用 generator 生成一个可迭代对象，该对象将迭代在生成器执行期间生成的值。


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

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

### Iterating over a custom iterable

可以使用`Symbol.iterator` 方法去实现一个自定义迭代器。你必须确定自定义的迭代器方法返回一个迭代器对象，即它必须有一个 next()


```js
const myEmptyIterable = {
  [Symbol.iterator]() {
    return []; // [] is iterable, but it is not an iterator -- it has no next method.
  },
};

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


下面是正确用法


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

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

参阅
--

* iterable protocol
* `Object.keys`
* `Object.entries`
* `Map`
* 生成器
* for…of
ReferenceError: can't access lexical declaration`X' before initialization
=========================================================================

消息提示
----
```

ReferenceError: assignment to undeclared variable "x" (Firefox)
```

错误类型
----

`ReferenceError`哪里出错了？
------

词法变量在初始化之前被访问。该错误可以发生于任何语句块中，当使用 let 或 const 修饰的变量在初始化之前被访问的时候。

示例
--

### 非法情况

在这个例子中，变量 "foo" 在语句块中再次声明，导致未初始化。


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

### 正确情况

在 if 语句块中修改变量 "foo" 的值，不应该在其中进行二次声明。


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

相关内容
----

* let 的暂存死区及相关错误
SyntaxError: missing } after property list
==========================================

信息
--
```

SyntaxError: missing } after property list
```

错误类型
----

`SyntaxError`哪里出错了？
------

在对象初始化的时候语法出错了。可能是遗漏了一个大括号，也可能是遗漏了逗号。还要检查是否以正确的顺序关闭了大括号或括号。缩进或格式化代码也许可以更好帮助你看清这些芜杂的。

示例
--

### 遗漏的逗号

很多情况下，对象初始值代码会中缺少逗号：


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


正确的是：


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

相关
--

* Object initializer
SyntaxError: invalid regular expression flag "x"
================================================

信息
--
```

SyntaxError: invalid regular expression flag "x" (Firefox)
SyntaxError: Invalid regular expression flags (Chrome)
```

错误类型
----

`语法错误`.

什么地方出错了？
--------

在代码中出现了无效的正则表达式的标记。在一个正则表达式字面量中，由闭合的两条斜线组成一个模式，（正则表达式的）标记定义在第二个（斜线）标记之后。他们也可以通过`正则表达式` 对象的构造函数（第二个参数）来定义。正则表达式的标记可以单独或者任意次序的组合使用，但 ECMAScript 只规定了五个。

要使正则表达式包含标记，使用此语法：


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


或


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


| 标记 | 说明 |
| --- | --- |
| `g` | 整体检索。 |
| i | 忽略大小写检索。 |
| m | 多行检索。 |
| u | Unicode; 将模式视为 Unicode 码点的序列 |
| y | sticky 检索将从目标字符串的当前位置开始匹配。参阅`sticky` |

示例
--

只有 5 个有效的正则表达式标记。


```js
/foo/bar;

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


你打算创建一个正则表达式吗？一个包含两条斜线的表达式被解释为一个正则表达式的字面量。


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

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


还是你想创建一个字符串呢？添加单引号或双引号创建一个字符串字面量。


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

### 有效的正则表达式标记

在 JavaScript 中允许的五个有效的正则表达式标记，参阅上表。


```js
/foo/g;
/foo/gim;
/foo/uy;
```

相关页面
----

* 正则表达式
* XRegEx flags – 正则表达式库提供新的四个标记 (`n`, `s`, `x`, `A`)
SyntaxError: function statement requires a name
===============================================

错误提示
----
```

SyntaxError: function statement requires a name [Firefox]
SyntaxError: Unexpected token ( [Chrome]
```

错误类型
----

`SyntaxError`哪里出错了？
------

函数声明需要提供函数名称。你需要检查函数是如何定义的，是否需要为其提供名称，出现问题的函数是否需要声明为函数表达式或立即调用函数表达式（IIFE），以及函数在上下文环境中出现的位置是否正确。

示例
--

### 语句与表达式

函数语句（或函数声明）需要命名，以下写法是不正确的：


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


你可以使用函数表达式（赋值）来代替：


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


者是你想将其作为立即调用函数表达式（IIFE，Immediately Invoked Function Expression），也就是定义后立即执行的函数。在这种情况下你需要用到更多的括号：


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

### 标号函数 (Labeled functions)

你使用函数标号 (labels)的时候，也需要在关键词 `function` 后面提供一个函数名称。这样的代码是不能运行的：


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


这个例子可以正常运行：


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

### 对象方法

如果你想创建创建一个对象方法，那么需要首先创建一个对象。以下语法（function 关键字后面没有提供名称）是合法的：


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

### 回调函数的语法

另外，如果使用到了回调函数，那么检查一下语法是否正确。大括号与逗号很容易使情况变糟。


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


正确的形式应该是这样的：


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

相关内容
----

* Functions in the JavaScript Guide
* function statement
* function expression
* IIFE
* label
SyntaxError: missing formal parameter
=====================================

信息提示
----
```

SyntaxError: missing formal parameter (Firefox)
```

错误类型
----

`SyntaxError`哪里出错了？
------

“形式参数”是“函数参数”一种更好的说法。函数声明缺少合法的参数定义。在函数声明中，参数定义必须为标记符（identifiers），而不是任何类似于数字、字符串或者对象的值。函数声明和函数调用是两个不同的步骤。函数声明中的参数需要使用标记符，而仅仅在函数被呼叫（调用）的时候才可以传入其所需要的值。

在 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: redeclaration of formal parameter "x"
RangeError: repeat count must be non-negative
=============================================

信息
--
```

RangeError: repeat count must be non-negative (Firefox)
RangeError: Invalid count value (Chrome)
```

错误类型
----

`RangeError`发生了什么？
------

代码中使用了 `String.prototype.repeat()`方法。它有一个计数参数，表示重复该字符串的次数。该参数必须在 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 will be converted to integer)
```

See also
--------

* `String.prototype.repeat()`
Error: Permission denied to access property "x"
===============================================

消息
--
```

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

错误类型
----

`错误`.

什么地方出错了？
--------

尝试访问无权访问的对象。这很可能出现在使用`<iframe>`元素时加载了一个不同域名下的页面，这在访问子页面时会违背同源策略。

示例
--


```html
<!doctype html>
<html>
  <head>
    <iframe
 id="myframe"
 src="http://www1.w3c-test.org/common/blank.html"></iframe>
    <script>
 console.log(document.getElementById("myframe").contentWindow.document);
 // Error: Permission denied to access property "document"
 </script>
  </head>
  <body></body>
</html>
```


可以参考

* `<iframe>`
* 同源策略
SyntaxError: for-in loop head declarations may not have initializers
====================================================================

错误提示
----
```

SyntaxError: for-in loop head declarations may not have initializers (Firefox)

SyntaxError: for-in loop variable declaration may not have an initializer. (Chrome)
```

错误类型
----

该 `SyntaxError` 只出现于严格模式下。

哪里出错了？
------

在 for...in 循环的头部存在初始化表达式。也就是存在变量声明并且被赋值，例如 |`for (var i = 0 in obj)`|。在非严格模式下，这种在循环头部的变量声明会被静默忽略，语句的表现形式与 `|for (var i in obj)|`相同。而在严格模式下，会报语法错误。

示例
--

下面这个示例会报语法错误（`SyntaxError`）：


```js
"use strict";

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

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

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

### 合法的 for-in 循环

可以把初始化语句 (`i = 0`) 从 for-in 循环的头部移除。


```js
"use strict";

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

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

### 数组迭代

for...in 循环不应该应用于数组迭代中。是否考虑使用 `for` 循环而不是 `for-in` 循环来遍历数组（`Array`）？在 for 循环中是允许使用初始化语句的：


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

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

// "c"
```

相关内容
----

* `for...in`
* `for...of` – 无论是在严格模式下还是非严格模式下也都不允许使用初始化语句。
* `for` – 更适用于数组迭代，因为允许使用初始化语句。
SyntaxError: missing ) after argument list
==========================================

消息
--
```

语法错误：参数列表后面缺少 )
```

错误类型
----

`SyntaxError`.

什么地方出错了？
--------

有一个函数在调用时出现错误。这可能是一个错误，丢失运算符或者转义字符等。

示例
--

因为没有使用“+”操作符来连接字符串，JavaScript 认为 `log` 函数的参数的值只是 `"PI: "`，在这种情况下，它应该用一个右括号作为结束。


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


你可以正确的调用 `log` 函数通过加上“+”操作符。


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

相关页面
----

* Functions
TypeError: More arguments needed
================================

信息
--
```

TypeError: Object.create requires more than 0 arguments
TypeError: Object.setPrototypeOf requires more than 1 argument
TypeError: Object.defineProperties requires more than 0 arguments
```

错误类型
----

`TypeError`.

哪里出错了？
------

调用函数的时候出现了错误。需要提供更多的参数。

示例
--

`Object.create()` 方法要求至少有一个参数，而 `Object.setPrototypeOf()` 方法要求至少有两个参数：


```js
var obj = Object.create();
// TypeError: Object.create requires more than 0 arguments

var obj = Object.setPrototypeOf({});
// TypeError: Object.setPrototypeOf requires more than 1 argument
```


你可以将 `null` 设置为原型：


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

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

相关
--

* Functions
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
```

错误类型
----

语法错误（`SyntaxError` ），只出现于严格模式下。

哪里出错了？
------

八进制字面量与八进制转义序列语法已经被废弃，在严格模式下会报语法错误（`SyntaxError`）。在 ECMAScript 2015 及以后的规范中，标准语法是前导 0 后面跟一个大写或小写的拉丁文字母 "O" (`0o` 或 `0O)`。

示例
--

### 前导"0"形式的八进制字面量


```js
"use strict";

03;

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

### 八进制转义序列


```js
"use strict";

"\251";

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

### 合法的八进制数字

使用前导 0 后面跟字母 "o" 或 "O" 的形式：


```js
0o3;
```


至于八进制转义序列，你可以使用十六进制转义序列来代替：


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

参见
--

* Lexical grammar
TypeError: invalid 'instanceof' operand 'x'
===========================================

消息
--
```

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` 属性且可以调用的对象。

示例
--


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

function Foo() {}
var f = Foo(); // Foo() is called and returns 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` 操作符
Warning: -file- is being assigned a //# sourceMappingURL, but already has one
=============================================================================

消息
--
```

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

错误类型
----

一个警告。JavaScript 的执行不会中止。

哪里有问题？
------

对于给定的 JavaScript 源码，源码映射规定了不止一次。

JavaScript 源码通常被组合和压缩，使其从服务器传递更加高效。使用了源码映射，调试器能够将执行的源码映射到原始的源码。有两种指派源码映射的方式，通过注释，或者对 JavaScript 设置标题。

示例
--

使用文件中的注释来设置源码映射：


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


或者，你可以对你的 JavaScript 文件设置一个标题：


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

另见
--

* 如何使用源码映射 – Firefox Tools documentation
* 源码映射简介 – HTML5 rocks
ReferenceError: reference to undefined property "x"
===================================================

当脚本尝试去访问一个不存在的对象属性时，就会出现 JavaScript 警告“reference to undefined property”。

消息
--
```

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

错误类型
----

（仅限 Firefox）仅在 `javascript.options.strict` 首选项设置为 `true` 的情况下会出现 `ReferenceError` 警告。

哪里出错了？
------

脚本尝试去访问一个不存在的对象属性。有两种方法可以访问属性，请参阅属性访问器参考页以获取更多信息。

示例
--

### 无效的

本例中，`bar` 属性是未定义的，因此会出现 `ReferenceError`。


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

### 有效的

为了避免错误，你需要向对象添加 `bar` 的定义或在尝试访问 `bar` 属性之前检查 `bar` 属性是否存在；可以使用 `in` 运算符或 `Object.hasOwn()` 方法来实现，如下所示：


```js
const foo = {};

// 定义 bar 属性

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

// 在访问 bar 属性之前测试其是否存在

if (Object.hasOwn(foo, "bar")) {
  console.log(foo.bar);
}
```

参见
--

* 属性访问器
SyntaxError: "x" is a reserved identifier
=========================================

消息提示
----
```

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

错误类型
----

`SyntaxError`哪里出错了？
------

保留字 用作标记符将会出错。这些标记符在严格模式和非严格模式下保留：

* `enum`

以下标记符只会在严格模式下才作为保留字：

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

### 严格与非严格模式下的保留字

在两种模式下，`enum` 标识符都会作为保留字。


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


在严格模式下，会有更多的保留字。


```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 = in const declaration
===========================================

错误提示
----
```

SyntaxError: missing = in const declaration (Firefox)
SyntaxError: Missing initializer in const declaration (Chrome)
```

错误类型
----

`SyntaxError`哪里出错了？
------

常量指的是在程序正常运行过程中不能被修改的值。它的值不能通过二次赋值来改变，同时也不能被再次声明。在 JavaScript 中，常量在声明时使用 `const` 关键字来修饰。常量需要初始化器；也就是说，必须在声明的同时为其赋值（鉴于常量值指定之后不能再进行修改，这样做是容易理解的）。

示例
--

### 初始值缺失

不同于 var 或 let 关键字，必须在常量声明中为其赋值。下面的例子中会报错：


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

### 错误修正

修正这个问题的方法有很多种。仔细检查对于问题中的常量，你想要达到什么目标。

#### 添加常量值

在声明语句中为其赋值：


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


#### `const`, `let` 还是 `var?`

如果你并不想声明一个常量值，那么就不要使用 const 关键字。或许你想要的是使用 `let` 来声明一个块状作用域变量或者是用 `var` 声明一个全局变量。这两者都不需要设置初始值。


```js
let columns;
```

相关内容
----

* `let`
* `var`