Backbone.Events

Backbone中Events的中只有3个方法，分别是on， off， trigger，十分清晰，也没有其他依赖，下面我们来分析一下。
 
Events 是一个可以被mix到任意对象的模块，它拥有让对象绑定和触发自定义事件的能力。 事件在被绑定之前是不需要事先声明的，还可以携带参数。我们通过一个例子来看：

var object = {};

_.extend(object, Backbone.Events);

object.bind("alert", function(msg) {
  alert("Triggered " + msg);
});
关键是_.extend ,调用了underscore中的extend的方法，又是extend下面是underscore从第690行开始的
 
//复制source对象中的所有属性覆盖到destination对象上，他是按照循序的，所以最后源将重写在前面参数相同名称的属性
  _.extend = function(obj) {
    each(slice.call(arguments, 1), function(source) {
      for (var prop in source) {
        obj[prop] = source[prop];
      }
    });
    return obj;
  };
 
 

    /**
     * Events 是一个可以被mix到任意对象的模块，
     * 它拥有让对象绑定和触发自定义事件的能力。
     * 事件在被绑定之前是不需要事先声明的，
     * 还可以携带参数。我们通过一个例子来看：
     *  var object = {};
     *    _.extend(object, Backbone.Events);
     *        object.bind("alert", function(msg) {
     *                alert("Triggered " + msg);
     *        });
     *   object.trigger("alert", "www.csser.com");
     * **/
    var Events = Backbone.Events = {

        /**
         * 绑定 callback 函数到 object 对象。 当事件触发时执行回调函数 callback 。
         * 如果一个页面中有大量不同的事件，按照惯例使用冒号指定命名空间
         * ： "poll:start", 或 "change:selection"
         * */
        on:function (events, callback, context) {
            var calls, event, list;
            if (!callback) return this;

            events = events.split(eventSplitter);

            calls = this._callbacks || (this._callbacks = {});
            //保存回调函数,与事件 到对象的_callbacks上
            while (event = events.shift()) {
                //取出每个事件名放到_callbacks作用对象的属性，然后把回调函数push到这个数组中
                list = calls[event] || (calls[event] = []);
                list.push(callback, context);
            }

            return this;
        },

        /**
         * 删除一个或许多回调。如果“上下文”是null,删除所有的回调　　
         * 与功能。如果“回调”是null,删除所有的回调　
         * 事件。如果“事件”是null,移除所有绑定回所有事件
         *
         * object.unbind("change", onChange);  只移除onChange回调函数
         *  object.unbind("change");           移除所有 "change" 回调函数
         * object.unbind();                    移除对象的所有回调函数
         *
         * **/
        off:function (events, callback, context) {
            var event, calls, list, i;

            // No events, or removing *all* events.
            if (!(calls = this._callbacks)) return this;
            if (!(events || callback || context)) {
                delete this._callbacks;
                return this;
            }

            events = events ? events.split(eventSplitter) : _.keys(calls);

            // Loop through the callback list, splicing where appropriate.
            while (event = events.shift()) {
                if (!(list = calls[event]) || !(callback || context)) {
                    delete calls[event];
                    continue;
                }

                for (i = list.length - 2; i >= 0; i -= 2) {
                    if (!(callback && list[i] !== callback || context && list[i + 1] !== context)) {
                        list.splice(i, 2);
                    }
                }
            }

            return this;
        },

        /**
         * / /触发一个或许多事件,解雇所有绑定回调。回调是　　
         * / /通过相同的参数作为“触发”是,除了事件的名字　　
         * / /(除非你监听的“所有”,这将导致你的回调　　
         * / /接收真实的事件名称作为第一个参数)。
         * **/
        trigger:function (events) {
            var event, calls, list, i, length, args, all, rest;
            if (!(calls = this._callbacks)) return this;

            rest = [];
            //事件分解
            events = events.split(eventSplitter);

            // Fill up `rest` with the callback arguments.  Since we're only copying
            // the tail of `arguments`, a loop is much faster than Array#slice.
            for (i = 1, length = arguments.length; i < length; i++) {
                rest[i - 1] = arguments[i];
            }

            // For each event, walk through the list of callbacks twice, first to
            // trigger the event, then to trigger any `"all"` callbacks.
            while (event = events.shift()) {
                //复制回调列表来防止修改
                if (all = calls.all) all = all.slice();
                if (list = calls[event]) list = list.slice();

                // 执行事件回调
                if (list) {
                    for (i = 0, length = list.length; i < length; i += 2) {
                        list[i].apply(list[i + 1] || this, rest);
                    }
                }

                // 执行 "all" 回调.
                if (all) {
                    args = [event].concat(rest);
                    for (i = 0, length = all.length; i < length; i += 2) {
                        all[i].apply(all[i + 1] || this, args);
                    }
                }
            }

            return this;
        }

    };

    //别名
    Events.bind = Events.on;
    Events.unbind = Events.off;