DIV CSS 佈局教程網

JavaScript效能優化實戰筆記:從作用域、DOM到記憶體的完整梳理
編輯:關於JavaScript     

隨著網站越做越「厚」,客戶端要扛的工作也越來越多。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 會建立自己的作用域,使作用域鏈變長,其中的程式碼勢必比外面慢。能不用就不用。

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) { /* ... */ }

避免與 null 做比較

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++];

四、字串與 DOM 操作

字串串接

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');

使用 DocumentFragment 減少 append 次數

每次操作 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);

用一次 innerHTML 取代大量 createElement

面對大範圍的 DOM 變更時,一次設定 innerHTML 通常比逐一建立節點快得多。

var html = [];
for (var i = 0; i < 1000; i++) {
  html.push('<p>' + i + '</p>');
}
document.body.innerHTML = html.join('');

用樣板節點 clone 取代 createElement

用字串拼 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);

用 firstChild 與 nextSibling 遍歷

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 是即時的集合,最小化存取次數能明顯改善效能。以下操作都會產生 NodeList:

  • 呼叫 getElementsByTagName()
  • 取得元素的 childNodes 屬性
  • 取得元素的 attributes 屬性
  • 存取 document.forms、document.images 等特殊集合

重複使用的結果先存成區域變量

// 避免重複取值
var h1 = element1.clientHeight + num1;
var h2 = element1.clientHeight + num2;

// 改寫後
var eleHeight = element1.clientHeight;
var h1 = eleHeight + num1;
var h2 = eleHeight + num2;

使用事件代理

任何可冒泡的事件,都能在目標的祖先節點上處理。把事件監聽掛到父層,就能一次負責多個子元素;對動態新增的內容尤其有效,不必為每個新節點重新綁定。此外,主流函式庫採用 observe 方式綁定事件,能在實作層面隔離 DOM 物件與處理函數之間的循環參照,值得優先採用。

刪除 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,循環自然斷開。

用 JS 建立的 DOM 一定要掛回頁面

在 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 有機會回收。

七、松散耦合與可維護性

HTML 與 JavaScript 解耦

避免把 JavaScript 直接寫在 HTML 裡、避免使用含內嵌程式碼的 script 元素、避免用 HTML 屬性指派事件處理函數;反過來,也不要在 JavaScript 裡嵌 HTML 字串再塞回頁面。層次分離之後,出錯時才能快速定位來源。

CSS 與 JavaScript 解耦

顯示問題的唯一來源應該是 CSS,行為問題的唯一來源應該是 JavaScript。所以 element.style.color = "red" 盡量改成 element.className = "edit",也不要在 CSS 裡用運算式嵌 JavaScript。

應用邏輯與事件處理分離

事件處理函數只負責從事件物件取出資訊,再交給處理業務邏輯的方法。這樣一來,更換觸發事件的成本降低,也能在不掛事件的情況下測試程式碼,撰寫單元測試容易得多。

八、撰寫時的注意事項

  • 每條語句結尾加分號;if 條件即使只有一行也該用大括號包起來,避免日後新增程式碼時邏輯出錯。
  • return 的寫法:回傳值不加括號;回傳運算式時要與 return 位於同一行,否則壓縮工具自動補上的分號會讓結果與預期不符。
  • 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
  • 不要使用生僻語法:機器讀得懂不代表好維護。
  • 函數回傳型別要一致:雖然弱型別語言允許前面回傳整數、後面回傳布林,但統一型別能大幅降低維護成本。
  • 永遠檢查輸入資料:一方面是安全,一方面是可用性。使用者隨時可能輸入錯誤資料,用 typeof 檢查參數是否合法是基本防線。
  • 引號的使用:HTML 中用雙引號、JavaScript 中用單引號,能避免混淆;但定義 JSON 物件時仍應使用雙引號以確保相容。

九、部署階段

上線前用 JSLint 這類驗證工具跑一遍,確認沒有語法錯誤或潛在問題;再用壓縮工具縮小檔案體積。

JavaScript 應盡量放在獨立 .js 檔中,透過 <script src="filename.js"> 引入,並把標籤放在文件後段(最好就在 </body> 之前),這樣才不會拖慢其他資源的載入。檔案編碼統一採用 UTF-8。

最後要說的是:效能優化不是一次性的工作,而是從專案開始到結束都該持續進行的重構過程。累積的每一次小改動,最終都會反映在實際的執行效率上。

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