隨著網站越做越「厚」,客戶端要扛的工作也越來越多。JavaScript 是直譯式語言,先天上難以與 C、Java 這類語言比拼執行速度,正因為如此,寫法上的每個選擇造成的相對差距反而更明顯。以下把實務中累積的優化經驗整理成主題式筆記,從作用域查找一路談到記憶體回收與程式碼組織。
存取區域變量比存取全域變量快,因此把常用的全域物件先存成區域變量,是成本最低、效果最直接的優化。
function search() {
// 每次都要沿作用域鏈往上找 window.location
alert(window.location.href + window.location.host);
}
// 改寫後
function search() {
var location = window.location;
alert(location.href + location.host);
}
with 會建立自己的作用域,使作用域鏈變長,其中的程式碼勢必比外面慢。能不用就不用。
with (a.b.c.d) {
property1 = 1;
property2 = 2;
}
// 改寫後
var obj = a.b.c.d;
obj.property1 = 1;
obj.property2 = 2;
同一頁面內的所有 JavaScript 都在同一個執行環境中運行,也就是說,後載入的腳本若宣告了同名變量或函數,會直接覆蓋掉你的。命名時用全大寫加底線分隔,並盡量把實作包進閉包或命名空間。
// 糟糕的做法
var current = null;
function init() { /* ... */ }
function change() { /* ... */ }
function verify() { /* ... */ }
// 不需要對外暴露時,用無名函數全部包住
(function () {
var current = null;
function init() { /* ... */ }
function change() { /* ... */ }
function verify() { /* ... */ }
})();
// 需要對外暴露時,用命名空間整理
myNameSpace = function () {
var current = null;
function init() { /* ... */ }
function change() { /* ... */ }
function verify() { /* ... */ }
return {
init: init,
set: change // 甚至可以取別名
};
}();
JavaScript 允許你在任何時候修改任何物件,這把雙刃劍意味著你可能以出乎意料的方式覆寫了別人的預設行為。不是你維護的物件,就不要動它:不為實例或原型新增屬性與方法、不重定義既有方法、不重複實作隊友已經寫好的功能。真的需要擴充時,請新增自己的型別並繼承,或建立一個包裝物件來與它互動。
雖然 "" + 1 看起來不太正式,但實測效能最佳:
("" +) > String() > .toString() > new String()
很多人習慣用 parseInt(),但那是用來把字串轉成數字的,不是拿來做浮點與整數之間的轉換。應該改用 Math.floor() 或 Math.round()。
var myVar = "3.14159",
str = "" + myVar, // 轉字串
i_int = ~~myVar, // 轉整數
f_float = 1 * myVar, // 轉浮點
b_bool = !!myVar, // 轉布林(非空字串與非 0 數字為 true)
array = [myVar]; // 轉陣列
若自訂了 toString() 作為轉換依據,建議直接顯式呼叫,因為引擎在嘗試各種可能之後才會回頭呼叫它,直接呼叫能省下這段嘗試成本。
function eventHandler(e) {
if (!e) e = window.event;
}
// 改寫後
function eventHandler(e) {
e = e || window.event;
}
if (myobj) { doSomething(myobj); }
// 改寫後
myobj && doSomething(myobj);
if (oTest != '#ff0000') { /* ... */ }
if (oTest != null) { /* ... */ }
if (oTest != false) { /* ... */ }
// 效果相同但更簡潔
if (!oTest) { /* ... */ }
JavaScript 是弱型別語言,不會自動幫你做型別檢查。看到與 null 比較的程式碼時,可以依情況改用:參考型別用 instanceof 檢查建構函數;基本型別用 typeof 檢查型別;要確認某方法存在時,用 typeof 檢查該名稱的方法是否為函數。
避免在 if、while 的條件中寫成賦值(例如 if (a = b));比較是否相等時,=== 與 !== 會比 == 與 != 更合適,因為後者會進行型別強制轉換。
var valueA = "1";
var valueB = 1;
if (valueA == valueB) { alert("Equal"); } // Equal
if (valueA === valueB) { alert("Equal"); } // Not equal
JavaScript 的「+」既是加法也是字串串接,還能當一元運算子把字串轉數字,一不小心就會與遞增符號混淆。
var valueA = 20; var valueB = "10"; alert(valueA + valueB); // 2010 alert(valueA + (+valueB)); // 30 alert(valueA + +valueB); // 30 alert(valueA ++ valueB); // 編譯錯誤
每次迭代都會重新計算終止條件,因此把長度等屬性提前存成區域變量。
var list = document.getElementsByTagName('p');
for (var i = 0; i < list.length; i++) { /* ... */ }
// 改寫後
var list = document.getElementsByTagName('p');
for (var i = 0, l = list.length; i < l; i++) { /* ... */ }
多數迴圈從 0 遞增到某個值,但很多情況下從最大值開始遞減反而更有效率。另外,for(;;)、while()、for(in) 三者中 for-in 效率最差(需要查詢雜湊鍵),能避開就避開;while 通常略優於 for(;;)。而 do-while 這類後測試迴圈可以省下第一次的條件計算。
var arr = [1, 2, 3, 4, 5, 6, 7];
var sum = 0;
for (var i = 0, l = arr.length; i < l; i++) { sum += arr[i]; }
// 可以考慮改寫成
var arr = [1, 2, 3, 4, 5, 6, 7];
var sum = 0, l = arr.length;
while (l--) { sum += arr[l]; }
迴圈體是執行次數最多的地方,值得優先優化。當循環次數已知且固定時,消除迴圈、改以多次函數呼叫有時反而更快。
var name = values[i]; i++; // 可合併為 var name = values[i++];
s += a; s += b; s += c; // 改寫後 s += a + b + c;
若在同一個字串上反覆累加,建議先用陣列收集、最後用 join 串接:
var buf = [];
for (var i = 0; i < 100; i++) {
buf.push(i.toString());
}
var all = buf.join("");
對字串呼叫方法(例如 'xxx'.length)時,瀏覽器會先把它包裝成 String 物件。若確定會用到 String 的實例方法,可以直接宣告為:
var myString = new String('Hello World');
每次操作 DOM 都可能觸發重排,因此先用文件碎片在記憶體中組好結構,再一次掛進文件。
for (var i = 0; i < 1000; i++) {
var el = document.createElement('p');
el.innerHTML = i;
document.body.appendChild(el);
}
// 改寫後
var frag = document.createDocumentFragment();
for (var i = 0; i < 1000; i++) {
var el = document.createElement('p');
el.innerHTML = i;
frag.appendChild(el);
}
document.body.appendChild(frag);
面對大範圍的 DOM 變更時,一次設定 innerHTML 通常比逐一建立節點快得多。
var html = [];
for (var i = 0; i < 1000; i++) {
html.push('<p>' + i + '</p>');
}
document.body.innerHTML = html.join('');
用字串拼 HTML 有兩個問題:無法保證結構正確,而且字串操作本身不快。改用 createElement 是基本做法;若文件裡已有现成的樣板節點,用 cloneNode() 更好,因為可以省下反覆設定屬性的次數。
var frag = document.createDocumentFragment();
var pEl = document.getElementsByTagName('p')[0];
for (var i = 0; i < 1000; i++) {
var el = pEl.cloneNode(false);
el.innerHTML = i;
frag.appendChild(el);
}
document.body.appendChild(frag);
var nodes = element.childNodes;
for (var i = 0, l = nodes.length; i < l; i++) {
var node = nodes[i];
// ...
}
// 改寫後
var node = element.firstChild;
while (node) {
// ...
node = node.nextSibling;
}
NodeList 是即時的集合,最小化存取次數能明顯改善效能。以下操作都會產生 NodeList:
// 避免重複取值 var h1 = element1.clientHeight + num1; var h2 = element1.clientHeight + num2; // 改寫後 var eleHeight = element1.clientHeight; var h1 = eleHeight + num1; var h2 = eleHeight + num2;
任何可冒泡的事件,都能在目標的祖先節點上處理。把事件監聽掛到父層,就能一次負責多個子元素;對動態新增的內容尤其有效,不必為每個新節點重新綁定。此外,主流函式庫採用 observe 方式綁定事件,能在實作層面隔離 DOM 物件與處理函數之間的循環參照,值得優先採用。
移除節點前,務必先解除註冊在它身上的事件(無論用 observe 還是 attachEvent 綁定),否則會產生無法回收的記憶體。而在 removeChild 與 innerHTML = '' 之間,通常優先選擇後者。
把可能性高的條件排前面,可以減少解譯器的判斷次數。分支超過兩個時,switch 通常優於 if,在 IE 上差距尤其明顯。另外,單純的雙向判斷可以用三元運算子壓縮:
if (a > b) { num = a; } else { num = b; }
// 改寫後
num = a > b ? a : b;
以下幾類值都應該抽成常數:在多處重複出現的值、要顯示給使用者看的字串(方便日後國際化)、URL(資源位置變動頻繁,集中管理才不會漏改),以及任何你預期未來可能變動的設定值。
盡量不要產生需要執行時再交給 JavaScript 解譯的字串。
少用 eval:等於在執行期再啟動一次解譯引擎,成本高昂,還伴隨安全風險。
不要用 Function 建構器,也不要把字串傳給 setTimeout/setInterval:
var num = 0;
setTimeout('num++', 10);
// 改寫後
var num = 0;
function addNum() { num++; }
setTimeout(addNum, 10);
var aTest = new Array(); // 改為 []
var aTest = new Object; // 改為 {}
var reg = new RegExp(); // 改為 /../
// 具初始特性的物件也能用字面量
var oFruit = new O;
oFruit.color = "red";
oFruit.name = "apple";
// 改寫後
var oFruit = { color: "red", name: "apple" };
JavaScript 中所有變量都能用單一 var 語句宣告,合併後能減少整體執行時間,可讀性也不差。
當循環參照中牽涉到 DOM 物件或 ActiveX 物件時就會發生洩漏,後果是即使重新整理頁面,這部分記憶體在瀏覽器關閉前都不會釋放。
最單純的循環參照長這樣:
var el = document.getElementById('MyElement');
var func = function () { /* ... */ }
el.func = func;
func.element = el;
實務上更常見的情況是替 DOM 元素掛上閉包:
function init() {
var el = document.getElementById('MyElement');
el.onclick = function () { /* ... */ }
}
init();
此時 context 參照了 el,el 參照了 function,function 又參照回 context,形成閉環。
解法一:把 DOM 變量置空
function init() {
var el = document.getElementById('MyElement');
el.onclick = function () { /* ... */ }
el = null; // 打斷循環參照
}
init();
若需要把 el 回傳出去,可以用 try/finally 確保置空一定執行:
function init() {
var el = document.getElementById('MyElement');
el.onclick = function () { /* ... */ }
try {
return el;
} finally {
el = null;
}
}
init();
解法二:建立新的 context
function elClickHandler() {
/* ... */
}
function init() {
var el = document.getElementById('MyElement');
el.onclick = elClickHandler;
}
init();
把函數抽到別的 context,它的作用域裡就不再參照 el,循環自然斷開。
在 IE 下,若腳本建立的 DOM 沒有 append 到頁面上,重新整理後這部分記憶體不會被回收。
function create() {
var gc = document.getElementById('GC');
for (var i = 0; i < 5000; i++) {
var el = document.createElement('div');
el.innerHTML = "test";
// 試著註解掉下一行,觀察工作管理員裡的記憶體變化
gc.appendChild(el);
}
}
把元素的 innerHTML 設為空字串,可以釋放其子元素佔用的記憶體。在單頁應用中使用者停留時間長,這個技巧很有幫助。
JavaScript 物件的部分:物件設為 obj = null;屬性用 delete obj.myproperty;陣列中不再需要的項目用 splice 移除。目的都是解除參照,讓 GC 有機會回收。
避免把 JavaScript 直接寫在 HTML 裡、避免使用含內嵌程式碼的 script 元素、避免用 HTML 屬性指派事件處理函數;反過來,也不要在 JavaScript 裡嵌 HTML 字串再塞回頁面。層次分離之後,出錯時才能快速定位來源。
顯示問題的唯一來源應該是 CSS,行為問題的唯一來源應該是 JavaScript。所以 element.style.color = "red" 盡量改成 element.className = "edit",也不要在 CSS 裡用運算式嵌 JavaScript。
事件處理函數只負責從事件物件取出資訊,再交給處理業務邏輯的方法。這樣一來,更換觸發事件的成本降低,也能在不掛事件的情況下測試程式碼,撰寫單元測試容易得多。
function F1() {
var valueA = 1;
var valueB = 2;
return valueA + valueB;
}
function F2() {
var valueA = 1;
var valueB = 2;
return
valueA + valueB;
}
alert(F1()); // 3
alert(F2()); // undefined
上線前用 JSLint 這類驗證工具跑一遍,確認沒有語法錯誤或潛在問題;再用壓縮工具縮小檔案體積。
JavaScript 應盡量放在獨立 .js 檔中,透過 <script src="filename.js"> 引入,並把標籤放在文件後段(最好就在 </body> 之前),這樣才不會拖慢其他資源的載入。檔案編碼統一採用 UTF-8。
最後要說的是:效能優化不是一次性的工作,而是從專案開始到結束都該持續進行的重構過程。累積的每一次小改動,最終都會反映在實際的執行效率上。