我们首先来讲下Callbacks是如何使用的：第一个例子
function a(){}
function b(){}
var cb = $.Callbacks();
cb.add(a);
cb.add(b);
cb.fire(); //就会先执行a方法，再执行b方法
上面大概的意思是：add方法，就是把方法添加到数组list中，每执行一次，就添加一个方法。而fire方法，就是把list数组中的方法按顺序执行。
使用场景：第二个例子
function a(n){ }
(function(){
function b(n){}
})
在这里你无法调用b方法，因为b方法是局部变量。因此，你可以使用Callbacks来解决这个问题。
function a(n){}
var cb = $.Callbacks();
cb.add(a);
(function(){
function b(n){}
cb.add(b);
})
cb.fire("hello");
这时，b方法即使是局部变量，也可以通过cb.fire()进行调用。而且fire中的参数"hello"，也可以传入a，b方法。
Callbacks 可以传4个值，jQuery.Callbacks(options)，options有四个值：once,memory,unique,stopOnFalse 。
在第一个例子中，假设我们调用两次cb.fire(); 那么第一次会执行a,b方法，第二次也会调用a,b方法。但是如果你定义cb时这样，var cb = $.Callbacks("once");那么只有第一次会执行a,b方法，第二次不会执行。once的意思是只执行list数组中的方法一次，之后你调用fire，不会执行list数组中的方法。
memory的作用是：
var cb = $.Callbacks();
cb.add(a);
cb.fire();
cb.add(b);
针对以上代码，方法a会执行，b方法不会执行。但是你在定义cb时，var cb = $.Callbacks("memory");这时，a，b方法都会执行。它具有记忆性。
unique的作用：去重，add如果添加相同的方法，在没有unique的情况下，添加几个相同的方法，就会执行几次相同的方法，但是你传入了unique，不管你添加多少次相同的方法，它都只会执行一次。
stopOnFalse的作用：
function a(){ return false;}
function b(){}
var cb = $.Callbacks();
cb.add(a);
cb.add(b);
cb.fire();
方法a，b都会执行。但是如果你定义cb时，var cb = $.Callbacks("stopOnFalse");只会执行a方法。因为a方法返回了false，而stopOnFalse的作用就是当方法返回false时，就停止循环list。因此b方法就不会执行了。
当然这四种参数，你可以组合使用，比如：var cb = $.Callbacks("once memory");
接下来，源码解析：由于代码比较多，因此给大家一个线索，$.Callbacks -> return self; -> self.add(a) -> list.push(a) -> self.add(b) -> list.push(b) -> self.fire() ->self.fireWith -> 私有方法fire() -> 循环list数组，执行里面的a,b方法。请按照此顺序看代码，然后再根据4个参数分别代表什么意思，再按顺序看一次。里面有详细的代码解释。
var optionsCache = {};
function createOptions( options ) {
var object = optionsCache[ options ] = {}; //optionsCache[once] = {}
jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
//core_rnotwhite = /S+/g, 取字符，options.match( core_rnotwhite ) = ["once"]，此正则是为了处理多个值时，比如"once match"变成["once","memory"]
object[ flag ] = true; //_是index值0，flag是value值"once"
});
return object; //optionsCache[once] = { "once":true }
}
jQuery.Callbacks = function( options ) { //options有四个值：once,memory,unique,stopOnFalse
options = typeof options === "string" ? ( optionsCache[ options ] || createOptions( options ) ) : jQuery.extend( {}, options );
//当传入参数时，就是字符串，比如：once，那么就会先去optionsCache中取once属性，如果之前没有此值，就调用createOptions(once)方法
var memory,
fired,
firing,
firingStart,
firingLength,
firingIndex,
list = [],
stack = !options.once && [], //如果有once，那么stack就是false，如果没有，那么stack就死[]，if条件里面空数组为真，因此在fire()->fireWith()时，就可以再次执行list数组中的方法了。
fire = function( data ) { //这里才是真正执行list数组中方法的地方
memory = options.memory && data;
fired = true;
firingIndex = firingStart || 0;
firingStart = 0;
firingLength = list.length;
firing = true; //正在触发list数组中的方法
for ( ; list && firingIndex < firingLength; firingIndex++ ) {
if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
//如果回调方法返回false，并且有传入stopOnFalse参数，就会停止for循环，停止执行list数组中后面的方法
memory = false;
break;
}
}
firing = false; //方法执行结束
if ( list ) { //当list数组中的方法执行结束后，就会判断stack是否有值
if ( stack ) {
if ( stack.length ) {
fire( stack.shift() ); //如果有值，就会再次触发fire执行
}
} else if ( memory ) { //如果有once，stack就是false，就会走else
list = []; //如果有传入了memory，只会清空list数组。举个例子：var cb = $.Callbacks("once memory");cb.add(a),cb.fire();cb.add(b);cb.fire()。因为有once，所以只会执行一次，因此第二个fire没用。又由于有memory，所以a，b方法都会执行一次。如果这里没有memory，就会执行下面的else语句，这时只会执行a方法，b方法也不会执行。
} else {
self.disable(); //阻止后面的所有fire操作
}
}
},
self = {
add: function() { //此add方法，就是往list数组中push方法（fire时调用的方法）
if ( list ) { //[]为真
var start = list.length;
(function add( args ) {
jQuery.each( args, function( _, arg ) {
var type = jQuery.type( arg );
if ( type === "function" ) { //如果是方法就push到list中
if ( !options.unique || !self.has( arg ) ) { //如果有唯一判断，比如传入unique，就必须判断list数组中是否有此方法了，如果没有，才push到list中。self.has(arg)方法就是判断list数组中是否有arg方法。
list.push( arg );
}
} else if ( arg && arg.length && type !== "string" ) {
add( arg ); //此时add([a,b])是立即执行方法add而不是self.add。
}
});
})( arguments ); //这里处理add(a,b)，add([a,b]),同时添加多个方法的情况
if ( firing ) {
firingLength = list.length;
} else if ( memory ) { //第一次调用add时，memory是undefined。当调用fire时，如果你传入了memory，则memory就会变成true，这时你再调用add，就会进入if语句，进行fire。所以你传入memory，fire后，再调用add(b)，b方法会执行。
firingStart = start;
fire( memory );
}
}
return this;
},
remove: function() { //去掉list数组中相应的方法
if ( list ) {
jQuery.each( arguments, function( _, arg ) {
var index;
while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
list.splice( index, 1 ); //主要通过数组的splice方法去掉
if ( firing ) {
if ( index <= firingLength ) {
firingLength--;
}
if ( index <= firingIndex ) {
firingIndex--;
}
}
}
});
}
return this;
},
has: function( fn ) { //jQuery.inArray( fn, list )，如果fn在list中就返回1，不在，就返回-1
return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length ); //如果不传入值，就判断list中是否有值，有值就返回true。
},
empty: function() {
list = [];
firingLength = 0;
return this;
},
disable: function() { //后面所有的操作都失效
list = stack = memory = undefined;
return this;
},
disabled: function() {
return !list;
},
lock: function() { //只会锁住后面的fire操作，让cb.fire方法失效。
stack = undefined;
if ( !memory ) {
self.disable();
}
return this;
},
locked: function() {
return !stack;
},
fireWith: function( context, args ) { //这里执行list数组中的方法
if ( list && ( !fired || stack ) ) { //第一次调用时fired是undefined，第二次调用时，fired为true，就要看stack了。
args = args || []; //如果fire中传了值，就是args，如果没传，就是空数组
args = [ context, args.slice ? args.slice() : args ];
if ( firing ) { //当for循环在执行list数组中的方法时，firing为真，这时调用fire()->fireWith的话，只会把args添加到stack中。当list数组中的方法执行完之后。就会根据stack中是否有值来进行处理。举个例子：var cb = $.Callbacks();function a(){ cb.fire()};funciton b(){};cb.add(a,b);cb.fire();执行a方法，这时又触发fire()，但是不会再次执行a方法,因为这时firing为true，所以只会把stack加1，而是先等b方法执行结束后，才会又重新执行a方法。私有fire方法中会判断stack的值，如果有值，就会继续循环list数组中的方法进行调用执行。
stack.push( args );
} else {
fire( args ); //真正执行list数组中的方法是私有方法fire。
}
}
return this;
},
fire: function() { //fire方法其实就是执行list中的方法
self.fireWith( this, arguments ); //它调用的是fireWith方法.arguments就是fire中传入的参数，它可以给list数组中的方法传值进去
return this;
},
fired: function() {
return !!fired; //只要调用过一次fire就会返回true
}
};
return self; //返回的是self对象。当调用var cb = $.Callbacks()，cb =self。所以调用cb.add，fire,其实就是self.add和fire方法
};
加油！