function a(elem) {
            elem.innerHTML = '我是函數(shù)a，我要改變Element的HTML結(jié)構(gòu)';
        };
        function b(elem) {
            elem.innerHTML = '我的函數(shù)b，我要改變Element的style';
        }
        window.onload = function () {
            var elem = document.getElementById('test');
            a(elem);
            b(elem);
        };

(function (window, undefined) {
            var Callbacks = function () {
                //通過(guò)閉包保護(hù)這些私有變量
                var list = [],//回調(diào)函數(shù)列表
                    fired;//是否執(zhí)行過(guò)
                //返回一個(gè)閉包的Callbakcs對(duì)象
                return {
                    add: function (fn) {
                        //當(dāng)Callbacks廢棄掉的時(shí)候，list為undefined
                        if (list) {
                            //添加一個(gè)回調(diào)函數(shù)
                            list.push(fn);
                            //支持鏈?zhǔn)交卣{(diào)
                        }
                        return this;
                    },
                    fireWith: function (context, data) {
                        //觸發(fā)回調(diào)函數(shù)，并指定上下文
                        if (list) {
                            fired = true;
                            for (var i = 0, len = list.length; i < len; i++) {
                                //當(dāng)Callbacks中某一個(gè)函數(shù)返回false的時(shí)候，停止Callbacks后續(xù)的執(zhí)行
                                if (list[i].apply(context, data) === false)
                                    break;
                            }
                        }
                        return this;
                    },
                    fire: function () {
                        //觸發(fā)回調(diào)函數(shù)
                        //調(diào)用fireWith并指定上下文
                        return this.fireWith(this, arguments);
                    },
                    empty: function () {
                        //清空l(shuí)ist即可
                        if (list)//當(dāng)這個(gè)Callbacks廢棄掉的時(shí)候，Callbacks不應(yīng)該可以繼續(xù)使用
                            list = [];
                        return this;
                    },
                    disable: function () {
                        //廢棄這個(gè)Callbacks對(duì)象，后續(xù)的回調(diào)函數(shù)列表不再執(zhí)行
                        list = undefined;
                        return this;
                    },
                    disabled: function () {//檢測(cè)這個(gè)Callbacks是否已經(jīng)廢掉
                        //轉(zhuǎn)換為boolean返回
                        return !list;
                    },
                    fired: function () {//這個(gè)callbacks是否執(zhí)行過(guò)
                        return !!fired;
                    }
                };
            };
            //注冊(cè)到window下
            window.Callbacks = Callbacks;
        }(window));

        var test = new Callbacks();
        test.add(function (value) {
            console.log('函數(shù)1，value是：' + value);
        });
        test.add(function (value) {
            console.log('函數(shù)2，value是：' + value);
        });
        test.fire('這是函數(shù)1和函數(shù)2的值');
        console.log('查看函數(shù)是否執(zhí)行過(guò)：' + test.fired());
        test.disable();//廢棄這個(gè)Callbacks
        console.log('查看函數(shù)是否被廢棄：' + test.disabled());
        test.add(function () {
            console.log('添加第三個(gè)函數(shù)，這個(gè)函數(shù)不應(yīng)該被執(zhí)行');
        });
        test.fire();

(function (window, undefined) {
            var Callbacks = function (once) {
                //通過(guò)閉包保護(hù)這些私有變量
                var list = [],//回調(diào)函數(shù)列表
                    fired;//是否執(zhí)行過(guò)
                //返回一個(gè)閉包的Callbakcs對(duì)象
                return {
                    //...省略部分代碼
                    fireWith: function (context, data) {
                        //觸發(fā)回調(diào)函數(shù)，并指定上下文
                        if (list) {
                            fired = true;
                            for (var i = 0, len = list.length; i < len; i++) {
                                //當(dāng)Callbacks中某一個(gè)函數(shù)返回false的時(shí)候，停止Callbacks后續(xù)的執(zhí)行
                                if (list[i].apply(context, data) === false)
                                    break;
                            }
                        }
                        //如果配置了once模型，則全局變量once為true，則list重置
                        if (once) list = undefined;
                        return this;
                    }
                    //...省略部分代碼
                };
            };
            //注冊(cè)到window下
            window.Callbacks = Callbacks;
        }(window));

(function (window, undefined) {
            var Callbacks = function (once, auto) {
                var list = [],
                    fired,
                    lastData;//保存最后一次執(zhí)行的參數(shù)
                return {
                    add: function (fn) {
                        if (list) {
                            list.push(fn);
                            // — 自動(dòng)執(zhí)行模式
                            //最后一次使用的參數(shù)傳遞過(guò)去，這里丟失了Context(上下文)
                            //為了不讓這里丟失上下文，我們或許還需要聲明一個(gè)變量保存最后一次使用的Context
                            if (auto) this.fire(lastData);
                        }
                        return this;
                    },
                    fireWith: function (context, data) {
                        if (list) {
                            lastData = data;// — 記錄最后一次使用的參數(shù)
                            fired = true;
                            for (var i = 0, len = list.length; i < len; i++) {
                                if (list[i].apply(context, data) === false)
                                    break;
                            }
                        }
                        if (once) list = [];
                        return this;
                    }
                    //部分代碼省略
                };
            };
            //注冊(cè)到window下
            window.Callbacks = Callbacks;
        }(window));

(function (window, undefined) {
            var Callbacks = function (auto) {
                var list = [],
                    fired,
                    memory,//主演在這里，就是memory
                    coreFire = function (data) {
                        //真正的觸發(fā)函數(shù)方法
                        if (list) {
                            //&&表達(dá)式妙用
                            memory = auto && data;//記錄最后一次的參數(shù)，如果不是auto模式則不會(huì)記錄這個(gè)參數(shù)
                            //如果是auto模式，那么這個(gè)auto將不會(huì)為false，它會(huì)是一個(gè)數(shù)組
                            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) {
                            //添加一個(gè)回調(diào)函數(shù)
                            list.push(fn);
                            //自動(dòng)執(zhí)行模式，注意如果auto模型
                            //memory是在coreFire()里賦值的，默認(rèn)是false
                            if (memory) coreFire(auto);
                        }
                        //支持鏈?zhǔn)交卣{(diào)
                        return this;
                    },
                    fireWith: function (context, data) {
                        if (once) list = [];
                        //這里調(diào)用coreFire，把參數(shù)轉(zhuǎn)換為數(shù)組了
                        coreFire([context, data]);
                        return this;
                    }
                    /*部分代碼省略*/
                };
            };
            window.Callbacks = Callbacks;
        }(window));

(function (window, undefined) {
    /*
    * 一個(gè)回調(diào)函數(shù)工具對(duì)象，注意這個(gè)工作對(duì)象工作完成之后就會(huì)清空數(shù)組:
    *   提供一組普通的API，但它有如下工作模型 -
    *                     once - 單次執(zhí)行模型：每次工作一次，后續(xù)不再工作
    *                     auto - 自動(dòng)執(zhí)行模型：每添加一個(gè)回調(diào)函數(shù)，自動(dòng)執(zhí)行現(xiàn)有的回調(diào)函數(shù)集合里的所有回調(diào)函數(shù)，并將本次的參數(shù)傳遞給所有的回調(diào)函數(shù)
    *
    */

    //工具函數(shù)
    var isIndexOf = Array.prototype.indexOf,    //Es6
        toString = Object.prototype.toString,   //緩存toString方法
        toSlice = Array.prototype.slice,        //緩存slice方法
        isFunction = (function () {             //判定一個(gè)對(duì)象是否是Function
            return "object" === typeof document.getElementById ?
            isFunction = function (fn) {
                //ie下對(duì)DOM和BOM的識(shí)別有問(wèn)題
                try {
                    return /^\s*\bfunction\b/.test("" + fn);
                } catch (x) {
                    return false
                }
            } :
            isFunction = function (fn) { return toString.call(fn) === '[object Function]'; };
        })(),
        each = function () {                    //循環(huán)遍歷方法
            //第一個(gè)參數(shù)表示要循環(huán)的數(shù)組，第二個(gè)參數(shù)是每次循環(huán)執(zhí)行的函數(shù)
            if (arguments.length < 2 || !isFunction(arguments[1])) return;
            //為什么slice無(wú)效？？
            var list = toSlice.call(arguments[0]),
                fn = arguments[1],
                item;
            while ((item = list.shift())) {//沒(méi)有直接判定length，加速
                // 為什么這里用call就可以，而apply就不行？
                //搞定 - apply的第二個(gè)參數(shù)必須是一個(gè)array對(duì)象（沒(méi)有驗(yàn)證array-like是否可以，而call沒(méi)有這個(gè)要求）
                //apply是這樣描述的：如果 argArray（第二個(gè)參數(shù)） 不是一個(gè)有效的數(shù)組或者不是 arguments 對(duì)象，那么將導(dǎo)致一個(gè) TypeError。
                fn.call(window, item);
            }
        },
        inArray = function () {                     //檢測(cè)數(shù)組中是否包含某項(xiàng)，返回該項(xiàng)索引
            //預(yù)編譯
            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 : {};
        //使用閉包，因?yàn)槊總€(gè)新建的callbacks都有自己的狀態(tài)
        var list = [],      //回調(diào)列表
            _list = [],     //如果鎖定這個(gè)callbacks對(duì)象，則清空l(shuí)ist，將原list置入_list
            fired,          //是否執(zhí)行過(guò)
            firingStart,    //當(dāng)前回調(diào)函數(shù)列表執(zhí)行的函數(shù)索引（起點(diǎn)）
            firingLength,   //回調(diào)函數(shù)的數(shù)組長(zhǎng)度
            auto,   //標(biāo)志是否自動(dòng)執(zhí)行，如果需要自動(dòng)執(zhí)行，則auto記憶著最后一次回調(diào)的參數(shù)（最后一次fire的參數(shù)），這是一個(gè)很詭異的且奇葩的用法
            //這個(gè)變量用法很詭異和犀利，既包含了是否指定執(zhí)行的標(biāo)志，又記錄了數(shù)據(jù)
            //這個(gè)auto配合once簡(jiǎn)直就是喪心病狂：【第一次】執(zhí)行了fire后才會(huì)自動(dòng)執(zhí)行，配合once可以做到：一次執(zhí)行，后面不再追加和執(zhí)行代碼，保證了一組回調(diào)數(shù)據(jù)的穩(wěn)定和安全
            stack = !option.once && [],     //一個(gè)callbacks棧，如果當(dāng)前正在執(zhí)行回調(diào)數(shù)組，而在執(zhí)行中又新添了回調(diào)函數(shù)，那么把新的回調(diào)函數(shù)，那么新的回調(diào)函數(shù)都會(huì)壓入該棧
            firing = false, //callbacks是否正在工作/執(zhí)行
        //觸發(fā)回調(diào)函數(shù)
            fire = function (data) {
                //注意這個(gè)data是個(gè)數(shù)組，如果配置了auto模式，那么auto永遠(yuǎn)不會(huì)為false，因?yàn)閍uto會(huì)是個(gè)數(shù)組
                auto = option.auto && data; //在這里，如果配置要求記憶最后的參數(shù)，則記憶這個(gè)參數(shù)（非常犀利的用法，直接取了數(shù)據(jù)）
                fired = true;
                firingIndex = firingStart || 0;
                firingStart = 0;//清空f(shuō)iringStart（不清空下次執(zhí)行有出問(wèn)題啦）
                firingLength = list.length;         //緩存list長(zhǎng)度，外界可以訪問(wèn)
                firing = true; //正在執(zhí)行回調(diào)函數(shù)
                for (; firingIndex < firingLength; firingIndex++) {
                    if (list[firingIndex].apply(data[0], data[1]) === false) {
                        //注意，如果配置了option.auto（自動(dòng)執(zhí)行），并且stack（棧）里存在函數(shù)，那么add()代碼里有一段對(duì)于auto判定會(huì)直接執(zhí)行本方法的代碼
                        //我們要阻止掉那段代碼，所以設(shè)置auto為false
                        auto = false;
                        break;
                    }//當(dāng)函數(shù)返回false，終止執(zhí)行后續(xù)隊(duì)列
                }
                firing = false; //標(biāo)志狀態(tài)已經(jīng)執(zhí)行完畢回調(diào)函數(shù)[stack(棧)里面的函數(shù)尚未執(zhí)行]
                //如果這個(gè)棧在沒(méi)有配置once的情況下肯定是[]，所以一定存在
                //這里主要作用是，如果沒(méi)有配置once，則攔截下面的代碼，如果配置了once，執(zhí)行完代碼清空數(shù)據(jù)
                if (stack) {
                    if (stack.length)//先把下面清空l(shuí)ist狀態(tài)的代碼攔截掉，再判定是否有棧
                        fire(stack.shift()); //從棧頭部取出，并遞歸fire()方法
                }
                else if (auto)    //代碼走到這里，證明已經(jīng)配置了option.once（只執(zhí)行一次），于是把list清空
                    list = [];
                else                //證明沒(méi)有配置auto，但是配置了once，那么祭出終極大法，直接廢了這個(gè)callbacks對(duì)象
                    self.disable();
            };
        var self = {
            add: function () {//添加一個(gè)回調(diào)函數(shù)
                if (list) {
                    var start = list.length;
                    (function addCallback(args) {
                        each(args, function (item) {
                            if (isFunction(item)) {//是函數(shù)，則壓入回調(diào)列表
                                list.push(item);
                                //注意typeof 和Object.prototype.toString是不一樣的
                            } else if (toString.call(item) === '[object Array]') {//如果是個(gè)數(shù)組，則遞歸壓入回調(diào)列表，這個(gè)判定拋棄了array-like
                                addCallback(item);
                            }
                        });
                    })(arguments);
                }
                if (firing)//如果當(dāng)前正有回調(diào)函數(shù)在執(zhí)行，那么需要更新當(dāng)前回調(diào)函數(shù)列表的length，否則這個(gè)新壓入的回調(diào)函數(shù)就會(huì)被掠過(guò)。
                    firingLength = list.length;
                else if (auto) {//如果當(dāng)前沒(méi)有執(zhí)行回調(diào)函數(shù)，并且要求自動(dòng)執(zhí)行
                    //注意這里是給firingStart賦值，上面fire方法中正在使用的是firingIndex，這里不會(huì)影響到上面代碼的執(zhí)行線路
                    firingStart = start;
                    //執(zhí)行我們新加入的小伙伴
                    fire(auto);
                }
                return this;
            },
            fire: function () {//觸發(fā)回調(diào)函數(shù)
                self.fireWith(this, arguments);
                return this;
            },
            fireWith: function (context, args) {//觸發(fā)回調(diào)函數(shù)，并指定上下文
                //如果配置了once，stack將為undefined，而once又需要保證只執(zhí)行一次，所以一旦執(zhí)行過(guò)一次，這里的代碼不會(huì)再執(zhí)行
                if (list && (!fired || stack)) {
                    //修正參數(shù)
                    //在這里,context索引為0
                    //而參數(shù)列表索引為2
                    //轉(zhuǎn)換為數(shù)組訪問(wèn)是因?yàn)閷?duì)象表示更加的消耗資源，在頂層的fire()代碼中有auto[記憶參數(shù)，自動(dòng)執(zhí)行]這個(gè)功能，如果采用對(duì)象則開銷了更大的內(nèi)存
                    args = [context,
                        args ?
                        args.slice && args.slice()
                        || toSlice.call(args) :
                        []
                    ];
                    fire(args);
                }
                return this;
            },
            remove: function () {//移除一個(gè)回調(diào)函數(shù)
                if (list) {
                    each(arguments, function (item) {
                        var index;
                        //可能有多項(xiàng)，index可以在循環(huán)中表示檢索的范圍，之前檢索的過(guò)的可以不用再檢索
                        while ((index = inArray(item, list, index)) > -1) {
                            list.splice(index, 1);
                            if (firing) {
                                //保證上面fire中正在執(zhí)行的函數(shù)列表能夠正確運(yùn)行，fire中設(shè)定全局這些變量為的就是這里可以異步移除
                                if (index <= firingLength)//修正長(zhǎng)度
                                    firingLength--;
                                if (index <= firingLength)//修正索引
                                    firingIndex--;
                            }
                        }
                    });
                }
                return this;
            },
            has: function (fn) {//是否包含一個(gè)回調(diào)函數(shù)
                return fn ? inArray(fn, list) > -1 : list && list.length;
            },
            empty: function () {//清空這個(gè)callbacks對(duì)象
                list = [];
                firingLength = 0;
                return this;
            },
            disable: function () {//廢掉這個(gè)callbacks對(duì)象，后續(xù)的回調(diào)函數(shù)列表不再執(zhí)行
                list = stack = auto = undefined;
                return this;
            },
            disabled: function () {//是否已經(jīng)廢掉
                return !list; //轉(zhuǎn)換為boolean
            },
            lock: function (isLock) {//鎖定或解鎖這個(gè)callbacks對(duì)象
                //無(wú)參，判斷這個(gè)callbacks是否被鎖定
                if (isLock == null) return !!_list;
                if (isLock) {//鎖
                    _list = stack && list.concat(stack) || list;
                    list = undefined;
                } else {//解鎖，jQuery并沒(méi)有提供解鎖功能，解鎖讓Callbacks變得不穩(wěn)定
                    list = _list;
                    _list = undefined;
                }
                return this;
            },
            fired: function () {//這個(gè)callbacks是否執(zhí)行過(guò)
                //轉(zhuǎn)換為boolean，包括undefined，null,''等
                return !!fired;
            }
        };
        return self;
    };
    window.$ = window.$ || {};
    window.$.Callbacks = window.Callbacks = Callbacks;
}(window));