DIV CSS 佈局教程網

jQuery 1.5源碼導讀:寫給中高階JS開發者的閱讀地圖
編輯:JQuery特效代碼     

jQuery 的各種功能彼此高度耦合,很難只抽出一塊來單獨理解。這篇文章分享讀 jQuery 源碼的心得,以及一套實際可行的閱讀方法。啃程式碼這件事沒有捷徑,但有章法之後效率會差很多。

1. 折疊程式碼是必須的

請務必用支援語法折疊的編輯器開啟源碼。從折疊層次一眼就能看出,整份 jQuery 其實都包在一個函式裡:

(function( window, undefined ) {
// jQuery 代碼

})(window);

這樣做有兩個好處:避免內部物件污染全域;把 window 與 undefined 當參數傳入,則是為了加快這兩個物件的搜尋速度——同時也順便解決了「舊環境下 undefined 可能被改寫」的隱患。

2. 打開第一層折疊

展開第一層後,可以發現 jQuery 是按這個順序組織的:

  • 定義 jQuery 函式(20 - 1081 行)
  • 產生 jQuery.support(1083 - 1276 行)
  • data 相關擴充(1279 - 1510 行)
  • 隊列相關擴充(1514 - 1605 行)
  • 屬性相關擴充(1609 - 1988 行)
  • 事件相關擴充(1993 - 3175 行)
  • 內部的 Sizzle CSS Selector Engine(3183 - 4518 行)
  • 節點相關擴充(4520 - 5492 行)
  • 樣式相關擴充(5497 - 5825 行)
  • ajax 相關擴充(5830 - 7172 行)
  • 效果相關擴充(7176 - 7696 行)
  • 定位相關擴充(7700 - 8065 行)

這個順序不是隨意的:下面的模組可以用上面的,上面的模組不需要下面的。理解這條依賴鏈,就掌握了閱讀的先後次序。

3. 定義 jQuery 函式(20 - 1081 行)

整段的骨架大致如下:

var jQuery = (function() {
 // 創建 jQuery 對象
var jQuery = function( selector, context ) {
 // 略

 };

 // 創建 jQuery.fn 對象
 jQuery.fn = jQuery.prototype = {
 // 略
 };

 // 聲明 jQuery.extend
 jQuery.extend = jQuery.fn.extend = function() {
 // 略
 };

 // 使用 jQuery.extend 擴展自己
 jQuery.extend({
 // 略

 });

 // 浏覽器方面的一些瑣碎
 // 略

 // 定義全局對象
 return (window.jQuery = window.$ = jQuery);

})();

第一個結論就出來了:我們平常用的 $,其實只是 jQuery 函式的別名。

3.1 jQuery 物件(23 - 26 行)

var jQuery = function( selector, context ) {
 // 實際上 jQuery 對象是 jQuery.fn.init 返回的。
 return new jQuery.fn.init( selector, context, rootjQuery );
}

也就是說,想知道 jQuery 到底是什麼,就必須去看 jQuery.fn.init。這同時解釋了為什麼寫程式時不需要 new jQuery。

再看 29 - 97 行,都是變數宣告,供後續函式使用。提前提取變數有兩個好處:正則表達式不必重複編譯,壓縮後的結果也更小。

3.2 jQuery.fn 物件(99 - 320 行)

fn 就是 jQuery.prototype,這正是「jQuery.fn 是擴充 jQuery 物件的唯一途徑」的原因。

你可能會疑惑:jQuery 回傳的是 new jQuery.fn.init,那原型應該是 jQuery.fn.init.prototype 才對,怎麼會是 jQuery.prototype?答案很乾脆——第 322 行明確寫著 jQuery.fn.init.prototype === jQuery.prototype。

把關係整理清楚:

  • jQuery 是個普通函式,回傳 jQuery.fn.init 的實例。
  • jQuery.fn === jQuery.prototype === jQuery.fn.init.prototype。
  • 因此 jQuery 回傳物件的成員,與 jQuery.fn 的成員完全對應。

jQuery.fn 下的主要成員:

  • init — 初始化(後述)
  • constructor — 手動指定建構函式,預設是 jQuery.fn.init
  • length — 讓這個物件更接近原生陣列
  • size — 回傳 length
  • toArray — 透過 Array.prototype.slice 轉成真陣列
  • get — 即 this[num],另外處理了索引參數的邊界
  • pushStack — 推入一個元素堆疊
  • ready — 瀏覽器就緒後執行(後述)
  • end — 透過 prevObject 退回上一層
  • each — 例遍,可參考 https://www.cnblogs.com/Fooo/archive/2011/01/11/1932900.html 與 https://www.cnblogs.com/rubylouvre/archive/2009/11/21/1607632.html

3.3 jQuery.fn.init(101 - 211 行)

這就是俗稱的 $ 函式。平常寫的 $("#id"),等同於 new jQuery.fn.init("#id")。

函式很長,但分支覆蓋率其實不高:

 init: function( selector, context, rootjQuery ) {
 // 參數: selector 選擇器
 // context 上下文
 // rootjQuery 父節點

 // 處理 $("")、 $(null) 和 $(undefined)
 if ( !selector ) {
 return this;
 }

 // 處理 $(DOMElement)
 if ( selector.nodeType ) {

 // 直接扔數組中, 就搞定了。
 this.context = this[0] = selector;
 this.length = 1;
 return this;
 }

 // 處理 $("body") body 元素只存在一次,單獨找它
 if ( selector === "body" && !context && document.body ) {

 // 同樣扔數組中, 順便把 selector 更新更新。
 this.context = document;
 this[0] = document.body;
 thisis.selector = "body";
 this.length = 1;
 return this;
 }

 // 處理 $(HTML 代碼 或者是 css 選擇器)
 if ( typeof selector === "string" ) {
 // 略

 // 處理 $(函數)
 } else if ( jQuery.isFunction( selector ) ) {

 // 如果是函數,則執行 $(document).ready , 這樣 $(document).ready(func) 簡為 $(func)
 return rootjQuery.ready( selector );
 }

 // 略。

 // 如果傳入的是一個 Dom列表 ( getElementsByTagName 結果 ) 則轉為 jQuery 數組。
 return jQuery.makeArray( selector, this );
}

接著是「略」掉的那段字串處理:

// 這部分代碼是 上段中 略 的 也就是說是 jQuery(字符串) 處理。

// 檢查是否字符串是常用選擇器 (/^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/)
match = quickExpr.exec( selector );

 // 檢查是否正確匹配
 if ( match && (match[1] || !context) ) {

 // 處理: $(html) -> $(array)
 if ( match[1] ) {

 // 獲取正文,默認 document
 context = context instanceof jQuery ? context[0] : context;
 doc = (context ? context.ownerDocument || context : document);

 // 如果傳入簡單的 "<標簽>", ( /^<(\w+)\s*\/?>(?:<\/\1>)?$/)
 ret = rsingleTag.exec( selector );

 // 返回 createElement("tag")

 return jQuery.merge( this, selector );

 // 處理: $("#id")
 } else {
 elem = document.getElementById( match[2] );

 // 因為有的浏覽器 getElementById 不只返回 id匹配的,所以做檢查。
 return this;
 }

 // 處理 $("標簽")
 } else if ( !context && !rnonword.test( selector ) ) {
 this.selector = selector;
 this.context = document;
 selector = document.getElementsByTagName( selector );
 return jQuery.merge( this, selector );

 //處理: $(選擇器, $(...))
 } else if ( !context || context.jquery ) {
 return (context || rootjQuery).find( selector );

 // 處理: $(選擇器, 上下文)
 // (相當於: $(上下文).find(選擇器)
 } else {
 return this.constructor( context ).find( selector );
 }

3.4 jQuery.fn.extend(324 - 386 行)

用於擴充函式。內部有多重參數判斷,目的是讓呼叫方式更靈活,基本原理就是 for (in)。

3.5 jQuery.noConflict(389 - 399 行)

noConflict: function( deep ) {
 window.$ = _$;

 if ( deep ) {
 window.jQuery = _jQuery;
 }

 return jQuery;
 },

讓 jQuery 把 $(以及可選的 jQuery)還給其他函式庫。

3.6 jQuery.ready(407 - 481 行)

裡面有兩個函式:jQuery.ready 負責觸發 readyList 中的所有函式,jQuery.bindReady 則負責讓 ready 能成功執行。

bindReady: function() {

 // 如果已經執行 bindReady 則返回。
 if ( readyBound ) {
 return;
 }

 readyBound = true;

 // 如果頁面已經加載, 馬上執行 jQuery.ready
 if ( document.readyState === "complete" ) {
 return setTimeout( jQuery.ready, 1 );
 }

 // 標准浏覽器支持 DOMContentLoaded
 if ( document.addEventListener ) {
 // 你懂的
 document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );

 // 為什麼還要 load ? , 因為有些時候 DOMContentLoaded 失敗(如 iframe) ,而 load 總是會成功, 所以,同時處理 DOMContentLoaded load, 在 jQuery.ready 中會刪除監聽函數,保證最後這個函數只執行一次
 window.addEventListener( "load", jQuery.ready, false );

 // IE浏覽器( IE 8 以下)
 } else if ( document.attachEvent ) {

 // 使用 onreadystatechange
 document.attachEvent("onreadystatechange", DOMContentLoaded);

 // 同理
 window.attachEvent( "onload", jQuery.ready );

 // 如果 IE 下且非 iframe, 這裡有個技巧。 見 doScrollCheck();
 // 原理: 浏覽器在沒加載時 設置 scrollLeft 會錯誤,所喲每隔1秒廁所 是否 scrollLeft 成功,如果發現成功,則執行 jQuery.ready 。但這只對非 frame 會有用。
 var toplevel = false;

 try {
 toplevel = window.frameElement == null;
 } catch(e) {}

 if ( document.documentElement.doScroll && toplevel ) {
 doScrollCheck();
 }
 }
 },

那個 IE 專用的 doScrollCheck 是經典 hack:利用「頁面未就緒時設定 scrollLeft 會失敗」這個特性,輪詢到成功為止。而 bindReady 是等到真正需要時才執行(1.4 之前是無條件執行),屬於效能上的小優化。

4. jQuery.support(1083 - 1276 行)

它解決了大量跨瀏覽器相容問題,做法是基于「特性檢測」而非判斷瀏覽器版本:建立一個元素,看它是否符合某些預期行為。例如測試是否支援 checkOn,就先設 check = 'on',再看讀出來是否等於 'on'。這種思路比 navigator.userAgent 可靠得多。

5. data 相關擴充(1279 - 1510 行)

jQuery.data() 用於存放一個字典,資料最終存在 jQuery.cache(1283 行),而全域物件則放在 windowData(1279 行)。

問題是:拿到一個物件之後,怎麼找到它在 cache 裡的對應項?答案就是 expando 字串。以物件 elem 為例,滿足:

elem.expando = "jQuery12321";

那麼 jQuery.cache["jQuery12321"] 就是存放該 elem 資料的物件。嚴格來說,鍵值並不是 elem.expando,而是 elem[jQuery.expando]。

由於每個物件的資料本身又是一個字典,所以執行 jQuery.data(elem, 'events') 之後,實際存取的位置是 jQuery.cache[elem[jQuery.expando]]['events']。

6. 隊列相關擴充(1514 - 1605 行)

隊列是 1.5 新增的機制,主要用在特效這類需要排隊等待執行的場合,核心操作就是進隊 queue 與出隊 dequeue。

隊列內部的資料狀態變化如下。尚未執行時:

[將執行的1, 將執行的2]

開始執行〈將執行的1〉,若 type 為空或 "fx",隊列變成:

["inprogress", 將執行的2]

執行完之後:

["將執行的2]

這些狀態都存在 jQuery.data(obj, (type || "fx") + "queue")(1520 - 1522 行)。而 jQuery.delay 則是延時執行,相當於把隊列更新成 setTimeout 之後的結果(1589 - 1598 行)。

7. 屬性相關擴充(1609 - 1988 行)

從這裡開始要先理解 jQuery.access。對於 attr、css 這類函式,取值時只回傳第一個元素的結果,設值時則作用於所有元素——這個神奇效果全靠 jQuery.access(794 - 819 行)完成。

jQuery 大部分函式都依賴它:對使用者而言呼叫的是 jQuery.fn.XX,而這個函式需要對多個元素操作,透過 access 轉換之後,最後只需寫「對單一元素的操作」,通常就是 jQuery.XX。這也解釋了為什麼我們常同時看到 jQuery.XX 與 jQuery.fn.XX——前者是底層實作,後者是給使用者用的便利工具。

jQuery.fn.attr(1632 - 1634 行)只有一句話,真正的實作在 jQuery.attr(1880 - 1988 行),又是一個百行以上的大函式:

attr: function( elem, name, value, pass ) {
 // 檢查是否為 nodeType 為 Element
 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || elem.nodeType === 2 ) {
 return undefined;
 }

 // 如果這個屬性需要特殊對待。 height/width/left 等屬性需特殊計算
 if ( pass && name in jQuery.attrFn ) {
 return jQuery(elem)[name](value);
 }

 // 檢查是否為 XML 還 HTML
 var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
 // Whether we are setting (or getting)
 set = value !== undefined;

 // 修正名字, 比如 float 改 cssFloat
 name = notxml && jQuery.props[ name ] || name;

 // 只有在節點的時候執行。
 if ( elem.nodeType === 1 ) {
 // 在 IE7- 下, href src 屬性直接獲取會返回絕對位置,而不是真實的位置字符串,
 // 要獲得它們的真實值,需要 elem.getAttribute("href", 2);
 var special = rspecialurl.test( name );

 // Safari 誤報默認選項。通過獲取父元素的已選擇索引來修復。
 if ( name === "selected" && !jQuery.support.optSelected ) {
 var parent = elem.parentNode;
 if ( parent ) {
 parent.selectedIndex;

 // 對 optgroups ,同理
 if ( parent.parentNode ) {
 parent.parentNode.selectedIndex;
 }
 }
 }

 // 檢查屬性是否存在, 有些時候 name in elem 會失敗,所以多次測試。
 if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {

 // 如果設置屬性
 if ( set ) {
 // 在IE, 不能設置屬性 type 。
 if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
 jQuery.error( "type property can't be changed" );
 }

 // 如果 value === null, 表示移除屬性
 if ( value === null ) {
 if ( elem.nodeType === 1 ) {
 elem.removeAttribute( name );
 }

 } else {

 // 一切屬性設置就是1句話。。。
 elem[ name ] = value;
 }
 }

 // 表單索引元素獲取需要 getAttributeNode( name ).nodeValue
 if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
 return elem.getAttributeNode( name ).nodeValue;
 }

 // elem.tabIndex 特殊處理
 if ( name === "tabIndex" ) {
 var attributeNode = elem.getAttributeNode( "tabIndex" );

 return attributeNode && attributeNode.specified ?
 attributeNode.value :
 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
 0 :
 undefined;
 }

 return elem[ name ];
 }

 // 處理 style 屬性
 if ( !jQuery.support.style && notxml && name === "style" ) {
 if ( set ) {
 elem.style.cssText = "" + value;
 }

 return elem.style.cssText;
 }

 if ( set ) {
 // 這裡除了 IE, 其它屬性使用標准 setAttribute
 elem.setAttribute( name, "" + value );
 }

 // 如果屬性不存在,返回 undefined, 而不是 null 或 "" 之類的。
 if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
 return undefined;
 }

 // 見上
 var attr = !jQuery.support.hrefNormalized && notxml && special ?
 // Some attributes require a special call on IE
 elem.getAttribute( name, 2 ) :
 elem.getAttribute( name );

 // 同上
 return attr === null ? undefined : attr;
 }
 // 如果不是 DOM 元素,檢查處理。
 if ( set ) {
 elem[ name ] = value;
 }
 return elem[ name ];
 }

8. 事件相關擴充(1993 - 3175 行)

8.1 事件綁定

平常呼叫的 click(func) 之類都只是工具函式,真正與事件掛鉤的是:

  • jQuery.fn.bind → 呼叫 jQuery.event.add
  • jQuery.fn.unbind → 呼叫 jQuery.event.remove
  • jQuery.fn.trigger → 呼叫 jQuery.event.trigger
  • jQuery.fn.one → 呼叫 jQuery.fn.bind 與 jQuery.fn.unbind

想理解事件原理,必須讀 jQuery.event.add(2012 - 2155 行):

add: function( elem, types, handler, data ) {

 // 只對節點操作。
 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
 return;
 }

 // IE 無法傳遞 window,而是復制這個對象 。
 if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
 elem = window;
 }

 // 如果 handler === false, 也就是說就是阻止某事件,
 // 這樣只要 bind("evt", false); 就是阻止此事件。
 if ( handler === false ) {
 handler = returnFalse;
 } else if ( !handler ) {
 return;
 }

 // handleObjIn 是內部處理句柄, handleObj 是直接使用的處理句柄。
 var handleObjIn, handleObj;

 if ( handler.handler ) {
 handleObjIn = handler;
 handler = handleObjIn.handler;
 }

 // 為函數生成唯一的 guid 。具體下面介紹。
 if ( !handler.guid ) {
 handler.guid = jQuery.guid++;
 }

 // 獲取一個節點的數據。
 var elemData = jQuery.data( elem );

 // 如果沒有數據,則直接返回。
 if ( !elemData ) {
 return;
 }

 // 避免和原生的js對象混淆。
 var eventKey = elem.nodeType ? "events" : "__events__",

 // 這裡就是關鍵。
 // elemData 是存儲數據的位置, 而 elemData[ eventKey ] 就是存儲當前事件的對象。 elemData.handle 就是當前綁定的所有函數數組。
 // 也就是說,當我們綁定一個函數時,會往 elemData.handle 放這個函數,然後事件觸發時,會遍歷 elemData.handle 中函數然後去執行。
 // 肯能有人會問,為什麼這麼做,因為原生的DOM內部也有一個 函數數組,事件觸發後會執行全部函數。答案還是 兼容。
 // 標准浏覽器使用 addEventListener
 // IE 使用 attachEvent
 // 而這2者還是有差距的。因為 addEventListener 執行函數的順序即添加函數的順序,然而 attachEvent 執行函數的順序和添加的順序是相反的。
 // jQuery 使用自定義的 handler 數組,好處有:
 // 因為最後僅綁定一次原生事件,事件觸發後,手動執行 數組中的函數。這樣保證兼容。
 // 同時也可以知道到底綁定了什麼函數,可以方便 trigger 函數的完成。

 events = elemData[ eventKey ],
 eventHandle = elemData.handle;

 // 一些功能。。
 if ( typeof events === "function" ) {
 eventHandle = events.handle;
 events = events.events;

 } else if ( !events ) {
 if ( !elem.nodeType ) {
 elemData[ eventKey ] = elemData = function(){};
 }

 elemData.events = events = {};
 }

 // 如果是第一次執行,需創建 eventHandle
 if ( !eventHandle ) {

 // eventHandle 就是真正綁定到原生事件的那個函數,這個函數用來執行events.hadlers 用。
 elemData.handle = eventHandle = function() {
 // Handle the second event of a trigger and when
 // an event is called after a page has unloaded
 return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
 jQuery.event.handle.apply( eventHandle.elem, arguments ) :
 undefined;
 };
 }

 // 綁定函數和原生,這樣可以保證函數可執行為目前作用域。
 eventHandle.elem = elem;

 // 處理 jQuery(...).bind("mouseover mouseout", fn);
 types = types.split(" ");

 var type, i = 0, namespaces;

 while ( (type = types[ i++ ]) ) {
 handleObj = handleObjIn ?
 jQuery.extend({}, handleObjIn) :
 { handler: handler, data: data };

 // 略

 // 綁定 type guid
 handleObj.type = type;
 if ( !handleObj.guid ) {
 handleObj.guid = handler.guid;
 }

 // 獲取當前的函數數組。
 var handlers = events[ type ],
 special = jQuery.event.special[ type ] || {};

 // 如果第一次,則創建這個數組。
 if ( !handlers ) {
 handlers = events[ type ] = [];

 // 特殊事件要執行 setup 而不是標准 addEventListener。
 // 此行用來支持自定義的事件。
 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
 // 標准事件。 這裡綁定的為 eventHandle
 if ( elem.addEventListener ) {
 elem.addEventListener( type, eventHandle, false );

 } else if ( elem.attachEvent ) {
 elem.attachEvent( "on" + type, eventHandle );
 }
 }
 }

 // 自定義事件,執行 add
 if ( special.add ) {
 special.add.call( elem, handleObj );

 if ( !handleObj.handler.guid ) {
 handleObj.handler.guid = handler.guid;
 }
 }

 // 不管是不是首次,都放入目前綁定的函數。
 handlers.push( handleObj );

 // 為實現 trigger 。
 jQuery.event.global[ type ] = true;
 }

 // 讓IE下可以正常回收 elem 內存。
 elem = null;
 },

這段最關鍵的設計是「只綁一次原生事件」。原生 DOM 本來也有函式陣列,但 addEventListener 依註冊順序執行,IE 的 attachEvent 卻是相反順序。jQuery 乾脆自己維護一個 handler 陣列,事件觸發後手動遍歷執行,既統一了順序,也讓 trigger 能知道究竟綁了哪些函式。

8.2 事件物件

框架的責任之一也包括修正事件參數。jQuery 自訂了 jQuery.Event(2583 - 2610 行)來模擬原生事件物件:

jQuery.Event = function( src ) {
 // 支持 沒有 new jQuery.Event
 if ( !this.preventDefault ) {
 return new jQuery.Event( src );
 }

 // 略

}

搭配 jQuery.event.fix(2470 - 2527 行)使用,把 IE 的 window.event 補齊成標準介面。

8.3 特殊(自訂)事件

都定義在 jQuery.event.special(2537 - 2567 行),預設有 ready、live、beforeunload。特殊事件是 jQuery 內部特別處理的事件,可自訂綁定、新增、刪除與觸發的行為。

8.4 觸發事件

程式碼在 2292 - 2403 行,目的是模擬觸發某事件,並支援冒泡。可參考 https://www.cnblogs.com/rooney/archive/2008/12/03/1346449.html

9. Sizzle 選擇器引擎(3183 - 4518 行)

專門解釋選擇器的文章已經很多,這裡不贅述。可參考 https://www.cnblogs.com/rooney/archive/2008/12/02/1346135.html 與 https://www.cnblogs.com/rubylouvre/archive/2009/11/23/1607917.html

10. 節點相關擴充(4520 - 5492 行)

parent、next 這類查找節點的工具都屬於這塊。它們都依賴 jQuery.fn.nth(),透過關係找到下一個節點,若是 Element 就回傳,否則繼續找。

10.1 clone(5010 - 5037 行)

1.5 的 clone 與 Mootools 一樣採用 cloneFixAttributes(5196 - 5225 行)。其中 cloneCopyEvent 不是複製 data,而是依 data 重新執行 bind;cloneFixAttributes 則先 clearAttributes 再 mergeAttributes(IE 專用),以確保屬性正確拷貝。

10.2 jQuery.buildFragment(5276 - 5308 行)

按 HTML 字串產生節點,也就是 $("複雜 html") 背後做的事,這裡用到了不常見的 document.createDocumentFragment()。

10.3 evalScript(5478 - 5492 行)

遇到 <script> 就交給 jQuery.globalEval 全域執行。之所以不直接塞進 head,是因為單獨插入 script 標籤容易造成記憶體洩漏。

10.4 clean(5340 - 5433 行)

清除元素的內容子節點。可參考 https://www.cnblogs.com/70buluo/archive/2009/06/03/1495040.html 與 https://www.cnblogs.com/rooney/archive/2008/12/02/1346135.html

11. 樣式相關擴充(5497 - 5825 行)

讀取元素的 CSS 屬性一直是件麻煩事。jQuery 先把少數屬性單獨處理,其餘則用 style[name] || (IE ? getComputedStyle(...).getProperty(name) : elem.currentStyle[name]) 的方式取值,並做一些相容處理。細節可參考 https://www.cnblogs.com/rubylouvre/archive/2009/09/05/1559883.html 與 https://www.cnblogs.com/rubylouvre/archive/2009/11/21/1607255.html

12. ajax 相關擴充(5830 - 7172 行)

1.5 重寫了整个 ajax 模組。值得注意的是,它並非直接依賴元素上的 onreadystatechange,而是自己維護一個輪詢機制,每隔十幾毫秒檢查一次 readyState 是否變化。可參考 https://www.cnblogs.com/qleelulu/archive/2008/04/21/1163021.html

13. 效果相關擴充(7176 - 7696 行)

可參考 https://www.cnblogs.com/rooney/archive/2008/12/03/1346475.html

這裡補充說明動畫的數學原理。大家都知道特效靠 setTimeout,但具體怎麼算?

假設運動是均勻的,從 x = x1 出發,在 dt 時間內移動到 x2。為了方便計算,引入一個 delta,滿足「當前位置 = x1 + (x2 - x1) × delta」。這樣一來,動畫開始時 delta = 0,結束時 delta = 1——無論 x1、x2 差距多大,計算都收斂到 delta 上。

delta 隨時間變化,即 delta = f(t)(0 < t < dt)。每畫一幀就把 t 加一,重新算出 delta 與 x。若要一秒顯示 fps 幀,就是每 1000/fps 毫秒更新一次:

var t = 0, f = 某個變換;

setInterval(function(){

 var delta = f(t);

 var x = x1 + (x2 - x1) * dalta;

 // 更新顯示 x

 t++;

}, 1000 / fps);

接著說明 f 是什麼。f 的輸入是時間、輸出是 delta,且 f(0) = 0、f(dt) = 1。任一時刻下 delta = (x - x1) / (x2 - x1),當 x 從 0 走到 x、t 從 0 走到 dt,根據微分的意義,f 其實就是 x 對 t 的導函數。

若是 x = k · t 的均勻運動(k = (x2 - x1) / dt),則 f 為常數;若是 x = k · t² 的拋物線,則 f = 2k · t。一般情況會用 sin 函式讓變化更柔和,所以 jQuery 預設採用 sin 變換:

x = sin( t - 3π/2) ( 最低點 )

f = x' = -(cos( πt ) - 1) / 2

(第 7477 行)

14. 定位相關擴充(7700 - 8065 行)

jQuery.offset 負責管理定位,其餘多為工具程式。jQuery.offset.initialize 測試瀏覽器的定位法則;jQuery.offset.bodyOffset 取得 body 的定位(因與其他元素不同而單獨測試);核心的 jQuery.fn.offset 回傳絕對位置,新瀏覽器直接用 getBoundingClientRect,否則自己遍歷父元素把相對位置累加。

jQuery.fn.position 回傳的值等同 style.left,算法是先算 offset 與父節點(offsetParent)的 offset,兩者相減即得偏移量。可參考 https://www.cnblogs.com/xuld/archive/2011/02/13/1953907.html

15. 總結

讀源碼時最好對照程式碼逐段理解。jQuery 雖然龐大,但程式碼可讀性相當不錯。解讀源碼的最終目的是为了更好地使用它——知道內部怎麼運作之後,自然就明白它為什麼能做這麼多事。

不過 jQuery 並不是唯一的選擇。在讚嘆它設計之餘,也該看看個性截然不同的框架,例如 Mootools,對照著讀往往能有更多收穫。

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