recursal/MDN huggingface dataset:
SyntaxError: redeclaration of formal parameter "x"
==================================================

信息
--
```

SyntaxError: redeclaration of formal parameter "x" (Firefox)
SyntaxError: Identifier "x" has already been declared (Chrome)
SyntaxError: Cannot declare a let variable twice: 'x' (WebKit)
```

错误类型
----

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

兼容性提醒
-----

* 在 Firefox 49 之前，会抛出的是 `TypeError`（Firefox bug 1275240）。
相关
--

* `let`
* `const`
* `var`
* Declaring variables in the JavaScript Guide
TypeError: Reduce of empty array with no initial value
======================================================

消息
--
```

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

错误类型
----

`TypeError`哪里出问题了？
-------

在 JavaScript 中，有一些 reduce 函数：

* `Array.prototype.reduce()`，`Array.prototype.reduceRight()` 和
* `TypedArray.prototype.reduce()`， `TypedArray.prototype.reduceRight()`)。

这些函数有选择性的接收 `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.
```


类似的，当选择器中有瑕疵的时候相同的问题会发生，或者是列表中未预期的数量的元素：


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

### 有效的情况

这个问题有两种可能的解决办法：

一种是提供一个初始值作为操作符的中立元素，比如加法里的 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
```


另一种办法是两方处理空的情况，要么在调用 `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()`
X.prototype.y called on incompatible type
=========================================

错误提示
----
```

TypeError: Function.prototype.toString called on incompatible object (Firefox)
TypeError: Function.prototype.bind called on incompatible target (Firefox)
TypeError: Method Set.prototype.add called on incompatible receiver undefined (Chrome)
TypeError: Bind must be called on a function (Chrome)
```

错误类型
----

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

当这个错误被抛出时，属于某个对象的函数被调用，但是没有提供给 `this` 与其所期望的函数类型一致的参数。

在调用 `Function.prototype.call()` 或`Function.prototype.apply()` 方法，但是为 `this` 提供的绑定对象与预期的不匹配时，这个问题就会出现。

该问题还会出现于将一个（存储在一个对象中的）函数提供给另外一个函数作为参数时。在这种情况下，函数所在的对象并非该函数的 `this` 绑定的目标对象。为了解决这个问题，你或者为其提供一个 lambda 表达式，该表达式完成函数要完成的任务，或者调用 `Function.prototype.bind()` 函数为 `this` 强制绑定期望的对象。

示例
--

### 错误示例


```js
var mySet = new Set();
["bar", "baz"].forEach(mySet.add);
// mySet.add is a function, but "mySet" is not captured as this.

var myFun = function () {};
["bar", "baz"].forEach(myFun.bind);
// myFun.bind is a function, but "myFun" is not captured as this.
```

### 正确示例


```js
var mySet = new Set();
["bar", "baz"].forEach(mySet.add.bind(mySet));
// This works due to binding "mySet" as this.

var myFun = function () {};
["bar", "baz"].forEach((x) => myFun.bind(x));
// This works using the "bind" function. It creates a lambda forwarding the argument.
```

相关内容
----

* `Function.prototype.call()`
* `Function.prototype.apply()`
* `Function.prototype.bind()`
SyntaxError: applying the 'delete' operator to an unqualified name is deprecated
================================================================================

错误提示
----
```

SyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox)
SyntaxError: Delete of an unqualified identifier in strict mode. (Chrome)
```

错误类型
----

`SyntaxError` 仅出现在严格模式下。

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

在 JavaScript 中，普通变量是不能通过 `delete` 操作符来删除的。在严格模式下，试图去删除一个变量会报错，这是不允许的。

delete 操作符只能用于删除对象中的属性。只有可配置的对象属性才“符合”被删除的条件。

与一般流行的观点相反的是，delete 操作符与直接释放内存**无关**。内存管理是通过切断引用来间接实现的。可以参考内存管理页面与 delete 操作符页面来获取更多的细节信息。

这个错误提示只出现于严格模式。在非严格模式下，该操作返回 false。

示例
--

在 JavaScript 中，普通变量是不能删除的，在严格模式下会报错：


```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: invalid Array.prototype.sort argument
================================================

信息
--
```

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: missing name after . operator
==========================================

错误提示
----
```

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）转到 JavaScript 的，很容易将点操作符 (.) 与连接操作符 (+) 混用：


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

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


相反要使用加号来进行字符串拼接：


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

相关页面
----

* 属性访问器
TypeError: can't assign to property "x" on "y": not an object
=============================================================

信息
--
```

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

错误类型
----

`TypeError`.

原因
--

在 `Strict_mode`下，当试图给一个symbol,string,number或者一个boolean类型的数据创建一个属性时就会报 `TypeError`, 任何 Primitive 值都不允许有property.

这个问题可能是由一个错误的值被放在了一个错误的地方导致的，或者预期`String`或`Number`的对象变体

示例
--

### 错误的情况


```js
"use strict";

var foo = "my string";
// 下面这行代码在非严格模式下不会执行。
foo.bar = {}; // TypeError: can't assign to property "bar" on "my string": not an object
```

### 如何正确使用

有两种方式，第一种修复这部分代码阻止primitive被用于这种情况，或者可以通过使用对象构造器创建来修复。


```js
"use strict";

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

页面相关
----

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

消息
--
```

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

错误类型
----

`SyntaxError` 只在严格模式下会出现的警告。

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

在通常期望进行相等判定（`==`）的地方出现了赋值`（=`）。为了帮助调试，JavaScript（在开启严格模式的情况下）会对这种情况进行警告。

示例
--

### 条件表达式内的赋值

不建议在条件表达式中（例如 `if...else`）使用简单赋值语句，因为在扫视代码的时候赋值操作与相等判定容易产生混淆。例如，不要使用以下写法：


```js
if (x = y) {
  // do the right thing
}
```


如果你需要在条件表达式中使用赋值语句，通常的做法是用一对括号把赋值语句包起来。例如：


```js
if ((x = y)) {
  // do the right thing
}
```


否则，你的本意可能是想用比较操作符（如 `==` 或 `===`）：


```js
if (x == y) {
  // do the right thing
}
```

相关页面
----

* Strict mode
* `if...else`
* Comparison operators (en-US)
TypeError: invalid 'in' operand "x"
===================================

错误提示
----
```

TypeError: invalid 'in' operand "x" (Firefox)
TypeError: Cannot use 'in' operator to search for 'x' in y (Chrome)
```

错误类型
----

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

`in` 操作符只可以用来检测对象中是否存在某个属性，而不能用来在字符串、数字或者其他基本类型的数据中进行检索。

示例
--

### 在字符串中进行检索

与其他语言不同（如 Python），不能使用 `in` 操作符在字符串中进行检索。


```js
"Hello" in "Hello World";
// TypeError: invalid 'in' operand "Hello World"
```


可以使用 `String.prototype.indexOf()` 来代替：


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

### 操作数不能为 null 或者 undefined

确保你将要进行探测的对象不为 `null` 或者 `undefined`.


```js
var foo = null;
"bar" in foo;
// TypeError: invalid 'in' operand "foo"
```


in 操作符的预期操作数只有对象类型。


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

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

### 在数组中进行检索

当使用 in 操作符来对 `Array` 对象进行检索的时候一定要特别小心，因为它检测的是索引值而不是位于索引位置的值。


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

相关内容
----

* `in` operator
SyntaxError: JSON.parse: bad parsing
====================================

信息
--
```

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()` 会把一个字符串解析成 JSON 对象。如果字符串书写正确，那么其将会被解析成一个有效的 JSON，但是这个字符串被检测出错误语法的时候将会抛出错误。

示例
--

### `JSON.parse()` 不允许在末尾添加多余的逗号

下面两行代码都会抛出错误：


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

### JSON 的属性名必须使用双引号

属性名上不能使用单引号，例如： '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 }');
```

### 前导 0 和小数点

数字不能用 0 开头，比如 01，并且你的小数点后面必须跟着至少一个数字。


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


正确的写法应该是只写一个 1，不书写前面的 0。在小数点的后面至少要跟上一个数字：


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

参见
--

* `JSON`
* `JSON.parse()`
* `JSON.stringify()`
TypeError: "x" has no properties
================================

错误信息
----
```

TypeError: null has no properties
TypeError: undefined has no properties
```

错误类型
----

`TypeError`.

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

`null` 和 `undefined`中，没有你需要的属性。

示例
--


```js
null.foo;
// 错误类型：null 没有这个属性

undefined.bar;
// 错误类型：undefined 没有这个属性
```

参考
--

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

信息
--
```

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 源码中使用了已废弃的 source map 语法。

JavaScript 源代码经常被组合和压缩，以便能更高效地从服务器获取它们。使用了 source maps，调试器就可以将正在执行的代码映射到原始源文件。

因为在 IE 浏览器中，只要页面存在 `//@cc_on` 注释，都会被 IE JScript 引擎解释为要打开条件编译，所以 source map 的规范更改了语法。条件编译注释 是 IE 的一个鲜为人知的特性，但是它破坏了 jQuery 和其他库的 source map。

示例
--

### 废弃的语法

使用 "@" 符号的语法已经被废弃了。


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

### 标准语法

使用 "#" 符号代替。


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


或者，你也可以为 JavaScript 文件设置 header，以避免添加注释：


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

参见
--

* How to use a source map – Firefox Tools documentation
* Introduction to source maps – HTML5 rocks
RangeError: invalid array length
================================

错误信息
----
```

RangeError: invalid array length (Firefox)
RangeError: Invalid array length (Chrome)
RangeError: Invalid array buffer length (Chrome)
```

错误类型
----

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

无效的数组错误长度通常会在以下情形中出现：

* 当创建一个长度为负数或者长度大于等于 2^32 的`Array` 或者 `ArrayBuffer` 时。
* 当设置 `Array.length` 属性为负数或者长度大于等于 2^32 时。

为什么 Array（数组）和 ArrayBuffer（数组缓冲区）的长度会受到限制？因为 Array 和 ArrayBuffer 的 length（长度）属性被定义为一个 32 位无符号整形（unsigned 32-bit integer）的值，所以它只能存储 0 - 2^32 - 1 之间的数。

当你使用构造函数来创建一个数组的时候，你可能想使用字面值的形式，第一个参数会被解释为数组的长度。

或者说，你想要在设置数组之前确定它的长度，或把它作为一个构造函数的参数。

示例
--

### 错误的示例


```js
new Array(Math.pow(2, 40));
new Array(-1);
new ArrayBuffer(Math.pow(2, 32)); // 32 位系统
new ArrayBuffer(-1);

const a = [];
a.length = a.length - 1; // 将 length 属性的值设置为 -1

const b = new Array(Math.pow(2, 32) - 1);
b.length = b.length + 1; // 将 length 属性的值设置为 2^32
b.length = 2.5; // 将 length 属性设置为浮点数

const c = new Array(2.5); // 传入浮点数
```

### 正确的示例


```js
[Math.pow(2, 40)]; // [ 1099511627776 ]
[-1]; // [ -1 ]
new ArrayBuffer(Math.pow(2, 32) - 1);
new ArrayBuffer(Math.pow(2, 33)); // 64-bit systems after Firefox 89
new ArrayBuffer(0);

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

const b = new Array(Math.pow(2, 32) - 1);
b.length = Math.min(0xffffffff, b.length + 1);
// 0xffffffff 0xffffffff 是 2^32 - 1 的十六进制表示方式
// 它也可以被写作 (-1 >>> 0)

b.length = 3;

const c = new Array(3);
```

参见
--

* `Array`
* `Array.length`
* `ArrayBuffer`
TypeError: can't define property "x": "obj" is not extensible
=============================================================

错误提示
----
```

TypeError: can't define property "x": "obj" is not extensible (Firefox)
TypeError: Cannot define property: "x", object is not extensible. (Chrome)
```

错误类型
----

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

通常情况下，对象是可以进行扩展的，即可以向其添加新的属性。然而当使用 `Object.preventExtensions()` 将一个对象标记为不再可以扩展的情况下，就无法对该对象添加在其被标记为不可扩展之前所拥有的属性之外的新属性了。

示例
--

在严格模式下，向已经标记为不可扩展的对象添加新属性会报 TypeError 错误。而在非严格模式下，添加属性“x”会被静默忽略。


```js
"use strict";

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

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


在严格模式和非严格模式下两种模式下，调用`Object.defineProperty()` 向标记为不可扩展的对象添加新属性都会报 TypeError 错误。


```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"; // add property first and only then prevent extensions

Object.preventExtensions(obj);
```

相关内容
----

* `Object.preventExtensions()`
ReferenceError: assignment to undeclared variable "x"
=====================================================

信息
--
```

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

错误类型
----

仅在严格模式中出现 `ReferenceError` 警告。

发生了什么？
------

在代码里赋值了一个未声明的变量。换句话说，有处没有带着 `var` 关键字的赋值。事实上已声明的和未声明的变量之间有一些差异，这可能会导致意想不到的结果，这就是为什么 JavaScript 在严格模式打印出这种错误。

关于已声明和未声明的变量，其有三个注意事项：

* 已声明的变量被约束在其执行上下文中。未声明的变量总是全局的。
* 已声明的变量在执行任何代码之前就创建了。未声明的变量则不存在，直到执行相关的代码。
* 已声明的变量是其执行上下文（函数或全局）的不可配置属性。而未声明的变量是可配置的（例如可以删除）。

更多信息及例子，请参考 `var` 页面。

关于未声明变量的赋值的错误仅在严格模式里出现。在非严格模式中，这些将被忽略。

示例
--

### 无效的

在本例中，"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 mode
SyntaxError: "use strict" not allowed in function with non-simple parameters
============================================================================

信息
--
```

Firefox:
句法错误："use strict" 不允许在带默认参数的函数中
句法错误："use strict" 不允许在带 rest 参数的函数中
句法错误："use strict" 不允许在带解构参数的函数中

Chrome:
句法错误：非法的'use strict'指令，在带有非简单参数列表的函数中
```

错误类型
----

`SyntaxError`.

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

在函数顶部直接写了 `"use strict"` ，而该函数拥有以下的参数其中之一：

* 默认参数
* 剩余参数
* 解构赋值

根据 ECMAScript 规范，不允许在这些函数的顶部使用“use strict”指令。

示例
--

### 函数语句

在这种情况下，函数 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 mode，并且整个脚本或封装函数也可以在严格模式下，可以移动 "use strict" 指令到函数之外：


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

### 函数表达式

函数表达式可以使用另一种解决方法：


```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
* 函数语句
* 函数表达式
* 默认参数
* 剩余参数
* 解构参数
TypeError: "x" is (not) "y"
===========================

JavaScript 异常“*x* is (not) *y*”在出现与期望不符的类型（通常为意外获得的 `undefined` 或 `null` 值）时被抛出。

消息
--
```

TypeError: Cannot read properties of undefined (reading 'x') (V8-based)
TypeError: "x" is undefined (Firefox)
TypeError: "undefined" is not an object (Firefox)
TypeError: undefined is not an object (evaluating 'obj.x') (Safari)

TypeError: "x" is not a symbol (V8-based & Firefox)
TypeError: Symbol.keyFor requires that the first argument be a symbol (Safari)
```

错误类型
----

`TypeError`。

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

出现了与期望不符的类型。这个错误常常由 `undefined` 或 `null` 值引起。

此外，某些方法，例如 `Object.create()` 或 `Symbol.keyFor()`，要求必须提供特定类型的参数。

示例
--

### 错误情形


```js
// undefined and null cases on which the substring method won't work
const foo = undefined;
foo.substring(1); // TypeError: foo is undefined

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

// Certain methods might require a specific type
const foo = {};
Symbol.keyFor(foo); // TypeError: foo is not a symbol

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

### 解决方法

要解决值为 `undefined` 或 `null` 的空指针问题，你可以首先测试值是否为 `undefined` 或 `null`。


```js
if (foo !== undefined && foo !== null) {
  // Now we know that foo is defined, we are good to go.
}
```


或者，你如果能确定 `foo` 的值不会是其他的假值（如：`""` 或 `0`），或者排除这些情况不是问题，那你可以简单地测试其是否为真。


```js
if (foo) {
  // Now we know that foo is truthy, it will necessarily not be null/undefined.
}
```

参见
--

* `undefined`
* `null`
TypeError: setting getter-only property "x"
===========================================

错误提示
----
```

TypeError: setting getter-only property "x" (Firefox)
TypeError: Cannot set property "prop" of #<Object> which has only a getter (Chrome)
```

错误类型
----

仅在严格模式下报 `TypeError` 错误。

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

该错误提示出现于试图给一个仅仅设置了 getter 特性的属性赋新值的时候。在非严格模式下会被静默忽略，而在严格模式下会报 `TypeError` 错误。

示例
--

下面的例子展示了如何为一个属性设置 getter 特性。由于没有设置 setter 特性，所以在试图将 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"
```


至于修复问题的方法，可以将第 16 行的代码移除，因为它试图为 temperature 属性赋值，或者是为它添加一个 setter 特性，就像下面这样：


```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()`
SyntaxError: missing ] after element list
=========================================

信息
--
```

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: missing : after property id
========================================

错误提示
----
```

SyntaxError: missing : after property id
```

错误类型
----

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

当使用对象初始化语法创建对象的时候，需要使用半角冒号 (:) 将属性键与属性值隔开。


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

示例
--

### 冒号与等号

下面的代码会运行失败，原因是对象初始化语法中不允许使用等号来代替冒号。


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


修复方法就是使用冒号，或者是在对象创建之后使用方括号语法来为其设定新的属性。


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

// or alternatively

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

相关内容
----

* Object initializer