良好的JavaScript编码风格（语法规则）

编码风格

1.概述

“编程风格”（programming style）指的是编写代码的样式规则。不一样的程序员，每每有不一样的编程风格。

有人说，编译器的规范叫作“语法规则”（grammar），这是程序员必须遵照的；而编译器忽略的部分，就叫“编程风格”（programming style），这是程序员能够自由选择的。这种说法不彻底正确，程序员当然能够自由选择编程风格，可是好的编程风格有助于写出质量更高、错误更少、更易于维护的程序。

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

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

2.缩进

行首的空格和 Tab 键，均可以产生代码缩进效果（indent）。

Tab 键能够节省击键次数，但不一样的文本编辑器对 Tab 的显示不尽相同，有的显示四个空格，有的显示两个空格，因此有人以为，空格键可使得显示效果更统一。

不管你选择哪种方法，都是能够接受的，要作的就是始终坚持这一种选择。不要一会使用 Tab 键，一会使用空格键。

3.区块

若是循环和判断的代码体只有一行，JavaScript 容许该区块（block）省略大括号。

if (a)  
   b();  
   c();

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

if (a) {
  b();
  c();
}

可是，实际效果倒是下面这样。

if (a) {
  b();
}
  c();

所以，建议老是使用大括号表示区块。

另外，区块起首的大括号的位置，有许多不一样的写法。最流行的有两种，一种是起首的大括号另起一行。

block
{
  // ...
}

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

block {
  // ...
}

通常来讲，这两种写法均可以接受。可是，JavaScript 要使用后一种，由于 JavaScript 会自动添加句末的分号，致使一些难以察觉的错误。

return
{
  key: value
};

// 至关于
return;
{
  key: value
};

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

return {
  key : value
};

所以，表示区块起首的大括号，不要另起一行。

4.圆括号

圆括号（parentheses）在 JavaScript 中有两种做用，一种表示函数的调用，另外一种表示表达式的组合（grouping）。

// 圆括号表示函数的调用
console.log('abc');

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

建议能够用空格，区分这两种不一样的括号。

1. 表示函数调用时，函数名与左括号之间没有空格。
2. 表示函数定义时，函数名与左括号之间没有空格。
3. 其余状况时，前面位置的语法元素与左括号之间，都有一个空格。

按照上面的规则，下面的写法都是不规范的。

foo (bar)
return(a+b);
if(a === 0) {...}
function foo (b) {...}
function(x) {...}

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

5.行尾的分号

5.1不使用分号的状况

首先，如下三种状况，语法规定原本就不须要在结尾添加分号。

（1）for 和 while 循环

for ( ; ; ) {
} // 没有分号

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

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

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

（2）分支语句：if，switch，try

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

switch () {
} // 没有分号

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

（3）函数的声明语句

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

注意，函数表达式仍然要使用分号。

var f = function f() {
};j

以上三种状况，若是使用了分号，并不会出错。由于，解释引擎会把这个分号解释为空语句。

5.2分号的自动添加

除了上一节的三种状况，全部语句都应该使用分号。可是，若是没有使用分号，大多数状况下，JavaScript 会自动添加。

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

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

所以，有人提倡省略句尾的分号。麻烦的是，若是下一行的开始能够与本行的结尾连在一块儿解释，JavaScript 就不会自动添加分号。

// 等同于 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)

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

x = y
(function () {
  // ...
})();

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

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

// 引擎解释为 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 引擎才会自动添加分号。

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

// 等同于下面的代码，
// 由于 0console 没有意义
if (a < 0) a = 0;
console.log(a)

另外，若是一行的起首是“自增”（++）或“自减”（--）运算符，则它们的前面会自动添加分号。

a = b = c = 1

a
++
b
--
c

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

上面代码之因此会获得1 2 0的结果，缘由是自增和自减运算符前，自动加上了分号。上面的代码实际上等同于下面的形式。

a = b = c = 1;
a;
++b;
--c;

若是continue、break、return和throw这四个语句后面，直接跟换行符，则会自动添加分号。这意味着，若是return语句返回的是一个对象的字面量，起首的大括号必定要写在同一行，不然得不到预期结果。

return
{ first: 'Jane' };

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

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

不该该省略结尾的分号，还有一个缘由。有些 JavaScript 代码压缩器（uglifier）不会自动添加分号，所以遇到没有分号的结尾，就会让代码保持原状，而不是压缩成一行，使得压缩没法获得最优的结果。

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

;var a = 1;
// ...

上面这种写法就能够避免与其余脚本合并时，排在前面的脚本最后一行语句没有分号，致使运行出错的问题。

6.全局变量

JavaScript 最大的语法缺点，可能就是全局变量对于任何一个代码块，都是可读可写。这对代码的模块化和重复使用，很是不利。

所以，建议避免使用全局变量。若是不得不使用，能够考虑用大写字母表示变量名，这样更容易看出这是全局变量，好比UPPER_CASE。

7.变量声明

JavaScript 会自动将变量声明“提高”（hoist）到代码块（block）的头部。

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

// 等同于
var x;
if (!x) {
  x = {};
}

这意味着，变量x是if代码块以前就存在了。为了不可能出现的问题，最好把变量声明都放在代码块的头部。

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

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

上面这样的写法，就容易看出存在一个全局的循环变量i。

另外，全部函数都应该在使用以前定义。函数内部的变量声明，都应该放在函数的头部。

8.with语句

with能够减小代码的书写，可是会形成混淆。

with (o) {
　foo = bar;
}

上面的代码，能够有四种运行结果：

o.foo = bar;
o.foo = o.bar;
foo = bar;
foo = o.bar;

这四种结果均可能发生，取决于不一样的变量是否有定义。所以，不要使用with语句。

9.相等和严格相等

JavaScript 有两个表示相等的运算符：“相等”（==）和“严格相等”（===）。

相等运算符会自动转换变量类型，形成不少意想不到的状况。

0 == ''// true
1 == true // true
2 == true // false
0 == '0' // true
false == 'false' // false
false == '0' // true
' \t\r\n ' == 0 // true

所以，建议不要使用相等运算符（==），只使用严格相等运算符（===）。

10.语句的合并

有些程序员追求简洁，喜欢合并不一样目的的语句。好比，原来的语句是

a = b;
if (a) {
  // ...
}

他喜欢写成下面这样。

if (a = b) {
  // ...
}

虽然语句少了一行，可是可读性大打折扣，并且会形成误读，让别人误解这行代码的意思是下面这样。

if （a === b）{
  // ...
}

建议不要将不一样目的的语句，合并成一行。

11.自增和自减

自增（++）和自减（--）运算符，放在变量的前面或后面，返回的值不同，很容易发生错误。事实上，全部的++运算符均可以用+= 1代替。

++x
// 等同于
x += 1;

改用+= 1，代码变得更清晰了。

建议自增（++）和自减（--）运算符尽可能使用+=和-=代替。

12.switch...case 结构

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

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

function doAction(action) {
  switch (action) {
    case 'hack':
      return 'hack';
    case 'slash':
      return 'slash';
    case 'run':
      return 'run';
    default:
      throw new Error('Invalid action.');
  }
}

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

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结构能够用对象结构代替。

13.参考连接

• 阮一峰，JavaScript教程
• Eric Elliott, Programming JavaScript Applications, Chapter 2. JavaScript Style Guide, O'Reilly, 2013
• Axel Rauschmayer, A meta style guide for JavaScript
• Axel Rauschmayer, Automatic semicolon insertion in JavaScript
• Rod Vagg, JavaScript and Semicolons

本文章采用知识共享 署名-相同方式共享 3.0协议