《高性能JavaScript》（讀書筆記）

時間 2019-12-07

原文原文鏈接

此次主要是對《高性能JavaScript》一書的讀書筆記，記錄下本身以前沒有注意到或者須要引發重視的地方

第一章加載和執行

js代碼在執行過程當中會阻塞瀏覽器的其餘進程，好比用戶界面的繪製。每次遇到script標籤，頁面都必須停下里等待代碼下載，執行，而後繼續處理其餘部分。下面是幾種能減小js對性能影響的方法：javascript

1.腳本位置

若是在<head>中加載js文件那麼因爲腳本會阻塞頁面渲染，直到它們所有下載並執行完，頁面渲染纔會繼續，表現爲明顯的延遲，顯示空白頁面。
IE8 firefox3.5 safari4 chrome2都容許並行下載js文件，因此script標籤在下載時不會相互影響，可是仍然會阻塞其餘資源的下載
所以推薦將script標籤放置在body標籤的底部，減小對頁面下載的影響css

2.合併腳本

頁面中的script標籤越少，加載也就越快，響應也就越迅速html

3.無阻塞的腳本

html4 爲script標籤訂義了一個擴展屬性defer。此屬性指明本元素所包含的腳本不會修改DOM,所以代碼能夠安全地延遲執行。
到了html5中 defer屬性僅當src屬性申明時才生效
html5中引入了async屬性用於異步加載腳本與defer的相同點是採用並行下載，不產生阻礙，區別在與執行時機
async是加載完成以後自動執行，defer須要等待頁面完成後執行（寫法爲defer='defer' async="true"）html5

推薦的無阻塞模式：
向頁面中添加大量js的推薦作法需兩步：先添加動態加載所需的代碼，而後化妝初始化頁面所須要的剩下的代碼。第一部分代碼儘可能精簡，一旦初始化代碼就位，就用它來加載剩餘的jsjava

推薦的工具備LAB.js和require.js
LAB.js:jquery

*LABjs 的核心是 LAB（Loading and Blocking）：Loading 指異步並行加載，Blocking 是指同步等待執行。LABjs 經過優雅的語法（script 和 wait）實現了這兩大特性，核心價值是性能優化。LABjs 是一個文件加載器。
做者：玉伯
連接：https://www.zhihu.com/questio...
來源：知乎
著做權歸做者全部。商業轉載請聯繫做者得到受權，非商業轉載請註明出處。*web

用法：（轉自阮一峯博客）ajax

引用文字下面根據ScriptJunkie的文章，舉一個最簡單的例子，來講明這兩個函數庫的基本用法。更高級的用法，請參閱它們的文檔。
　　<script src="script1.js"></script>
　　<script src="script2-a.js"></script>
　　<script src="script2-b.js"></script>
　　<script type="text/javascript">
　　　　initScript1();
　　　　initScript2();
　　</script>
　　<script src="script3.js"></script>
　　<script type="text/javascript">
　　　　initScript3();
　　</script>
上面這段代碼，將依次加載4個javascript文件：script1.js、script2-a.js、script2-b.js和script3.js。在加載完前三個文件後，運行兩個函數initScript1()和initScript2()；加載完第四個文件後，再運行函數initScript3()。
下面，用LABjs對其進行改寫：
　　<script src="LAB.js"></script>
　　<script type="text/javascript">
　　　　$LAB
　　　　　.script("script1.js").wait()
　　　　　.script("script2-a.js")
　　　　　.script("script2-b.js")
　　　　　.wait(function(){
　　　　　　　initScript1();
　　　　　　　initScript2();
　　　　　})
　　　　　.script("script3.js")
　　　　　.wait(function(){
　　　　　　　initScript3();
　　　　　});
　　</script>
首先，$LAB對象替代了<script>標籤，而後.script()方法表示加載Javascript文件，不帶參數的.wait()方法表示當即運行剛纔加載的Javascript文件，帶參數的.wait()方法也是當即運行剛纔加載的Javascript文件，可是還運行參數中指定的函數。
這裏須要注意的是，能夠同時運行多條$LAB鏈，可是它們之間是徹底獨立的，不存在次序關係。若是你要確保一個Javascript文件在另外一個文件以後運行，你只能把它們寫在同一個鏈操做之中。只有當某些腳本是徹底無關的時候，你才應該考慮把它們分紅不一樣的$LAB鏈，表示它們之間不存在相關關係。正則表達式

require.js
require.js是一個模塊加載器chrome

http://www.ruanyifeng.com/blo...

引自Javascript模塊化編程（三）：require.js的用法

1、爲何要用require.js？
最先的時候，全部Javascript代碼都寫在一個文件裏面，只要加載這一個文件就夠了。後來，代碼愈來愈多，一個文件不夠了，必須分紅多個文件，依次加載。下面的網頁代碼，相信不少人都見過。
　　<script src="1.js"></script>
　　<script src="2.js"></script>
　　<script src="3.js"></script>
　　<script src="4.js"></script>
　　<script src="5.js"></script>
　　<script src="6.js"></script>
這段代碼依次加載多個js文件。
這樣的寫法有很大的缺點。首先，加載的時候，瀏覽器會中止網頁渲染，加載文件越多，網頁失去響應的時間就會越長；其次，因爲js文件之間存在依賴關係，所以必須嚴格保證加載順序（好比上例的1.js要在2.js的前面），依賴性最大的模塊必定要放到最後加載，當依賴關係很複雜的時候，代碼的編寫和維護都會變得困難。
require.js的誕生，就是爲了解決這兩個問題：
　　（1）實現js文件的異步加載，避免網頁失去響應；
　　（2）管理模塊之間的依賴性，便於代碼的編寫和維護。
2、require.js的加載
使用require.js的第一步，是先去官方網站下載最新版本。
下載後，假定把它放在js子目錄下面，就能夠加載了。
　　<script src="js/require.js"></script>
有人可能會想到，加載這個文件，也可能形成網頁失去響應。解決辦法有兩個，一個是把它放在網頁底部加載，另外一個是寫成下面這樣：
　　<script src="js/require.js" defer async="true" ></script>
async屬性代表這個文件須要異步加載，避免網頁失去響應。IE不支持這個屬性，只支持defer，因此把defer也寫上。
加載require.js之後，下一步就要加載咱們本身的代碼了。假定咱們本身的代碼文件是main.js，也放在js目錄下面。那麼，只須要寫成下面這樣就好了：
　　<script src="js/require.js" data-main="js/main"></script>
data-main屬性的做用是，指定網頁程序的主模塊。在上例中，就是js目錄下面的main.js，這個文件會第一個被require.js加載。因爲require.js默認的文件後綴名是js，因此能夠把main.js簡寫成main。
3、主模塊的寫法
上一節的main.js，我把它稱爲"主模塊"，意思是整個網頁的入口代碼。它有點像C語言的main()函數，全部代碼都從這兒開始運行。
下面就來看，怎麼寫main.js。
若是咱們的代碼不依賴任何其餘模塊，那麼能夠直接寫入javascript代碼。
　　// main.js
　　alert("加載成功！");
但這樣的話，就不必使用require.js了。真正常見的狀況是，主模塊依賴於其餘模塊，這時就要使用AMD規範定義的的require()函數。
　　// main.js
　　require(['moduleA', 'moduleB', 'moduleC'], function (moduleA, moduleB, moduleC){
　　　　// some code here
　　});
require()函數接受兩個參數。第一個參數是一個數組，表示所依賴的模塊，上例就是['moduleA', 'moduleB', 'moduleC']，即主模塊依賴這三個模塊；第二個參數是一個回調函數，當前面指定的模塊都加載成功後，它將被調用。加載的模塊會以參數形式傳入該函數，從而在回調函數內部就可使用這些模塊。
require()異步加載moduleA，moduleB和moduleC，瀏覽器不會失去響應；它指定的回調函數，只有前面的模塊都加載成功後，纔會運行，解決了依賴性的問題。
下面，咱們看一個實際的例子。
假定主模塊依賴jquery、underscore和backbone這三個模塊，main.js就能夠這樣寫：
　　require(['jquery', 'underscore', 'backbone'], function ($, _, Backbone){
　　　　// some code here
　　});
require.js會先加載jQuery、underscore和backbone，而後再運行回調函數。主模塊的代碼就寫在回調函數中。
4、模塊的加載
上一節最後的示例中，主模塊的依賴模塊是['jquery', 'underscore', 'backbone']。默認狀況下，require.js假定這三個模塊與main.js在同一個目錄，文件名分別爲jquery.js，underscore.js和backbone.js，而後自動加載。
使用require.config()方法，咱們能夠對模塊的加載行爲進行自定義。require.config()就寫在主模塊（main.js）的頭部。參數就是一個對象，這個對象的paths屬性指定各個模塊的加載路徑。
　　require.config({
　　　　paths: {
　　　　　　"jquery": "jquery.min",
　　　　　　"underscore": "underscore.min",
　　　　　　"backbone": "backbone.min"
　　　　}
　　});
上面的代碼給出了三個模塊的文件名，路徑默認與main.js在同一個目錄（js子目錄）。若是這些模塊在其餘目錄，好比js/lib目錄，則有兩種寫法。一種是逐一指定路徑。
　　require.config({
　　　　paths: {
　　　　　　"jquery": "lib/jquery.min",
　　　　　　"underscore": "lib/underscore.min",
　　　　　　"backbone": "lib/backbone.min"
　　　　}
　　});
另外一種則是直接改變基目錄（baseUrl）。
　　require.config({
　　　　baseUrl: "js/lib",
　　　　paths: {
　　　　　　"jquery": "jquery.min",
　　　　　　"underscore": "underscore.min",
　　　　　　"backbone": "backbone.min"
　　　　}
　　});
若是某個模塊在另外一臺主機上，也能夠直接指定它的網址，好比：
　　require.config({
　　　　paths: {
　　　　　　"jquery": "https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min"
　　　　}
　　});
require.js要求，每一個模塊是一個單獨的js文件。這樣的話，若是加載多個模塊，就會發出屢次HTTP請求，會影響網頁的加載速度。所以，require.js提供了一個優化工具，當模塊部署完畢之後，能夠用這個工具將多個模塊合併在一個文件中，減小HTTP請求數。
5、AMD模塊的寫法
require.js加載的模塊，採用AMD規範。也就是說，模塊必須按照AMD的規定來寫。
具體來講，就是模塊必須採用特定的define()函數來定義。若是一個模塊不依賴其餘模塊，那麼能夠直接定義在define()函數之中。
假定如今有一個math.js文件，它定義了一個math模塊。那麼，math.js就要這樣寫：
　　// math.js
　　define(function (){
　　　　var add = function (x,y){
　　　　　　return x+y;
　　　　};
　　　　return {
　　　　　　add: add
　　　　};
　　});
加載方法以下：
　　// main.js
　　require(['math'], function (math){
　　　　alert(math.add(1,1));
　　});
若是這個模塊還依賴其餘模塊，那麼define()函數的第一個參數，必須是一個數組，指明該模塊的依賴性。
　　define(['myLib'], function(myLib){
　　　　function foo(){
　　　　　　myLib.doSomething();
　　　　}
　　　　return {
　　　　　　foo : foo
　　　　};
　　});
當require()函數加載上面這個模塊的時候，就會先加載myLib.js文件。
6、加載非規範的模塊
理論上，require.js加載的模塊，必須是按照AMD規範、用define()函數定義的模塊。可是實際上，雖然已經有一部分流行的函數庫（好比jQuery）符合AMD規範，更多的庫並不符合。那麼，require.js是否可以加載非規範的模塊呢？
回答是能夠的。
這樣的模塊在用require()加載以前，要先用require.config()方法，定義它們的一些特徵。
舉例來講，underscore和backbone這兩個庫，都沒有采用AMD規範編寫。若是要加載它們的話，必須先定義它們的特徵。
　　require.config({
　　　　shim: {
'underscore':{
　　　　　　　　exports: '_'
　　　　　　},
　　　　　　'backbone': {
　　　　　　　　deps: ['underscore', 'jquery'],
　　　　　　　　exports: 'Backbone'
　　　　　　}
　　　　}
　　});
require.config()接受一個配置對象，這個對象除了有前面說過的paths屬性以外，還有一個shim屬性，專門用來配置不兼容的模塊。具體來講，每一個模塊要定義（1）exports值（輸出的變量名），代表這個模塊外部調用時的名稱；（2）deps數組，代表該模塊的依賴性。
好比，jQuery的插件能夠這樣定義：
　　shim: {
　　　　'jquery.scroll': {
　　　　　　deps: ['jquery'],
　　　　　　exports: 'jQuery.fn.scroll'
　　　　}
　　}
7、require.js插件
require.js還提供一系列插件，實現一些特定的功能。
domready插件，可讓回調函數在頁面DOM結構加載完成後再運行。
　　require(['domready!'], function (doc){
　　　　// called once the DOM is ready
　　});
text和image插件，則是容許require.js加載文本和圖片文件。
　　define([
　　　　'text!review.txt',
　　　　'image!cat.jpg'
　　　　],
function(review,cat){
　　　　　　console.log(review);
　　　　　　document.body.appendChild(cat);
　　　　}
　　);
相似的插件還有json和mdown，用於加載json文件和markdown文件。

第二章數據的存取

在js中，數據存儲的位置會對代碼總體性能產生重大影響。數據存儲共有4中方式：字面量，變量，數組項，對象成員

1.管理做用域

字面量（字符串，數字，布爾值，對象，數組，函數，正則表達式以及null undefined）只表明自身不存儲在特定位置
訪問字面量和局部變量的速度最快，相反，訪問數組元素和對象成員相對較慢
在沒有優化的js引擎的瀏覽器中，建議儘量使用局部變量。一個好的經驗法則是：若是某個跨做用域的值在函數中被引用一次以上，那麼就把它存儲到局部變量裏
eg:for 循環以前 var len = obj.length 而不是直接將obj.length寫在for循環中
局部變量存在於做用域鏈的起始位置，所以訪問局部變量比訪問跨做用域的變量更快。變量在做用域鏈中的位置越深，訪問所需時間就越長。所有變量處於做用域的最末端，所以訪問速度也是最慢的。

2.對象成員

嵌套的成員對象會明顯影響性能
屬性或方法在原型鏈中的位置越深，那麼訪問速度就越慢
經過把經常使用的對象成員，數組元素，跨域變量保存在局部變量中來改善js性能，局部變量的訪問速度更快

第三章DOM編程

1. DOM的訪問與修改

1.最小化DOM訪問次數，儘量在js端處理
2.若是須要屢次訪問某個DMO節點，使用局部變量存儲它的應用
3.當心處理HTML集合，由於它實時連繫着底層文檔。把集合的長度緩存到一個變量中，並在迭代中使用它，若是須要常常操做集合，那麼建議把它拷貝到一個數組中
4.使用速度更快的API 如:document.querySelectorALL()

2. 重繪與重排

1.引自阮老師的網頁性能管理詳解
http://www.ruanyifeng.com/blo...

引用文字1、網頁生成的過程
要理解網頁性能爲何很差，就要了解網頁是怎麼生成的。
網頁的生成過程，大體能夠分紅五步。
HTML代碼轉化成DOM
CSS代碼轉化成CSSOM（CSS Object Model）
結合DOM和CSSOM，生成一棵渲染樹（包含每一個節點的視覺信息）
生成佈局（layout），即將全部渲染樹的全部節點進行平面合成
將佈局繪製（paint）在屏幕上
這五步裏面，第一步到第三步都很是快，耗時的是第四步和第五步。
"生成佈局"（flow）和"繪製"（paint）這兩步，合稱爲"渲染"（render）。
2、重排和重繪
網頁生成的時候，至少會渲染一次。用戶訪問的過程當中，還會不斷從新渲染。
如下三種狀況，會致使網頁從新渲染。
修改DOM
修改樣式表
用戶事件（好比鼠標懸停、頁面滾動、輸入框鍵入文字、改變窗口大小等等）
從新渲染，就須要從新生成佈局和從新繪製。前者叫作"重排"（reflow），後者叫作"重繪"（repaint）。
須要注意的是，"重繪"不必定須要"重排"，好比改變某個網頁元素的顏色，就只會觸發"重繪"，不會觸發"重排"，由於佈局沒有改變。可是，"重排"必然致使"重繪"，好比改變一個網頁元素的位置，就會同時觸發"重排"和"重繪"，由於佈局改變了。
3、對於性能的影響
重排和重繪會不斷觸發，這是不可避免的。可是，它們很是耗費資源，是致使網頁性能低下的根本緣由。
提升網頁性能，就是要下降"重排"和"重繪"的頻率和成本，儘可能少觸發從新渲染。
前面提到，DOM變更和樣式變更，都會觸發從新渲染。可是，瀏覽器已經很智能了，會盡可能把全部的變更集中在一塊兒，排成一個隊列，而後一次性執行，儘可能避免屢次從新渲染。
div.style.color = 'blue';
div.style.marginTop = '30px';
上面代碼中，div元素有兩個樣式變更，可是瀏覽器只會觸發一次重排和重繪。
若是寫得很差，就會觸發兩次重排和重繪。
div.style.color = 'blue';
var margin = parseInt(div.style.marginTop);
div.style.marginTop = (margin + 10) + 'px';
上面代碼對div元素設置背景色之後，第二行要求瀏覽器給出該元素的位置，因此瀏覽器不得不當即重排。
通常來講，樣式的寫操做以後，若是有下面這些屬性的讀操做，都會引起瀏覽器當即從新渲染。
offsetTop/offsetLeft/offsetWidth/offsetHeight
scrollTop/scrollLeft/scrollWidth/scrollHeight
clientTop/clientLeft/clientWidth/clientHeight
getComputedStyle()
因此，從性能角度考慮，儘可能不要把讀操做和寫操做，放在一個語句裏面。
// bad
div.style.left = div.offsetLeft + 10 + "px";
div.style.top = div.offsetTop + 10 + "px";
// good
var left = div.offsetLeft;
var top = div.offsetTop;
div.style.left = left + 10 + "px";
div.style.top = top + 10 + "px";
通常的規則是：
樣式表越簡單，重排和重繪就越快。
重排和重繪的DOM元素層級越高，成本就越高。
table元素的重排和重繪成本，要高於div元素
4、提升性能的九個技巧
有一些技巧，能夠下降瀏覽器從新渲染的頻率和成本。
第一條是上一節說到的，DOM 的多個讀操做（或多個寫操做），應該放在一塊兒。不要兩個讀操做之間，加入一個寫操做。
第二條，若是某個樣式是經過重排獲得的，那麼最好緩存結果。避免下一次用到的時候，瀏覽器又要重排。
第三條，不要一條條地改變樣式，而要經過改變class，或者csstext屬性，一次性地改變樣式。
// bad
var left = 10;
var top = 10;
el.style.left = left + "px";
el.style.top = top + "px";
// good
el.className += " theclassname";
// good
el.style.cssText += "; left: " + left + "px; top: " + top + "px;";
第四條，儘可能使用離線DOM，而不是真實的網面DOM，來改變元素樣式。好比，操做Document Fragment對象，完成後再把這個對象加入DOM。再好比，使用 cloneNode() 方法，在克隆的節點上進行操做，而後再用克隆的節點替換原始節點。
第五條，先將元素設爲display: none（須要1次重排和重繪），而後對這個節點進行100次操做，最後再恢復顯示（須要1次重排和重繪）。這樣一來，你就用兩次從新渲染，取代了可能高達100次的從新渲染。
第六條，position屬性爲absolute或fixed的元素，重排的開銷會比較小，由於不用考慮它對其餘元素的影響。
第七條，只在必要的時候，纔將元素的display屬性爲可見，由於不可見的元素不影響重排和重繪。另外，visibility : hidden的元素只對重繪有影響，不影響重排。
第八條，使用虛擬DOM的腳本庫，好比React等。
第九條，使用 window.requestAnimationFrame()、window.requestIdleCallback() 這兩個方法調節從新渲染（詳見後文）。