JavaScript性能優化小竅門彙總（含實例）

時間 2019-11-20

標籤 javascript 性能優化竅門彙總實例欄目 JavaScript 简体版

原文原文鏈接

在衆多語言中，JavaScript已經佔有重要的一席之地，利用JavaScript咱們能夠作不少事情，應用普遍。在web應用項目中，須要大量JavaScript的代碼，未來也會愈來愈多。可是因爲JavaScript是一個做爲解釋執行的語言，並且它的單線程機制，決定了性能問題是JavaScript的弱點，也是開發者在寫JavaScript的時候需注意的一個問題，由於常常會遇到Web 2.0應用性能欠佳的問題，主因就是JavaScript性能不足，致使瀏覽器負荷太重。 Javascript性能優化毫不是一種書面的技能，那麼應該如何正確的加載和執行 JavaScript代碼，從而提升其在瀏覽器中的性能呢？下面就W3Cschool小編給你們作一些優化小竅門的知識彙總。javascript

不管當前 JavaScript 代碼是內嵌仍是在外鏈文件中，頁面的下載和渲染都必須停下來等待腳本執行完成。JavaScript 執行過程耗時越久，瀏覽器等待響應用戶輸入的時間就越長。瀏覽器在下載和執行腳本時出現阻塞的緣由在於，腳本可能會改變頁面或JavaScript的命名空間，它們會對後面頁面內容形成影響。一個典型的例子就是在頁面中使用：css

document.write()

示例：html

<html>
  <head>
    <title>Source Example</title>
  </head>
  <body>
    <p>
      <script type="text/javascript">
        document.write("Today is " + (new Date()).toDateString());
      </script>
    </p>
  </body>
</html>

當瀏覽器遇到<script>標籤時，當前 HTML 頁面無從獲知 JavaScript 是否會向<p> 標籤添加內容，或引入其餘元素，或甚至移除該標籤。所以，這時瀏覽器會中止處理頁面，先執行 JavaScript代碼，而後再繼續解析和渲染頁面。一樣的狀況也發生在使用 src 屬性加載 JavaScript的過程當中，瀏覽器必須先花時間下載外鏈文件中的代碼，而後解析並執行它。在這個過程當中，頁面渲染和用戶交互徹底被阻塞了。java

不要使用 with() 語句

這是由於 with() 語句將會在做用域鏈的開始添加額外的變量。額外的變量意味着，當任何變量須要被訪問的時候，JavaScript引擎都須要先掃描with()語句產生的變量，而後纔是局部變量，最後是全局變量。web

So with() essentially gives local variables all the performance drawbacks of global ones, and in turn derails Javascript optimization.

所以with()語句同時給局部變量和全局變量的性能帶來負面影響，最終使咱們優化JavaScript性能的計劃破產。編程

對象屬性和數組元素的速度都比變量慢

談到JavaScript的數據，通常來講有4種訪問方式：數值、變量、對象屬性和數組元素。在考慮優化時，數值和變量的性能差很少，而且速度顯著優於對象屬性和數組元素。所以當你屢次引用一個對象屬性或者數組元素的時候，你能夠經過定義一個變量來得到性能提高。（這一條在讀、寫數據時都有效）雖然這條規則在絕大多數狀況下是正確的，可是Firefox在優化數組索引上作了一些有意思的工做，可以讓它的實際性能優於變量。可是考慮到數組元素在其餘瀏覽器上的性能弊端，仍是應該儘可能避免數組查找，除非你真的只針對於火狐瀏覽器的性能而進行開發。數組

避免全局查找

在一個函數中會用到全局對象存儲爲局部變量來減小全局查找，由於訪問局部變量的速度要比訪問全局變量的速度更快些瀏覽器

function search() {
  //當我要使用當前頁面地址和主機域名
  alert(window.location.href + window.location.host);
}
//最好的方式是以下這樣  先用一個簡單變量保存起來
function search() {
  var location = window.location;
  alert(location.href + location.host);
}

避免with語句

和函數相似，with語句會建立本身的做用域，所以會增長其中執行的代碼的做用域鏈的長度，因爲額外的做用域鏈的查找，在with語句中執行的代碼確定會比外面執行的代碼要慢，在能不使用with語句的時候儘可能不要使用with語句。緩存

with (a.b.c.d) {
  property1 = 1;
  property2 = 2;
}
//能夠替換爲：
  var obj = a.b.c.d;
  obj.property1 = 1;
  obj.property2 = 2;

數字轉換成字符串
般最好用」" + 1來將數字轉換成字符串，雖然看起來比較醜一點，但事實上這個效率是最高的，性能上來講：安全

(「」 +) > String() > .toString() > new String()

經過模板元素clone，替代createElement

不少人喜歡在JavaScript中使用document.write來給頁面生成內容。事實上這樣的效率較低，若是須要直接插入HTML，能夠找一個容器元素，好比指定一個div或者span，並設置他們的innerHTML來將本身的HTML代碼插入到頁面中。一般咱們可能會使用字符串直接寫HTML來建立節點，其實這樣作:
1：沒法保證代碼的有效性;
2：字符串操做效率低，因此應該是用document.createElement()方法，而若是文檔中存在現成的樣板節點，應該是用cloneNode()方法，由於使用createElement()方法以後，你須要設置屢次元素的屬性，使用cloneNode()則能夠減小屬性的設置次數——一樣若是須要建立不少元素，應該先準備一個樣板節點。

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);
        //替換爲：
        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);

避免低效率的腳本位置

HTML 4 規範指出 <script> 標籤能夠放在 HTML 文檔的<head>或<body>中，並容許出現屢次。Web 開發人員通常習慣在 <head> 中加載外鏈的 JavaScript，接着用 <link> 標籤用來加載外鏈的 CSS 文件或者其餘頁面信息。

低效率腳本位置示例：

<html>
  <head>
    <title>Source Example</title>
    <script type="text/javascript" src="script1.js"></script>
    <script type="text/javascript" src="script2.js"></script>
    <script type="text/javascript" src="script3.js"></script>
    <link rel="stylesheet" type="text/css" href="styles.css">
  </head>
  <body>
    <p>Hello world!</p>
  </body>
</html>

然而這種常規的作法卻隱藏着嚴重的性能問題。在清單 2 的示例中，當瀏覽器解析到 <script> 標籤（第 4 行）時，瀏覽器會中止解析其後的內容，而優先下載腳本文件，並執行其中的代碼，這意味着，其後的 styles.css 樣式文件和<body>標籤都沒法被加載，因爲<body>標籤沒法被加載，那麼頁面天然就沒法渲染了。所以在該 JavaScript 代碼徹底執行完以前，頁面都是一片空白。下圖描述了頁面加載過程當中腳本和樣式文件的下載過程。

腳本位置

咱們能夠發現一個有趣的現象：第一個 JavaScript 文件開始下載，與此同時阻塞了頁面其餘文件的下載。此外，從 script1.js 下載完成到 script2.js 開始下載前存在一個延時，這段時間正好是 script1.js 文件的執行過程。每一個文件必須等到前一個文件下載並執行完成纔會開始下載。在這些文件逐個下載過程當中，用戶看到的是一片空白的頁面。從 IE 八、Firefox 3.五、Safari 4 和 Chrome 2 開始都容許並行下載 JavaScript 文件。這是個好消息，由於<script>標籤在下載外部資源時不會阻塞其餘<script>標籤。遺憾的是，JavaScript 下載過程仍然會阻塞其餘資源的下載，好比樣式文件和圖片。儘管腳本的下載過程不會互相影響，但頁面仍然必須等待全部 JavaScript 代碼下載並執行完成才能繼續。所以，儘管最新的瀏覽器經過容許並行下載提升了性能，但問題還沒有徹底解決，腳本阻塞仍然是一個問題。因爲腳本會阻塞頁面其餘資源的下載，所以推薦將全部<script>標籤儘量放到<body>標籤的底部，以儘可能減小對整個頁面下載的影響。

推薦的代碼放置位置示例：

<html>
<head>
    <title>Source Example</title>
    <link rel="stylesheet" type="text/css" href="styles.css">
</head>
<body>
    <p>Hello world!</p>
    <!-- Example of efficient script positioning -->
    <script type="text/javascript" src="script1.js"></script>
    <script type="text/javascript" src="script2.js"></script>
    <script type="text/javascript" src="script3.js"></script>
</body>
</html>

這段代碼展現了在 HTML 文檔中放置<script>標籤的推薦位置。儘管腳本下載會阻塞另外一個腳本，可是頁面的大部份內容都已經下載完成並顯示給了用戶，所以頁面下載不會顯得太慢。這是優化 JavaScript 的首要規則：將腳本放在底部。

當心使用閉包

雖然你可能還不知道「閉包」，但你可能在不經意間常用這項技術。閉包基本上被認爲是JavaScript中的new，當咱們定義一個即時函數的時候，咱們就使用了閉包，好比：

document.getElementById('foo').onclick = function(ev) { };

閉包的問題在於：根據定義，在它們的做用域鏈中至少有三個對象：閉包變量、局部變量和全局變量。這些額外的對象將會致使其餘的性能問題。可是Nicholas並非要咱們因噎廢食，閉包對於提升代碼可讀性等方面仍是很是有用的，只是不要濫用它們（尤爲在循環中）。

在循環時將控制條件和控制變量合併起來

提到性能，在循環中須要避免的工做一直是個熱門話題，由於循環會被重複執行不少次。因此若是有性能優化的需求，先對循環開刀有可能會得到最明顯的性能提高。
一種優化循環的方法是在定義循環的時候，將控制條件和控制變量合併起來，下面是一個沒有將他們合併起來的例子：

for ( var x = 0; x < 10; x++ ) {
};

當咱們要添加什麼東西到這個循環以前，咱們發現有幾個操做在每次迭代都會出現。JavaScript引擎須要：

#1：檢查 x 是否存在
#2：檢查 x 是否小於 0 <span style="color: #888888;">（這裏可能有筆誤）</span>
#3：使 x 增長 1

然而若是你只是迭代元素中的一些元素，那麼你可使用while循環進行輪轉來替代上面這種操做：

var x = 9;
do { } while( x-- );

使用 XMLHttpRequest(XHR)對象

此技術首先建立一個 XHR 對象，而後下載 JavaScript 文件，接着用一個動態<script>
元素將 JavaScript 代碼注入頁面。
經過 XHR 對象加載 JavaScript 腳本：

var xhr = new XMLHttpRequest();
xhr.open("get", "script1.js", true);
xhr.onreadystatechange = function(){
    if (xhr.readyState == 4){
        if (xhr.status >= 200 && xhr.status < 300 || xhr.status == 304){
            var script = document.createElement ("script");
            script.type = "text/javascript";
            script.text = xhr.responseText;
            document.body.appendChild(script);
        }
    }
};
xhr.send(null);

此代碼向服務器發送一個獲取 script1.js 文件的 GET 請求。onreadystatechange 事件處理函數檢查readyState 是否是 4，而後檢查 HTTP 狀態碼是否是有效（2XX 表示有效的迴應，304 表示一個緩存響應）。若是收到了一個有效的響應，那麼就建立一個新的<script>元素，將它的文本屬性設置爲從服務器接收到的 responseText 字符串。這樣作實際上會建立一個帶有內聯代碼的<script>元素。一旦新<script>元素被添加到文檔，代碼將被執行，並準備使用。這種方法的主要優勢是，您能夠下載不當即執行的 JavaScript 代碼。因爲代碼返回在<script>標籤以外（換句話說不受<script>標籤約束），它下載後不會自動執行，這使得您能夠推遲執行，直到一切都準備好了。另外一個優勢是，一樣的代碼在全部現代瀏覽器中都不會引起異常。此方法最主要的限制是：JavaScript 文件必須與頁面放置在同一個域內，不能從 CDN 下載（CDN 指」內容投遞網絡（Content Delivery Network）」，因此大型網頁一般不採用 XHR 腳本注入技術。

注意NodeList

最小化訪問NodeList的次數能夠極大的改進腳本的性能

var images = document.getElementsByTagName('img');
for (var i = 0, len = images.length; i < len; i++) {
}

編寫JavaScript的時候必定要知道什麼時候返回NodeList對象，這樣能夠最小化對它們的訪問

進行了對getElementsByTagName()的調用
獲取了元素的childNodes屬性
獲取了元素的attributes屬性
訪問了特殊的集合，如document.forms、document.images等等
要了解了當使用NodeList對象時，合理使用會極大的提高代碼執行速度

避免與null進行比較

因爲JavaScript是弱類型的，因此它不會作任何的自動類型檢查，因此若是看到與null進行比較的代碼，嘗試使用如下技術替換：

若是值應爲一個引用類型，使用instanceof操做符檢查其構造函數
若是值應爲一個基本類型，做用typeof檢查其類型
若是是但願對象包含某個特定的方法名，則使用typeof操做符確保指定名字的方法存在於對象上

尊重對象的全部權

由於JavaScript能夠在任什麼時候候修改任意對象，這樣就能夠以不可預計的方式覆寫默認的行爲，因此若是你不負責維護某個對象，它的對象或者它的方法，那麼你就不要對它進行修改，具體一點就是說：

不要爲實例或原型添加屬性
不要爲實例或者原型添加方法
不要重定義已經存在的方法
不要重複定義其它團隊成員已經實現的方法
永遠不要修改不是由你全部的對象，你能夠經過如下方式爲對象建立新的功能:
建立包含所需功能的新對象，並用它與相關對象進行交互
建立自定義類型，繼承須要進行修改的類型，而後能夠爲自定義類型添加額外功能

循環引用

若是循環引用中包含DOM對象或者ActiveX對象，那麼就會發生內存泄露。內存泄露的後果是在瀏覽器關閉前，即便是刷新頁面，這部份內存不會被瀏覽器釋放。
簡單的循環引用：

var el = document.getElementById('MyElement');
var func = function () {
  //…
}
el.func = func;
func.element = el;

可是一般不會出現這種狀況。一般循環引用發生在爲dom元素添加閉包做爲expendo的時候。

function init() {
  var el = document.getElementById('MyElement');
  el.onclick = function () {
    //……
  }
}
init();

init在執行的時候，當前上下文咱們叫作context。這個時候，context引用了el，el引用了function，function引用了context。這時候造成了一個循環引用。
下面2種方法能夠解決循環引用：

一、置空dom對象

function init() {
  var el = document.getElementById('MyElement');
  el.onclick = function () {
    //……
  }
}
init();
//能夠替換爲：
function init() {
  var el = document.getElementById('MyElement');
  el.onclick = function () {
    //……
  }
  el = null;
}
init();

將el置空，context中不包含對dom對象的引用，從而打斷循環應用。

若是咱們須要將dom對象返回，能夠用以下方法：

function init() {
  var el = document.getElementById('MyElement');
  el.onclick = function () {
    //……
  }
  return el;
}
init();
//能夠替換爲：
function init() {
  var el = document.getElementById('MyElement');
  el.onclick = function () {
    //……
  }
  try {
    return el;
  }
  finally {
    el = null;
  }
}
init();

二、構造新的context

function init() {
  var el = document.getElementById('MyElement');
  el.onclick = function () {
    //……
  }
}
init();
//能夠替換爲：
function elClickHandler() {
  //……
}
function init() {
  var el = document.getElementById('MyElement');
  el.onclick = elClickHandler;
}
init();

把function抽到新的context中，這樣，function的context就不包含對el的引用，從而打斷循環引用。

經過javascript建立的dom對象，必須append到頁面中
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);
  }
}

字符串鏈接

若是要鏈接多個字符串，應該少使用+=，如

s+=a;
s+=b;
s+=c;

應該寫成s+=a + b + c；
而若是是收集字符串，好比屢次對同一個字符串進行+=操做的話，最好使用一個緩存，使用JavaScript數組來收集，最後使用join方法鏈接起來

var buf = [];
for (var i = 0; i < 100; i++) {
  buf.push(i.toString());
}
var all = buf.join("");

各類類型轉換

var myVar = "3.14159",
str = "" + myVar, //  to string  
i_int = ~ ~myVar,  //  to integer  
f_float = 1 * myVar,  //  to float  
b_bool = !!myVar,  /*  to boolean - any string with length 
and any number except 0 are true */
array = [myVar];  //  to array

若是定義了toString()方法來進行類型轉換的話，推薦顯式調用toString()，由於內部的操做在嘗試全部可能性以後，會嘗試對象的toString()方法嘗試可否轉化爲String，因此直接調用這個方法效率會更高

多個類型聲明

在JavaScript中全部變量均可以使用單個var語句來聲明，這樣就是組合在一塊兒的語句，以減小整個腳本的執行時間，就如上面代碼同樣，上面代碼格式也挺規範，讓人一看就明瞭。

插入迭代器

如var name=values[i]; i++;前面兩條語句能夠寫成var name=values[i++]

使用直接量

var aTest = new Array(); //替換爲
var aTest = [];
var aTest = new Object; //替換爲
var aTest = {};
var reg = new RegExp(); //替換爲
var reg = /../;
//若是要建立具備一些特性的通常對象，也可使用字面量，以下：
var oFruit = new O;
oFruit.color = "red";
oFruit.name = "apple";
//前面的代碼可用對象字面量來改寫成這樣：
var oFruit = { color: "red", name: "apple" };

避免雙重解釋

若是要提升代碼性能，儘量避免出現須要按照JavaScript解釋的字符串，也就是
一、儘可能少使用eval函數
使用eval至關於在運行時再次調用解釋引擎對內容進行運行，須要消耗大量時間，並且使用Eval帶來的安全性問題也是不容忽視的。
二、不要使用Function構造器
不要給setTimeout或者setInterval傳遞字符串參數

var num = 0;
setTimeout('num++', 10);
//能夠替換爲：
var num = 0;
function addNum() {
  num++;
}
setTimeout(addNum, 10);

縮短否認檢測

if (oTest != '#ff0000') {
  //do something
}
if (oTest != null) {
  //do something
}
if (oTest != false) {
  //do something
}
//雖然這些都正確，但用邏輯非操做符來操做也有一樣的效果：
if (!oTest) {
  //do something
}

釋放javascript對象

在rich應用中，隨着實例化對象數量的增長，內存消耗會愈來愈大。因此應當及時釋放對對象的引用，讓GC可以回收這些內存控件。
對象：obj = null
對象屬性：delete obj.myproperty
數組item：使用數組的splice方法釋放數組中不用的item

性能方面的注意事項

一、儘可能使用原生方法
二、switch語句相對if較快
經過將case語句按照最可能到最不可能的順序進行組織
三、位運算較快
當進行數字運算時，位運算操做要比任何布爾運算或者算數運算快
四、巧用||和&&布爾運算符

function eventHandler(e) {
  if (!e) e = window.event;
}
//能夠替換爲：
function eventHandler(e) {
  e = e || window.event;
}
if (myobj) {
  doSomething(myobj);
}
//能夠替換爲：
myobj && doSomething(myobj);

避免錯誤應注意的地方
一、每條語句末尾須加分號
在if語句中，即便條件表達式只有一條語句也要用{}把它括起來，以避免後續若是添加了語句以後形成邏輯錯誤

二、使用+號時需謹慎
JavaScript 和其餘編程語言不一樣的是，在 JavaScript 中，’+'除了表示數字值相加，字符串相鏈接之外，還能夠做一元運算符用，把字符串轉換爲數字。於是若是使用不當，則可能與自增符’++’混淆而引發計算錯誤

var valueA = 20;
var valueB = "10";
alert(valueA + valueB);     //ouput: 2010 
alert(valueA + (+valueB));  //output: 30 
alert(valueA + +valueB);    //output:30 
alert(valueA ++ valueB);     //Compile error

三、使用return語句須要注意
一條有返回值的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());  //output: 3 
alert(F2());  //ouput: undefined

==和===的區別

避免在if和while語句的條件部分進行賦值，如if (a = b)，應該寫成if (a == b)，可是在比較是否相等的狀況下，最好使用全等運行符，也就是使用===和!==操做符會相對於==和!=會好點。==和!=操做符會進行類型強制轉換

var valueA = "1";
var valueB = 1;
if (valueA == valueB) {
  alert("Equal");
}
else {
  alert("Not equal");
}
//output: "Equal"
if (valueA === valueB) {
  alert("Equal");
}
else {
  alert("Not equal");
}
//output: "Not equal"

不要使用生偏語法

不要使用生偏語法，寫讓人迷惑的代碼，雖然計算機可以正確識別並運行，可是晦澀難懂的代碼不方便之後維護

函數返回統一類型

雖然JavaScript是弱類型的，對於函數來講，前面返回整數型數據，後面返回布爾值在編譯和運行均可以正常經過，但爲了規範和之後維護時容易理解，應保證函數應返回統一的數據類型

老是檢查數據類型

要檢查你的方法輸入的全部數據，一方面是爲了安全性，另外一方面也是爲了可用性。用戶隨時隨地都會輸入錯誤的數據。這不是由於他們蠢，而是由於他們很忙，而且思考的方式跟你不一樣。用typeof方法來檢測你的function接受的輸入是否合法

什麼時候用單引號，什麼時候用雙引號

雖然在JavaScript當中，雙引號和單引號均可以表示字符串, 爲了不混亂，咱們建議在HTML中使用雙引號，在JavaScript中使用單引號，但爲了兼容各個瀏覽器，也爲了解析時不會出錯，定義JSON對象時，最好使用雙引號部署

用JSLint運行JavaScript驗證器來確保沒有語法錯誤或者是代碼沒有潛在的問
部署以前推薦使用壓縮工具將JS文件壓縮
文件編碼統一用UTF-8
JavaScript 程序應該儘可能放在 .js 的文件中，須要調用的時候在 HTML 中以 <script src=」filename.js」> 的形式包含進來。

JavaScript 代碼若不是該 HTML 文件所專用的，則應儘可能避免在 HTML 文件中直接編寫 JavaScript 代碼。由於這樣會大大增長 HTML 文件的大小，無益於代碼的壓縮和緩存的使用。另外，<script src=」filename.js」> 標籤應儘可能放在文件的後面,最好是放在</body>標籤前。這樣會下降因加載 JavaScript 代碼而影響頁面中其它組件的加載時間。

永遠不要忽略代碼優化工做，重構是一項從項目開始到結束須要持續的工做，只有不斷的優化代碼才能讓代碼的執行效率愈來愈好。

原文連接：http://www.w3cschool.cn/javascript/javascript-optimization.html