JavaScript 常见错误

本章讲解一些常见的 JavaScript 错误。


意外使用赋值运算符

如果程序员在 if 语句中意外使用赋值运算符(=)而不是比较运算符(===),JavaScript 程序可能会产生一些无法预料的结果。

这条 if 语句返回 false(正如预期),因为 x 不等于 10:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 0;
  7. document.getElementById("demo").innerHTML = Boolean(x == 10);
  8. </script>
  9. </body>
  10. </html>

这条 if 语句返回 true(也许不像预期),因为 10 为 true:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 0;
  7. document.getElementById("demo").innerHTML = Boolean(x = 10);
  8. </script>
  9. </body>
  10. </html>

这条 if 语句返回 false(也许不像预期),因为 0 为 false:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 0;
  7. document.getElementById("demo").innerHTML = Boolean(x = 0);
  8. </script>
  9. </body>
  10. </html>

赋值总是返回赋值的值。


期望松散的比较

在常规比较中,数据类型不重要。这条 if 语句返回 true

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 10;
  7. var y = "10";
  8. document.getElementById("demo").innerHTML = Boolean(x == y);
  9. </script>
  10. </body>
  11. </html>

在严格比较中,数据类型确实重要。这条 if 语句返回 false

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 10;
  7. var y = "10";
  8. document.getElementById("demo").innerHTML = Boolean(x === y);
  9. </script>
  10. </body>
  11. </html>

有一个常见的错误是忘记在 switch 语句中使用严格比较,

这条 switch 语句会显示提示框:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 10;
  7. switch(x) {
  8. case 10: alert("Hello");
  9. }
  10. </script>
  11. </body>
  12. </html>

这条 switch 语句不会显示提示框:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 10;
  7. switch(x) {
  8. case "10": alert("Hello");
  9. }
  10. </script>
  11. </body>
  12. </html>

加法和级联的问题

加法用于加数值

级联(Concatenation)用于加字符串

在 JavaScript 中,这两种运算均使用相同的 + 运算符。

正因如此,将数字作为数值相加,与将数字作为字符串相加,将产生不同的结果:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 10 + "5";
  7. document.getElementById("demo").innerHTML = x;
  8. </script>
  9. </body>
  10. </html>

如果是两个变量相加,很难预测结果:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 10;
  7. var y = "5";
  8. var z = x + y;
  9. document.getElementById("demo").innerHTML = z;
  10. </script>
  11. </body>
  12. </html>

浮点型的处理方式

JavaScript 中的数字均保存为 64 位的浮点数(Floats)。所有编程语言,包括 JavaScript,都存在处理浮点值的困难:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 0.1;
  7. var y = 0.2;
  8. var z = x + y;
  9. document.getElementById("demo").innerHTML = z;
  10. </script>
  11. </body>
  12. </html>

为了解决上面的问题,请使用乘除运算:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 0.1;
  7. var y = 0.2;
  8. var z = (x * 10 + y *10) / 10;
  9. document.getElementById("demo").innerHTML = z;
  10. </script>
  11. </body>
  12. </html>

对 JavaScript 字符串换行

JavaScript 允许您把一条语句换行为两行:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. document.getElementById("demo").innerHTML =
  7. "Hello World!";
  8. </script>
  9. </body>
  10. </html>

但是,在字符串中间来换行是不对的:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. document.getElementById("demo").innerHTML = "Hello
  7. World!";
  8. </script>
  9. </body>
  10. </html>

如果必须在字符串中换行,则必须使用反斜杠:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. document.getElementById("demo").innerHTML = "Hello \
  7. World!";
  8. </script>
  9. </body>
  10. </html>

错位的分号

因为一个错误的分号,此代码块无论 x 的值如何都会执行:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. var x = 5;
  7. if (x == 19);
  8. {
  9. document.getElementById("demo").innerHTML = "Hello";
  10. }
  11. </script>
  12. </body>
  13. </html>

对 return 语句进行换行

在一行的结尾自动关闭语句是默认的 JavaScript 行为。

正因如此,下面两个例子返回相同的结果:

例子 1
  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. document.getElementById("demo").innerHTML = myFunction(55);
  7. function myFunction(a) {
  8. var power = 10
  9. return a * power
  10. }
  11. </script>
  12. </body>
  13. </html>
例子 2
  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. document.getElementById("demo").innerHTML = myFunction(55);
  7. function myFunction(a) {
  8. var power = 10;
  9. return a * power;
  10. }
  11. </script>
  12. </body>
  13. </html>

JavaScript 也允许您将一条语句换行为两行。

正因如此,例子 3 也将返回相同的结果:

例子 3
  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. document.getElementById("demo").innerHTML = myFunction(55);
  7. function myFunction(a) {
  8. var
  9. power = 10;
  10. return a * power;
  11. }
  12. </script>
  13. </body>
  14. </html>

但是,如果把 return 语句换行为两行会发生什么呢:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. document.getElementById("demo").innerHTML = myFunction(55);
  7. function myFunction(a) {
  8. var
  9. power = 10;
  10. return
  11. a * power;
  12. }
  13. </script>
  14. </body>
  15. </html>

此函数将返回 undefined!为什么呢?因为 JavaScript 认为你的意思是:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p id="demo">
  5. <script>
  6. document.getElementById("demo").innerHTML = myFunction(55);
  7. function myFunction(a) {
  8. var
  9. power = 10;
  10. return;
  11. a * power;
  12. }
  13. </script>
  14. </body>
  15. </html>

解释

如果某条语句是不完整的:

  1. var

JavaScript 将通过读取下一行来完成这条语句:

  1. power = 10;

但是由于这条语句是完整的:

  1. return

JavaScript 会自动关闭该语句:

  1. return;

发生这种情况是因为,在 JavaScript 中,用分号来关闭(结束)语句是可选的。

JavaScript 会在行末关闭 return 语句,因为它本身就是一条完整的语句。

所以,绝不要对 return 语句进行换行。


通过命名索引来访问数组

很多编程语言支持带有命名索引的数组。

带有命名索引的数组被称为关联数组(或散列)。

JavaScript 不支持带有命名索引的数组。

在 JavaScript 中,数组使用数字索引

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <h1>JavaScript 数组</h1>
  5. <p id="demo">
  6. <script>
  7. var person = [];
  8. person[0] = "John";
  9. person[1] = "Doe";
  10. person[2] = 46;
  11. document.getElementById("demo").innerHTML =
  12. person[0] + " " + person.length;
  13. </script>
  14. </body>
  15. </html>

在 JavaScript 中,对象使用命名索引

如果您使用命名索引,那么在访问数组时,JavaScript 会将数组重新定义为标准对象。

在自动重定义之后,数组方法或属性将产生未定义或非正确的结果:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <h1>JavaScript 数组</h1>
  5. <p>如果在访问数组时使用命名索引,JavaScript 会将数组重新定义为标准对象,并且某些数组方法和属性将产生未定义或不正确的结果。</p>
  6. <p id="demo">
  7. <script>
  8. var person = [];
  9. person["firstName"] = "埃隆";
  10. person["lastName"] = "马斯克";
  11. person["age"] = 46;
  12. document.getElementById("demo").innerHTML =
  13. person[0] + " " + person.length;
  14. </script>
  15. </body>
  16. </html>

用逗号来结束定义

对象和数组定义中的尾随逗号在 ECMAScript 5 中是合法的。

对象实例:
  1. person = {firstName:"埃隆", lastName:"马斯克", age:62,}
数组实例:
  1. points = [35, 450, 2, 7, 30, 16,];

但是在 Internet Explorer 8 会崩溃。

JSON 不允许末端加逗号。

JSON:
  1. person = {firstName:"埃隆", lastName:"马斯克", age:62}
JSON:
  1. points = [35, 450, 2, 7, 30, 16];

Undefined 不是 Null

JavaScript 对象、变量、属性和方法可以是未定义的。

此外,空的 JavaScript 对象的值可以为 null

这可能会使测试对象是否为空变得有点困难。

您可以通过测试类型是否为 undefined,来测试对象是否存在:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <h2>JavaScript</h2>
  5. <p>要测试对象是否不存在,请测试类型是否是 undefined:</p>
  6. <p id="demo">
  7. <script>
  8. document.getElementById("demo").innerHTML = typeof myObj === "undefined";
  9. </script>
  10. </body>
  11. </html>

但是您无法测试对象是否为 null,因为如果对象未定义,将抛出错误:

不正确:
  1. if (myObj === null)

要解决此问题,必须测试对象是否为 null,而不是未定义。

但这仍然会引发错误:

不正确:
  1. if (myObj !== null && typeof myObj !== "undefined")

因此,在测试非 null 之前,必须先测试未定义:

正确:

if (typeof myObj !== "undefined" && myObj !== null)


期望块级范围

JavaScript 不会为每个代码块创建新的作用域。

很多编程语言都是如此,但是 JavaScript 并非如此

认为这段代码会返回 undefined,是新的 JavaScript 开发者的常见错误:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <h2>JavaScript</h2>
  5. <p>JavaScript不会为每个代码块创建新的作用域。</p>
  6. <p>此代码将显示 i(10)的值,即使在 for 循环块之外:</p>
  7. <p id="demo">
  8. <script>
  9. for (var i = 0; i < 10; i++) {
  10. // some code
  11. }
  12. document.getElementById("demo").innerHTML = i;
  13. </script>
  14. </body>
  15. </html>