才華橫溢的 Stoyan Stefanov 在 O'Reilly 出版的《JavaScript Patterns》(JavaScript 模式)一書中,系統性地整理了好程式碼的要素:避免全域變數、使用單一 var 宣告、在迴圈中預先快取 length、遵循可讀性慣例等等。本文是這些觀念的整理摘要。
其中也包含一些與程式碼本身無直接關係、但對整體品質至關重要的習慣:撰寫 API 文件、執行同儕審查、跑過 JSLint。這些做法能幫你寫出更易理解、更易維護的程式碼——幾個月甚至幾年後回頭看,仍會感到自豪。
修 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; // 兩者皆為區域變數
}
避免全域變數的另一個理由是可移植性。若程式碼要在不同環境執行,使用全域變數如同走在薄冰上——你可能不知不覺覆蓋了原本環境不存在、而目標環境才有的物件。
隱式全域變數與明確宣告的全域變數有個細微差異:能否被 delete 刪除。
這說明隱式全域變數在技術上並非真正的變數,而是全域物件的屬性——屬性能刪,變數不能:
// 定義三個全域變數
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 陳述式宣告所有區域變數,有幾個好處:
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 迴圈中,你可以遍取值組或類陣列物件的值,例如 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,物件用 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 過濾時會出現在迴圈列舉中,造成混淆。
因此,最佳实践是不擴充內建原型。只有同時滿足以下三個條件時才例外:
若三個條件都滿足,可以這樣做:
if (typeof Object.prototype.myMethod !== "function") {
Object.prototype.myMethod = function () {
// 實作...
};
}
你可以透過特定風格的 switch 陳述式提升可讀性與健壯性:
var inspect_me = 0, result = '';
switch (inspect_me) {
case 0:
result = "zero";
break;
case 1:
result = "one";
break;
default:
result = "unknown";
}
這個例子遵循的風格約定如下:
JavaScript 變數在比較時會進行隱式轉型,這就是 false == 0 或 "" == 0 回傳 true 的原因。为避免混淆,比較值與表達式型別時請一律使用 === 與 !==:
var zero = 0;
if (zero === false) {
// 不執行,因為 zero 是 0 而非 false
}
// 反面示例
if (zero == false) {
// 執行了...
}
也有觀點認為 == 就夠了、=== 是多餘的——例如用 typeof 時已知它回傳字串,沒有嚴格相等的必要。但 JSLint 要求嚴格相等,這讓程式碼更一致,也降低閱讀時的心智負擔(「這裡的 == 是刻意還是一時疏忽?」)。
若你的程式碼用了 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() 可從字串取出數值,它接受第二個「基數」參數,這參數經常被省略,但不該省略。當字串以 "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 (var i = 0; i < 10; i += 1) {...}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() {}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;
}
最後一個要注意的空格是大括號間距。最好使用空格:
空格的唯一缺點是增加檔案大小,但壓縮即可解決。
還有一個常被忽略的可讀性面向是垂直空格。你可以用空行分隔程式碼區塊,就像文學作品用段落分隔概念一樣。
另一種讓程式碼更具可預測性與可維護性的方式,是採用命名規範——用一致的形式為變數與函式命名。
以下建議你可以原樣採用,也可以依喜好調整。同樣地,遵循規範比規範具體內容更重要。
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_()__proto__ 與 __parent__你必須為程式碼撰寫註解,即使不會有其他人接觸它。通常深入一個問題時,你很清楚程式碼在幹嘛;但一週後回頭看,恐怕也要耗掉不少腦細胞才能弄懂。
顯然,註解不能走極端——為每個變數或每行都寫註解並不合理。但你通常應該記錄所有函式、它們的參數與回傳值,以及任何不尋常的技術或方法。註解能給未來的閱讀者諸多提示:讀者需要的是「不要讀太多」,僅憑註解與函式屬性名就能理解你的程式碼。例如某段五六行的程式碼執行特定任務,只要你提供一行說明「目的與為何在此」,閱讀者就能直接跳過細節。沒有硬性規定程式碼與註解的比例,某些部分(如正則表達式)註解甚至可能多於程式碼。
最重要、卻也最難遵守的習慣是:保持註解即時更新,因為過時的註解比沒有註解更具誤導性。
Stoyan Stefanov 是 Yahoo! 的網頁開發人員,多本 O'Reilly 書籍的作者、投稿者與技術審查者。他常在會議與個人部落格 www.phpied.com 上發表網頁開發主題的演講。Stoyan 同時是 smush.it 圖片優化工具的創造者、YUI 貢獻者,以及雅虎效能優化工具 YSlow 2.0 的架構設計師。