jQuery的callback函数基本使⽤
如果不传⼊参数flags，则回调函数列表的⾏为类似于事件监听函数，能够被触发多次
// 基本使⽤
function aaa(){
alert(1);
}
function bbb(){
alert(2);
}
var cb = $.Callbacks();
cb.add(aaa);
cb.add(bbb);
cb.fire();
//-------------------------------
var cb = $.Callbacks();
function aaa(){
alert(1);
}
cd.add(aaa);
(function(){
function bbb(){
alert(2);
去火的食物有哪些}
cb.add(bbb);
})
cd.fire();
//-----------------------------------
// 四个参数的作⽤
/
/ once: fire() 只能触发⼀次
var cb = $.Callbacks('once');
// memory: 只要写⼊Callbacks⾥⾯的，不管先后顺序，都可以触发
var cb = $.Callbacks('memory');
cb.add(aaa);
db.fire();
cb.add(bbb);
cb.add(bbb);
// unique: 不会重复触发相同的函数
// stopOnFal
function aaa(){
alert(1);
return fal;// 会终⽌，以后的不会触发
}
转经筒function bbb(){
alert(2);
}
function ccc(){
alert(3)
}
var cb = $.Callbacks('stopOnFal');
cb.add(aaa);
cb.add(bbb);
cd.fire();
// 组合使⽤
自制炼乳var cb = $.Callbacks('stopOnFal once');
代码
// String to Object options format cache
// {"once": true, "memory": true}
var optionsCache ={};
// Convert String-formatted options into Object-formatted ones and store in cache
function createOptions( options ){
// 变量object和flagsCache[ flags ]指向了同⼀个空对象，object改变的时候，optionsCatche也会改变
var object = optionsCache[ options ]={};
// core_rnotwhite = /\S+/g,
// console.log("111 222 333".match(/\S+/g));
// ["111", "222", "333"]
jQuery.each( options.match( core_rnotwhite )||[],function( _, flag ){
// {"once": true, "memory": true}
object[ flag ]=true;
});
return object;
}
应用型人才
/**
* 四个参数的作⽤：
* 1. once ：fire() 只能触发⼀次
* 2. memory ：只要写⼊Callbacks⾥⾯的，不管先后顺序，都可以触发
* 3. unique ：不会重复触发相同的函数
* 4. stopOnFal ：某个回调函数返回fal之后中断后⾯的回调函数
*/
jQuery.Callbacks=function( options ){
// Convert options from String-formatted to Object-formatted if needed
// (we check in cache first)
// options 可以传⼊⼀个字符串或⼀个对象
// {"test": "true", "one": "true", "two": "true", "three": "true"}
/
/ 先尝试从缓存对象flagsCache中获取标记字符串flags对应的标记对象，如果没有找到，再调⽤⼯具函数createFlags(flags)将标记字符串flags解析为标记对象，并放⼊缓存对象flagsCache中
options =typeof options ==="string"?
( optionsCache[ options ]||createOptions( options )):
// d() 函数⽤于将⼀个或多个对象的内容合并到⽬标对象。如果⽬标对象有相同属性，后⾯的覆盖前⾯的
var// Last fire value (for non-forgettable lists)
// 最近⼀次触发回调的参数
// 最近⼀次触发回调的参数
// 变量memory的初始值为undefined，表⽰当前回调函数列表未被触发过
memory,
// Flag to know if list was already fired
// 是否回调列表已经执⾏过⾄少⼀次
fired,
// Flag to know if list is currently firing
// 回调列表是否在执⾏中
firing,
// First callback to fire (ud internally by add and fireWith)
// 初始执⾏的位置
蟹黄酱怎么吃
firingStart,
// End of the loop when firing
// 执⾏过程的结尾
firingLength,
// Index of currently firing callback (modified by remove if needed)
// 正在执⾏回调函数的索引
firingIndex,
// Actual callback list
// 回调列表
list =[],
// Stack of fire calls for repeatable lists
// 可重复的回调函数堆栈，⽤于控制触发回调时的参数列表
// once的作⽤在这⾥体现（once：只能触发⼀次）
// stack = fal
stack =! &&[],
/**
* 我终于看懂啥意思了，⾸先看add函数，看完了吧，之后咱看fire函数
*/
// Fire callbacks
// 触发回调函数列表
// fire(context,args)，参数context⽤于指定回调函数执⾏时的上下⽂，即关键字this所引⽤的对象，参数args⽤于指定调⽤回调函数时传⼊的参数fire=function( data ){
memory = && data;
// 是否回调列表已经执⾏过⾄少⼀次
fired =true;
firingIndex = firingStart ||0;
firingStart =0;
firingLength = list.length;
// 回调列表是否在执⾏中
firing =true;
for(; list && firingIndex < firingLength; firingIndex++){
// 有关stopOnFal的代码
// db.fire(); / db.fire(context, "XXX") 可以传参数，也可以不传参数
// 如果执⾏这个函数的返回值是fal，且ur需要stopOnFal，就终⽌循环
// 且如果有memory，也改为fal
if( list[ firingIndex ].apply( data[0], data[1])===fal&& options.stopOnFal ){
memory =fal;// To prevent further calls using add
break;
}
}
firing =fal;
// 如果list⾥⾯有内容，说明是刚才存下来的，得把⾥⾯的参数都执⾏了
// 为什么不⽤while循环执⾏stack⾥⾯的内容，因为是递归，下次还会检查list⾥⾯是否有内容
if( list ){人大代表提议
if( stack ){
// stack = ! && [],
if( stack.length ){
// shift () ⽅法⽤于把数组的第⼀个元素从其中删除，并返回第⼀个元素的值
/
/ 删除，说明这个已经执⾏过了，之后不⽤再执⾏了
fire( stack.shift());
}
// once + memory 模式
// 则清空数组list，后续添加的回调函数还会⽴即执⾏
}el if( memory ){
}el if( memory ){
list =[];
}el{
lf.disable();
}
}
},
// lf是最后返回的对象
// 添加⼀个或多个回调函数到数组list中。如果是unique模式，并且待添加的回调函数已添加过，则不会添加。该函数通过闭包机制引⽤数组list
lf ={
// Add a callback or a collection of callbacks to the list
// ⽅法callbacks.add()⽤于添加⼀个或⼀组回调函数到回调函数列表中，通过调⽤⼯具函数add(args)实现；在memory模式下，如果回调函数列表未在执⾏中，并且已经被触发过，则⽴即执⾏新添加的回调函数。
add:function(){
// 如果list存在
if( list ){
// 从list的末尾开始添加
var start = list.length;
// 匿名函数⾃执⾏ add the function to list
// cb.add(aaa, bbb);
// 把回调函数逐个添加到数组list中。添加时检查args[i]的类型，如果args[i]是数组，则迭代调⽤⼯具函数add(args)把数组中的回调函数添加到数组list中；如果args[i]是函数并且不是unique模式，或者是unique模式但未添加过，才会添加args[i]到数组list中。函数以外的类型，则被忽略。
(function add( args ){
jQuery.each( args,function( _, arg ){
var type = pe( arg );
if( type ==="function"){
出血性胃炎
// if options.unique == true, this is said ur need unique
// so have to check list has arg or not
if(!options.unique ||!lf.has( arg )){
list.push( arg );
}
// arg is function or sameFunction ([] or {0: , 1: , 2: , length: 3})
// cb.add([aaa, bbb], ccc);
}el if( arg && arg.length && type !=="string"){
// 递归调⽤
add( arg );
}
});
})( arguments );
// Do we need to add the callbacks to the
// current firing batch?
// 如果正在fire list⾥⾯的内容
// 改变firingLength的长度
// 修正结束下标firingLength，使得新添加的回调函数也得以执⾏。
if( firing ){
firingLength = list.length;
// With memory, if we're not firing then
// we should call right away
/
/ 如果在调⽤这个函数之前，设置了memory状态，直接将这个函数之后所有函数fire⼀遍
}el if( memory ){
firingStart = start;
fire( memory );
}
}
return this;
},
// Remove a callback from the list
// cb.remove(aaa, bbb);
remove:function(){
if( list ){
jQuery.each( arguments,function( _, arg ){
var index;
// 万⼀有多个，所以⽤while
while(( index = jQuery.inArray( arg, list, index ))>-1){
list.splice( index,1);
// Handle firing indexes
// Handle firing indexes
// 则会修正结束下标firingLength和当前下标firingIndex，确保移除的同时不会遗漏执⾏回调函数。
if( firing ){
if( index <= firingLength ){
firingLength--;
}
if( index <= firingIndex ){
firingIndex--;
}
}
}
});
}
return this;
},
/
/ Check if a given callback is in the list.
// If no argument is given, return whether or not list has callbacks attached.
// 如果!!( list && list.length )成⽴，fn为null undefined 都返回true
has:function( fn ){
return fn ? jQuery.inArray( fn, list )>-1:!!( list && list.length );
},
// Remove all callbacks from the list
empty:function(){
list =[];
firingLength =0;
return this;
},
// Have the list do nothing anymore
// 禁⽤回调列表中的回调
disable:function(){
list = stack = memory = undefined;
return this;
},
// Is it disabled?
// 判断是否处于disabled状态，返回true或fal
disabled:function(){
return!list;
},
// Lock the list in its current state
// 回调列被锁死，再调⽤callbacks.fire()或callbacks.fireWith()都将失效
// callbacks有memory标记：当前fire()或fireWith()⽅法中没有执⾏的回调会继续执⾏，但回调中的callbacks.fire()和callbacks.fireWith()都不会再起作⽤。// callbacks⽆memory标记：所有回调全部被清空，也就是说后⾯的回调都不再执⾏。教培机构
lock:function(){
stack = undefined;
if(!memory ){
lf.disable();
}
return this;
},
// Is it locked?
locked:function(){
return!stack;
},
// Call all callbacks with the given context and arguments
// 使⽤指定的上下⽂context和参数args调⽤数组list中的回调函数。该函数通过闭包机制引⽤数组list
// 在memory模式下，回调函数列表的⽅法callbacks.add()在添加回调函数后，如果回调函数列表未禁⽤并且已经被触发过，也会调⽤⼯具函数fire(context, args)来⽴即执⾏新添加的回调函数。
fireWith:function( context, args ){
// fired是是否⾄少执⾏过⼀次，如果没执⾏过，是fal，可以执⾏下⾯的内容
// 如果之前执⾏过，再看看stack是否存在，如果stack存在，也可以执⾏下⾯的内容
if( list &&(!fired || stack )){
args = args ||[];
args =[ context, args.slice ? args.slice(): args ];
if( firing ){
// 如果执⾏函数的时候，不需要参数，args就是[]
