callbacks工具方法，作用是函数回调的统一管理
jQuery.Callbacks = function( options ) {
}
使用：类似于事件绑定，fire之后，之前绑定的方法，都执行。
观察者模式。
function aaa() {
alert(1);
}
function bbb() {
alert(2);
}
function ccc() {
alert(3)
}
var cb = $.Callbacks();
cb.add(aaa);
cb.add(bbb);
cb.add(ccc);
cb.fire(); // 弹出了 1 和 2, 3
add(fun)-->List添加方法。
fire对list数组，进行for循环执行。
/**********************************************************/
function aaa() {
alert(1);
}
(function () {
function bbb() {
alert(2);
}
})();
aaa();
bbb();
//这里无法同时执行弹出1 和 2，因为无法进行统一作用域的管
/**********************************************************/
// 但是Callbacks可以搞定，这个问题。
var cb = $.Callbacks();
function aaa() {
alert(1);
}
cb.add(aaa);
(function () {
function bbb() {
alert(2);
}
cb.add(bbb);
})();
cb.fire(); // 只需要一句就可以了。触发所有
//这里只要回调对象时全局的， 就可以随时向回调函数中添加函数，而后执行。
/**********************************************************/
jQuery.Callbacks = function( options )
options配置参数。四个！！！
* once: will ensure the callback list can only be fired once (like a Deferred)
*
* memory: will keep track of previous values and will call any callback added
* after the list has been fired right away with the latest "memorized"
* values (like a Deferred)
*
* unique: will ensure a callback can only be added once (no duplicate in the list)
*
* stopOnFalse: interrupt callings when a callback returns false
Callbacks的四个参数。
var cb = $.Callbacks();
cb.fire();
cb.fire(); //fire可以执行多次触发的。
（1）once：代表，fire只能触发一次。
cb.fire();
cb.fire(); //不会执行。
让fire执行一次就好了
（2）memory：
var cb = $.Callbacks();
function aaa() {
alert(1);
}
cb.add(aaa);
cb.fire();
function bbb() {
alert(2);
}
cb.add(bbb);
//这段代码执行过后，只能fire出1，不能执行bbb函数
var cb = $.Callbacks('memory');
function aaa() {
alert(1);
}
cb.add(aaa);
cb.fire();
function bbb() {
alert(2);
}
cb.add(bbb);
//这段代码就是会打印出1 2 。后面的2也可以触发，只要添加就可以执行。
memory是作用到add上面，然后再调用fire。
var cb = $.Callbacks('memory');
function aaa() {
alert(1);
return false;
}
cb.add(aaa);
cb.fire();
function bbb() {
alert(2);
}
setTimeout(function () {
cb.add(bbb);
}, 1000);
我想了一个例子，应该可以讲的明白，如果变量里面定义了memory，作为初始化，
那么，就执行。当你调用了fire以后，再向内添加add函数的时候，就直接继续执行。
（3）unique:去重复，让函数具有唯一性。作用于add
var cb = $.Callbacks();
function aaa() {
alert(1);
}
cb.add(aaa);
cb.add(aaa);
cb.fire();
//这里触发2次
var cb = $.Callbacks('unique');
function aaa() {
alert(1);
}
cb.add(aaa);
cb.add(aaa);
cb.fire();
//这里触发1次，重复的函数名，不能放入list，
（4）stopOnFalse
var cb = $.Callbacks('stopOnFalse');
function aaa() {
alert(1);
return false;
}
cb.add(aaa);
function bbb() {
alert(2);
}
cb.add(bbb);
cb.fire();
//这里只是执行了alert（1）。而alert(2)，并没有背执行
//这个变量作用于fire中，判断函数中是否返回false，如果返回false，就立刻推出list循环。
当然还可以接受到组合的形式，比如，memory和once组合的形式，通过空格来分隔开的。
var cb = $.Callbacks('once stopOnFalse');
Callbacks方法：
add： 将函数，push入 list 中。
remove： 删除
has 检测是否有这个函数，返回false／true
empty 清空数组
disable 全部锁住。禁止，不执行。
lock 锁住。stack＝undefined
locked 判断是否锁住
fireWith
fire： －－》调用的是fireWith. －－》fire ＝ function（data）；
fired 判断是否fired
list = [], 用了保存函数列表。
add 添加。
add: function() {
if ( list ) {
// First, we save the current length
var start = list.length;
(function add( args ) {
//这里支持传入多个，cb.add(aaa, bbb);
jQuery.each( args, function( _, arg ) {
var type = jQuery.type( arg );
if ( type === "function" ) {
//判断是不是唯一。unique!!!
if ( !options.unique || !self.has( arg ) ) {
list.push( arg );
}
}
//支持数组形式， cb.add([aaa, bbb]);
else if ( arg && arg.length && type !== "string" ) {
// Inspect recursively
add( arg );
}
});
})( arguments );
// Do we need to add the callbacks to the
// current firing batch?
if ( firing ) {
firingLength = list.length;
//有merory就直接执行。
} else if ( memory ) {
firingStart = start;
fire( memory );
}
}
return this;
},
支持这个：
cb.add(aaa);
cb.add(aaa, bbb);
cb.add([aaa, bbb]);
remove：删除。
对数组进行遍历删除。splice
remove: function() {
if ( list ) {
jQuery.each( arguments, function( _, arg ) {
var index;
while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
list.splice( index, 1 );
// Handle firing indexes
if ( firing ) {
if ( index <= firingLength ) {
firingLength--;
}
if ( index <= firingIndex ) {
firingIndex--;
}
}
}
});
}
return this;
},
cb.add(aaa);
cb.add(bbb);
cb.add(ccc);
cb.remove(bbb);
cb.fire(); // 就只有aaa 和 ccc
fire:执行。
fire = function( data ) {
memory = options.memory && data;
fired = true;
firingIndex = firingStart || 0;
firingStart = 0;
firingLength = list.length;
firing = true; //触发开始
for ( ; list && firingIndex < firingLength; firingIndex++ ) {
if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
memory = false; // To prevent further calls using add
break;
}
}
firing = false; //触发结束
if ( list ) { //判断list
if ( stack ) {
if ( stack.length ) { //stack的长度部位空，
//递归调用
fire( stack.shift() ); //将栈中的第一个返回。并且fire
}
}
//如果有记忆，
else if ( memory ) {
//列表清空
list = [];
} else {
self.disable();
}
}
},
//Call all callbacks with the given context and arguments
fireWith: function( context, args ) {
if ( list && ( !fired || stack ) ) {
args = args || [];
//如果是数组，就转换为对象。
args = [ context, args.slice ? args.slice() : args ];
if ( firing ) {
stack.push( args );
} else {
fire( args );
}
}
return this;
},
// Call all the callbacks with the given arguments
fire: function() {
self.fireWith( this, arguments );
return this;
},
// To know if the callbacks have already been called at least once
fired: function() {
return !!fired;
}
stack = !options.once && [], //这里定义了一个栈
firing 事件触发的时候。
fireWith：
fireWith: function( context, args ) {
if ( list && ( !fired || stack ) ) {
args = args || [];
args = [ context, args.slice ? args.slice() : args ];
//这里，如果是firing时，就讲fire压入栈
if ( firing ) {
stack.push( args );
} else {
fire( args );
}
}
return this;
},
有个例子
var cb = $.Callbacks();
var singal = true;
function aaa() {
alert(1);
if (singal) {
cb.fire(); //stack.push( args );
singal = false;
}
}
cb.add(aaa);
function bbb () {
alert(2);
}
cb.add(bbb);
cb.fire();
弹出顺序是1，2 1，2.
这个是在fire中实现的。
if ( list ) { //判断list
if ( stack ) {
if ( stack.length ) { //stack的长度部位空，
//递归调用
fire( stack.shift() ); //将栈中的第一个返回。并且fire
}
}
//如果有memory的时候，就清空数组。
else if ( memory ) {
//列表清空
list = [];
} else {
self.disable();
}
}