每次都需要腳本引擎把原始碼轉成可執行碼,而且用 eval 處理字串必須在執行期才解析。
// 慢
function addMethod(object, property, code) {
object[property] = new Function(code);
}
addMethod(myObj, 'methodName', 'this.localVar=foo');
// 快
function addMethod(object, property, func) {
object[property] = func;
}
addMethod(myObj, 'methodName', function () { this.localVar = foo; });
編譯時無法確定作用域上下文,因此要多做一次查找。
// 慢
with (test.object) {
foo = 'Value of foo property of object';
bar = 'Value of bar property of object';
}
// 快
var myObj = test.object;
myObj.foo = 'Value of foo property of object';
myObj.bar = 'Value of bar property of object';
順帶一提,with 在嚴格模式下是被完全禁止的語法。
try-catch-finally 每次執行都會在當前作用域建立新變數。異常處理應該放在腳本的高層,也就是比較少發生異常的位置,例如迴圈外面。
// 慢
for (i = 0; i < object.length; i++) {
try { /* 可能拋出例外 */ } catch (e) { /* 處理 */ }
}
// 快
try {
for (i = 0; i < object.length; i++) { /* 主要邏輯 */ }
} catch (e) { /* 處理 */ }
// 慢
var i, str = '';
function globalScope() {
for (i = 0; i < 100; i++) { str += i; } // 全域參照較慢
}
globalScope();
// 快
function localScope() {
var i, str = '';
for (i = 0; i < 100; i++) { str += i; }
}
localScope();
for-in 需要建立一張所有可枚舉屬性的清單,並檢查是否重複。
// 慢
var sum = 0;
for (var i in arr) { sum += arr[i]; }
// 快
var sum = 0;
for (var i = 0, len = arr.length; i < len; i++) { sum += arr[i]; }
// 較慢 a += 'x' + 'y'; // 較快 a += 'x'; a += 'y';
// 慢 var min = Math.min(a, b); arr.push(val); // 快 var min = a < b ? a : b; arr[arr.length] = val;
傳字串會被 eval 解析而變慢。
// 慢
setInterval('doSomethingPeriodically()', 1000);
setTimeout('doSomethingAfterFiveSeconds()', 5000);
// 快
setInterval(doSomethingPeriodically, 1000);
setTimeout(doSomethingAfterFiveSeconds, 5000);
// 較差
var car = new Object();
car.color = "red";
car.type = "sedan";
// 較好
var car = { color: "red", type: "sedan" };
同理,new Array() 與 new Function() 一般也應改用 [...] 與 function(){}。
// 較慢 var url = location.href; // 較快 var url = window.location.href;
把參照路徑寫明確,可以少走一層查找。
特別是在函式、迴圈與陣列內部。不必要的註解會拖慢腳本執行並增加檔案大小。
// 不建議
function someFunction() {
var person_full_name = "somename"; /* stores the full name */
}
// 較好
function someFunction() {
var name = "somename";
}
作用域鏈越深,識別符解析越慢;局部變數最快。把頻繁使用的外部變數存到局部,讀寫都會明顯加快。
// 慢
function doSomething(text) {
var divs = document.getElementsByTagName('div'),
text = ['foo', 'bar'];
for (var i = 0, l = divs.length; i < l; i++) {
divs[i].innerHTML = text[i];
}
}
// 快
function doSomethingFaster(text) {
var doc = document,
divs = doc.getElementsByTagName('div'),
text = ['foo', 'bar'];
for (var i = 0, l = divs.length; i < l; i++) {
divs[i].innerHTML = text[i];
}
}
大迴圈中反覆存取同一個 DOM 方法時,把它存成區域變數會更快:
function doSomethingElseFaster() {
var get = document.getElementsByTagName;
for (var i = 0; i < 100000; i++) { get('head'); }
}
例一:迴圈前先算好。
// 差
var d = 35;
for (var i = 0; i < 1000; i++) { y += Math.sin(d) * 10; }
// 好
var d = 55;
var math_sind = Math.sin(d) * 10;
for (var i = 0; i < 1000; i++) { y += math_sind; }
例二:快取陣列長度。
// 差:每次都重算 length
for (var i = 0; i < arr.length; i++) { /* ... */ }
// 好
for (var i = 0, len = arr.length; i < len; i++) { /* ... */ }
核心精神一句話:做過一次的事,不要不必要地重複做。若同一個表達式的值在一個作用域中被多次使用,存成變數即可避免重複計算。
關於第 2 點:JavaScript 主要不是編譯型而是直譯型,嚴謹的說法應該是「引擎會做即時編譯(JIT)」。雖不影響結論,但表述上值得留意。
關於第 6 點:原文排版有些錯位,對照組應為 a += 'x' + 'y'; 對比 a += 'x'; a += 'y';。這個差異在現代引擎上其實非常微小,因為字串拼接早已最佳化,甚至 += 在迴圈中也常被 roping 優化。真正大量拼接時,正確做法是用陣列 push 後 join,或直接用 +=(現代引擎的 += 已優於舊版的 Array join 技巧)。
關於第 9 點:new Object 本身並不是 DOM 參照,這點原文表述有誤。真正的意思是:不要輕易使用 new Object()、new Array()、new Function(),一般情況改用 {...}、[...]、f = function(){...} 即可。這與第 10 點講的其實是同一件事。
補充:少用位運算。JavaScript 的所有數值運算最終(到引擎這一層)都是轉成浮點來算的,因此位運算在 JS 中可能反而更慢。不過這條在現代引擎上已有改善,| 0 取整、>>> 等技巧仍常被用來加速整數運算,實務上建議實測而非憑印象。