原生js部分
參考文章
DOM編程
建議將對象進行緩存處理，特別是DOM訪問是比較消耗資源的
使用DocumentFragment優化多次append
一旦需要更新DOM,請考慮使用文檔碎片來構建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賦值代替構建dom元素
對於大的DOM更改，使用innerHTML要比使用標准的DOM方法創建同樣的DOM結構快得多。
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 html = [];
for (var i = 0; i < 1000; i++) {
html.push('<p>' + i + '</p>');
}
document.body.innerHTML = html.join('');
通過模板元素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);
使用firstChild和nextSibling代替childNodes遍歷dom元素
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;
刪除DOM節點
刪除dom節點之前,一定要刪除注冊在該節點上的事件,不管是用observe方式還是用attachEvent方式注冊的事件,否則將會產生無法回收的內存。另外，在removeChild和innerHTML=''二者之間,盡量選擇后者. 因為在sIEve(內存泄露監測工具)中監測的結果是用removeChild無法有效地釋放dom節點
使用事件代理
任何可以冒泡的事件都不僅僅可以在事件目標上進行處理，目標的任何祖先節點上也能處理，使用這個知識就可以將事件處理程序附加到更高的地方負責多個目標的事件處理，同樣，對於內容動態增加並且子節點都需要相同的事件處理函數的情況，可以把事件注冊提到父節點上，這樣就不需要為每個子節點注冊事件監聽了。另外，現有的js庫都采用observe方式來創建事件監聽,其實現上隔離了dom對象和事件處理函數之間的循環引用,所以應該盡量采用這種方式來創建事件監聽
重復使用的調用結果，事先保存到局部變量
//避免多次取值的調用開銷
var h1 = element1.clientHeight + num1;
var h2 = element1.clientHeight + num2;
//可以替換為：
var eleHeight = element1.clientHeight;
var h1 = eleHeight + num1;
var h2 = eleHeight + num2;
注意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對象時，合理使用會極大的提升代碼執行速度
算法和流程控制
建議不要在函數內進行過深的嵌套判斷
盡量不要用for-in 循環去訪問數組，建議用 for 循環進行循環
優化循環
可以使用下面幾種方式來優化循環
倒序循環
大多數循環使用一個從0開始、增加到某個特定值的迭代器，在很多情況下，從最大值開始，在循環中不斷減值的迭代器更加高效
參考文章：javascript for循環從入門到偏門(效率優化+奇特用法)
把減法操作放到控制條件中，例如：i--，這樣只是比較“它是true嗎？”速度更快。
var i = arr.length;
for(;i>0;i--){
//alert(i);
}
簡化終止條件
由於每次循環過程都會計算終止條件，所以必須保證它盡可能快，也就是說避免屬性查找或者其它的操作，最好是將循環控制量保存到局部變量中，也就是說對數組或列表對象的遍歷時，提前將length保存到局部變量中，避免在循環的每一步重復取值。
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++) {
//……
}
簡化循環體
循環體是執行最多的，所以要確保其被最大限度的優化
使用后測試循環
在JavaScript中，我們可以使用for(;😉,while(),for(in)三種循環，事實上，這三種循環中for(in)的效率極差，因為他需要查詢散列鍵，只要可以，就應該盡量少用。for(;;)和while循環，while循環的效率要優於for(;😉，可能是因為for(;;)結構的問題，需要經常跳轉回去。
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];
}
最常用的for循環和while循環都是前測試循環，而如do-while這種后測試循環，可以避免最初終止條件的計算，因此運行更快。
展開循環
當循環次數是確定的，消除循環並使用多次函數調用往往會更快。
避免雙重解釋
如果要提高代碼性能，盡可能避免出現需要按照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
}
條件分支
將條件分支，按可能性順序從高到低排列：可以減少解釋器對條件的探測次數
在同一條件子的多（>2）條件分支時，使用switch優於if：switch分支選擇的效率高於if，在IE下尤為明顯。4分支的測試，IE下switch的執行時間約為if的一半。
使用三目運算符替代條件分支
if (a > b) {
num = a;
} else {
num = b;
}
//可以替換為：
num = a > b ? a : b;
數據存取
使用直接量
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" };
字符串連接
如果要連接多個字符串，應該少使用+=，如
s+=a;s+=b;s+=c;
應該寫成s+=a + b + c；
而如果是收集字符串，比如多次對同一個字符串進行+=操作的話，最好使用一個緩存，使用JavaScript數組來收集，最后使用join方法連接起來
var buf = [];
for(vari = 0; i < 100; i++) {
buf.push(i.toString());
}
var all = buf.join("");
避免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() > newString()
浮點數轉換成整型
很多人喜歡使用parseInt()，其實parseInt()是用於將字符串轉換成數字，而不是浮點數和整型之間的轉換，我們應該使用Math.floor()或者Math.round()
各種類型轉換
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語句來聲明，這樣就是組合在一起的語句，以減少整個腳本的執行時間，就如上面代碼一樣，上面代碼格式也挺規范，讓人一看就明了。
使用常量
重復值:任何在多處用到的值都應該抽取為一個常量
用戶界面字符串:任何用於顯示給用戶的字符串，都應該抽取出來以方便國際化
URLs:在Web應用中，資源位置很容易變更，所以推薦用一個公共地方存放所有的URL
任意可能會更改的值:每當你用到字面量值的時候，你都要問一下自己這個值在未來是不是會變化，如果答案是“是”，那么這個值就應該被提取出來作為一個常量。
避免與null進行比較
由於JavaScript是弱類型的，所以它不會做任何的自動類型檢查，所以如果看到與null進行比較的代碼，嘗試使用以下技術替換
如果值應為一個引用類型，使用instanceof操作符檢查其構造函數
如果值應為一個基本類型，作用typeof檢查其類型
如果是希望對象包含某個特定的方法名，則使用typeof操作符確保指定名字的方法存在於對象上
避免全局量
全局變量應該全部字母大寫，各單詞之間用_下划線來連接。盡可能避免全局變量和函數, 盡量減少全局變量的使用，因為在一個頁面中包含的所有JavaScript都在同一個域中運行。所以如果你的代碼中聲明了全局變量或者全局函數的話，后面的代碼中載入的腳本文件中的同名變量和函數會覆蓋掉（overwrite）你的。
//糟糕的全局變量和全局函數
var current = null;
function init(){
//...
}
function change() {
//...
}
function verify() {
//...
}
//解決辦法有很多，Christian Heilmann建議的方法是：
//如果變量和函數不需要在“外面”引用，那么就可以使用一個沒有名字的方法將他們全都包起來。
(function(){
var current = null;
function init() {
//...
}
function change() {
//...
}
function verify() {
//...
}
})();
//如果變量和函數需要在“外面”引用，需要把你的變量和函數放在一個“命名空間”中
//我們這里用一個function做命名空間而不是一個var，因為在前者中聲明function更簡單，而且能保護隱私數據
myNameSpace = function() {
var current = null;
function init() {
//...
}
function change() {
//...
}
function verify() {
//...
}
//所有需要在命名空間外調用的函數和屬性都要寫在return里面
return {
init: init,
//甚至你可以為函數和屬性命名一個別名
set: change
};
};
避免全局查找
將全局變量存儲到局部變量中：因為全局變量總是存在於執行環境作用域鏈的最末端，所以，訪問全局變量是最慢的，訪問局部變量是最快的。尤其是對於未優化過的JavaScript引擎。
function search() {//當我要使用當前頁面地址和主機域名
alert(window.location.href + window.location.host);
}
//最好的方式是如下這樣 先用一個簡單變量保存起來
function search() {
var location = window.location;
alert(location.href + location.host);
}
尊重對象的所有權
因為JavaScript可以在任何時候修改任意對象，這樣就可以以不可預計的方式覆寫默認的行為，所以如果你不負責維護某個對象，它的對象或者它的方法，那么你就不要對它進行修改，具體一點就是說：
不要為實例或原型添加屬性
不要為實例或者原型添加方法
不要重定義已經存在的方法
不要重復定義其它團隊成員已經實現的方法，永遠不要修改不是由你所有的對象，你可以通過以下方式為對象創建新的功能:
創建包含所需功能的新對象，並用它與相關對象進行交互
創建自定義類型，繼承需要進行修改的類型，然后可以為自定義類型添加額外功能
定時器
如果針對的是不斷運行的代碼，不應該使用setTimeout，而應該是用setInterval，因為setTimeout每一次都會初始化一個定時器，而setInterval只會在開始的時候初始化一個定時器
var timeoutTimes = 0;
functiontimeout() {
timeoutTimes++;
if(timeoutTimes < 10) {
setTimeout(timeout, 10);
}}
timeout();
//可以替換為：
var intervalTimes = 0
functioninterval() {
intervalTimes++;
if(intervalTimes >= 10){
clearInterval(interv);
}}
var interv = setInterval(interval, 10);
插入迭代器
如var name=values[i]; i++;前面兩條語句可以寫成var name=values[i++]
循環引用
如果循環引用中包含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種方法可以解決循環引用：
1) 置空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();
2) 構造新的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);
}
}
釋放dom元素占用的內存
將dom元素的innerHTML設置為空字符串，可以釋放其子元素占用的內存。
在rich應用中，用戶也許會在一個頁面上停留很長時間，可以使用該方法釋放積累得越來越多的dom元素使用的內存。
釋放javascript對象
在rich應用中，隨着實例化對象數量的增加，內存消耗會越來越大。所以應當及時釋放對對象的引用，讓GC能夠回收這些內存控件。
- 對象：obj = null
- 對象屬性：delete obj.myproperty
- 數組item：使用數組的splice方法釋放數組中不用的item
避免string的隱式裝箱
對string的方法調用，比如'xxx'.length，瀏覽器會進行一個隱式的裝箱操作，將字符串先轉換成一個String對象。推薦對聲明有可能使用String實例方法的字符串時，采用如下寫法：
var myString = new String(‘Hello World');
松散耦合
1、解耦HTML/JavaScript
JavaScript和HTML的緊密耦合：直接寫在HTML中的JavaScript、使用包含內聯代碼的
HTML和JavaScript的緊密耦合：JavaScript中包含HTML，然后使用innerHTML來插入一段html文本到頁面
其實應該是保持層次的分離，這樣可以很容易的確定錯誤的來源，所以我們應確保HTML呈現應該盡可能與JavaScript保持分離
2、解耦CSS/JavaScript
顯示問題的唯一來源應該是CSS，行為問題的唯一來源應該是JavaScript，層次之間保持松散耦合才可以讓你的應用程序更加易於維護，所以像以下的代碼element.style.color=”red”盡量改為element.className=”edit”，而且不要在css中通過表達式嵌入JavaScript
3、解耦應用程序/事件處理程序
將應用邏輯和事件處理程序相分離：一個事件處理程序應該從事件對象中提取，並將這些信息傳送給處理應用邏輯的某個方法中。這樣做的好處首先可以讓你更容易更改觸發特定過程的事件，其次可以在不附加事件的情況下測試代碼，使其更易創建單元測試
性能方面的注意事項
1、盡量使用原生方法
2、switch語句相對if較快
通過將case語句按照最可能到最不可能的順序進行組織
3、位運算較快
當進行數字運算時，位運算操作要比任何布爾運算或者算數運算快
4、巧用||和&&布爾運算符
function eventHandler(e) {
if (!e) e = window.event;
}
//可以替換為：
function eventHandler(e) {
e = e || window.event;
}
if (myobj) {
doSomething(myobj);
}
//可以替換為：
myobj && doSomething(myobj);
避免錯誤應注意的地方
1、每條語句末尾須加分號
在if語句中，即使條件表達式只有一條語句也要用{}把它括起來，以免后續如果添加了語句之后造成邏輯錯誤
2、使用+號時需謹慎
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
3、使用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 中以
標簽前。這樣會降低因加載 JavaScript 代碼而影響頁面中其它組件的加載時間。
永遠不要忽略代碼優化工作，重構是一項從項目開始到結束需要持續的工作，只有不斷的優化代碼才能讓代碼的執行效率越來越好
關於JQ部分
這部分很多其實和原生js的優化原理是一樣的
1.用數組方式來遍歷jQuery 對象集合
如果可以使用復雜的選擇器直接選中元素，就不要使用循環，去一個個辨認元素。
javascript原生循環方法for和while，要比jQuery的.each()方法快，應該優先使用原生方法。
在性能方面，對於jQuery each方法這種優雅實現是有代價的。有一個辦法能夠更快地遍歷一個jQuery對象。就是通過數組來實現，jQuery對象集合就是一個類數組，具有length和value屬性。
2.選擇器優化
選擇器執行速度：id選擇器>class選擇器>后代Class選擇器>后代選擇器>偽類與屬性選擇器
3. 理解子元素和父元素的關系
當父元素已經生成可以鏈式操作時，
最佳選擇是$parent.find('.child')。由於$parent往往在前面的操作已經生成，jQuery會進行緩存，所以進一步加快了執行速度。
當父元素未生成，為選擇元素添加context選擇區域會更快。
$('.child', $('#parent'))
$parent.find('.child')> $('.child', $parent)>$('.child', $('#parent'))>$parent.children('.child')>$('#parent > .child')>$('#parent .child')
(1) $('.child', $parent)
這條語句的意思是，給定一個DOM對象，然后從中選擇一個子元素。jQuery會自動把這條語句轉成$.parent.find('child')，這會導致一定的性能損失。它比最快的形式慢了5%-10%。
(2) $parent.find('.child')
這條是最快的語句。.find()方法會調用瀏覽器的原生方法（getElementById，getElementByName，getElementByTagName等等），所以速度較快。
(3) $parent.children('.child')
這條語句在jQuery內部，會使用$.sibling()和javascript的nextSibling()方法，一個個遍歷節點。它比最快的形式大約慢50%。
(4) $('#parent > .child')
jQuery內部使用Sizzle引擎，處理各種選擇器。Sizzle引擎的選擇順序是從右到左，所以這條語句是先選.child，然后再一個個過濾出父元素#parent，這導致它比最快的形式大約慢70%。
(5) $('#parent .child')
這條語句與上一條是同樣的情況。但是，上一條只選擇直接的子元素，這一條可以於選擇多級子元素，所以它的速度更慢，大概比最快的形式慢了77%。
(6) $('.child', $('#parent'))
jQuery內部會將這條語句轉成$('#parent').find('.child')，比最快的形式慢了23%。
4.有原生方法可以使用的場合，盡量避免使用jQuery
this.id的速度比$(this).attr('id')快了20多倍；
5.做好緩存
使用選擇器的次數應該越少越好，並且盡可能緩存選中的結果，便於以后反復使用。
6.使用鏈式寫法
采用鏈式寫法時，jQuery自動緩存每一步的結果，因此比非鏈式寫法要快。
7.事件的委托處理
8.少改動DOM結構
- 改動DOM結構開銷很大，因此不要頻繁使用.append()、.insertBefore()和.insetAfter()這樣的方法。
如果要插入多個元素，就先把它們合並，然后再一次性插入。根據測試，合並插入比不合並插入，快了將近10倍。 - 如果你要對一個DOM元素進行大量處理，應該先用.detach()方法，把這個元素從DOM中取出來，處理完畢以后，再重新插回文檔。根據測試，使用.detach()方法比不使用時，快了60%。
- 如果你要在DOM元素上儲存數據，不要寫成下面這樣：
var elem = $('#elem');
elem.data(key,value);
而要寫成
var elem = $('#elem');
$.data(elem[0],key,value);
根據測試， 后一種寫法要比前一種寫法，快了將近10倍。因為elem.data()方法是定義在jQuery函數的prototype對象上面的， 而$.data()方法是定義jQuery函數上面的，調用的時候不從復雜的jQuery對象上調用，所以速度快得多。（此處可以參閱下面第10點。）
4. 插入html代碼的時候，瀏覽器原生的innterHTML()方法比jQuery對象的html()更快。
9.選擇作用域鏈最短的方法
Javascript的變量采用鏈式作用域。讀取變量的時候，先在當前作用域尋找該變量，如果找不到，就前往上一層的作用域尋找該變量。因而讀取局部變量比讀取全局變量快得多。