Callback模块是用来治理回调函数,也作为deferred耽误对象得基本部份,如今一同来看看他的源码。
可选参数:
Options:
once: 是不是最多实行一次,
memory: 是不是记着近来的上下文和参数
stopOnFalse: 当某个回调函数返回false时中缀实行
unique: 雷同得回调只被增加一次
这是可选参数,下面能够举行试验:
var a = function (value) {
console.log('a:' + value);
};
var b = function (value) {
console.log('b:' + value);
};
var callbacks = $.Callbacks();
callbacks.add(a);
callbacks.fire(['hello']);
callbacks.add(b);
callbacks.fire('中');
下面是他的输出效果:
a: hello,
a:中,
b:中
能够看到得是,当我们第二次fire得时刻,a函数也会实行。
在到场参数举行试验,起首到场memory
var callbacks = $.Callbacks({
memory: true
});
callbacks.add(a);
callbacks.fire('hello');
callbacks.add(b);
输出:
a:hello,
b:hello
到场memory参数,memory记录上一次触发还调函数,以后增加的函数都用这参数马上实行。在来看once的运用
var callbacks = $.Callbacks({
once: true
});
callbacks.add(a);
callbacks.fire('hello');
callbacks.fire('中');
输出:
a:hello
能够看到的是,虽然实行了两次fire要领,然则只输出了一次效果。其他两个参数很好明白,细节的部份本身去尝试。
$.Callbacks = function(options) {
options = $.extend({}, options)
var memory,
fired,
firing,
firingStart,
firingLength,
firingIndex,
list = [],
stack = !options.once && []
}
再看看各个参数的意义,memory会在影象形式下记着上一次触发的上下文和参数,fired代表回调是不是已触发过,firing示意回调正在触发,firingStart回调使命最先的位置,firingLength回调使命的长度,firingIndex当前回调的索引,list示意实在的回调行列,在不是触发一次的情况下,用来缓存触发过程当中没有实行的使命参数。
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
break
}
}
firing = false
if (list) {
if (stack) stack.length && fire(stack.shift())
else if (memory) list.length = 0
else Callbacks.disable()
}
}
fire函数是唯一内置的函数,他的作用是用于触发list的回调实行,起首看看他传进的参数,和我们在外部挪用$.Callbacks的fire还不太一样,这里的data是一个数组,data[0]示意上下文,data[1]是要领挪用的参数。然后就是各个参数的的初始化,memory示意假如options.memory为true,则保留data,fired为true,假如firingStart为0,那末firingIndex 为0,firingStart置为0,正在触发的回调标记firing为true。
然后遍历回调列表,逐一实行回调,这个里边的if推断示意的是假如回调函数返回的是false而且options.stopOnFalse是false,则清空memory的缓存。遍历完成后,将实行的状况改成false。假如list存在,stack也存在,把使命参数取出来,挪用fire函数实行。假如memory存在,则清空列表,不然举行回调实行
终究这个文件返回的是Callbacks,我们来看看他的详细完成:
Callbacks = {
add: function () {
if (list) {
var start = list.length,
add = function (args) {
$.each(args, funciton(_, arg) {
if (typeof arg === 'function') {
if (!options.unique || !Callbacks.has(arg)) list.push(arg);
} else if (arg && arg.length && typeof arg !== 'string') add(arg);
})
}
add(arguments)
if (firing) firingLength = list.length;
else if (memory) {
firingStart = start;
fire(memory)
}
}
return this;
}
}
这个函数重要的作用就是像list里边push回调。起首推断list是不是存在,假如存在,start赋值为list的长度,在内部增加一个add要领,内部add要领重如果向list增加回调,假如我们传入的参数是数组,就再次挪用add要领。然后就是挪用add要领,把arguments传进去。假如回调正在举行,则修改回调使命的长度firingLength为当前使命列表的长度,以便后续增加的回调函数能够实行。假如memory存在,则把最先设置为新增加列表的第一位,然后挪用fire。
我们再来看看fireWith的做法:
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;
}
传入的参数包含上下文,和参数列表。函数实行的前提是list存在而且回调没有实行或许stack存在,stack能够为空。起首对args举行从新赋值,args[0]是上下文,args[1]是复制过来的列表。假如回调正在举行,向stack里边增加args,或许就实行args。