文章目录
  1. 1. 编程风格
  2. 2. 区块
  3. 3. 圆括号
  4. 4. 行尾的分号
    1. 4.1. 不使用分号的情况
      1. 4.1.1. for和while循环
      2. 4.1.2. 分支语句:if,switch,try
      3. 4.1.3. 函数的声明语句
    2. 4.2. 分号的自动添加
  5. 5. 变量声明
  6. 6. new命令
  7. 7. 相等和严格相等
  8. 8. switch…case结构

编程风格

所谓”编程风格”(programming style),指的是编写代码的样式规则。不同的程序员,往往有不同的编程风格。

有人说,编译器的规范叫做”语法规则”(grammar),这是程序员必须遵守的;而编译器忽略的部分,就叫”编程风格”(programming style),这是程序员可以自由选择的。这种说法不完全正确,程序员固然可以自由选择编程风格,但是好的编程风格有助于写出质量更高、错误更少、更易于维护的程序。

所以,”编程风格”的选择不应该基于个人爱好、熟悉程度、打字量等因素,而要考虑如何尽量使代码清晰易读、减少出错。你选择的,不是你喜欢的风格,而是一种能够清晰表达你的意图的风格。这一点,对于JavaScript这种语法自由度很高的语言尤其重要。

必须牢记的一点是,如果你选定了一种“编程风格”,就应该坚持遵守,切忌多种风格混用。如果你加入他人的项目,就应该遵守现有的风格。

区块

如果循环和判断的代码体只有一行,JavaScript允许该区块(block)省略大括号。

1
2
3
if (a)
b();
c();

上面代码的原意可能是下面这样。

1
2
3
4
if (a) {
b();
c();
}

但是,实际效果却是下面这样。

1
2
3
4
if (a) {
b();
}
c();

因此,总是使用大括号表示区块。

另外,区块起首的大括号的位置,有许多不同的写法。

最流行的有两种。一种是起首的大括号另起一行:

1
2
3
4
block
{
// ...
}

另一种是起首的大括号跟在关键字的后面。

1
2
3
block {
// ...
}

一般来说,这两种写法都可以接受。但是,JavaScript要使用后一种,因为JavaScript会自动添加句末的分号,导致一些难以察觉的错误。

1
2
3
4
5
6
7
8
9
10
return
{
key: value
};

// 相当于
return;
{
key: value
};

上面的代码的原意,是要返回一个对象,但实际上返回的是undefined,因为JavaScript自动在return语句后面添加了分号。为了避免这一类错误,需要写成下面这样。

1
2
3
return {
key : value
};

因此,表示区块起首的大括号,不要另起一行。

圆括号

圆括号(parentheses)在JavaScript中有两种作用,一种表示函数的调用,另一种表示表达式的组合(grouping)。

1
2
3
4
5
// 圆括号表示函数的调用
console.log('abc');

// 圆括号表示表达式的组合
(1 + 2) * 3

我们可以用空格,区分这两种不同的括号。

  1. 表示函数调用时,函数名与左括号之间没有空格。
  2. 表示函数定义时,函数名与左括号之间没有空格。
  3. 其他情况时,前面位置的语法元素与左括号之间,都有一个空格。
    按照上面的规则,下面的写法都是不规范的。
    1
    2
    3
    4
    5
    foo (bar)
    return(a+b);
    if(a === 0) {...}
    function foo (b) {...}
    function(x) {...}

上面代码的最后一行是一个匿名函数,function是语法关键字,不是函数名,所以与左括号之间应该要有一个空格。

行尾的分号

分号表示一条语句的结束。JavaScript规定,行尾的分号可以省略。事实上,确实有一些开发者行尾从来不写分号。但是,由于下面要讨论的原因,建议还是不要这个分号。

不使用分号的情况

for和while循环

1
2
3
4
5
for ( ; ; ) {
} // 没有分号

while (true) {
} // 没有分号

需要注意的是do...while循环是有分号的。

1
2
3
do {
a--;
} while(a > 0); // 分号不能省略

分支语句:if,switch,try

1
2
3
4
5
6
7
8
9
if (true) {
} // 没有分号

switch () {
} // 没有分号

try {
} catch {
} // 没有分号

函数的声明语句

1
2
function f() {
} // 没有分号

但是函数表达式仍然要使用分号。

1
2
var f = function f() {
};

以上三种情况,如果使用了分号,并不会出错。因为,解释引擎会把这个分号解释为空语句。

分号的自动添加

除了上一节的三种情况,所有语句都应该使用分号。但是,如果没有使用分号,大多数情况下,JavaScript会自动添加。

1
2
3
var a = 1
// 等同于
var a = 1;

这种语法特性被称为“分号的自动添加”(Automatic Semicolon Insertion,简称ASI)。

因此,有人提倡省略句尾的分号。麻烦的是,如果下一行的开始可以与本行的结尾连在一起解释,JavaScript就不会自动添加分号。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 等同于 var a = 3
var
a
=
3

// 等同于 'abc'.length
'abc'
.length

// 等同于 return a + b;
return a +
b;

// 等同于 obj.foo(arg1, arg2);
obj.foo(arg1,
arg2);

// 等同于 3 * 2 + 10 * (27 / 6)
3 * 2
+
10 * (27 / 6)

上面代码都会多行放在一起解释,不会每一行自动添加分号。这些例子还是比较容易看出来的,但是下面这个例子就不那么容易看出来了。

1
2
3
4
5
6
7
x = y
(function () {
// ...
})();

// 等同于
x = y(function () {...})();

下面是更多不会自动添加分号的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 解释为 c(d+e)
var a = b + c
(d+e).toString();

// 解释为 a = b/hi/g.exec(c).map(d)
// 正则表达式的斜杠,会当作除法运算符
a = b
/hi/g.exec(c).map(d);

// 解释为'b'['red', 'green'],
// 即把字符串当作一个数组,按索引取值
var a = 'b'
['red', 'green'].forEach(function (c) {
console.log(c);
})

// 解释为 function(x) { return x }(a++)
// 即调用匿名函数,结果f等于0
var a = 0;
var f = function(x) { return x }
(a++)

只有下一行的开始与本行的结尾,无法放在一起解释,JavaScript引擎才会自动添加分号。

1
2
3
4
5
6
7
8
if (a < 0) a = 0
console.log(a)

// 等同于下面的代码,
// 因为0console没有意义

if (a < 0) a = 0;
console.log(a)

另外,如果一行的起首是“自增”(++)或“自减”(--)运算符,则它们的前面会自动添加分号。

1
2
3
4
5
6
7
8
9
10
a = b = c = 1

a
++

b
--

c

console.log(a, b, c)
// 1 2 0

上面代码之所以会得到“1 2 0”的结果,原因是自增和自减运算符前,自动加上了分号。上面的代码实际上等同于下面的形式。

1
2
3
4
a = b = c = 1;
a;
++b;
--c;

如果continuebreakreturnthrow这四个语句后面,直接跟换行符,则会自动添加分号。这意味着,如果return语句返回的是一个对象的字面量,起首的大括号一定要写在同一行,否则得不到预期结果。

1
2
3
4
5
6
return
{ first: 'Jane' };

// 解释成
return;
{ first: 'Jane' };

由于解释引擎自动添加分号的行为难以预测,因此编写代码的时候不应该省略行尾的分号。

不应该省略结尾的分号,还有一个原因。有些JavaScript代码压缩器不会自动添加分号,因此遇到没有分号的结尾,就会让代码保持原状,而不是压缩成一行,使得压缩无法得到最优的结果。

另外,不写结尾的分号,可能会导致脚本合并出错。所以,有的代码库在第一行语句开始前,会加上一个分号。

1
2
;var a = 1;
// ...

上面这种写法就可以避免与其他脚本合并时,排在前面的脚本最后一行语句没有分号,导致运行出错的问题。

变量声明

JavaScript会自动将变量声明”提升”(hoist)到代码块(block)的头部。

1
2
3
4
5
6
7
8
9
10
if (!o) {
var o = {};
}

// 等同于

var o;
if (!o) {
o = {};

}

为了避免可能出现的问题,最好把变量声明都放在代码块的头部。

1
2
3
4
5
6
7
8
9
10
for (var i = 0; i < 10; i++) {
// ...
}

// 写成

var i;
for (i = 0; i < 10; i++) {
// ...
}

另外,所有函数都应该在使用之前定义,函数内部的变量声明,都应该放在函数的头部。

new命令

JavaScript使用new命令,从构造函数生成一个新对象。

1
var o = new myObject();

上面这种做法的问题是,一旦你忘了加上newmyObject()内部的this关键字就会指向全局对象,导致所有绑定在this上面的变量,都变成全局变量。

因此,建议使用Object.create()命令,替代new命令。如果不得不使用new,为了防止出错,最好在视觉上把构造函数与其他函数区分开来。比如,构造函数的函数名,采用首字母大写(InitialCap),其他函数名一律首字母小写。

相等和严格相等

JavaScript有两个表示”相等”的运算符:”相等”(==)和”严格相等”(===)。

因为”相等”运算符会自动转换变量类型,造成很多意想不到的情况:

1
2
3
4
5
6
7
0 == ''// true
1 == true // true
2 == true // false
0 == '0' // true
false == 'false' // false
false == '0' // true
’ \t\r\n ' == 0 // true

因此,不要使用“相等”(==)运算符,只使用“严格相等”(===)运算符。

switch…case结构

switch...case结构要求,在每一个case的最后一行必须是break语句,否则会接着运行下一个case。这样不仅容易忘记,还会造成代码的冗长。

而且,switch...case不使用大括号,不利于代码形式的统一。此外,这种结构类似于goto语句,容易造成程序流程的混乱,使得代码结构混乱不堪,不符合面向对象编程的原则。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function doAction(action) {
switch (action) {
case 'hack':
return 'hack';
break;
case 'slash':
return 'slash';
break;
case 'run':
return 'run';
break;
default:
throw new Error('Invalid action.');
}
}

上面的代码建议改写成对象结构。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function doAction(action) {
var actions = {
'hack': function () {
return 'hack';
},
'slash': function () {
return 'slash';
},
'run': function () {
return 'run';
}
};

if (typeof actions[action] !== 'function') {
throw new Error('Invalid action.');
}

return actions[action]();
}

建议避免使用switch...case结构,用对象结构代替。
转自: 阮一峰教程

文章目录
  1. 1. 编程风格
  2. 2. 区块
  3. 3. 圆括号
  4. 4. 行尾的分号
    1. 4.1. 不使用分号的情况
      1. 4.1.1. for和while循环
      2. 4.1.2. 分支语句:if,switch,try
      3. 4.1.3. 函数的声明语句
    2. 4.2. 分号的自动添加
  5. 5. 变量声明
  6. 6. new命令
  7. 7. 相等和严格相等
  8. 8. switch…case结构