recursal/MDN huggingface dataset:
ReferenceError: invalid assignment left-hand side
=================================================

Message
-------
```

ReferenceError: invalid assignment left-hand side
```

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

`ReferenceError`.

What went wrong?
----------------

有时会出现不可预料的赋值情况。这可能是因为赋值运算符 (en-US)或比较运算符 (en-US)不匹配的缘故。正确的是，使用“=”号将值赋给一个变量，使用“==”或者“===”来比较一个值。

Examples
--------


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

See also
--------

* 赋值运算符 (en-US)
* 比较运算符 (en-US)
SyntaxError: Unexpected token
=============================

信息
--
```

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`哪里出错了？
------

期望获得一个特定的语法结构，但得到了其他的。可能只是一个简单的错字。

示例
--

### 期望的表达式

例如，在调用函数时，不允许使用尾随逗号。有尾逗号的时候，JavaScript 会期望有另一个参数，可以是任何表达式。


```js
Math.max(2, 42,);
// SyntaxError: expected expression, got ')'
```


正确的方法是省略最后一个逗号或添加另一个参数：


```js
Math.max(2, 42);
Math.max(2, 42, 13 + 37);
```

相关
--

* `Math.max()`
SyntaxError: illegal character
==============================

错误提示
----
```

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

错误类型
----

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

在代码中有非法的或者不期望出现的标记符号出现在不该出现的位置。请使用支持语法高亮功能的编辑器仔细检查你的代码，看看是否存在张冠李戴的情况，比如减号 (`-`) 与连接符 (`–`) ，或者是英文双引号 (`"`) 与中文双引号 (`“`)。

示例
--

### 错配字符

一些字符看起来会很相像，但是会导致于语法解析器解析代码失败。


```js
“This looks like a string”;
// SyntaxError: illegal character

42 – 13;
// SyntaxError: illegal character
```


下面这样是可以正常运行的：


```js
"This is actually a string";

42 - 13;
```

### 遗漏的字符

很容易就会在这里或那里遗漏一些字符。


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


把遗漏的引号给 '#333' 添加上。


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

### 隐藏字符

当从外部复制粘贴代码的时候，有可能就有非法的隐藏字符的存在，需要引起注意！


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


当使用文本编辑器如 VIM 进行探测的时候，可以发现这里存在一个零宽空格 (ZWSP) (U+200B)。


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

相关内容
----

* Lexical grammar
RangeError: argument is not a valid code point
==============================================

JavaScript 异常“Invalid code point”会在 `String.fromCodePoint()` 方法与 `NaN` 值、负整数（-1）、非整数（5.4）或大于 0x10FFFF（1114111）的值一起使用时抛出。

错误信息
----
```

RangeError: Invalid code point -1 (V8-based)
RangeError: -1 is not a valid code point (Firefox)
RangeError: Arguments contain a value that is out of range of code points (Safari)
```

错误类型
----

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

`String.fromCodePoint()` 方法在被传入 `NaN` 值、负整数（-1）、非整数（5.4）或大于 0x10FFFF 的值时抛出该错误。

码位（code point）是 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); // 'Є' (U+0404)
String.fromCodePoint(0x2f804); // '你' (U+2F804)
String.fromCodePoint(194564); // '你'
String.fromCodePoint(0x1d306, 0x61, 0x1d307); // '𝌆a𝌇'
```

参见
--

* `String.fromCodePoint()`
SyntaxError: unterminated string literal
========================================

信息
--
```

SyntaxError: unterminated string literal
```

错误类型
----

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

某处 js 解析字符串出错。字符串必须使用单引号或双引号来正确的关闭。在 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
```


可以使用"+"运算符 (en-US)，反斜杠，或模板字符串来代替多行。“+”运算符的使用如下：


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


另一种方式是使用 ES 2015 的环境所支持模板字符串（反引号` `）。


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

相关
--

* `String`
* 模板字符串
SyntaxError: missing ) after condition
======================================

错误提示
----
```

SyntaxError: missing ) after condition
```

错误类型
----

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


如果你是从其他语言转到 JavaScript 的，那么很容易在 JavaScript 中使用与之含义不同或者没有任何意义的关键字。


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

// SyntaxError: missing ) after condition
```


相反你需要使用正确的比较操作符 (en-US)，如下：


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

相关内容
----

* `if...else`
* 比较操作符 (en-US)
* 在代码中做判断 — 条件表达式
TypeError: "x" is not a constructor
===================================

信息
--
```

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: SIMD is not a constructor
TypeError: Atomics is not a constructor
```

错误类型
----

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

是因为尝试将不是构造器的对象或者变量来作为构造器使用。参考 constructor 或者 `new` operator 来了解什么是构造器。

有很多的全局对象比如 `String`、`Array` 等等都是可以使用 `new` 操作符的构造器。但是有一些全局对象并不是，且其属性和方法都是静态 的。下面的 JavaScript 标准内置对象都不是构造器：`Math`，`JSON`，`Symbol`，`Reflect`，`Intl`，`SIMD`，`Atomics`。

Generator functions 也不能作为构造器来使用。

示例
--

### 无效的


```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`，并且你希望它具有 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);
```

### 关于 Promises

当返回了一个 immediately-resolved 或者 immediately-rejected Promise 的时候，你根本不需要去创建、操作一个新的 Promise 对象。

这是不合法的（Promise constructor 被错误的调用了）且会抛出一个 错误 `TypeError: this is not a constructor` exception:


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


使用 Promise.resolve() 或者 Promise.reject() 静态方法来代替：


```js
// 这是合法的，但是没必要这么长：
return new Promise((resolve, reject) => {
  resolve(true);
});

// 用静态方法来代替：
return Promise.resolve(true);
return Promise.reject(false);
```

参见
--

* constructor
* `new` 运算符
RangeError: repeat count must be less than infinity
===================================================

信息
--
```

RangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox)

RangeError: Invalid count value (Chrome)
```

错误类型
----

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

代码中使用了 `String.prototype.repeat()`方法。它有一个计数参数，表示重复该字符串的次数。该参数必须在 0 及正 `Infinity` 之间，且不能为负数。该值的合法范围可以这样表示： [0, +∞)。

其结果字符串也不能长于最大字符串，不同 JavaScript 引擎中可能有所不同。在 Firefox (SpiderMonkey) 里最大字符串大小为 2^28 -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 will be converted to integer)
```

See also
--------

* `String.prototype.repeat()`
RangeError: invalid date
========================

消息
--
```

范围错误：非法数据 (Firefox)
范围错误：非法时间值 (Chrome)
范围错误：提供的数据不是有效的 (Chrome)
```

错误类型
----

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

为 `Date` 或 `Date.parse()` 提供了一个会导致无效日期的字符串。

示例
--

### 错误示例

ISO 格式化字符串中不可识别的字符串或者包含非法元素值的日期一般会返回 `NaN`。然而，根据实现的不同，不符合 ISO 格式的字符串可能也会抛出 `RangeError: invalid date`，比如在火狐浏览器中有以下情形：


```js
new Date("foo-bar 2014");
new Date("2014-25-23").toISOString();
new Date("foo-bar 2014").toString();
```


然而下面这种情形会返回 `NaN` ：


```js
Date.parse("foo-bar 2014"); // NaN
```


参见 `Date.parse()` 文档，了解更多详情。

### 正确示例


```js
new Date("05 October 2011 14:48 UTC");
```

另见
--

* `Date`
* `Date.prototype.parse()`
* `Date.prototype.toISOString()`
TypeError: can't redefine non-configurable property "x"
=======================================================

错误提示
----
```

TypeError: can't redefine non-configurable property "x" (Firefox)
TypeError: Cannot redefine property: "x" (Chrome)
```

错误类型
----

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

这种错误的起因在于试图给对象重新定义一个属性，但是该属性是不可配置的。 `configurable` 特性控制着该属性是否可以从对象中删除，以及它的各个特性（除 writable 之外）是否可以修改。通常使用对象初始化语句定义的对象属性是可配置的。而使用 `Object.defineProperty()` 定义的属性则默认不可配置。

示例
--

### 使用 object.defineProperty 创建的不可配置属性

在使用 `Object.defineProperty()` 创建属性的时候，如果没有明确将其设定为可配置的，那么创建出来的属性就是不可配置的。


```js
var obj = Object.create({});
Object.defineProperty(obj, "foo", { value: "bar" });

Object.defineProperty(obj, "foo", { value: "baz" });
// TypeError: can't redefine non-configurable property "foo"
```


如果想要稍后重新定义的话，那么需要将 "foo" 属性设置为可配置的。


```js
var obj = Object.create({});
Object.defineProperty(obj, "foo", { value: "bar", configurable: true });
Object.defineProperty(obj, "foo", { value: "baz", configurable: true });
```

参见
--

* [[Configurable]]
* `Object.defineProperty()`
SyntaxError: return not in function
===================================

错误信息
----
```

SyntaxError: return not in function
SyntaxError: yield not in function
```

错误类型
----

`SyntaxError`.

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

`return` 返回的或者 `yield` 语句在函数 function 外被调用。或许是少了一个花括号， `return` 返回的和 `yield` 语句必须是在一个函数里，因为它们会停止（暂停或恢复）函数的继续执行，然后返回。

范例
--


```js
var cheer = function(score) {
  if (score === 147)
    return "Maximum!";
  };
  if (score > 100) {
    return "Century!";
  }
}

// SyntaxError: return not in function
// 语法错误：不是在函数里返回
```


初次看好像没什么错误，但是上面这段代码在第一个 if 后面少了一个“ { ”。正确的应该如下：


```js
var cheer = function (score) {
  if (score === 147) {
    return "Maximum!";
  }
  if (score > 100) {
    return "Century!";
  }
};
```

相关信息
----

* `return`
* `yield`
TypeError: can't delete non-configurable array element
======================================================

错误提示
----
```

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

错误类型
----

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

这个错误提示发生于当试图缩短一个数组的长度的时候，其中有元素是不可配置的（non-configurable）。正常情况下，缩短数组的长度，则超出限度的元素会被删除，而这里指的是这种操作失效的情况。

`configurable` 特性控制着属性是否可以从对象中删除，以及它的特性（除了 writable 之外）是否可以发生改变。

通常，使用数组初始化语句创建的对象是可配置的，而通过 `Object.defineProperty()` 创建的属性，默认则是不可配置的。

示例
--

### `通过 Object.defineProperty 创建的不可配置属性`

使用 `Object.defineProperty()` 且在没有明确将属性设定为可配置的情况下，默认可以创建不可配置属性。


```js
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
var arr = [];
Object.defineProperty(arr, 0, { value: 0, configurable: true });
Object.defineProperty(arr, 1, { value: "1", configurable: true });

arr.length = 1;
```

### `密封的数组`

`Object.seal()` 函数会将数组中现存的所有元素标记为不可配置。


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

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


（为了解决上述问题，）或者是移除 `Object.seal()` 调用，或者将数组拷贝一份。在拷贝数组的情况下，缩短备份数组的长度并不会修改原始数组的长度。


```js
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: cyclic object value
==============================

在JSON中出现循环引用时，JavaScript 会抛出 "cyclic object value" 的异常。`JSON.stringify()`并不会尝试解决这个问题，因此导致运行失败。

提示信息
----


```js
TypeError: cyclic object value (Firefox)
TypeError: Converting circular structure to JSON (Chrome and Opera)
TypeError: Circular reference in value argument not supported (Edge)
```

错误类型
----

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

JSON 格式本身不支持循环引用对象（尽管存在IETF 草案)，因此 `JSON.stringify()` 并不会尝试解决这个问题而是直接运行失败。

示例
--

### 循环引用

在如下循环结构中：


```js
var circularReference = { otherData: 123 };
circularReference.myself = circularReference;
```


`JSON.stringify()` 将会报错


```js
JSON.stringify(circularReference);
// TypeError: cyclic object value
```


要处理循环引用的 JSON，可以使用支持这种结构的库 (例如cycle.js))，或者自己实现，需要通过可序列化值查找、替换或者移除循环引用。

下面的代码片段演示了如何使用`JSON.stringify()`的 `replacer` 参数查找和过滤（会导致数据丢失）循环引用。


```js
const getCircularReplacer = () => {
  const seen = new WeakSet();
  return (key, value) => {
    if (typeof value === "object" && value !== null) {
      if (seen.has(value)) {
        return;
      }
      seen.add(value);
    }
    return value;
  };
};

JSON.stringify(circularReference, getCircularReplacer());
// {"otherData":123}
```

参见
--

* `JSON.stringify`
* cycle.js
 – 介绍两个方法，`JSON.decycle` 和
 `JSON.retrocycle`，这两个方法能够对循环对象引用结构进行编码和解码，并且使之成为一种扩展的且向下兼容的 JSON 格式。
TypeError: "x" is not a non-null object
=======================================

提示信息
----
```

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()` 及{jsxref("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`
SyntaxError: a declaration in the head of a for-of loop can't have an initializer
=================================================================================

错误信息
----
```

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` 循环形式

需要将初始化器 (`value = 50`) 从`for-of` 循环的头部移除。或许你的本意是给每个值添加 50 的偏移量，在这种情况下，可以在循环体中进行添加。


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

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

相关内容
----

* `for...of`
* `for...in` – 在严格模式下也同样禁止使用初始化器 (SyntaxError: for-in loop head declarations may not have initializers)
* `for` – 在迭代时允许定义初始化器
TypeError: "x" is not a function
================================

JavaScript 异常"is not a function"会在试图去调用一个像函数一样的值，但是该值实际上不是函数时被抛出。信息
--
```

TypeError: Object doesn't support property or method {x} (Edge)
TypeError: "x" is not a function
```

错误类型
----

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

问题出在你试图去调用一个像函数一样的值，但是该值实际上不是函数，有时候你的代码需要调用一些函数，但是那种值并不能当作函数来被调用。

也许函数名称上有错别字？也许你正在调用 Object 对象没有这个方法？例如，在 JavaScript 中单纯的对象 (Object) 没有**map**函数，但是 JavaScript 数组 (Array) 对象却有这个函数。

再比如，在 JavaScript 中很多原生对象的内置方法需要你提供一个（回调）函数。所以你必须提供一个函数，以使这些方法正常工作：

* 当你在使用 `Array` 或 `TypedArray` 对象时：
    + `Array.prototype.every()`, `Array.prototype.some()`, `Array.prototype.forEach()`, `Array.prototype.map()`, `Array.prototype.filter()`, `Array.prototype.reduce()`, `Array.prototype.reduceRight()`, `Array.prototype.find()`
* 当你在使用 `Map` 和 `Set` 对象时：
    + `Map.prototype.forEach()` and `Set.prototype.forEach()`
示例
--

### 函数的名称错误

函数的名称拼写错误，这种情况是经常发生的：


```js
var x = document.getElementByID("foo");
// TypeError: document.getElementByID is not a function
```


正确的方法名应该是 `getElementById：`


```js
var x = document.getElementById("foo");
```

### 调用 Object 类型中不存在的方法

对于某些特殊的方法，它只属于某些特定的原生对象中，你必须提供一个回调函数才能正常运行。例如：这里调用了一个 `Array.prototype.map()` 方法，但是这方法只能被 `Array` 对象所调用。


```js
var obj = { a: 13, b: 37, c: 42 };

obj.map(function (num) {
  return num \* 2;
});

// TypeError: obj.map is not a function
```


正确的做法，使用一个数组来代替：


```js
var numbers = [1, 4, 9];

numbers.map(function (num) {
  return num \* 2;
});

// Array [ 2, 8, 18 ]
```

### 函数与已有属性重名

当你在创建类时，可能会存在某个属性和某个方法的名称相同，当你在调用该函数时，编译器会认为该函数不存在。


```js
var Dog = function () {
  this.age = 11;
  this.color = "black";
  this.name = "Ralph";
  return this;
};

Dog.prototype.name = function (name) {
  this.name = name;
  return this;
};

var myNewDog = new Dog();
myNewDog.name("Cassidy"); //Uncaught TypeError: myNewDog.name is not a function
```


正确的做法是使用不同的变量名。


```js
var Dog = function () {
  this.age = 11;
  this.color = "black";
  this.dogName = "Ralph"; //Using this.dogName instead of .name
  return this;
};

Dog.prototype.name = function (name) {
  this.dogName = name;
  return this;
};

var myNewDog = new Dog();
myNewDog.name("Cassidy"); //Dog { age: 11, color: 'black', dogName: 'Cassidy' }
```

### 使用括号进行乘法运算

在数学中，你可以将 2 × (3 + 5) 写为 2\*(3 + 5) 或者省略为 2(3 + 5).

使用后者时将会抛出错误：


```js
const sixteen = 2(3 + 5);
alert("2 x (3 + 5) is " + String(sixteen));
//Uncaught TypeError: 2 is not a function
```


你可以添加乘法运算符 `*` 来改正代码：


```js
const sixteen = 2 \* (3 + 5);
alert("2 x (3 + 5) is " + String(sixteen));
//2 x (3 + 5) is 16
```

### 正确地导入和导出模块

确保正确导入模块。

以下为一个示例模块 (`helpers.js`)
```

let helpers = function () { };

helpers.groupBy = function (objectArray, property) {
  return objectArray.reduce(function (acc, obj) {
    var key = obj[property];
    if (!acc[key]) {
      acc[key] = [];
    }
    acc[key].push(obj);
    return acc;
  },
{});
}

export default helpers;
```


在 `App.js`中正确导入该模块：
```

import helpers from './helpers'
```

相关
--

* Functions
SyntaxError: missing ; before statement
=======================================

信息
--
```

SyntaxError: Expected ';' (Edge)
```


```
 SyntaxError: missing ; before statement (Firefox)
```

错误类型
----

`SyntaxError`.

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

某个地方丢失了一个 (`;`)。 JavaScript 语句必须以分号结束。有一些是由 自动分号插入 (ASI) 的使用所影响到的，但在这种情况下，你需要提供一个分号，以便于 JavaScript 可以将源代码解析正确。然而，通常情况下，这个错误只是另一个错误一个导致的，如不正确转义字符串，使用 var 的错误。你也可能有太多的括号的地方。当出现此错误时，仔细检查语法。

示例
--

转义字符串

这个错误可能发生不正确时容易转义字符串 JavaScript 引擎是希望你的字符串的末尾已经。例如：


```js
var foo = 'Tom's bar';
// SyntaxError: missing ; before statement
```


你可以用双引号，或者用\转义：


```js
var foo = "Tom's bar";
var foo = 'Tom\'s bar';
```

### 用 var 声明属性

你不能将带有变量声明的对象或数组的属性用`var`来声明。


```js
var obj = {};
var obj.foo = "hi"; // SyntaxError missing ; before statement

var array = [];
var array[0] = "there"; // SyntaxError missing ; before statement
```


而是省略掉`var`关键词：


```js
var obj = {};
obj.foo = "hi";

var array = [];
array[0] = "there";
```

### 不推荐使用的关键字

如果你用的是另一种编程语言，那么在 javaScript 中使用不具有相同或完全没有意义的关键字也是很常见的：


```js
def print(info){
  console.log(info);
}; // SyntaxError missing ; before statement
```


因此，建议使用`function`而不是`def`：


```js
function print(info) {
  console.log(info);
}
```

参考
--

* 自动分号插入 (ASI)
* JavaScript 语句
ReferenceError: deprecated caller or arguments usage
====================================================

信息
--
```

Warning: ReferenceError: deprecated caller usage (Firefox)
Warning: ReferenceError: deprecated arguments usage (Firefox)
TypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari)
```

错误类型
----

仅在严格模式下出现的 `ReferenceError` 警告。JavaScript 的执行将不会停止。

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

在 strict mode 中，`Function.caller` 和 `Function.arguments` 属性是不该使用的。它们都是已经被废弃的了，因为这两者泄露了函数的调用者，是不标准的，难于优化和有这潜在的性能问题。

实力
--

### 废弃的 `function.caller` or `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
```

相关
--

* Deprecated and obsolete features
* Strict mode
* `Function.arguments`
* `Function.caller` and `arguments.callee.caller`
ReferenceError: "x" is not defined
==================================

错误信息
----
```

ReferenceError: "x" is not defined
```

错误类型
----

`ReferenceError`.

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

在某些地方引用一个不存在的变量的时候。当你使用变量的时候，这个变量必须是已经被声明的，或者你可以确保它在你当前的脚本或作用域 (scope) 中可用。

**备注：** 当你加载一个库的时候（例如 jQuery），请确保你在这个库加载完毕后再使用这个库中的变量，如“$”。将你想加载的库的 `<script>` 标签放置在你的代码前面。

示例
--

### 变量没有被声明


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


“foo”变量没有在任何地方被声明。它需要是某种字符串，这样 `String.prototype.substring()` 方法才可以正常工作。


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

### 错误的作用域

变量必须是在它当前的执行环境中可用的。在一个函数（function）中定义的变量不能从这个函数外部的任何地方访问，因为这个变量的作用域仅在这个函数的内部。


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

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


然而，一个函数可用使用在它所被定义的作用域中的所有变量。换句话说，当一个函数被定义在全局作用域的时候，它可以访问所有在全局作用域中定义的变量。


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

function numbers() {
  return num1 + num2;
}

console.log(num1); // 2
```

相关页面
----

* Scope
* Declaring variables in the JavaScript Guide
* Function scope in the JavaScript Guide
RangeError: radix must be an integer
====================================

消息
--
```

RangeError: radix must be an integer at least 2 and no greater than 36 (Firefox)
RangeError: toString() radix argument must be between 2 and 36 (Chrome)
```

错误类型
----

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

在使用`Number.prototype.toString()`方法时使用了可选的基数参数，参数应该为一个 2 到 36 之间的整型 (数字)，返回对应数字的转换为字符串时表示的该进制对应的数字量。

为什么小于 36 呢？因为一个大于 (包含等于)10 的基数在使用时需要用一个字母表字符来代替。不能超过 36 是因为拉丁字母表中只有 26 个字符。

你可能会用到以下的常见基数：

* 2 for 二进制,
* 8 for 八进制,
* 10 for 十进制,
* 16 for 十六进制.
示例
--

### 错误示例


```js
(42).toString(0);
(42).toString(1);
(42).toString(37);
(42).toString(150);
// You cannot use a string like this for formatting:
(12071989).toString("MM-dd-yyyy");
```

### 正确示例


```js
(42).toString(2); // "101010" (binary)
(13).toString(8); // "15" (octal)
(0x42).toString(10); // "66" (decimal)
(100000).toString(16); // "186a0" (hexadecimal)
```

参考
--

* `Number.prototype.toString()`