DIV CSS 佈局教程網

編寫高效能 JavaScript:V8 優化、內存管理與效能實測全解析
編輯:關於JavaScript     

譯者按:本文為英文原文的翻譯整理。原文篇幅較長、資訊量大,可能需要分段消化,歡迎針對細節留言探討。內容主要聚焦 V8 的效能優化,部分結論並不適用於所有 JS 引擎。

許多 JavaScript 引擎——如 Google 的 V8(Chrome 與 Node 採用)——是專為執行大型應用而設計的。如果你關心內存使用與頁面效能,就該了解使用者瀏覽器中的引擎如何運作。無論是 V8、SpiderMonkey(Firefox)、Carakan(Opera)、Chakra(IE)或其他引擎,理解它們能幫助你更好地優化應用程式。

這並不是說應該為特定瀏覽器做優化——千萬別這麼做。而是應該捫心自問幾個問題:

  • 我的程式碼能否寫得更有效率?
  • 主流 JS 引擎做了哪些優化?
  • 哪些是引擎無法優化的?垃圾回收器能否回收我期望的東西?

載入快速的網站就像一輛快速跑車,需要特別定制的零件。圖片來源:dHybridcars。

撰寫高效能程式碼有一些常見陷阱,本文將說明幾種經過驗證的更好做法。

JavaScript 在 V8 裡如何運作

對 JS 引擎了解不深,也能開發大型 Web 應用——就像多數人會開車,卻沒看過引擎蓋下的東西。以下談 Chrome 的 V8,它由幾個核心部分組成:

  • 一個基本編譯器:在程式碼執行前解析 JavaScript 並生成機器碼,而非執行位元組碼或逐行解釋。這些程式碼最初並未高度優化。
  • 物件模型:JavaScript 中物件表現為關聯陣列,但 V8 把它們視為隱藏類別(hidden classes)——一個為了優化屬性查詢而存在的內部型別系統。
  • 執行期分析器:監控運行中的系統,標記出「hot」函數,即耗時較長的程式碼。
  • 優化編譯器:重新編譯並優化被標記為 hot 的程式碼,進行「內聯」等優化——例如用被呼叫者的主體替換函數呼叫的位置。
  • 去優化(deoptimization):V8 支援撤銷優化。若優化編譯器發現自己對程式碼的假設過於樂觀,會捨棄已優化的版本,退回基本編譯器的結果。
  • 垃圾回收器:了解它的運作方式,與優化 JavaScript 同等重要。

垃圾回收

垃圾回收是一種內存管理形式:由收集器嘗試回收不再被使用的物件所占用的內存。在這類語言中,仍被引用的物件不會被清除。

手動消除物件引用在大多數情況下沒有必要。只要把變數放在需要它們的地方(理想情況是盡可能是局部作用域,即放在使用它的函數內而非外層),一切都能正常運作。

垃圾回收器嘗試回收內存。圖片來源:Valtteri Mäki。

在 JavaScript 中,不可能強制進行垃圾回收。你不該這麼做,因為回收時機由執行期掌控,它比你更清楚何時清理最合適。

「消除引用」的誤解

網上關於 JS 內存回收的討論常提到 delete 關鍵字。它確實能刪除物件(map)中的屬性(key),但有部分開發者誤以為它能用來強制「消除引用」。

建議盡可能避免使用 delete。以下範例中 delete o.x 的弊大於利,因為它改變了 o 的隱藏類別,使其成為一個「慢物件」:

 var o = { x: 1 };
 delete o.x;   // true
 o.x;          // undefined

你會在流行的 JS 庫中找到引用刪除的寫法——這是出於語言的目的性考量。要注意的是:避免在執行期修改 hot 物件的結構。V8 能偵測出這類物件並嘗試優化;若物件在整個生命週期中結構沒有大的改變,引擎就更容易優化它。而 delete 恰好會觸發這種結構改變,因此不利於優化。

關於 null 也有誤解。把物件引用設為 null,並未讓物件變「空」,只是把引用設為空。使用 o.x = null 比 delete 好,但也未必必要:

 var o = { x: 1 };
 o = null;
 o;      // null
 o.x;    // TypeError

若此引用是該物件的最後一個引用,物件就會被回收;若不是,物件仍可被存取,不會被回收。

另外要注意:全域變數在整個頁面生命週期內不會被垃圾回收器清理。無論頁面開多久,全域物件作用域中的變數會一直存在。

 var myGlobalNamespace = {};

全域物件只在重新整理頁面、導航到其他頁面、關閉分頁或退出瀏覽器時才會被清理。函數作用域的變數則在超出作用域時被回收——離開函數後已無任何引用,自然被清理。

經驗法則

要讓回收器盡早收回盡可能多的物件,不要持有不再使用的物件。幾件要記住的事:

  • 如前所述,在合適的範圍內使用變數是更好的選擇。一個變數只在一個函數作用域中使用,就不要在全域宣告它——這意味著更乾淨、更省心的程式碼。
  • 確保解除那些不再需要的事件監聽器,尤其是即將被銷毀的 DOM 物件上所綁定的事件。
  • 若把資料快取在本地,確保有清理或老化機制,避免大量不再重用的資料持續累積。

函數與閉包

垃圾收集的原理是回收不再被存取的內存區塊。以下用範例說明。

 function foo() {
  var bar = new LargeObject();
  bar.someCall();
}

當 foo 返回時,bar 指向的物件會被自動回收,因為已無任何引用存在。

對比一下:

 function foo() {
  var bar = new LargeObject();
  bar.someCall();
  return bar;
}
// 其他地方
var b = foo();

現在有一個引用指向 bar 物件,它的生命週期就從 foo 的呼叫一直持續到呼叫端把 b 指向別的變數(或 b 超出作用域)。

閉包是特別需要注意的情況。當一個函數回傳內部函數,該內部函數會取得範圍外的存取權,即使在外部函數執行完之後亦然。這可以在特定上下文中保存變數:

 function sum (x) {
  function sumIt(y) {
    return x + y;
  }
  return sumIt;
}
// 使用
var sumA = sum(4);
var sumB = sumA(3);
console.log(sumB);   // 7

在 sum 呼叫上下文中產生的函數物件(sumIt)無法被回收,因為它被全域變數 sumA 引用,且可透過 sumA(n) 呼叫。

來看另一個例子——我們還能存取 largeStr 嗎?

 var a = function () {
  var largeStr = new Array(1000000).join('x');
  return function () {
    return largeStr;
  };
}();

可以,透過 a() 能取到 largeStr,所以它沒有被回收。那這個呢?

 var a = function () {
  var smallStr = 'x';
  var largeStr = new Array(1000000).join('x');
  return function (n) {
    return smallStr;
  };
}();

我們無法再存取 largeStr,它已是回收候選人——因為返回的閉包只捕獲了 smallStr,largeStr 已不存在外部引用。

這個例子說明了一個實用技巧:閉包只會保留它實際用到的變數。引擎能靜態分析出哪些變數被引用,未用到的不會被 retention 拖累。

定時器

最糟的內存洩漏來源之一是在迴圈中,或在 setTimeout() / setInterval() 裡建立閉包——而這相當常見:

 var myObj = {
  callMeMaybe: function () {
    var myRef = this;
    var val = setTimeout(function () {
      console.log('Time is running out!');
      myRef.callMeMaybe();
    }, 1000);
  }
};

執行 myObj.callMeMaybe() 啟動計時器後,主控台每秒印出一次訊息。若接著執行 myObj = null,計時器依然在跑。為了能持續執行,閉包把 myObj 傳給了 setTimeout,因此 myObj 無法被回收;反過來它也持續引用著 myObj,因為它捕獲了 myRef。這與為了保持引用而把閉包傳給其他函數是同一回事。

同樣要記住:傳給 setTimeout / setInterval 的函數中的引用,需要等到執行完畢才可以被回收。

當心效能陷阱

在你真正需要之前,永遠不要優化程式碼。現在經常能看到某些基準測試宣稱「N 比 M 在 V8 中更優化」,但在實際模組或應用中測一次會發現,這些優化的真實效果遠比預期小。

做得過多還不如什麼都不做。圖片來源:Tim Sheerman-Chase。

舉個例子,假設要打造一個模組,它需要:

  • 一個本地資料源,包含數字 ID
  • 繪製包含這些資料的表格
  • 綁定事件,讓使用者點擊任一儲存格時切換該格的 CSS class

這問題有幾個面向:如何存資料、如何高效繪製並 append 到 DOM、如何更好地處理表格事件?

最直覺(也最天真)的做法是:用物件存資料再放進陣列,用 jQuery 遍歷資料繪製表格並 append 到 DOM,最後用事件綁定點擊行為。

注意:這不是推薦做法

 var moduleA = function () {
  return {
    data: dataArrayObject,
    init: function () {
      this.addTable();
      this.addEvents();
    },
    addTable: function () {
      for (var i = 0; i < rows; i++) {
        $tr = $('<tr></tr>');
        for (var j = 0; j < this.data.length; j++) {
          $tr.append('<td>' + this.data[j]['id'] + '</td>');
        }
        $tr.appendTo($tbody);
      }
    },
    addEvents: function () {
      $('table td').on('click', function () {
        $(this).toggleClass('active');
      });
    }
  };
}();

這段程式碼簡單有效地完成了任務。但在這個場景中,我們遍歷的資料其實只是應簡單存在陣列中的數字 ID。有趣的是,直接使用 DocumentFragment 與原生 DOM 方法比用 jQuery 生成表格更有效率;而事件代理也比逐一綁定每個 td 效能更高。

要注意,雖然 jQuery 內部使用 DocumentFragment,但在這個範例中,程式碼在迴圈內呼叫 append,每次呼叫都涉及額外開銷,因此 Fragment 的優化作用被抵銷了。這提醒我們:務必對自己的程式碼做基準測試,而非照搬他人結論。

改用 DocumentFragment 與事件代理後:

 var moduleD = function () {
  return {
    data: dataArray,
    init: function () {
      this.addTable();
      this.addEvents();
    },
    addTable: function () {
      var td, tr;
      var frag = document.createDocumentFragment();
      var frag2 = document.createDocumentFragment();
      for (var i = 0; i < rows; i++) {
        tr = document.createElement('tr');
        for (var j = 0; j < this.data.length; j++) {
          td = document.createElement('td');
          td.appendChild(document.createTextNode(this.data[j]));
          frag2.appendChild(td);
        }
        tr.appendChild(frag2);
        frag.appendChild(tr);
      }
      tbody.appendChild(frag);
    },
    addEvents: function () {
      $('table').on('click', 'td', function () {
        $(this).toggleClass('active');
      });
    }
  };
}();

接下來看其他提升效能的方式。你可能讀過「原型模式比模組模式更優」,或聽說「JS 模板框架效能更好」。有時的確如此,但使用它們其實是為了程式碼可讀性。還有預編譯!來看實踐中的表現:

 moduleG = function () {};
 moduleG.prototype.data = dataArray;
 moduleG.prototype.init = function () {
  this.addTable();
  this.addEvents();
};
 moduleG.prototype.addTable = function () {
  var template = _.template($('#template').text());
  var html = template({'data' : this.data});
  $tbody.append(html);
};
 moduleG.prototype.addEvents = function () {
  $('table').on('click', 'td', function () {
    $(this).toggleClass('active');
  });
};
var modG = new moduleG();

結果顯示,在這個案例中原型與模板帶來的效能提升可以忽略不計。也就是說,效能並不是開發者採用它們的原因——可讀性、繼承模型與可維護性才是。

更複雜的問題包括高效地在 canvas 上繪製圖片,以及操作帶或不帶型別陣列的像素資料。

在把任何方法套用到自己的應用前,一定要多了解這些方案的基準測試。也許有人還記得 JS 模板的 shoot-off 及其後的擴充版。關鍵是:基準測試不該存在於你看不見的虛擬應用中,而應在真實程式碼裡驗證優化效果。

V8 優化技巧

逐一介紹每個 V8 優化點超出本文範圍,但有幾個值得銘記的技巧,記住它們能減少效能低下的程式碼。

  • 特定寫法會讓 V8 無法優化,例如 try-catch。欲了解哪些函數能或不能優化,可在 V8 的 d8 工具中使用 --trace-opt file.js。
  • 若在意速度,盡量讓函數職責單一,並確保變數(包括屬性、陣列、函數參數)只使用相同隱藏類別的物件。例如別這樣寫:
     function add(x, y) {
      return x + y;
    }
    add(1, 2);
    add('a', 'b');                      // 型別不一致,去優化
    add(my_custom_object, undefined);   // 更糟
  • 不要載入未初始化或已刪除的元素。這麼做不會報錯,但會拖慢速度。
  • 不要讓函數體過大,否則優化更困難。

更多內容可參考 Daniel Clifford 在 Google I/O 的分享〈Breaking the JavaScript Speed Limit with V8〉,以及〈Optimizing For V8 — A Series〉。

物件還是陣列?

  • 若要存一串數字或同類型的物件,用陣列。
  • 若語意上需要一堆不同型別的屬性,用物件。這在內存方面非常有效率,速度也相當快。
  • 以整數索引的元素,無論存在陣列或物件中,都比遍歷物件的屬性快得多。
  • 物件屬性較複雜:它們可以被 setter 建立,具有不同的可列舉性與可寫性。陣列則沒有這種定制性,只有「有」與「無」兩種狀態。在引擎層面,這允許更多儲存結構上的優化——特別是當陣列中存在數字時。例如需要容器時,用陣列即可,不必定義一個具有 x、y、z 屬性的類別。

JavaScript 中物件與陣列只有一個主要區別:陣列那個神奇的 length 屬性。如果你自己維護這個屬性,那麼在 V8 中物件與陣列的速度是一樣快的。

使用物件時的技巧

  • 用一個構造函數來建立物件。這確保所有物件具有相同的隱藏類別,有助於避免更改這些類別。額外的好處是它略快於 Object.create()。
  • 對使用不同型別物件與其複雜度是沒有限制的(在合理範圍內:長原型鏈往往有害;只有極少屬性的小物件會比大物件快一點)。對 hot 物件,盡量保持短原型鏈與少屬性。

物件克隆

物件克隆是應用開發中的常見問題。雖然各種基準測試顯示 V8 對此處理得不錯,但仍要小心——複製大物件通常較慢,別這麼做。

JS 中的 for...in 迴圈尤其糟糕,因為它有著繁瑣的規範,且在任何引擎中都可能永遠比不過其他方案。

若一定要在關鍵路徑上複製物件,使用陣列或自訂的「拷貝構造函數」明確複製每個屬性,這可能是最快的方式:

 function clone(original) {
  this.foo = original.foo;
  this.bar = original.bar;
}
var copy = new clone(original);

模組模式中緩存函數

使用模組模式時緩存函數可能帶來效能提升。以下範例中,若不緩存,每次呼叫都會重新建立函數副本:

使用模組模式或原型模式時的效能提升

 // 原型模式
 Klass1 = function () {}
 Klass1.prototype.foo = function () { log('foo'); }
 Klass1.prototype.bar = function () { log('bar'); }

 // 模組模式
 Klass2 = function () {
  var foo = function () { log('foo'); },
      bar = function () { log('bar'); };
  return { foo: foo, bar: bar }
 }

 // 模組模式 + 緩存函數
 var FooFunction = function () { log('foo'); };
 var BarFunction = function () { log('bar'); };
 Klass3 = function () {
  return { foo: FooFunction, bar: BarFunction }
 }

 // 迭代測試
 // 原型模式
 var i = 1000, objs = [];
 while (i--) {
  var o = new Klass1()
  objs.push(new Klass1());
  o.bar; o.foo;
 }

 // 模組模式
 var i = 1000, objs = [];
 while (i--) {
  var o = Klass2()
  objs.push(Klass2());
  o.bar; o.foo;
 }

 // 模組模式 + 緩存函數
 var i = 1000, objs = [];
 while (i--) {
  var o = Klass3()
  objs.push(Klass3());
  o.bar; o.foo;
 }

注意這裡的第三種寫法:函數定義提到外部只建立一次,模組內部只是回傳參照。它不僅比不緩存的模組模式快,也比原型模式更優(經 jsPerf 確認)。

使用陣列時的技巧

一般原則:不要刪除陣列元素,這會使陣列過渡到較慢的內部表示。當索引變得稀疏,V8 會把元素轉為更慢的字典模式。

陣列字面值

陣列字面值非常有用,它能暗示 VM 陣列的大小與型別,通常用於體積不大的陣列:

 // V8 能看出你要一個含 4 個數字的陣列
 var a = [1, 2, 3, 4];

 // 不要這樣
 a = [];
 for(var i = 1; i <= 4; i++) {
  a.push(i);
 }

存單一型別 vs 多型別

把混合型別(數字、字串、undefined、true/false)的資料存在同一個陣列中絕不是好主意:

 var arr = [1, "1", undefined, true, "true"];

型別推論的效能測試顯示,整數陣列是最快的。

稀疏陣列 vs 滿陣列

使用稀疏陣列時要注意,存取元素遠慢於滿陣列。因為 V8 不會為只用部分空間的陣列配置整塊記憶體,而是改用字典管理——節省了空間,卻付出了存取時間的代價。

預分配空間 vs 動態分配

不要預配置大陣列(例如超過 64K 元素),而應動態分配。這項結論僅適用部分 JS 引擎。

空字面值與預分配陣列在不同瀏覽器的測試結果

Nitro(Safari)對預分配的陣列更有利;而在其他引擎(V8、SpiderMonkey)中,預先分配並不划算。

 // 空陣列
 var arr = [];
 for (var i = 0; i < 1000000; i++) {
  arr[i] = i;
 }

 // 預分配陣列
 var arr = new Array(1000000);
 for (var i = 0; i < 1000000; i++) {
  arr[i] = i;
 }

優化你的應用

在 Web 應用的世界裡,速度就是一切。沒人願意用一個要花幾秒計算某欄總數、或花幾分鐘彙總資訊的表格應用。這就是為什麼要在程式碼中壓榨每一點效能。

圖片來源:Per Olof Forsberg。

理解並改善應用效能很有價值,同時也很困難。建議依下列步驟處理效能瓶頸:

  • 測量:找出應用中慢的地方(約 45% 的時間)
  • 理解:釐清真正的問題是什麼(約 45%)
  • 修復(約 10%)

基準化(Benchmarking)

跑 JS 程式碼片段的效能測試有許多方式,一般假設是比較兩個時間戳。這個模式被 jsPerf 團隊指出,並用於 SunSpider 與 Kraken 測試套件:

 var totalTime,
     start = new Date,
     iterations = 1000;

 while (iterations--) {
  // 測試的程式碼片段
 }
 // totalTime → 執行 1000 次所花的毫秒數
 totalTime = new Date - start;

要測試的程式碼放在迴圈中執行固定次數(例如 6 次),之後用開始時間減去結束時間,得出迴圈中操作的耗時。

然而這種做法過於簡單,特別是當你想跨多個瀏覽器與環境測試時。垃圾回收器本身會影響結果。即使使用 window.performance 這類方案,也必須考慮這些缺陷。

不論你是只跑幾行程式碼,還是編寫完整的測試套件或基準庫,JavaScript 基準測試都比想像中複雜。如需更詳細的指南,強烈建議閱讀 Mathias Bynens 與 John-David Dalton 的〈Javascript Benchmarking〉。

分析(Profiling)

Chrome 開發者工具對 JavaScript 分析有完善支援,可用來偵測哪些函數佔用了大部分時間,進而針對性優化。這很重要,即使是很小的改動也可能對整體表現產生顯著影響。

Chrome 開發者工具的分析面板

分析過程先取得程式碼效能基線,再以時間線形式呈現,告訴我們程式碼需要多長時間執行。「Profiles」標籤提供了更清晰的視角:JavaScript CPU 分析檔顯示多少 CPU 時間用在我們的程式碼上,CSS 選擇器分析檔顯示多少時間花在處理選擇器上,堆億快照則顯示多少內存被物件佔用。

有了這些工具,我們可以分離、調整並重新分析,衡量優化是否真的有效。

「Profile」標籤展示了程式碼效能資訊。

一個好的分析入門可參考 Zack Grossbart 的〈JavaScript Profiling With The Chrome Developer Tools〉。

提示:理想情況下,若要確保分析未受已安裝應用或擴充影響,可用 --user-data-dir <empty_directory> 參數啟動 Chrome。在大多數情況下這種方法已足夠。

避免內存洩漏——三快照技術

在 Google 內部,Chrome 開發者工具被 Gmail 等團隊大量用於發現與排除內存洩漏。

Chrome 開發者工具中的內存統計

內存統計面板呈現我們關注的私有內存使用、JavaScript 堆的大小、DOM 節點數量、儲存清理、事件監聽計數器,以及垃圾收集器正要回收的東西。

推薦 Loreena Lee 的「三快照」技術。要點是:在程式中記錄某段行為,強制垃圾回收,檢查 DOM 節點數量是否恢復到預期基線,然後分析三個堆的快照來判斷是否有洩漏。三個快照分別對應行為發生前、行為後、以及強制回收後——差異之處就是洩漏的嫌疑。

單頁應用的內存管理

單頁應用(如 AngularJS、Backbone、Ember)的內存管理至關重要,因為它們幾乎永不刷新頁面,內存洩漏的影響會相當明顯。行動裝置上的 SPA 尤其棘手——設備內存有限,使用者又會長時間停留在同一個 Email 客戶端或社群程式中。能力愈大,責任愈重。

Backbone 中,確保使用 dispose() 處理舊視圖與引用(Backbone Edge 已提供)。這個函數會移除加到視圖「event」物件中的處理函數,以及透過第三個參數(回呼上下文)綁定的 model 或 collection 事件監聽器。dispose() 也會被視圖的 remove() 呼叫,處理元素被移除時的主要清理工作。Ember 等其他庫在偵測到元素被移除時也會清理監聽器以避免洩漏。

Derick Bailey 的一些建議:

與其死記事件與引用如何運作,不如遵循標準規則來管理 JavaScript 中的內存。如果你想把資料載入一個存滿使用者物件的 Backbone 集合,必須清空這個集合使它不再佔用內存——也就是清除這個集合的所有引用,以及集合內每個物件的引用。一旦所有引用都清楚了,資源就會被回收。這就是標準的 JavaScript 垃圾回收規則。

Derick 在文中涵蓋了許多使用 Backbone.js 時的常見內存缺陷與解法。Felix Geisendörfer 關於在 Node 中除錯內存洩漏的教學也值得一讀,特別是當它構成更廣泛 SPA 技術棧的一部分時。

減少回流(Reflows)

當瀏覽器重新渲染文件中的元素時,需要重新計算它們的位置與幾何形狀,我們稱之為回流。回流會阻塞使用者在瀏覽器中的操作,因此理解如何縮短回流時間很有幫助。

回流時間圖表

你應該批次觸發回流或重繪,但要節制使用。盡量不操作 DOM 也很重要。可以使用 DocumentFragment——一個輕量級的文件物件,你可以把它當作提取文件樹一部分的方法,或建立一個新的文件「片段」。與其不斷添加 DOM 節點,不如先放進 Fragment,最後只執行一次插入操作,避免過多回流。

例如,寫一個函數給某元素添加 20 個 div。若每次 append 一個,會觸發 20 次回流:

 function addDivs(element) {
  var div;
  for (var i = 0; i < 20; i ++) {
    div = document.createElement('div');
    div.innerHTML = 'Heya!';
    element.appendChild(div);
  }
}

改用 DocumentFragment 後,先把 20 個 div 都放進片段,最後一次插入,只會觸發一次回流:

 function addDivs(element) {
  var div;
  // 建立一個新的空 DocumentFragment
  var fragment = document.createDocumentFragment();
  for (var i = 0; i < 20; i ++) {
    div = document.createElement('a');
    div.innerHTML = 'Heya!';
    fragment.appendChild(div);
  }
  element.appendChild(fragment);
}

可參考〈Make the Web Faster〉、〈JavaScript Memory Optimization〉與〈Finding Memory Leaks〉。

補充:Fragment 有效是因為它不在渲染樹中,對它的操作不觸發重排。但要注意,一旦 Fragment 被插入 DOM,它就空了,其內容成為文件的正式子節點。另外,讀取 offsetHeight、getComputedStyle() 等屬性會強制同步重排——在迴圈中反覆讀寫 DOM 是回流問題的主要來源,實務上應把讀取集中在寫入之前。

JS 內存洩漏探測器

為了幫助發現 JavaScript 內存洩漏,Google 開發人員(Marja Hölttä 與 Jochen Eisinger)開發了一個工具,它與 Chrome 開發者工具結合使用,擷取堆的快照並偵測出是哪些物件導致了洩漏。

一個 JavaScript 內存洩漏檢測工具

該項目頁面有完整的使用說明,建議自行前往了解。

若想知道為何這樣的工具還沒整合進開發工具,原因有二:它最初是在 Closure 庫中為了捕捉特定內存場景而生,而它更適合作為一個獨立的外部工具存在。

V8 優化除錯與垃圾回收的旗標位

Chrome 支援直接傳一些旗標給 V8,以取得更詳細的引擎優化輸出。例如追蹤 V8 的優化:

 "/Applications/Google Chrome/Google Chrome" --js-flags="--trace-opt --trace-deopt"

Windows 使用者可執行 chrome.exe –js-flags="--trace-opt --trace-deopt"。

開發應用時可用的 V8 旗標:

  • trace-opt —— 記錄被優化的函數名稱,並顯示因優化器不知如何處理而跳過的程式碼。
  • trace-deopt —— 記錄執行期將要「去優化」的程式碼。
  • trace-gc —— 記錄每一次的垃圾回收。

V8 的處理腳本用 *(星號)標識優化過的函數,用 ~(波浪號)表示未優化的函數。

若想深入了解 V8 的旗標與內部運作,強烈建議閱讀 Vyacheslav Egorov 關於 V8 internals 的文章。

高精度時間與 Navigation Timing API

高精度時間(HRT)提供不受系統時間與使用者調整影響的亞毫秒級時間介面,可視為比 new Date 與 Date.now() 更精準的度量方式,對撰寫基準測試幫助很大。

高精度時間提供了當前亞毫秒級的時間精度

HRT 早期在 Chrome 中以 window.performance.webkitNow() 形式提供,後續版本移除了前綴,可透過 window.performance.now() 呼叫。Paul Irish 在 HTML5Rocks 上有更多關於 HRT 的說明。

有了精確的當前時間,那有沒有能準確測量頁面效能的 API?Navigation Timing API 正是為此而生,它提供一種簡單方式取得網頁從載入到呈現給使用者的精確詳細時間記錄。在 console 中使用 window.performance.timing 即可取得:

顯示在控制台中的時間資訊

從這些數據可推算出多項有用指標,例如:

· 網路延遲 = responseEnd − fetchStart

· 頁面載入時間 = loadEventEnd − responseEnd

· 導航與頁面載入的處理時間 = loadEventEnd − navigationStart

此外,performance.memory 屬性也能顯示 JavaScript 的內存使用情況,如總堆大小。

更多細節可參考 Sam Dutton 的〈Measuring Page Load Speed With Navigation Timing〉。

現代補充:performance.timing 因資訊粒度過細而被認為有安全隱憂,已逐步被 Navigation Timing Level 2 取代。新寫法使用 performance.getEntriesByType('navigation')[0],回傳 PerformanceNavigationTiming 物件,欄位名稱改為 domContentLoadedEventEnd、responseStart 等,且以 DOMHighResTimeStamp 表示,精度更高。

about:memory 與 about:tracing

Chrome 中的 about:tracing 提供瀏覽器的效能視圖,記錄了所有執行緒、分頁與行程。

About:Tracing 提供了瀏覽器的效能視圖

這個工具真正的用處是允許你擷取 Chrome 的運行數據,據此調整 JavaScript 執行或優化資源載入。Lilli Thompson 有一篇寫給遊戲開發者、使用 about:tracing 分析 WebGL 遊戲的文章,對 JavaScript 開發者同樣適用。

在 Chrome 網址列輸入 about:memory 也很實用,可取得每個分頁的內存使用情況,對定位洩漏很有幫助。

現況說明:這兩個頁面如今已被整合進 Chrome 開發者工具。效能分析改用 Performance 面板(前身即 Timeline),內存分析改用 Memory 面板,功能更完整且有圖表化介面。此外 about:blank 之類的內部頁面名稱在近年版本中亦有調整。

總結

我們看到,JavaScript 的世界裡有許多隱藏的陷阱,且並沒有提升效能的銀彈。只有把多種優化方案綜合應用到真實測試環境,才能獲得最大的效能收益。即便如此,了解引擎如何解釋與優化程式碼,能幫助你更有方向地調整應用。

測量,理解,修復。不斷重複這個循環。

圖片來源:Sally Hunter

謹記關注優化,但為了開發效率可以捨棄一些微小的優化。例如,有些開發者選擇 forEach 與 Object.keys 取代 for 與 for...in 迴圈,儘管前者較慢但更易讀。要保持清醒的頭腦,判斷哪些優化是必要的、哪些是過度的。

同時注意,雖然 JavaScript 引擎越來越快,下一個真正的瓶頸是 DOM。減少回流與重繪同樣重要,所以非必要不動 DOM。還要關注網路——HTTP 請求是珍貴的,尤其在行動端,因此要用 HTTP 快取減少資源載入。

記住這幾點,你應該已掌握本文的大部分資訊,希望對你有所幫助。

原文:https://coding.smashingmagazine.com/2012/11/05/writing-fast-memory-efficient-javascript/

作者:Addy Osmani

譯後補記:這篇文章的時代座標

原文寫於 2012 年,距今已逾十年,其中部分技術細節需要更新視角:

· api 已被標準取代。文中「預分配陣列」的結論在現代 V8 已不同;performance.timing 讓位給 Navigation Timing Level 2;about:tracing 演進為 Performance 面板。

· ES6+ 改變了最佳實踐。let / const 的塊級作用域讓「變數放在最小範圍」更容易實踐;Promise 與 async/await 改變了異步組織方式;Map、Set、WeakMap 提供了更合適的資料結構選擇——特別是 WeakMap 與 WeakRef,它們讓「不阻止垃圾回收的引用」成為可能,是處理快取與 observer 洩漏的正確工具。

· 核心心法依然成立。「測量、理解、修復」這個循環、對隱藏類別與 inline 優化的理解、避免在 hot 物件上做結構變更、用 DocumentFragment 批次操作 DOM、三快照排查洩漏——這些原則跨越了具體 API 的更替,至今仍是效能工作的基礎。

換言之:具體技巧會過時,理解引擎如何思考不會。這正是這篇文章值得一读再读的原因。

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