jQuery-1.9.1源码分析系列（五） 回调对象

            //
            执行函数
            function
             runList(arr){
    
            for(var i = 0; i < arr.length; i++){
        arr[i]();　　　　
    }
　　arr.length = 0;
}

var list = [];
//添加函数队列
list[list.length] = function(){alert(1)};
list[list.length] = function(){alert(2)};
list[list.length] = function(){alert(3)}; 

            //
            执行
            
runList(list);//三个函数顺序执行

            var callbacks = $.Callbacks("unique");

callbacks.add( function(){alert(1)} );
callbacks.add( function(){alert(2)} );
callbacks.add( function(){alert(3)} );
//执行
callbacks.fire();//三个函数顺序执行

            var f1 = function(value) { console.log(value); };
var callbacks = $.Callbacks(‘once‘);

callbacks.add(f1);//无执行结果,添加一个回调
callbacks.fire(1);//执行结果1。清除回调列表
callbacks.add(f1);//没有添加回调直接返回
callbacks.fire(2);//无执行结果
callbacks.add(f1);//没有添加回调直接返回
callbacks.fire(3);//无执行结果

            var f1 = function(value) {    console.log(value); };
var callbacks = $.Callbacks("memory");
 
callbacks.add( fn1 );//无执行结果
callbacks.fire( "1" );//执行结果1。保存场景参数1 
callbacks.add( fn1 );//执行结果1。使用上次保存的场景参数1
callbacks.fire( "2" );//执行结果2,2。保存场景参数2 
callbacks.add( fn1 );//执行结果2。使用上次保存的场景参数2
callbacks.fire( "3" );//执行结果3,3,3。保存场景参数3 
callbacks.add( fn1 );//执行结果3。使用上次保存的场景参数3
callbacks.fire( "4" );//执行结果4,4,4,4。保存场景参数4

            var f1 = function(value) { console.log(value); };
var callbacks = $.Callbacks(‘once memory‘);

callbacks.add(f1);//无执行结果,添加一个回调
callbacks.fire(1);//执行结果1。清除回调列表，保存场景参数1
callbacks.add(f1);//添加一个回调并执行结果1，使用上次保存的场景参数。清除回调列表
callbacks.fire(2);//无执行结果
callbacks.add(f1);//添加一个回调并执行结果1，使用上次保存的场景参数。清除回调列表
callbacks.fire(3);//无执行结果

            var f1 = function(value) { console.log(value); };
var callbacks = $.Callbacks(‘once,memory‘);

callbacks.add(f1);//无执行结果,添加一个回调
callbacks.fire(1);//执行结果1
callbacks.add(f1);//添加一个回调
callbacks.fire(2);//执行结果2,2
callbacks.add(f1);//添加一个回调
callbacks.fire(3);//执行结果3,3,3
callbacks.add(f1);//添加一个回调
callbacks.fire(4);//执行结果4,4,4,4

            //
             使用过的选项缓存
            var optionsCache = {};

// 新增和缓存回调设置于optionsCache中function createOptions( options ) {
    var object = optionsCache[ options ] = {};
    jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
        object[ flag ] = true;
    });
    return object;
}

jQuery.Callbacks = function( options ) {
    // 尽可能读取缓存，没有则新增缓存
    options = typeof options === "string" ?
    ( optionsCache[ options ] || createOptions( options ) ) :
    jQuery.extend( {}, options );

    var// 回调列表正在执行（为true的时候）的标志        firing,
        // 最后执行的值（为memory选项下保存）        memory,
        // 回调已经被执行过的标志        fired,
        // 循环执行回调列表的结束位置        firingLength,
        // 当前真正执行的回调的索引值 (执行下个回调的时候回更改【如果必要的话】)        firingIndex,
        // 循环执行回调列表的开始位置(在函数add和fireWith中使用)        firingStart,
        // 回调列表
        list = [],
        // Stack记录要重复执行的回调列表
        stack = !options.once && [],
        // data数组一般第一个元素是上下文环境，第二个元素是参数//执行回调列表
        fire = function( data ) {…},
        // 回调对象
        self = {
            // 添加回调
            add: function() {…},
            // 移除回调
            remove: function() {…},
            ...
            // 给定 context 和 arguments执行所有回调
            fireWith: function( context, args ) {
                args = args || [];
                //组装args，第一个元素为上下文环境，第二个元素为参数列表
                args = [ context, args.slice ? args.slice() : args ];
                //有list且函数列表没有被执行过或者存在要循环执行的函数列表if ( list && ( !fired || stack ) ) {
                    //如果正在fire，则把函数场景记录在stack中if ( firing ) {
                        stack.push( args );
                    //否则，至此那个fire
                    } else {
                        fire( args );
                    }
                }
                returnthis;
            },
            // 使用给定的arguments执行所有回调
            fire: function() {
                self.fireWith( this, arguments );
                returnthis;
            },
            ...
        };
    return self;
};

        (function add( args ) {
            jQuery.each( args, function( _, arg ) {
                var type = jQuery.type( arg );
                if ( type === "function" ) {
                    //当$.Callbacks(‘unique‘)时，保证列表里面不会出现重复的回调if ( !options.unique || !self.has( arg ) ) {
                        list.push( arg );
                    }
                //如果是数组则递归添加
                } elseif ( arg && arg.length && type !== "string" ) {
                    add( arg );
                }
            });
        })( arguments );

            //
            如果列表没有定义或null（一般只有在用户设置once且执行过一次后list才会白置为未定义）
            if
             ( list ) {
        ...
    }
    
            return
            this;

            //
             如果正在fire，则设定要执行结束的点firingLength，使后续添加的函数最后不会执行
            if
             ( firing ) {
            firingLength = list.length;
        // 对于memory（设置了‘memory‘ option并fire过了，memory才能通过该else if语句）,//如果没有回调真正fire,应当马上执行fire(memory)。
        } elseif ( memory ) {
            //这里保证了前面执行过得函数不再执行
            firingStart = start;
            fire( memory );
        }

            if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
       memory = false; // 阻止未来可能由于add所产生的回调break;
}

fire = function( data ) {
　　//有memory才给memory赋值当前场景data
　　memory = options.memory && data;
　　fired = true;
　　firingIndex = firingStart || 0;
　　//每次fire后都会重置成0，下次$.callbacks.fire调用都会从0开始。当然设置为‘memory’使用add函数内部fire会设置firingStart的值导致回调函数列表执行起始位置更改
　　firingStart = 0;
　　firingLength = list.length;
　　firing = true;
　　//函数开始执行从firingStart到firingLength的所有函数　　for ( ; list && firingIndex < firingLength; firingIndex++ ) {
　　　　//执行firingIndex对应的函数，如果设置是遇到false返回就停止，则设置memory，阻止后续函数执行　　　　if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
　　　　　　memory = false; // 阻止未来可能由于add所产生的回调　　　　　　break;
　　　　}
　　}

　　//标记回调结束
　　firing = false;

　　//如果列表存在　　if ( list ) {
　　　　//如果堆栈存在（一般没有设置once的时候都进入该分支）　　　　if ( stack ) {
　　　　　　//如果堆栈不为空　　　　　　if ( stack.length ) {
　　　　　　　　//执行stack中第一个元素
　　　　　　　　fire( stack.shift() );
　　　　　　}
　　　　//如果有记忆，则清空列表(在设置为once且memory的时候会进入到此分支)
　　　　} elseif ( memory ) {
　　　　　　list = [];
　　　　//禁用回调,该callbacks将不可用，将list/stack/memory都设为未定义
　　　　} else {
　　　　　　self.disable();
　　　　}
　　}
},

            if
             ( list ){
    ...
}
        

                disable: function() {
                    list = stack = memory = undefined;
                    returnthis;
                }

            //
            禁用回调,该callbacks将不可用，将list/stack/memory都设为未定义
　　　　} else {
　　　　　　self.disable();
　　　　}

            　　　　//
            如果有记忆，则清空列表(在设置为once且memory的时候会进入到此分支)
　　　　} elseif ( memory ) {