jQuery的回调对象Callbacks分析

Callbacks在jQuery中的地位是Deferred的基础，当然，也对外公开其方法。

Callbacks对象是统一管理多个函数的利器。其核心是参数options中的几个状态码的任意组合，非常灵活。

先来看看options

once: 只触发一次回调

memory: 如果是触发后状态，add后立即触发

unique: 添加相同回到函数，只触发其中一个

stopOnFalse: 回调中遇到return false， 后面都不执行。

首先是：

list = []

我们的工作就是在维护这个list

add: function() {
if ( list ) {
// First, we save the current length
var start = list.length;
(function add( args ) {
jQuery.each( args, function( _, arg ) {
var type = jQuery.type( arg );
if ( type === "function" ) {
if ( !options.unique || !self.has( arg ) ) {
list.push( arg );
}
} 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;
// With memory, if we're not firing then
// we should call right away
} else if ( memory ) {
firingStart = start;
fire( memory );
}
}
return this;
},

其核心就是那个push方法。代码为什么这么多？ 支持数组方式参数，遇到参数中有memory情况，执行方法。

remove方法：

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;
},

其核心也是那个splice方法。

针对这个firing，后面介绍。

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 ) {
if ( stack ) {
if ( stack.length ) {
fire( stack.shift() );
}
} else if ( memory ) {
list = [];
} else {
self.disable();
}
}
}

其核心是哪个循环，拿出来一个个执行。

在这里有个stack

stack = !options.once && []

这是一个数组，干嘛用的呢？这是针对有些函数是延时函数，这种情况fire可能会延时，要先把它放到stack函数中。

这样，以上的firing状态也就可以理解了。

这就是Callbacks整体，其核心原理还算是比较简单了。