DIV CSS 佈局教程網

編寫高品質 JavaScript 程式碼的核心要點
編輯:關於JavaScript     

才華橫溢的 Stoyan Stefanov 在 O'Reilly 出版的《JavaScript Patterns》(JavaScript 模式)一書中,系統性地整理了好程式碼的要素:避免全域變數、使用單一 var 宣告、在迴圈中預先快取 length、遵循可讀性慣例等等。本文是這些觀念的整理摘要。

其中也包含一些與程式碼本身無直接關係、但對整體品質至關重要的習慣:撰寫 API 文件、執行同儕審查、跑過 JSLint。這些做法能幫你寫出更易理解、更易維護的程式碼——幾個月甚至幾年後回頭看,仍會感到自豪。

撰寫可維護的程式碼

修 bug 的成本很高,而且會隨時間累積;尤其當 bug 潛伏到已發布的軟體中才爆發時。發現當下就修是最好的,因為此時你腦中對問題的脈絡還很清晰。否則一旦轉移到其他任務、久而久之再回頭看,就得:

  • 花時間重新理解這個問題
  • 花時間理解該問題相關的程式碼

更別說在團隊或大公司裡,修 bug 的人往往不是寫程式碼的人。所以降低「理解成本」至關重要——這直接關係到營收與開發者的幸福感,因為我們更應該去開發新功能,而不是花幾小時甚至幾天維護歷史包袱。

另一個軟體開發的現實是:讀程式碼的時間遠多於寫程式碼。專注時你或許能一下午寫出大量程式碼,而且很快就能跑起來。但隨著應用成熟,各種變化接踵而來:

  • bug 被暴露出來
  • 新功能被加入
  • 執行環境改變(例如新瀏覽器問世)
  • 程式碼用途改變
  • 需要重寫、移植到另一個架構,甚至改用另一種語言

因此,短短數小時寫成的程式碼,最終可能要花數週去閱讀。這就是可維護性如此重要的原因。

可維護的程式碼意味著:可讀、一致、可預測、看起來像同一個人寫的、且有文件。

極小化全域變數

JavaScript 透過函式管理作用域。函式內部宣告的變數僅在該函式內可用;反之,在函式外宣告或「未宣告直接使用」的變數就是全域變數。

每個 JavaScript 環境都有一個全域物件,在函式外使用 this 即可存取。你建立的每個全域變數都會成為它的屬性;在瀏覽器中,這個全域物件有個附加屬性叫 window,通常指向自己:

myglobal = "hello"; // 不推薦寫法
console.log(myglobal);          // "hello"
console.log(window.myglobal);   // "hello"
console.log(window["myglobal"]); // "hello"
console.log(this.myglobal);     // "hello"

全域變數的問題

問題在於你的應用程式與頁面上所有程式碼共享這些全域變數,它們住在同一個命名空間。當程式的兩個不同部分定義了同名但用途不同的全域變數,命名衝突幾乎無可避免。

而網頁包含非本頁開發者撰寫的程式碼相當常見,例如:第三方 JavaScript 函式庫、廣告腳本、使用者追蹤與分析腳本、各類小元件與按鈕。

舉例來說,第三方腳本定義了一個名為 result 的全域變數,接著你的函式也定義了同名變數,結果後者覆蓋前者,第三方腳本瞬間就壞了。

因此,要與其他腳本和平共處,盡可能少用全域變數非常重要。後文提到的命名空間模式、立即執行函式都能減少全域變數,但最根本的一條是:永遠用 var 宣告變數。

JavaScript 有兩個特性讓「不小心創造全域變數」變得意外容易:一是變數不宣告也能使用;二是任何未宣告的變數都會自動成為全域物件的屬性:

function sum(x, y) {
  // 不推薦:隱式全域變數
  result = x + y;
  return result;
}

這段程式照樣能跑,但呼叫後你的命名空間多了一個 result,這就是問題的根源。經驗法則很簡單——永遠用 var 宣告:

function sum(x, y) {
  var result = x + y;
  return result;
}

另一個常見陷阱是「鏈式賦值時部分漏宣告」:

// 反例,勿使用
function foo() {
  var a = b = 0; // b 是全域變數
  // ...
}

原因是賦值由右至左:先執行 b = 0,此時 b 未宣告,於是成為全域變數;表達式回傳 0,再賦給用 var 宣告的區域變數 a。等價於:

var a = (b = 0);

若已準備好宣告,鏈式賦值就安全了:

function foo() {
  var a, b;
  a = b = 0; // 兩者皆為區域變數
}

避免全域變數的另一個理由是可移植性。若程式碼要在不同環境執行,使用全域變數如同走在薄冰上——你可能不知不覺覆蓋了原本環境不存在、而目標環境才有的物件。

忘記 var 的副作用

隱式全域變數與明確宣告的全域變數有個細微差異:能否被 delete 刪除。

  • 用 var 建立的全域變數(在函式外宣告)無法被刪除。
  • 無 var 的隱式全域變數(不論是否在函式內建立)可以被刪除。

這說明隱式全域變數在技術上並非真正的變數,而是全域物件的屬性——屬性能刪,變數不能:

// 定義三個全域變數
var global_var = 1;
global_novar = 2; // 反面教材

(function () {
  global_fromfunc = 3; // 反面教材
}());

// 嘗試刪除
delete global_var;     // false
delete global_novar;   // true
delete global_fromfunc; // true

// 驗證
typeof global_var;     // "number"
typeof global_novar;   // "undefined"
typeof global_fromfunc; // "undefined"

在 ES5 嚴格模式下,存取未宣告的變數會直接拋出錯誤。

存取全域物件

在瀏覽器中,全域物件可透過 window 屬性在任何位置存取(除非你搞怪地宣告了一個名為 window 的區域變數)。但在其他環境下,這個屬性可能叫別的名字甚至不存在。若需要在不硬編碼 window 的情況下取得全域物件,可以這樣做:

var global = (function () {
  return this;
}());

因為該函式是被當作普通函式呼叫(非透過 new),this 永遠指向全域物件。但這招在 ES5 嚴格模式下失效,此時可改成把程式碼包進立即函式,並從全域作用域傳入 this 的引用。

單一 var 模式

在函式頂部用單一 var 陳述式宣告所有區域變數,有幾個好處:

  • 提供單一位置查閱函式所需的所有區域變數
  • 避免「變數在宣告前被使用」的邏輯錯誤
  • 幫助你記住自己宣告了哪些變數,从而减少全域變數
  • 程式碼量更少
function func() {
  var a = 1,
      b = 2,
      sum = a + b,
      myobject = {},
      i,
      j;
  // 函式主體...
}

用一個 var 搭配逗號宣告多個變數,並在宣告時一併初始化,是很值得推薦的習慣。這麼做能防止邏輯錯誤(未初始化的變數值為 undefined),也提升可讀性——看到初始值就能大致推斷變數用途。

宣告時也可以順便做事,例如上面的 sum = a + b;或者在使用 DOM 時把引用一次宣告為區域變數:

function updateElement() {
  var el = document.getElementById("result"),
      style = el.style;
  // 後續使用 el 與 style...
}

預解析:變數宣告分散的問題

在 JavaScript 中,你可以在函式任何位置宣告 var,它們的行為如同在函式頂部宣告,這稱為 hoisting(預解析)。若變數先被使用、之後才宣告,就可能產生邏輯錯誤。因為只要在同一作用域內,無論宣告寫在哪裡,都被視為已宣告:

// 反例
myname = "global"; // 全域變數

function func() {
  alert(myname); // "undefined"
  var myname = "local";
  alert(myname); // "local"
}
func();

你可能預期第一個 alert 顯示 "global",因為那時 myname 尚未宣告,理應去找全域變數。但實際上它顯示 "undefined"——因為 myname 被視為函式的區域變數(儘管宣告在後面),所有宣告都被提前到函式頂部了。为避免這種混淆,最好預先宣告你想使用的所有變數。

上述程式碼實際等效於:

myname = "global";

function func() {
  var myname; // 等同 var myname = undefined;
  alert(myname); // "undefined"
  myname = "local";
  alert(myname); // "local"
}
func();

補充一個實作層面的細節:程式碼處理分兩階段,第一階段建立變數、函式宣告與參數,第二階段才執行程式碼。出於實用目的,我們用 hoisting 這個詞(ECMAScript 規範並未定義此術語)來描述這種行為。

for 迴圈

在 for 迴圈中,你可以遍取值組或類陣列物件的值,例如 arguments 與 HTMLCollection。常見寫法如下:

// 次佳的迴圈
for (var i = 0; i < myarray.length; i++) {
  // 使用 myarray[i] 做些什麼
}

這種寫法的缺陷是每次迭代都要重新取得長度,會拖慢效能——尤其當 myarray 不是陣列而是 HTMLCollection 時。

HTMLCollection 指的是 DOM 方法回傳的物件,例如:

document.getElementsByName()
document.getElementsByClassName()
document.getElementsByTagName()

還有一些在 DOM 標準之前引入、至今仍在使用:

document.images: 頁面上所有圖片元素
document.links: 所有 a 標籤元素
document.forms: 所有表單
document.forms[0].elements: 第一個表單中的所有欄位

集合的麻煩在於它們是對文件的即時查詢。也就是說,每次存取集合的長度都要重新查詢 DOM,而 DOM 操作通常代價不低。

因此,遍取值時快取長度是更好的形式:

for (var i = 0, max = myarray.length; i < max; i++) {
  // 使用 myarray[i] 做些什麼
}

如此一來,整個迴圈只取一次長度。在各瀏覽器上,快取 HTMLCollection 長度都能提速(約 2 倍到 190 倍不等,視瀏覽器而異;此數據年代久遠,僅供參考)。

注意:若你明確想在迴圈中修改集合(例如新增 DOM 元素),則反而應該讓長度即時更新。

搭配單一 var 模式,可以把變數提到迴圈外:

function looper() {
  var i = 0, max, myarray = [];
  // ...
  for (i = 0, max = myarray.length; i < max; i++) {
    // 使用 myarray[i] 做些什麼
  }
}

好處是風格一致;缺點是重構時複製貼上整個迴圈較麻煩——從一個函式複製到另一個函式時,你得確認 i 與 max 已在新函式中宣告。

最後一個微調是把 i++ 改成 i = i + 1 或 i += 1。JSLint 如此建議,是因為 ++ 與 -- 容易造成「過度取巧」的寫法。若不採用,把 JSLint 的 plusplus 選項設為 false 即可。

還有兩種變形寫法略有改進,因為:少一個變數(不需要 max);且遞減到 0 通常更快,因為與 0 比較比與其他數值比較更有效率:

// 第一種變形
var i, myarray = [];
for (i = myarray.length; i--;) {
  // 使用 myarray[i] 做些什麼
}

// 第二種:使用 while
var myarray = [], i = myarray.length;
while (i--) {
  // 使用 myarray[i] 做些什麼
}

這些改進僅體現在效能上,而 JSLint 同樣會對 i-- 提出抱怨。

for-in 迴圈

for-in 應該用在非陣列物件的遍歷上,這種用法也稱為「列舉」。

技術上你可以用 for-in 遍歷陣列(因為陣列也是物件),但不推薦。原因有二:若陣列物件被擴充了自訂功能,可能發生邏輯錯誤;且 for-in 的屬性列舉順序無法保證。所以最佳实践是陣列用普通 for,物件用 for-in。

另一個重點是 hasOwnProperty(),它能過濾掉從原型鏈繼承而來的屬性。

// 物件
var man = { hands: 2, legs: 2, heads: 1 };

// 程式碼某處,為所有物件加上一個方法
if (typeof Object.prototype.clone === "undefined") {
  Object.prototype.clone = function () {};
}

這個例子中,man 定義完之後,某處在原型上加了個 clone() 方法。由於原型鏈是即時的,所有物件都能存取它。为避免列舉 man 時出現 clone(),需要用 hasOwnProperty() 過濾,否則函式會被顯示出來,在大多數情況下並非我們所願:

// 1. 正確寫法
for (var i in man) {
  if (man.hasOwnProperty(i)) {
    console.log(i, ":", man[i]);
  }
}
/* 輸出
hands : 2
legs : 2
heads : 1
*/

// 2. 反面例子:未檢查 hasOwnProperty()
for (var i in man) {
  console.log(i, ":", man[i]);
}
/* 輸出
hands : 2
legs : 2
heads : 1
clone: function () {}
*/

另一種寫法是直接借用 Object.prototype 上的方法:

for (var i in man) {
  if (Object.prototype.hasOwnProperty.call(man, i)) {
    console.log(i, ":", man[i]);
  }
}

好處是即使 man 重新定義了自己的 hasOwnProperty 也不受影響,同時避免長屬性查找——可以用區域變數快取:

var i, hasOwn = Object.prototype.hasOwnProperty;
for (i in man) {
  if (hasOwn.call(man, i)) {
    console.log(i, ":", man[i]);
  }
}

嚴格說來,不用 hasOwnProperty() 並不算錯誤。依任務性質與你對程式碼的把握程度,可以省略它以換取些許速度;但當你不確定當前物件的內容與原型鏈時,加上它更保險。

有一種通不過 JSLint 的寫法會省略大括號、把 if 寫在同一行,優點是讀起來像一個完整想法:

// 警告:通不過 JSLint 檢測
var i, hasOwn = Object.prototype.hasOwnProperty;
for (i in man)
  if (hasOwn.call(man, i)) {
    console.log(i, ":", man[i]);
  }

(不)擴充內建原型

擴充建構函式的 prototype 是增加功能的有力手段,但有時它太有力了。

為 Object()、Array()、Function() 等內-built 建構函式的原型添加屬性很誘人,卻嚴重降低可維護性,因為它讓程式碼變得難以預測。使用你程式碼的其他開發者,通常會預期內建方法照常運作,而不是多出你自訂的方法。

此外,加到原型的屬性在沒有 hasOwnProperty 過濾時會出現在迴圈列舉中,造成混淆。

因此,最佳实践是不擴充內建原型。只有同時滿足以下三個條件時才例外:

  • 可以預期未來的 ECMAScript 版本或 JavaScript 實作會把該功能作為內建方法實現(例如提前實作 ES5 描述的方法,等瀏覽器跟上)
  • 你檢查過該自訂屬性尚不存在(可能已在其他地方實作,或已是引擎的一部分)
  • 你清楚記錄並與團隊溝通了這個變更

若三個條件都滿足,可以這樣做:

if (typeof Object.prototype.myMethod !== "function") {
  Object.prototype.myMethod = function () {
    // 實作...
  };
}

switch 模式

你可以透過特定風格的 switch 陳述式提升可讀性與健壯性:

var inspect_me = 0, result = '';

switch (inspect_me) {
  case 0:
    result = "zero";
    break;
  case 1:
    result = "one";
    break;
  default:
    result = "unknown";
}

這個例子遵循的風格約定如下:

  • 每個 case 與 switch 對齊(縮排規則的唯一例外)
  • case 內的程式碼縮排
  • 每個 case 以 break 明確結束
  • 避免貫穿(故意忽略 break)。若你非常確信貫穿是最好的做法,務必註解說明,否則讀者可能誤以為是錯誤
  • 以 default 結尾,確保即使無任何情況匹配也有合理結果

避免隱式型別轉換

JavaScript 變數在比較時會進行隱式轉型,這就是 false == 0 或 "" == 0 回傳 true 的原因。为避免混淆,比較值與表達式型別時請一律使用 === 與 !==:

var zero = 0;

if (zero === false) {
  // 不執行,因為 zero 是 0 而非 false
}

// 反面示例
if (zero == false) {
  // 執行了...
}

也有觀點認為 == 就夠了、=== 是多餘的——例如用 typeof 時已知它回傳字串,沒有嚴格相等的必要。但 JSLint 要求嚴格相等,這讓程式碼更一致,也降低閱讀時的心智負擔(「這裡的 == 是刻意還是一時疏忽?」)。

避免 eval()

若你的程式碼用了 eval(),記住這句咒語:「eval() 是魔鬼」。它接受任意字串並當作 JavaScript 執行。若程式碼是事先已知的(而非執行期才決定),就沒有理由使用它。若是執行期動態產生,通常也有不用 eval 的更好做法,例如用中括號表示法存取動態屬性:

// 反面示例
var property = "name";
alert(eval("obj." + property));

// 更好的做法
var property = "name";
alert(obj[property]);

使用 eval() 也帶來安全隱患,因為被執行的程式碼(例如來自網路)可能已被竄改。處理 Ajax 回傳的 JSON 時這是常見的反面教材——此時應使用內建的 JSON 解析方法以確保安全與有效;若瀏覽器不支援 JSON.parse(),可引入 JSON.org 的函式庫。

同樣要記住:給 setInterval()、setTimeout() 與 Function() 建構函式傳字串,多數情況與 eval() 類似,應避免。幕後 JavaScript 仍需評估並執行你傳入的字串:

// 反面示例
setTimeout("myFunc()", 1000);
setTimeout("myFunc(1, 2, 3)", 1000);

// 更好的做法
setTimeout(myFunc, 1000);
setTimeout(function () {
  myFunc(1, 2, 3);
}, 1000);

新的 Function() 建構方式類似 eval(),應謹慎使用。它確實強大,但也常被誤用。如果非得執行動態程式碼,可以考慮用 new Function() 取代 eval()——有個潛在好處:其中的程式碼在區域函式作用域中執行,因此以 var 定義的變數不會自動變成全域變數。另一種阻止自動全域化的方式,是把 eval() 呼叫包進立即函式中。

看下面的例子,只有 un 污染了命名空間:

console.log(typeof un);    // "undefined"
console.log(typeof deux);  // "undefined"
console.log(typeof trois); // "undefined"

var jsstring = "var un = 1; console.log(un);";
eval(jsstring); // logs "1"

jsstring = "var deux = 2; console.log(deux);";
new Function(jsstring)(); // logs "2"

jsstring = "var trois = 3; console.log(trois);";
(function () {
  eval(jsstring);
}()); // logs "3"

console.log(typeof un);    // number
console.log(typeof deux);  // "undefined"
console.log(typeof trois); // "undefined"

eval() 與 Function 建構的另一差異是:eval() 可以存取並修改它所在外層作用域的變數,而 Function 只看到全域作用域(使用 Function 與 new Function 效果相同):

(function () {
  var local = 1;
  eval("local = 3; console.log(local)"); // logs "3"
  console.log(local); // logs "3"
}());

(function () {
  var local = 1;
  Function("console.log(typeof local);")(); // logs undefined
}());

parseInt() 的數值轉換

使用 parseInt() 可從字串取出數值,它接受第二個「基數」參數,這參數經常被省略,但不該省略。當字串以 "0" 開頭時可能出問題:在 ECMAScript 3 中,以 "0" 開頭的字串會被當作八進位處理(此行為在 ES5 中已修正)。为避免矛盾與意外結果,請永遠指定基數:

var month = "06",
    year = "09";
month = parseInt(month, 10);
year = parseInt(year, 10);

若省略基數,parseInt(year) 會回傳 0,因為 "09" 被當作八進位(等同 parseInt(year, 8)),而 09 在八進位中不是有效數字。

替代方案是直接轉數字:

+"08"          // 8
Number("08")   // 8

這些通常比 parseInt() 快,因為顧名思義,parseInt 是「解析整數」而非單純轉型。但若要處理 "08 hello" 這種輸入,parseInt() 仍會回傳數字,其他方式則以 NaN 告終。

編碼規範

建立並遵循編碼規範很重要,它讓程式碼保持一致、可預測、易讀易懂。新成員加入團隊時,只要讀過規範就能理解他人寫的程式碼,更快進入狀況。

關於規範的具體面向(例如縮排用 Tab 還是空格)常引發激烈討論。如果你是規範的提案者,要有心理準備面對各種反對聲浪。但請記住:建立並堅定遵循規範,遠比糾結規範的細節重要。

縮排

沒有縮排的程式碼幾乎無法閱讀。而唯一比不縮排更糟的,是不一致的縮排——它看起來像是遵循了某種規範,實際上卻一路伴隨混亂與驚喜。

有人偏好 Tab,因為每個人都能用編輯器調整成自己喜歡的寬度;有人偏好空格(通常四個)。這都無所謂,只要團隊遵循同一規範即可。本書例如採用四個空格,這也是 JSLint 的預設值。

什麼該縮排?規則很簡單——大括號裡的東西。也就是函式主體、迴圈(do、while、for、for-in)、if、switch,以及物件字面量中的屬性:

function outer(a, b) {
  var c = 1,
      d = 2,
      inner;

  if (a > b) {
    inner = function () {
      return { r: c - d };
    };
  } else {
    inner = function () {
      return { r: c + d };
    };
  }
  return inner;
}

大括號

大括號應永遠使用,即使語法允許省略。技術上,若 if 或 for 內只有一條陳述式,括號可以省;但仍應一律加上,這讓程式碼更一致、更易於後續修改。

想像你有一個只有單行陳述式的 for 迴圈,省略括號也不會報錯:

// 糟糕的實例
for (var i = 0; i < 10; i += 1)
  alert(i);

但後來你在迴圈主體又加了一行:

// 糟糕的實例
for (var i = 0; i < 10; i += 1)
  alert(i);
  alert(i + " is " + (i % 2 ? "odd" : "even"));

第二個 alert 已經在迴圈之外,縮排欺騙了你。為了長遠著想,即使只有一行也請加上括號:

// 好的實例
for (var i = 0; i < 10; i += 1) {
  alert(i);
}

if 條件同理:

// 壞
if (true)
  alert(1);
else
  alert(2);

// 好
if (true) {
  alert(1);
} else {
  alert(2);
}

左大括號的位置

開發者對左括號該放在同一行或下一行各有偏好:

if (true) {
  alert("It's TRUE!");
}

// 或
if (true)
{
  alert("It's TRUE!");
}

多數情況這純屬風格問題,但有一類情況會導致不同行為,原因在於分號插入機制——JavaScript 很「不挑剔」,當你沒寫分號結尾時它會自動補上。這可能造成麻煩,例如返回物件字面量而左括號換行時:

// 警告:意外的回傳值
function func() {
  return
  // 下面的程式碼不會執行
  {
    name: "Batman"
  }
}

若你期望函式回傳一個含 name 屬性的物件,結果會讓你驚訝:由於隱含分號,函式回傳 undefined。上述程式碼等價於:

// 警告:意外的回傳值
function func() {
  return undefined;
  // 下面的程式碼不會執行
  {
    name: "Batman"
  }
}

結論:永遠使用大括號,並把左括號放在與前一句相同的一行:

function func() {
  return {
    name: "Batman"
  };
}

關於分號的補充:如同大括號,即使解析器會自動補上,你也應該永遠顯式撰寫分號。這不僅讓程式碼更嚴謹,也能避免前述的歧異。

空格

空格的使用同樣有助於可讀性與一致性。寫英文時,逗號與句號後會留空格;在 JavaScript 中,你可以依相同邏輯在「列表模樣的表達式」(對應逗號)與陳述式結尾(對應句號)之後留空格。

適合使用空格的位置:

  • for 迴圈中分號隔開的各段之後:for (var i = 0; i < 10; i += 1) {...}
  • for 迴圈中初始化的多個變數之後:for (var i = 0, max = 10; i < max; i += 1) {...}
  • 分隔陣列項的逗號之後:var a = [1, 2, 3];
  • 物件屬性的逗號之後,以及分隔屬性名與值的冒號之後:var o = {a: 1, b: 2};
  • 函式參數之間:myFunc(a, b, c)
  • 函式宣告的括號之前:function myFunc() {}
  • 匿名函式表達式中 function 的之後:var myFunc = function () {};

在運算子與運算元之間留空格也是好習慣,也就是 +、-、*、=、<、>、<=、>=、===、!==、&&、||、+= 等前後都需要空格:

// 寬鬆一致的間距,讓程式碼更易讀、更「透氣」
var d = 0,
    a = b + 1;

if (a && b && c) {
  d = a % c;
  a += d;
}

// 反面例子:缺失或間距不一,讓程式碼變得可疑
var d = 0,
    a = b + 1;
if (a && b && c) {
  d = a % c;
  a += d;
}

最後一個要注意的空格是大括號間距。最好使用空格:

  • 函式、if-else、迴圈、物件字面量的左括號之前
  • else 或 while 之前的右括號之後

空格的唯一缺點是增加檔案大小,但壓縮即可解決。

還有一個常被忽略的可讀性面向是垂直空格。你可以用空行分隔程式碼區塊,就像文學作品用段落分隔概念一樣。

命名規範

另一種讓程式碼更具可預測性與可維護性的方式,是採用命名規範——用一致的形式為變數與函式命名。

以下建議你可以原樣採用,也可以依喜好調整。同樣地,遵循規範比規範具體內容更重要。

建構函式首字母大寫

JavaScript 沒有類別,但有以 new 呼叫的建構函式:

var adam = new Person();

因為建構函式本質上仍是函式,函式名稱就成了判斷依據。約定首字母大寫代表「這是建構函式」,小寫則代表不應以 new 呼叫:

function MyConstructor() {...}
function myFunction() {...}

單詞分隔

當變數或函式名含多個單詞時,最好遵循統一的分隔規範。常見做法是「駝峰命名法」:單詞小寫,每個單詞首字母大寫。

建構函式可用大駝峰(upper camel case),如 MyConstructor();函式與方法則用小駝峰(lower camel case),如 myFunction()、calculateArea()、getFirstName()。

若變數不是函式,通常也用小駘峰;另一種做法是所有單詞小寫並以底線連接,例如 first_name、favorite_bands、old_company_name。這種標記法能直觀區分函式與其他識別字。

ECMAScript 的屬性與方法均使用駝峰標記法,儘管多字屬性名稱相當罕見(如正則表達式物件的 lastIndex 與 ignoreCase)。

其他命名慣例

有時開發者會用命名規範來彌補或替代語言特性。

例如 JavaScript 沒有定義常數的方法(儘管有些內建的如 Number.MAX_VALUE),於是慣例是以全大寫命名那些在程式生命週期內都不會改變的變數:

// 珍貴常數,只可遠觀
var PI = 3.14,
    MAX_WIDTH = 800;

另一個全大寫慣例是:全域變數名稱全部大寫。這能強化「減少全域變數」的實踐,同時讓它們易於辨識。

還有一種用規範模擬功能的做法是私有成員。雖然 JavaScript 能做到真正的私有,但開發者發現僅用一個底線前綴表示私有更簡單:

var person = {
  getName: function () {
    return this._getFirst() + ' ' + this._getLast();
  },
  _getFirst: function () {
    // ...
  },
  _getLast: function () {
    // ...
  }
};

此例中 getName() 是公開方法,屬於穩定的 API;_getFirst() 與 _getLast() 則表示私有。它們仍是正常的公開方法,但底線前綴在警告使用者:這些方法在下一版可能不再保證可用,請勿直接呼叫。注意 JSLint 對底線前綴有意見,除非你把 noman 選項設為 false。

其他常見的_private慣例:

  • 使用結尾底線表示私有,如 name_ 與 getElements_()
  • 一個底線前綴表示 _protected(保護)屬性,兩個表示 __private(私有)
  • Firefox 中一些非語言標準部分的內建屬性,用前後雙底線表示,如 __proto__ 與 __parent__

撰寫註解

你必須為程式碼撰寫註解,即使不會有其他人接觸它。通常深入一個問題時,你很清楚程式碼在幹嘛;但一週後回頭看,恐怕也要耗掉不少腦細胞才能弄懂。

顯然,註解不能走極端——為每個變數或每行都寫註解並不合理。但你通常應該記錄所有函式、它們的參數與回傳值,以及任何不尋常的技術或方法。註解能給未來的閱讀者諸多提示:讀者需要的是「不要讀太多」,僅憑註解與函式屬性名就能理解你的程式碼。例如某段五六行的程式碼執行特定任務,只要你提供一行說明「目的與為何在此」,閱讀者就能直接跳過細節。沒有硬性規定程式碼與註解的比例,某些部分(如正則表達式)註解甚至可能多於程式碼。

最重要、卻也最難遵守的習慣是:保持註解即時更新,因為過時的註解比沒有註解更具誤導性。

關於作者

Stoyan Stefanov 是 Yahoo! 的網頁開發人員,多本 O'Reilly 書籍的作者、投稿者與技術審查者。他常在會議與個人部落格 www.phpied.com 上發表網頁開發主題的演講。Stoyan 同時是 smush.it 圖片優化工具的創造者、YUI 貢獻者,以及雅虎效能優化工具 YSlow 2.0 的架構設計師。

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