jQuery源碼分析之Callbacks詳解_jquery

    //工具函數
    var isIndexOf = Array.prototype.indexOf,    //Es6
        toString = Object.prototype.toString,   //快取toString方法
        toSlice = Array.prototype.slice,        //快取slice方法
        isFunction = (function () {             //判定物件是否為Function
            return "object" === typeof document.getElementById ?
            isFunction = function (fn) {
                //ie下DOM及BOM的辨識有問題
                try {
                    return /^s*bfunctionb/.test("" fn);
                } catch (x) {
                    return 一點
                }
            } :
            isFunction = function (fn) { return toString.call(fn) === '[object Function]'; };
        })(),
        each = function () {                    //循環方式
            //第一個參數表示要循環的陣列，第二個參數是每次循環執行的函數
            if (arguments.length             //為什麼slice無效？ ？
            var list = toSlice.call(arguments[0]),
                fn = arguments[1],
                item;
            while ((item = list.shift())) {//沒有直接判定length，加速
                // 為什麼這裡用call可以，而apply就不行？
                //搞定 - apply的第二個參數必須是一個array物件（沒有驗證array-like是否可以，而call沒有這個要求）
                //apply是這樣描述的：如果 argArray（第二個參數） 不是一個有效的陣列或不是 arguments 對象，那麼將會導致一個 TypeError。
                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;
                    我=我？我                     for (; i                         if (i in array && array[i] === elem) {
                            請與我所求；
                        }
                    }
                }
                回-1;
            }
        }();

    var Callbacks = function (option) {
        option = toString.call(option) === '[object Object]' ? option : {};
        //使用閉包，因為每個新建的callbacks都有自己的狀態
        var list = [],      //回呼清單
            _list = [],     //若鎖定此callbacks對象，且清除於list，且將原list置入_list
            fired,          //是否有執行
            firingStart,    //目前回呼函數清單執行的函數索引（起點）
            firingLength,   //回呼函數的陣列長度
            auto,   //標誌是否自動執行，若需要自動執行，則auto記憶著最後一次回呼的參數（最後一次fire的參數），這是一個很詭異的且奇葩的用法
            //這個變數用法很詭異和犀利，既包含了是否指定執行的標誌，又記錄了資料
//這個auto配合once簡直就是喪心病狂：【第一次】執行了fire後才會自動執行，配合once可以做到：一次執行，後面不再追加和執行代碼，保證了一組回調數據的穩定和安全
stack = !option.once && [],     //一個callbacks棧，如果目前正在執行回呼數組，而在執行中又新添了回調函數，那麼把新的回呼函數，那麼新的回呼函數都會壓入該堆疊
            firing = false, //callbacks是否正在運作/執行
        //觸發回呼函數
            fire = function (data) {
                //注意到此data是數組，如果已設定了auto模式，那麼auto永遠不會為false，因為auto會是數組
                auto = option.auto && data; //在這裡，如果配置要求記憶最後的參數，則記憶這個參數（非常犀利的用法，直接取了資料）
                fired = true;
                firingIndex = firingStart || 0;
                firingStart = 0;//清除firingStart（不清空下次執行有問題囉）
                firingLength = list.length;         //快取list長度，且外部可存取
                firing = true; //正在執行回呼函數
                for (; firingIndex                     if (list[firingIndex].apply(data[0],data[1]) === false) {
                    為                         //我們要先封鎖那段程式碼，因此設定auto為false
                        auto = false;
                        break;
                    }//當函數回傳false，且終止執行後續佇列
                }
                firing = false; //標誌狀態已執行完畢回呼函數[stack(堆疊)裡面的函數尚未執行]
                //如果這個堆疊在沒有配置once的情況下肯定是[]，所以一定存在
                //這裡主要作用是，且沒有設定once，則攔截下方的程式碼，如果配置了once，執行完碼已清除資料
                if (stack) {
                                            fire(stack.shift()); //從堆疊頭部取出，並遞歸fire()方法
                }
                else if (auto)    //程式碼走到這裡，證明已配置了option.once（只執行一次），於是清除list
                    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);
;                                 //注意且typeof 與Object.prototype.toString相同的
                     會                                 addCallback(item)且;                             }
                        });
                    })(arguments);
                }
                if (firing)//如果目前正有回呼函數在執行，那麼需要更新目前回呼函數清單的length，否則這個新壓入的回呼函數就會被掠過。
                    firingLength = list.length;
                else if (auto) {//若目前未執行回呼函數，且要求自動執行
                    //注意這裡有使用於firingStart賦值，而上面fire方法中正在使用的是firingIndex，這裡不會影響到上面代碼的執行線路
                    firingStart = start;
                    //執行我們新加入的夥伴
                    fire(auto);
                }
                return this;
            },
            fire: function () {//觸發回呼函數
                self.fireWith(this, arguments);
                return this;
            },
            fireWith: function (context, args) {//觸發回呼函數，並指定情境
                //如果已設定了once，且stack將為undefined，而once需要保證只執行一次，所以一旦執行過一次，這裡的程式碼不會再執行
                if (list && (!fired || stack)) {
                    //修正參數
                    //以0
                    //而參數清單索引為2
                    //轉換為陣列存取是因為物件表示更加的消耗資源，在頂層的fire()代碼中有auto[記憶參數，自動執行]這個功能，如果採用物件則開銷了更大的記憶體
                    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) {
                             的                                                                  地                                                                  地                             }
                        }
                    });
                }
                return this;
            },
            has: function (fn) {//是否包含一個回呼函數
                return fn ? inArray(fn, list) > -1 : list && list.length;
            },
            empty: function () {//清除此callbacks物件
                list = [];
                firingLength = 0;
                return this;
            },
            disable: function () {//廢掉此callbacks對象，後續的回呼函數清單不再執行
                list = stack = auto = undefined;
                return this;
            },
            disabled: function () {//是否已被廢至