DIV CSS 佈局教程網

深入剖析 jQuery 源碼中的 Callbacks 回調物件設計
編輯:JQuery特效代碼     

程式的本質,往往在於「順序」與「有序」這兩個概念,這在 JavaScript 中尤其明顯——畢竟它是一款單執行緒的引擎。

JavaScript 擁有函數式編程的特性,加上單執行緒的運行模型,我們撰寫的函數總是需要按部就班地執行。優秀的程式碼通常會把功能切割成各自獨立的模組,再在特定條件成立時觸發。既然這些函數是有序執行的,那麼我們為什麼不設計一個統一管理的物件,專門負責協調這些函數呢?於是,Callbacks(回調函數)應運而生。

什麼是 Callbacks

JavaScript 的世界裡處處可見函數編程的身影。最簡單的例子莫過於 window.onload,它承接的就是一個函數。但惱人的是,直接賦值給 window.onload 只能掛上一個函數。如果有好幾個函數都想在頁面載入時執行,我們就得寫出這樣的程式碼:

程式碼如下:

        function a(elem) {
            elem.innerHTML = '我是函數a,我要改變Element的HTML結構';
        };
        function b(elem) {
            elem.innerHTML = '我的函數b,我要改變Element的style';
        }
        window.onload = function () {
            var elem = document.getElementById('test');
            a(elem);
            b(elem);
        };

回調函數的初衷正是建立在這樣的基礎之上:不再讓函數四散在各處,而是把它們統一整理起來。可以看到,我們希望在 window.onload 裡針對同一個 Element 做兩件事——先改變 HTML 結構,再改變它的樣式。這兩個函數操作的都是同一個元素,而它們的執行順序是明確的。既然如此,我們何不設計一個物件來集中管理這些函數呢?

當然,這只是回調函數最基礎的存在意義。我們真正需要的,是一個更強大的回調機制。

Callbacks 的本質就是控制函數有序地執行。JavaScript 是單執行緒引擎,也就是說同一時間只會有一處程式碼在運行——即便是看似非同步的 Ajax 與 setTimeout 也不例外。瀏覽器在執行 JavaScript 時,會把這些程式碼有序地壓入一個佇列,再從佇列中逐一取出執行。Callbacks 正是順應了這種單執行緒引擎的運行特性。

在 jQuery 源碼中,Callbacks 提供了一組函數的基本管理能力,為 Deferred(非同步佇列)奠定了基礎,同時也服務於 Queue(同步佇列)。Deferred 用於抹平大量回調嵌套所產生的「金字塔式」程式碼;而 Queue 則驅動著 jQuery.animate 動畫引擎的運作。

Callbacks 模型

Array(陣列):既然 Callbacks 要承接一系列函數,就必然需要一個容器。我們可以用一個陣列,把每個函數壓入其中,需要執行時再遍歷陣列逐一觸發。

工作模型:這個 Callbacks 需要足夠強大,而不只是「壓入函數、執行函數」這麼簡單,它應該具備良好的執行模型:

once:當前 Callbacks 物件中的所有函數只會執行一次,執行完畢後便會被釋放,確保函數不會重複觸發,讓流程更穩定可靠。

auto:自動執行模型,這是個相當有意思的設計。有些函數依賴上一層函數的結果,例如函數 b 的執行取決於函數 a。我們可以提供這樣的模型:第一次執行 Callbacks 之後,每當有新函數被加入,就自動執行過去已添加的函數,並把最後一次的參數傳遞給它們,從而抹平了依賴函數之間需要反覆觸發的關係。

once&auto:把兩者結合起來就更強大了——每次加入新函數時,過去的函數都會被執行,然後立即釋放;由於 once 模型的關係,下次再加入函數時,這些舊函數不會再被觸發。

API 一覽

add(function):添加一個或多個函數到 Callbacks 物件中。即使你沒有傳入函數,也不會拋出異常。

remove(function):從 Callbacks 中移除指定的函數,為操作提供反悔的餘地。

has(function):判斷 Callbacks 中是否包含某個函數。

empty():清空 Callbacks 中的所有函數,釋放記憶體。

disable():徹底廢棄這個 Callbacks 物件,使其不再可用。

disabled():判斷 Callbacks 是否已被廢棄。

lock(boolean):鎖定 Callbacks 物件,接收一個布林值決定是否鎖定;無參數時則用於查詢目前是否已鎖定。

fire(data):執行 Callbacks 中的函數,傳入的參數會成為這些函數的入參。

fireWith(context,data):執行函數並指定上下文(context)。fire() 中所有函數的上下文都是 Callbacks 物件本身,而 fireWith() 允許你自訂上下文,自由度更高。

fired():判斷 Callbacks 過去是否已經執行過。

基本模組實作

我們先來打造一個最簡單的 Callbacks:

程式碼如下:

(function (window, undefined) {
                var Callbacks = function () {
                     //通過閉包保護這些私有變量
                     var list = [],//回調函數列表
                         fired;//是否執行過
                     //返回一個閉包的Callbakcs對象
                     return {
                        add: function (fn) {
                            //當Callbacks廢棄掉的時候,list為undefined
                           if (list) {
                                //添加一個回調函數
                                list.push(fn);
                            //支持鏈式回調
                        }
                     return this;
                   },
                     fireWith: function (context, data) {
                           //觸發回調函數,並指定上下文
                           if (list) {
                                fired = true;
                                for (var i = 0, len = list.length; i < len; i++) {
                                        //當Callbacks中某一個函數返回false的時候,停止Callbacks後續的執行
                                        if (list[i].apply(context, data) === false)
                                            break;
                            }
                     }
                     return this;
                   },
                     fire: function () {
                           //觸發回調函數
                           //調用fireWith並指定上下文
                     return this.fireWith(this, arguments);
                     },
                     empty: function () {
                           //清空list即可
                           if (list)//當這個Callbacks廢棄掉的時候,Callbacks不應該可以繼續使用
                     list = [];
                     return this;
                     },
                     disable: function () {
                           //廢棄這個Callbacks對象,後續的回調函數列表不再執行
                        list = undefined;
                     return this;
                     },
                     disabled: function () {//檢測這個Callbacks是否已經廢掉
                           //轉換為boolean返回
                     return !list;
                     },
                     fired: function () {//這個callbacks是否執行過
                           return !!fired;
                     }
                     };
                 };
                 //注冊到window下
                 window.Callbacks = Callbacks;
             }(window));

接著我們來測試這個 Callbacks:

程式碼如下:

        var test = new Callbacks();
        test.add(function (value) {
            console.log('函數1,value是:' + value);
        });
        test.add(function (value) {
            console.log('函數2,value是:' + value);
        });
        test.fire('這是函數1和函數2的值');
        console.log('查看函數是否執行過:' + test.fired());
        test.disable();//廢棄這個Callbacks
        console.log('查看函數是否被廢棄:' + test.disabled());
        test.add(function () {
            console.log('添加第三個函數,這個函數不應該被執行');
        });
        test.fire();

打開瀏覽器控制台,可以看到運行結果一切正常。

once 與 auto(memory)模型的實作

once:once 讓 Callbacks 中的函數執行一次後便不再運行。原理很簡單,我們用一個變數保存當前的執行模型,若是 once 模型,就在 fireWith() 裡讓 list 失效即可。

程式碼如下:

(function (window, undefined) {
            var Callbacks = function (once) {
                var list = [],
                     fired;
                return {
                     fireWith: function (context, data) {
                           if (list) {
                                fired = true;
                                for (var i = 0, len = list.length; i < len; i++) {
                                        if (list[i].apply(context, data) === false)
                                        break;
                            }
                     }
                     if (once) list = undefined;
                     return this;
                }
                };
            };
            window.Callbacks = Callbacks;
            }(window));

auto:auto(memory)模型在 jQuery 中以 memory 命名,最初這個命名讓不少人感到困惑,仔細研究用法後才確認它其實就是「自動執行」。它的作用是:第一次 fire() 之後,後續 add() 的函數會自動執行。當你已經添加了一組函數,臨時又想追加一個新函數時,這個新函數會立即被執行——為了使用上的便利,這個模式乍看之下確實有點難以理解。

實作關鍵在於:add() 時判斷是否為 auto 模型,若是則執行該函數。但要注意,只有在第一次 fire() 之後才會自動執行,且每次自動執行時都要把最後一次的參數傳遞過去。

jQuery 在這裡採用了一個相當巧妙的用法:讓 auto 變數不僅表示「當前是否為 auto 執行模式」,同時作為「最後一次參數的容器」。它既是 auto,也是 memory,一石二鳥。(以下程式碼依據 jQuery 思路改寫,非原始碼)

程式碼如下:

(function (window, undefined) {
            var Callbacks = function (auto) {
                var list = [],
                     fired,
                     memory,
                     coreFire = function (data) {
                        if (list) {
                            memory = auto && data;
                            fired = true;
                            for (var i = 0, len = list.length; i < len; i++) {
                                if (list[i].apply(data[0], data[1]) === false)
                                   break;
                            }
                     }
                     };
                return {
                     add: function (fn) {
                        if (list) {
                            list.push(fn);
                            if (memory) coreFire(auto);
                        }
                     return this;
                     },
                     fireWith: function (context, data) {
                        coreFire([context, data]);
                     return this;
                     }
                     };
            };
            window.Callbacks = Callbacks;
            }(window));

在 jQuery 的設計中,它並不是在 add() 時給 auto(memory)賦值,而是選擇在 coreFire() 中賦值,這樣就能保證只有在第一次 fire() 之後才開啟自動執行。coreFire() 接收的參數是一個陣列,第一項是上下文,第二項是外部傳入的參數,並把整個陣列賦值給 auto,於是 auto 的定義就搖身一變成了 memory(記憶最後一次傳遞的參數)。這正是 auto 這個命名的鬼斧神工之處,值得我們仔細品味。

至於 once&auto 的組合,只需把兩段邏輯揉合在一起:在 coreFire() 裡判斷,如果是 auto 模式就把 list 重置為新陣列,否則直接設為 undefined 即可。

完整源碼

以下這份程式碼是對照 jQuery 手寫的版本,將一些 jQuery 公用函數也一併寫了進來,並非片段,因此可以直接引用運行。

程式碼如下:

(function (window, undefined) {
    var isIndexOf = Array.prototype.indexOf,
        toString = Object.prototype.toString,
        toSlice = Array.prototype.slice,
        isFunction = (function () {
            return "object" === typeof document.getElementById ?
            isFunction = function (fn) {
                try {
                   return /^\s*\bfunction\b/.test("" + fn);
                } catch (x) {
                   return false
                }
            } :
            isFunction = function (fn) { return toString.call(fn) === '[object Function]'; };
        })(),
        each = function () {
            if (arguments.length < 2 || !isFunction(arguments[1])) return;
            var list = toSlice.call(arguments[0]),
            fn = arguments[1],
            item;
            while ((item = list.shift())) {
                fn.call(window, item);
            }
        },
        inArray = function () {
            return isIndexOf ? function (array, elem, i) {
               if (array)
                   return isIndexOf.call(array, elem, i);
               return -1;
            } : function (elem, array, i) {
                var len;
                if (array) {
                   len = array.length;
                   i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
                   for (; i < len; i++) {
                     if (i in array && array[i] === elem) {
                        return i;
                     }
                }
               }
            return -1;
            }
        }();

    var Callbacks = function (option) {
        option = toString.call(option) === '[object Object]' ? option : {};
        var list = [],
          _list = [],
          fired,
          firingStart,
          firingLength,
          auto,
          stack = !option.once && [],
          firing = false,
          fire = function (data) {
                auto = option.auto && data;
                fired = true;
                firingIndex = firingStart || 0;
                firingStart = 0;
                firingLength = list.length;
                firing = true;
                for (; firingIndex < firingLength; firingIndex++) {
                    if (list[firingIndex].apply(data[0], data[1]) === false) {
                        auto = false;
                        break;
                     }
                firing = false;
                if (stack) {
                    if (stack.length)
                      fire(stack.shift());
                }
                else if (auto)
                   list = [];
                else
                self.disable();
            };
        var self = {
            add: function () {
                if (list) {
                   var start = list.length;
                   (function addCallback(args) {
                      each(args, function (item) {
                         if (isFunction(item)) {
                             list.push(item);
                         } else if (toString.call(item) === '[object Array]') {
                         addCallback(item);
                         }
                     });
                   })(arguments);
                }
                if (firing)
                   firingLength = list.length;
                else if (auto) {
                   firingStart = start;
                   fire(auto);
                }
                return this;
            },
            fire: function () {
                self.fireWith(this, arguments);
                return this;
            },
            fireWith: function (context, args) {
                if (list && (!fired || stack)) {
                   args = [context,
                      args ?
                      args.slice && args.slice()
                      || toSlice.call(args) :
                     []
                     ];
                     fire(args);
                }
                return this;
            },
            remove: function () {
                if (list) {
                   each(arguments, function (item) {
                      var index;
                      while ((index = inArray(item, list, index)) > -1) {
                        list.splice(index, 1);
                        if (firing) {
                           if (index <= firingLength)
                             firingLength--;
                           if (index <= firingLength)
                           firingIndex--;
                        }
                     }
                });
                }
                return this;
            },
            has: function (fn) {
                return fn ? inArray(fn, list) > -1 : list && list.length;
                },
            empty: function () {
                list = [];
                firingLength = 0;
                return this;
            },
            disable: function () {
                list = stack = auto = undefined;
                return this;
            },
            disabled: function () {
                return !list;
            },
            lock: function (isLock) {
                if (isLock == null) return !!_list;
                if (isLock) {
                   _list = stack && list.concat(stack) || list;
                   list = undefined;
                } else {
                   list = _list;
                   _list = undefined;
                }
                return this;
            },
            fired: function () {
                return !!fired;
            }
        };
        return self;
    };
    window.$ = window.$ || {};
    window.$.Callbacks = window.Callbacks = Callbacks;
    }(window));

原始碼下載

Github:https://github.com/linkFly6/linkfly.so/blob/master/LinkFLy/jQuery/jQuery.LinkFLy/Callbacks.js

以上就是本文為大家分享的全部內容,希望對喜愛研究 jQuery 源碼的朋友有所幫助。

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