DIV CSS 佈局教程網

前端開發規範(三):JavaScript 撰寫約定與最佳實踐
編輯:JavaScript基礎知識     

變數宣告

永遠使用 var 宣告變數。若省略 var,變數會被隱式宣告為全域變數,導致難以控制,也讓所處定義域變得模糊(可能是 Document 或 Window,也可能不小心進入區域定義域)。此外,啟用嚴格模式後,手誤打錯變數名時能透過錯誤訊息快速定位問題。

變數命名

變數名建議使用駝峰法(camelCase);全域變數與常數(如 PI)使用全大寫(UPPERCASE);函式方面,建構函式首字母大寫,非建構函式首字母小寫。變數名不要以 $ 作為起始標記,以免與許多 JavaScript 函式庫衝突。

避免污染全域命名空間

總是把程式碼包進 IIFE(Immediately-Invoked Function Expression),以建立獨立隔絕的定義域。這麼做既能防止全域命名空間被污染,也能確保程式碼不會輕易被其他程式碼(第三方函式庫、window 參照、被覆寫的 undefined 等)改動。

// 不推薦
var x = 10, y = 100;
// 在全域宣告變數會造成全域污染,所有變數都會掛到 window 上
console.log(window.x + ' ' + window.y);

// 推薦
(function(log, w, undefined){
  'use strict';
  var x = 10, y = 100;
  // 輸出 true true
  log((w.x === undefined) + ' ' + (w.y === undefined));
}(window.console.log, window));

IIFE 的寫法

任何時候需要一個新的封閉定義域,就用 IIFE。它不僅避免干擾,還能讓記憶體在執行完後立即釋放。所有腳本檔都建議從 IIFE 開始。

執行用的括號應該寫在外層括號內。寫在內或外都有效,但寫在內讓整個表達式看起來更完整,因此推薦這麼做。

// 不推薦
(function(){})();

// 推薦
(function(){}());

// 建議格式
(function(){
  'use strict';
  // Code goes here
}());

若要引用全域變數或外層 IIFE 的變數,用傳參方式帶入:

(function($, w, d){
  'use strict';
  $(function() {
    w.alert(d.querySelectorAll('div').length);
  });
}(jQuery, window, document));

嚴格模式

ECMAScript 5 的嚴格模式可在整個腳本或個別方法內啟用,它會在不同情境下做更嚴格的錯誤檢查,確保程式碼更健壯、運行更快,並阻止使用未來可能成為保留字的關鍵字。

建議在獨立的 IIFE 中啟用,而不是寫在腳本第一行——那樣會讓所有腳本都進入嚴格模式,可能引發第三方函式庫的問題。

// 不推薦
'use strict';
(function(){
  // Your code starts here
}());

// 推薦
(function(){
  'use strict';
  // Your code starts here
}());

理解定義域與定義域提升

JavaScript 會把變數與函式定義自動提升到執行之前。它只有 function 級定義域,沒有塊級定義域,因此在函式內某個語句或迴圈中宣告的變數,作用範圍會擴及整個函式。

原始程式碼:

(function(log){
  'use strict';
  var a = 10;
  for(var i = 0; i < a; i++) {
    var b = i * i;
    log(b);
  }
  if(a === 10) {
    var f = function() { log(a); };
    f();
  }
  function x() { log('Mr. X!'); }
  x();
}(window.console.log));

被 JS 提升後:

(function(log){
  'use strict';
  // 閉包內所有變數都會被提升到函式頂部
  var a, i, b, f;

  // 閉包內所有函式宣告也會被提升到頂部
  function x() { log('Mr. X!'); }

  a = 10;
  for(i = 0; i < a; i++) {
    b = i * i;
    log(b);
  }
  if(a === 10) {
    // 函式指派的結果只會產生被提升的變數,函式體不會被提升
    // 只有真正的函式宣告,才會連同函式體一起提升
    f = function() { log(a); };
    f();
  }
  x();
}(window.console.log));

理解這套機制後,下面這段看似混亂的程式碼其實完全合法:

(function(log){
  'use strict';
  var a = 10;
  i = 5;
  x();
  for(var i; i < a; i++) {
    log(b);
    var b = i * i;
  }
  if(a === 10) {
    f = function() { log(a); };
    f();
    var f;
  }
  function x() { log('Mr. X!'); }
}(window.console.log));

正因為結果容易出乎意料,養成良好的宣告習慣才能把風險降到最低。

提升宣告(手動把宣告集中到頂部)

為避免自動提升造成誤解,我們應該手動把變數與函式定義放在函式開頭。只用一個 var 關鍵字,多個變數以逗號隔開。

// 不推薦
(function(log){
  'use strict';
  var a = 10;
  var b = 10;
  for(var i = 0; i < 10; i++) {
    var c = a * b * i;
  }
  function f() { }
  var d = 100;
  var x = function() { return d * d; };
  log(x());
}(window.console.log));

// 推薦
(function(log){
  'use strict';
  var a = 10, b = 10, i, c, d, x;
  function f() { }
  for(i = 0; i < 10; i++) {
    c = a * b * i;
  }
  d = 100;
  x = function() { return d * d; };
  log(x());
}(window.console.log));

賦值盡量寫在宣告處:

// 不推薦
var a, b, c;
a = 10; b = 10; c = 100;

// 推薦
var a = 10, b = 10, c = 100;

使用嚴格相等比較

一律使用 ===,避免 JavaScript 的強制型別轉換帶來困擾。使用 === 時,比較雙方必須同型別才可能相等。只寫 == 的話,轉換規則會讓結果變得難以追蹤:

(function(log){
  'use strict';
  log('0' == 0);   // true
  log("" == false); // true
  log('1' == true); // true
  log(null == undefined); // true

  var x = { valueOf: function() { return 'X'; } };
  log(x == 'X');   // true,因為觸發了 valueOf
}(window.console.log));

明智地使用真假判斷

在 if 條件中使用變數或表達式時會做真假判斷。if(a == true) 與 if(a) 並不相同,後者就是真假判斷,會依下列規則轉為布林值:false、0、undefined、null、NaN、""(空字串)一律為假。

(function(log){
  'use strict';
  function logTruthyFalsy(expr) {
    if(expr) { log('truthy'); } else { log('falsy'); }
  }

  logTruthyFalsy(true);       // truthy
  logTruthyFalsy(1);          // truthy
  logTruthyFalsy({});         // truthy
  logTruthyFalsy([]);         // truthy
  logTruthyFalsy('0');        // truthy
  logTruthyFalsy(false);      // falsy
  logTruthyFalsy(0);          // falsy
  logTruthyFalsy(undefined);  // falsy
  logTruthyFalsy(null);       // falsy
  logTruthyFalsy(NaN);        // falsy
  logTruthyFalsy("");         // falsy
}(window.console.log));

賦值時善用邏輯運算子

邏輯運算子 || 與 && 也可用來回傳布林值。若運算元不是布林,每個表達式會由左而右做真假判斷,最終總有一個被回傳,這在賦值時能大幅精簡程式碼。

// 不推薦
if(!x) {
  if(!y) { x = 1; } else { x = y; }
}

// 推薦
x = x || y || 1;

這個技巧常用於設定方法的預設參數:

(function(log){
  'use strict';
  function multiply(a, b) {
    a = a || 1;
    b = b || 1;
    log('Result ' + a * b);
  }

  multiply();       // Result 1
  multiply(10);     // Result 10
  multiply(3, NaN); // Result 3
  multiply(9, 5);   // Result 45
}(window.console.log));

分號

永遠補上分號。隱式的語句串接會引發難以察覺的問題:

// 1.
MyClass.prototype.myMethod = function() { return 42; } // 這裡沒有分號
(function() {
  // 用函式包起來建立區域定義域
})();

var x = { 'i': 1, 'j': 2 } // 這裡沒有分號

// 2.
[ffVersion, ieVersion][isIE]();

var THINGS_TO_EAT = [apples, oysters, sprayOnCheese] // 這裡沒有分號

// 3.
-1 == resultOfOperation() || die();

會發生什麼事?

JavaScript 報錯——回傳 42 的那個函式被下一段當作參數呼叫,接著數字 42 也被「呼叫」而抛出錯誤。第二段則可能出現「undefined 中沒有該屬性」的錯誤,因為實際呼叫形式是 x[ffVersion, ieVersion][isIE]()。第三段中 die() 永遠會被執行,因為陣列減 1 得到 NaN,而 NaN 不等於任何值。

原因?

JavaScript 語句必須以分號結束,換行並不會終結語句。以上每段範例中,函式宣告、物件或陣列都被併入了同一句話。閉合的圓括號不代表語句結束——除非下一個 token 是中綴運算子或圓括號運算子,否則 JavaScript 不會終結語句。

分號與函式的區別

分號用在表達式結尾,而非函式宣告結尾:

var foo = function() { return true; }; // 需要分號
function foo() { return true; }        // 不需要分號

嵌套函式

嵌套函式非常有用,例如在持續建立並隱藏輔助函式的場景中,可以自由使用。

語句塊內的函式宣告

切勿在語句塊內宣告函式——在 ECMAScript 5 嚴格模式下這是不合法的。函式宣告應放在定義域頂層;若確有必要,改寫成函式表達式賦值給變數。

// 不推薦
if (x) { function foo() {} }

// 推薦
if (x) { var foo = function() {}; }

異常處理

做大型開發時你很難完全避免異常。若沒有自訂異常機制,從有回傳值的函式中回傳錯誤訊息會相當棘手也不優雅。常見的陋習包括傳入一個參照物件來接收錯誤,或總是回傳一個可能含錯誤物件的清單。在複雜環境中,建議拋出物件而非僅拋出字串:

if(name === undefined) {
  throw {
    name: 'System Error',
    message: 'A name should always be specified!'
  }
}

優先使用標準特性

為兼顧擴充性與相容性,應優先採用標準特性而非非標準寫法。例如用 string.charAt(3) 而非 string[3];用標準 DOM 方法取得元素參照,而非特定應用的快捷方法。

簡易的原型繼承

若只需簡單繼承,可用以下模式;若預期會遇到複雜繼承結構,建議引入專門的繼承庫。

(function(log){
  'use strict';

  // 建構函式
  function Apple(name) {
    this.name = name;
  }

  // 定義方法
  Apple.prototype.eat = function() {
    log('Eating ' + this.name);
  };

  // 子類建構函式
  function GrannySmithApple() {
    // 呼叫父類建構函式
    Apple.prototype.constructor.call(this, 'Granny Smith');
  }

  // 以 Object.create 建立原型副本並指定為父類原型
  GrannySmithApple.prototype = Object.create(Apple.prototype);
  // 修正 constructor 指向,否則會指回 Apple
  GrannySmithApple.prototype.constructor = GrannySmithApple;

  // 覆寫並呼叫父類方法
  GrannySmithApple.prototype.eat = function() {
    // 記得用 call(this) 套用到當前物件
    Apple.prototype.eat.call(this);
    log('Poor Grany Smith');
  };

  var apple = new Apple('Test Apple');
  var grannyApple = new GrannySmithApple();

  log(apple.name);        // Test Apple
  log(grannyApple.name);  // Granny Smith

  log(apple instanceof Apple);            // true
  log(apple instanceof GrannySmithApple); // false
  log(grannyApple instanceof Apple);      // true
  log(grannyApple instanceof GrannySmithApple); // true

  grannyApple.eat(); // Eating Granny Smith / Poor Grany Smith
}(window.console.log));

使用閉包

閉包的建立可能是 JS 最有用也最容易被忽略的能力,理解它的運作方式對寫出可靠的非同步程式碼至關重要。

切勿在迴圈中建立函式

在迴圈中加入函式很容易形成閉包而帶來隱患,以下就是典型的陷阱:

// 不推薦
(function(log, w){
  'use strict';
  var numbers = [1, 2, 3], i;
  for(i = 0; i < numbers.length; i++) {
    w.setTimeout(function() {
      // 執行時 i 已變成 3,因此會 alert 三次 "Index 3 with number undefined"
      w.alert('Index ' + i + ' with number ' + numbers[i]);
    }, 0);
  }
}(window.console.log, window));

用 IIFE 建立獨立閉包雖然能解決問題,但仍有兩個函式被建立,違反了「不在迴圈中建立函式」的原則:

// 不推薦
(function(log, w){
  'use strict';
  var numbers = [1, 2, 3], i;
  for(i = 0; i < numbers.length; i++) {
    (function(index, number){
      w.setTimeout(function() {
        w.alert('Index ' + index + ' with number ' + number);
      }, 0);
    }(i, numbers[i]));
  }
}(window.console.log, window));

把產生閉包的動作抽到迴圈外,雖然已解決問題,寫法卻顯得繁瑣:

// 不完全推薦
(function(log, w){
  'use strict';
  var numbers = [1, 2, 3], i;

  function alertIndexWithNumber(index, number) {
    return function() {
      w.alert('Index ' + index + ' with number ' + number);
    };
  }

  for(i = 0; i < numbers.length; i++) {
    w.setTimeout(alertIndexWithNumber(i, numbers[i]), 0);
  }
}(window.console.log, window));

改用函式式寫法(如 forEach)才是最好的解法,每次迭代自然對應一次閉包,語意清楚且可預期:

// 推薦
(function(log, w){
  'use strict';
  var numbers = [1, 2, 3];

  numbers.forEach(function(number, index) {
    w.setTimeout(function() {
      w.alert('Index ' + index + ' with number ' + number);
    }, 0);
  });
}(window.console.log, window));

eval 函式

eval() 既混淆語境又存在風險,永遠有更好、更清晰、更安全的替代方案,請盡量不要使用這個「魔鬼函式」。

this 關鍵字

只在物件建構器、方法,以及設定好的閉包中使用 this。它的語意容易誤導:時而指向全域物件,時而指向呼叫者的定義域(如在 eval 中),時而指向 DOM 樹中的節點(事件綁定到 HTML 屬性時),時而指向新建的物件(建構式中),被 call() 與 apply() 呼叫時又指向另一個物件。

正因為容易出錯,請把它的使用限制在:建構函式中、物件方法中(含由此建立的閉包內)。

首選函式式風格

函式式編程能簡化程式碼並降低維護成本,因為它容易複用、適當解耦且依賴更少。以陣列求和為例:

// 不推薦
(function(log){
  'use strict';
  var arr = [10, 3, 7, 9, 100, 20], sum = 0, i;
  for(i = 0; i < arr.length; i++) {
    sum += arr[i];
  }
  log('The sum of array ' + arr + ' is: ' + sum)
}(window.console.log));

// 推薦
(function(log){
  'use strict';
  var arr = [10, 3, 7, 9, 100, 20];
  var sum = arr.reduce(function(prevValue, currentValue) {
    return prevValue + currentValue;
  }, 0);
  log('The sum of array ' + arr + ' is: ' + sum);
}(window.console.log));

又如依規則篩選陣列:

// 不推薦
(function(log){
  'use strict';
  var numbers = [11, 3, 7, 9, 100, 20, 14, 10],
      numbersGreaterTen = [], i;
  for(i = 0; i < numbers.length; i++) {
    if(numbers[i] > 10) {
      numbersGreaterTen.push(numbers[i]);
    }
  }
  log('From the list of numbers ' + numbers
    + ' only ' + numbersGreaterTen + ' are greater than ten');
}(window.console.log));

// 推薦
(function(log){
  'use strict';
  var numbers = [11, 3, 7, 9, 100, 20, 14, 10];
  var numbersGreaterTen = numbers.filter(function(element) {
    return element > 10;
  });
  log('From the list of numbers ' + numbers
    + ' only ' + numbersGreaterTen + ' are greater than ten');
}(window.console.log));

例外情況:當程式碼效能比維護性更關鍵時,應選擇效能最佳的解法,例如用簡單的 for 迴圈取代 forEach。

善用 ES5 新增語法

陣列與物件的迭代:用 ES5 的迭代方法處理陣列,需要在特定條件下中斷時可用 every。

(function(log){
  'use strict';

  [1, 2, 3, 4, 5].every(function(element, index, arr) {
    log(element + ' at index ' + index + ' in array ' + arr);
    if(index !== 5) { return true; }
  });

  var obj = { a: 'A', b: 'B', 'c-d-e': 'CDE' };

  Object.keys(obj).forEach(function(element, index, arr) {
    log('Key ' + element + ' has value ' + obj[element]);
  });
}(window.console.log));

不要使用 switch:switch 在各語言中都是較難控制的語句,建議用 if/else 取代。

使用陣列與物件字面量

用字面量取代建構器。陣列建構器特別容易在參數上出錯:

// 不推薦
var a1 = new Array(x1, x2, x3); // 長度 3
var a2 = new Array(x1, x2);     // 長度 2
var a3 = new Array(x1);         // 若 x1 是自然數,長度為 x1;若非自然數則抛出異常;否則視為單一元素
var a4 = new Array();           // 長度 0

也就是說,把原本兩個參數的呼叫改成一個,陣列長度就可能出現意料之外的變化。因此請一律使用可讀性更高的字面量:

// 推薦
var a  = [x1, x2, x3];
var a2 = [x1, x2];
var a3 = [x1];
var a4 = [];

物件建構器沒有類似問題,但為了可讀性與一致性,同樣建議使用字面量:

// 不推薦
var o = new Object();
var o2 = new Object();
o2.a = 0;
o2.b = 1;
o2.c = 2;
o2['strange key'] = 3;

// 推薦
var o = {};
var o2 = { a: 0, b: 1, c: 2, 'strange key': 3 };

禁止修改內建原型的原型鏈

修改 Object.prototype、Array.prototype 這類內建物件是被嚴格禁止的。修改 Function.prototype 等危害雖小,但仍會造成難以除錯的問題,同樣應避免。

自訂 toString() 方法

自訂 toString() 可以控制物件的字串化行為,但必須確保它永遠成功且無副作用。若 toString() 內呼叫了帶有斷言的方法,斷言失敗時可能又需要輸出所屬物件的名稱,於是再次呼叫 toString(),容易引發嚴重問題。

圓括號

只在語法與語意真正需要時才謹慎使用圓括號。不要用在單元運算子(delete、typeof、void)上,也不要放在 return、throw、case、new 等關鍵字之後。

字串

統一使用單引號,不使用雙引號。這在組出 HTML 字串時尤其方便:

var msg = 'This is some HTML <div class="makes-sense"></div>';

三元條件運算子

用三元運算子處理簡單的賦值或回傳,避免用在複雜情境——沒人願意用十行三元運算繞暈自己。

// 不推薦
if(x === 10) {
  return 'valid';
} else {
  return 'invalid';
}

// 推薦
return x === 10 ? 'valid' : 'invalid';

註 1:作者指的是採用嚴謹的語句寫法,從根本上杜絕因缺少分號引起的程式碼歧義。

註 2:中綴運算子,指像 x + y 中的 +。

註 3:斷言一般指測試時的假設,通常是布林表達式;為真則程式續行,為假則程式終止。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved