var callbacks=$.Callbacks(options) 创建实例
options.once 是否只执行一次，默认为否
options.memory:是否记录上次执行的回调函数参数，记录后，再次执行回调时将该参数推入queue参数数组中，默认为否
options.unique:保证回调函数的单一性，默认为否
options.stopOnFalse:当回调返回值为否时，是否终止回调函数执行，默认为否
配置项可以用字符串输入，将自动转化为对象形式，如"once"将转化为{once:true}
callbacks.add(fn) 添加回调函数
callbacks.fire("foo") 将参数"foo"传给各回调函数，并触发回调函数执行
callbacks.fireWith(content,“foo”) 回调函数上下文设为content，参数为"foo"，并触发回调函数执行
callbacks.has(fn) 回调函数数组list是否有函数fn
callbacks.empty() 清空回调函数数组list
callbacks.remove(fn) 清除回调函数数组list指定的回调函数fn
callbacks.disable() 使回调函数中add和fireWith、fire方法均不可用，清空回调函数列表list、参数列表queue
callbacks.disabled() 判断实例是否不可用
callbacks.lock() 使回调函数中add方法均不可用，fireWith、fire方法根据memory有无设置有效性，若无且执行状态为不在执行中，fireWith、fire方法不可用
callbacks.lock() 判断实例是否锁死
源码书写的长处：
利用循环语句实现回调函数的顺序执行
利用循环语句+数组方法起始查询位清空数组中的重复项
利用转换类型的方式卡死if条件判断，进而阻止函数执行，如list回调函数列表在disable方法执行时设为""，而非[]，使其在add方法的条件返回否值，阻止add方法执行
通过闭包驻留缓存信息如list回调函数数组、queue参数数组、memory前次执行参数记录等
源码：
define([
"./core",
"./var/rnotwhite"// 返回匹配空白的正则
], function( jQuery,rnotwhite ){
// 当options为字符串时，使用match方法分割空格类字符，各数组项作为object的属性，赋值为true后返回
function createOptions(options){
var object={};
jQuery.each( options.match( rnotwhite )||[], function(_,flag){
object[flag]=true;// 空数组不执行该语句
} );
return object;
}
/*
* Create a callback list using the following parameters:
*
* options: an optional list of space-separated options that will change how
* the callback list behaves or a more traditional option object
*
* By default a callback list will act like an event callback list and can be
* "fired" multiple times.
*
* Possible options:
*
* once:是否只执行一次，默认为否
* memory:是否记录上次执行的回调函数参数，记录后，再次执行回调时将该参数推入queue参数数组中，默认为否
* unique:保证回调函数的单一性，默认为否
* stopOnFalse:当回调返回值为否时，是否终止回调函数执行，默认为否
*/
jQuery.Callbacks=function(options){
// 将字符串格式的options转化成对象形式
options=typeof options==="string" ? createOptions(options) : jQuery.extend({},options);
var firing,// 回调函数正在执行中状态
memory,// 前次执行时回调函数使用的参数
fired,// 回调函数已执行状态
locked,// 锁定回调函数，回调函数数组清空
list=[],// 所有回调都添加到list数组列表中
queue=[],// 数组形式存储回调函数的参数，每个数组项又是数组形式，其中首项为this，即Callbacks对象
firingIndex=-1,// 用以指向list回调函数数组的序号，便于循环执行回调
// 内部函数，执行回调
fire=function(){
locked=options.once;
fired=firing=true;
for ( ; queue.length; firingIndex=-1 ){
memory=queue.shift();
while ( ++firingIndex<list.length ){// 利用循环语句使回调函数顺序执行
if ( list[firingIndex].apply(memory[0], memory[1])===false && options.stopOnFalse ){
firingIndex=list.length;
memory=false;
}
}
}
// 在不记录前次执行回调函数参数的前提下，当memory中的参数已执行，则将memory置为否
if ( !options.memory ){
memory=false;
}
firing=false;
// once设为真，只执行一次的前提下，清空回调函数数组
if ( locked ){
if ( memory ){
list=[];
}else{
list="";// memory为否，即options.memory为否，此时add方法失效
}
}
},
self={
// 添加回调函数
add:function(){
if ( list ){
if ( memory && !firing ){
firingIndex=list.length-1;// 重新设置firingIndex的意义？？？
queue.push(memory);
}
(function add(args){
jQuery.each(args,function(_,arg){
if ( jQuery.isFunction(arg) ){
if ( !options.unique || !self.has(arg) ){
list.push(arg);
}
}else if( arg && arg.length && jQuery.type(arg)!=="string" ){
// 递归添加回调函数
add(arg);
}
} );
})(arguments);
if ( memory && !firing ){// options.memory设为真，且没有回调函数执行的前提下，执行回调函数
fire();
}
}
return this;
},
// 从list列表清除某些回调函数
remove:function(){
jQuery.each(arguments, function(_,arg){
var index;
// 利用循环语句查找list回调函数数组中与arg函数相同的项
while ( ( index=jQuery.inArray(arg,list,index) ) > -1 ){
list.splice(index,1);
if ( index<=firingIndex ){// 影响当前执行的Callbacks实例中的回调函数，函数删除后序号减1
firingIndex--;
}
}
} );
return this;
},
// 传入参数时判断函数是否list回调函数数组中，否则判断list中是否有回调函数
has:function(fn){
return fn ? jQuery.inArray(fn,list)>-1 : list.length>0;
},
// 清空回调函数
empty: function(){
if ( list ){
list=[];
}
return this;
},
// locked设为[]，list设为""，使add、fireWith方法失效
disable: function(){
locked=queue=[];
list=memory="";
return this;
},
// 返回当前实例的fire、add方法是否有效，locked判断fire方法可能有效
disabled: function(){
return !list;
},
// fire方法执行后，执行lock方法，清空参数队列，且locked设为[]，使fireWith方法无效(需要locked为否)
// 当memory和firing均为否时，list置为""，使add方法无效(需要list为否)
lock: function(){
locked=queue=[];
if ( !memory && !firing ) {
list=memory="";
}
return this;
},
// 返回当前实例是否被锁定，参数数组queue或回调函数数组list被清空
locked: function(){
return !!locked;
},
// 执行回调函数，queue数组首项为Callbacks构造函数，其余项为给回调函数的参数
fireWith: function(context, args){
if ( !locked ) {
args=args||[];
args=[context, args.slice?args.slice():args];
queue.push(args);
if ( !firing ){
fire();
}
}
return this;
},
// 执行回调函数，arguments以数组形式传给各回调函数
fire: function(){
self.fireWith(this,arguments);
return this;
},
// 返回回调函数是否被调用
fired: function(){
return !!fired;
}
};
return self;
};
return jQuery;
});