Callbacks是jQuery中一个独立的模块，这个模块就我所了解的好像是从$.Deferred中抽离出来的，但不仅仅只为$.Deferred服务。Callbacks顾名思义就是回调，但和回调没什么关系，这个模块实际上是观察者模式的实现。

贴一段代码来展示Callbacks的整体结构

    // 回调模块
    jQuery.Callbacks = function () {

        var
            list = [], // 观察者集合

            fire = function () {
                for (var i = 0; i < list.length; i++) {
                    list[i]();
                }
            },

            self = {
                add: function () {
                    list.push(fn);
                },

                fire: function() {
                    fire();
                }
            };

        return self;
    }

真正的观察者模式就这么简单，但jQuery的Callbacks模块在这个基础上实现了4种不同的模式

模式	描述
once	确保回调列表只执行一次（即只能调用一次fire()方法，再次调用不会执行任何逻辑）
memory	每当添加新的函数时，立即执行该函数，并且将最后一次调用fire()时传入的参数作为该函数的参数
unique	确保添加的回调函数没有重复
stopOnFalse	当回调函数返回false时中断调用

以下是实现这四种模式后的代码

    // 回调模块
    jQuery.Callbacks = function (options) {
        options = typeof options === 'string' ?
            createOptions(options) :
            jQuery.extend({}, options);

        var
            firing,             // list是否使用中
            fired,              // list是否使用过
            locked,             // list是否锁定中
            memory,             // { Callbacks对象, fire()的参数 }
            list = [],          // 观察者集合
            queue = [],         // 保存着上一次调用fire()时传入的参数
            firingIndex = -1,   // 当传入参数有memory时要用到这个参数定位

            fire = function () {
                // 标记list使用中并且已经执行过一次了
                fired = firing = true;

                memory = queue.shift();
                for (; ++firingIndex < list.length;) {
                    var result = list[firingIndex].apply(memory[0], memory[1]);
                    if (options.stopOnFalse && result === false) {
                        break;
                    }
                }

                if (options.once) {
                    list = [];
                }

                // 重置firingIndex
                firingIndex = -1;
                // list使用结束
                firing = false;
            },

            self = {
                add: function () {
                    if (memory && !firing) {
                        firingIndex = list.length - 1;
                        queue.push(memory);
                    }

                    jQuery.each(arguments, function (fn) {
                        // unique并且list中已经添加过该方法了
                        if (options.unique && list.indexOf(fn) !== -1) {
                            return;
                        }

                        list.push(fn);
                    })

                    // 如果options中有memory，add过程中会立即执行当前函数
                    if (memory && !firing) {
                        fire();
                    }
                },

                fireWith: function(context, args) {
                    args = args || [];
                    args = [context, args.slice ? args.slice() : args];
                    // 把[context, 参数]放进queue里面
                    queue.push(args);
                    if (!firing) {
                        fire();
                    }
                    return this;
                },

                fire: function() {
                    return self.fireWith(this, arguments);
                }
            };

        return self;
    }

其他辅助性代码

    var rnothtmlwhite = /[^\W]+/g;

    // 供jQuery.Callbacks使用
    function createOptions(options) {
        var object = {};
        jQuery.each(options.match(rnothtmlwhite) || [], function (item) {
            object[item] = true;
        })
        return object;
    }

虽然jQuery源码比上面代码多得多，但以上代码已经将主要的功能实现，代码我也亲测过，请放心使用。

4中模式里面once、unique和stopOnFalse实现起来都很容易，memory实现最复杂。接下来讲讲这个模块的一些小细节。
1.首先是回调模块中有个参数firing用于标识list是否使用中，如果为true则不会执行fire()方法，这是用来规避多线程问题的，但js是单线程语言，感觉这一步处理没什么必要。
2.add()函数中jQuery.each(arguments, function (fn) {这种写法是处理一次性添加多个函数的情况，考虑的很周到。而且fire()函数也同样没有定义形参，而是用arguments解决参数问题，这也是出于参数可能不止一个的考虑。
3.使用memory和queue两个变量来保存最后一次调用fire()时传入的参数，其实我来写的话肯定会只用一个变量去保存，但是由于只用一个变量有一些bug没有解决掉，所以memory这一块的实现我是照搬的jQuery源码