前言：作为参数传递给另一个函数执行的函数我们称为回调函数，那么该回调又是否是异步的呢，何谓异步，如：作为事件处理器，或作为参数传递给(setTimeout，setInterval)这样的异步函数，或作为ajax发送请求，应用于请求各种状态的处理，我们可以称为异步回调，jQuery.Callbacks为我们封装了一个回调对象模块，我们先来看一个应用场景： // 为什么jQuery中的ready事件可以执行多个回调，这得益于我们的jQuery.Deferred递延对象(是基于jQuery.Callbacks回调模块)  jQuery(function($) {      console.log('document is ready!');      // do something  });   jQuery(function($) {      // do something  });   // 实现原型  // jQuery.Deferred版代码  var df = jQuery.Deferred();  df.resolve(); // 在ready事件中调用   // 可以多次执行绑定的函数  df.done(fn1, fn2, fn3);  df.done(fn4);  // ...    // jQuery.Callbacks版代码  var cb = jQuery.Callbacks('once memory');  cb.fire(); // 在ready事件中调用   // 可以多次执行绑定的函数  cb.add(fn1, fn2, fn3);  cb.add(fn4);  // ... 现在我们知道jQuery中的ready事件是可以这样执行多个回调的，要想深入理解其源码，让我们继续看下面吧 一、jQuery.Callbacks设计思路使用一个私有变量list(数组)存储回调，执行jQuery.Callbacks函数将返回一个可以操作回调列表list的接口对象，而传入jQuery.Callbacks函数的options参数则用来控制返回的回调对象操作回调列表的行为 回调对象中的方法 {      add:        增加回调到list中      remove:     从list中移除回调      fire:       触发list中的回调      fired:      回调对象是否执行过fire方法      fireWith:   触发list中的回调，第一个参数为执行域      has:        判断函数是否在list中      empty:      将list致空，list = [];      lock:       锁定list      locked:     是否锁定      disable:    禁用回调对象      disabled:   是否禁用  } 参数标志:options = {      once:       回调对象仅触发(fire)一次       memory:     跟踪记录每一次传递给fire函数的参数，在回调对象触发后(fired)，                  将最后一次触发(fire)时的参数(value)传递给在add操作后即将被调用的回调       unique:     在add操作中，相同的函数仅只一次被添加(push)到回调列表中       stopOnFalse:当回调函数返回false，中断列表中的回调循环调用，且memory === false，阻止在add操作中将要触发的回调  }

 

二、源码解析    var // Used for splitting on whitespace          core_rnotwhite = /\S+/g;           var optionsCache = {};           // Convert String-formatted options into Object-formatted ones and store in cache      // 将字符串格式选项转化成对象格式形式，并存储在缓存对象optionsCache[options]中      // 该缓存起作用适用于执行多次jQuery.Callbacks函数，且传递options参数一致，我们在jQuery.Deferred      // 源码就可以看到tuples二维数组中执行了两次jQuery.Callbacks('once memory')      function createOptions( options ) {          var object = optionsCache[ options ] = {};          jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {              object[ flag ] = true;          });          return object;      }      jQuery.Callbacks = function( options ) {               // Convert options from String-formatted to Object-formatted if needed          // (we check in cache first)          options = typeof options === "string" ?              ( optionsCache[ options ] || createOptions( options ) ) :              jQuery.extend( {}, options );               var // Flag to know if list is currently firing              firing,              // Last fire value (for non-forgettable lists)              memory,              // Flag to know if list was already fired              fired,              // End of the loop when firing              firingLength,              // Index of currently firing callback (modified by remove if needed)              firingIndex,              // First callback to fire (used internally by add and fireWith)              firingStart,              // Actual callback list              list = [],              // Stack of fire calls for repeatable lists              stack = !options.once && [],              // Fire callbacks              fire = function( data ) {                  memory = options.memory && data;                  fired = true;                  firingIndex = firingStart || 0;                  firingStart = 0;                  firingLength = list.length;                  firing = true;                  // 迭代list回调列表，列表中的回调被应用(或执行回调)                  for ( ; list && firingIndex < firingLength; firingIndex++ ) {                      // 如果回调返回false，且options.stopOnFlase === true，则中断循环                      // 注：data[1]是一个伪数组(self.fire方法中的arguments(参数集合))                      if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {                                              memory = false; // To prevent further calls using add   // 阻止在add操作中可能执行的回调                          break;                      }                  }                  firing = false;                  if ( list ) {                      // (options.once === undefined)，回调对象可以触发多次                      if ( stack ) {                          // 处理正在执行的回调中的fireWith操作                          // 注：如果执行的回调中真的拥有fire或fireWith操作，那么列表中的回调将会无限循环的执行，请看实例1                          if ( stack.length ) {                              fire( stack.shift() );                          }                      }                      // (options.once === true && options.memory === true)                      // 回调列表致空，但允许add继续添加并执行回调                      else if ( memory ) {                          list = [];                      }                      // (options.once === true && options.memory === undefined)                      // 禁用回调对象                      else {                          self.disable();                      }                  }              },              // Actual Callbacks object              self = {                  // Add a callback or a collection of callbacks to the 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" ) {                                      // 回调不唯一 或 唯一且不存在，则push                                      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?                          // 如果正在执行的回调执行了add操作，更新firingLength，将列表中新加进来的最后一个回调加入到回调执行的队列中                          if ( firing ) {                              firingLength = list.length;                               // With memory, if we're not firing then                          // we should call right away                          // 如果可能(options.memory === true)，在回调对象不能再次fire(options.once === true)时，                          // 我们应该使用memory(记录的最后一次fire时的参数)立即调用回调                          } else if ( memory ) {                              firingStart = start;                              fire( memory );                          }                      }                      return this;                  },                  // Remove a callback from the list                  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                                  // 在回调对象触发(fire)时，如果firingLength、firingIndex(正在执行的回调在列表list中的索引index)                                  // 大于等于 移除的回调的索引(index)，分别减一，确保回调执行队列中未执行的回调依次执行                                  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.                  // 检查给定的回调是否在列表中                  // 如果未给定回调参数，返回列表是否有回调                  has: function( fn ) {                      return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );                  },                  // Remove all callbacks from the list                  // 将列表致空，list = []; firingLenght = 0;                  empty: function() {                      list = [];                      firingLength = 0;                      return this;                  },                  // Have the list do nothing anymore                  // 禁用回调对象                  // 将list赋值为undefined就可以使self中的add，remove，fire，fireWith方法停止工作                  // 我认为这里把stack、memory赋值为undefined与否是没有任何关系的                  disable: function() {                      list = stack = memory = undefined;                      return this;                  },                  // Is it disabled?                  disabled: function() {                      return !list;                  },                  // Lock the list in its current state                  // 锁定回调列表                  // 如果(fired !== true || options.memory === false)，则视为禁用(disable)                  // 如果(fired === true && options.memory === true)，则视为options.once === true                  // 请看实例2                  lock: function() {                      stack = undefined;                      if ( !memory ) {                          self.disable();                      }                      return this;                  },                  // Is it locked?                  locked: function() {                      return !stack;                  },                  // Call all callbacks with the given context and arguments                  fireWith: function( context, args ) {                      // 回调对象未执行过fire 或且 可以执行多次(options.once === false)                      // 如果(fired === true && options.once === true)，则不会执行fire操作                      if ( list && ( !fired || stack ) ) {                          args = args || [];                          args = [ context, args.slice ? args.slice() : args ];                          if ( firing ) {                              stack.push( args );                          } else {                              fire( args );                          }                      }                      return this;                  },                  // Call all the callbacks with the given arguments                  fire: function() {                      self.fireWith( this, arguments );                      return this;                  },                  // To know if the callbacks have already been called at least once                  fired: function() {                      return !!fired;                  }              };               return self;      };

三、实例实例1、 处理回调函数中的fire，或fireWidth操作     var cb = jQuery.Callbacks();           var fn1 = function(arg){ console.log( arg + '1' ); };      var fn2 = function(arg){ console.log( arg + '2' ); cb.fire();  };      var fn3 = function(arg){ console.log( arg + '3' ); };           cb.add(fn1, fn2, fn3);           cb.fire('fn'); // 其中回调fn1,fn2,fn3无限制的循环调用           /*      控制台将无限制输出如下:      fn1      fn2      fn3      fn1      fn2      fn3      fn1      fn2      fn3      .      .      .      */  实例2、 锁定(lock)操作各种场景中的用法    var cb1 = jQuery.Callbacks();      var cb2 = jQuery.Callbacks('memory');      var cb3 = jQuery.Callbacks('memory');           var fn1 = function(arg){ console.log( arg + '1' ); };      var fn2 = function(arg){ console.log( arg + '2' ); };      var fn3 = function(arg){ console.log( arg + '3' ); };           // 如果options.memory !== true，锁定操作视为禁用回调对象      cb1.add(fn1);      cb1.lock();      // 以下操作无任何反应      cb1.add(fn2);      cb1.fire('fn');           // 如果fried !== true，锁定操作也视为禁用回调对象      cb2.add(fn1);      cb2.lock();      // 以下操作无任何反应      cb2.add(fn2);      cb2.fire('fn');           // 如果(fired === true && options.memory === true)，锁定操作类似控制标志once(options.once === true);      cb3.add(fn1);      cb3.fire('fn'); // fn1，此时fired === true      cb3.lock();     // 像是传入了'once'标志，jQuery.Callbacks('once memory');      cb3.add(fn2);   // fn2      cb3.fire('fn'); // 再次触发，无任何反应      cb3.add(fn3);   // fn3                // 再来看看jQuery.Deferred中的一段源码      var tuples = [          // action, add listener, listener list, final state          [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],          [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],          [ "notify", "progress", jQuery.Callbacks("memory") ]      ];           // Handle state      if ( stateString ) {          list.add(function() {              // state = [ resolved | rejected ]              state = stateString;               // [ reject_list | resolve_list ].disable; progress_list.lock          }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );      }           /*          当执行了tuples中前面两组中任意一个回调对象的fire方法时，后一组回调对象被锁定，          相当于(fired === true && options.memory === true)，后一组回调对象实际为执行          jQuery.Callbacks('once memory')生成的回调对象。      */