jQuery1.9.1--queue队列源码分析(非动画部分)

 jQuery.extend({
         // 显示或操作在匹配元素上执行的函数队列
         queue: function (elem, type, data) {
             var queue;

             if (elem) {
                 // type没定义的话就默认使用fxqueue
                 type = (type || 'fx') + 'queue';
                 // 先获取elem上的缓存数据
                 queue = jQuery._data(elem, type);

                 if (data) {
                     // 如果没有缓存数据或者data是数组
                     // 则给elem设置缓存数据
                     if (!queue || jQuery.isArray(data)) {
                         queue = jQuery._data(elem, type, jQuery.makeArray(data));
                     } else {
                         // 否则存在缓存数据数组直接入栈
                         queue.push(data);
                     }
                 }
                 return queue || [];
             }
         },
         // 从队列最前端移除一个队列函数，并执行它
         dequeue: function (elem, type) {
             type = type || 'fx';

             var
             // 获取缓存队列
                 queue = jQuery.queue(elem, type),
                 startLength = queue.length,
             // 取得队列的第一个元素
                 fn = queue.shift(),
             // 钩子对象，如果获取不到缓存的钩子对象，就设置新的钩子对象并返回
                 hooks = jQuery._queueHooks(elem, type),
             // 用来执行下一个队列
                 next = function () {
                     jQuery.dequeue(elem, type);
                 };

             // 如果第一个元素是"inprogress",取下一个元素，长度相应减1
             if (fn === 'inprogress') {
                 fn = queue.shift();
                 startLength--;
             }

             // 为钩子对象添加cur方法
             hooks.cur = fn;
             // 如果此时fn不为null || false || undefined
             if (fn) {
                 // 如果type为“fx”，给队列添加"inprogress",防止自动出列(dequeue)
                 if (type === 'fx') {
                     queue.unshift('inprogress');
                 }

                 // 删除上一个队列的stop函数
                 delete hooks.stop;
                 // 执行fn函数，并且把下一个队列函数设置为fn的第一个参数
                 /*
                 可以这样使用：
                  $(document.body).queue('test', function(next){
                  console.log(11);
                  next();
                  });
                  $(document.body).queue('test', function(){
                  console.log(22);
                  });
                  $(document.body).dequeue('test');
                  */
                 fn.call(elem, next, hooks);
             }

             // 如果队列长度为0且存在钩子对象，则删除缓存
             if (!startLength && hooks) {
                 hooks.empty.fire();
             }
         },
         // 私有方法，生成一个队列钩子对象（即从缓存数据中获取的队列钩子）
         // 或者设置缓存队列钩子对象，这个对象的empty属性是一个Callbacks对象，这里的作用是删除缓存队列和缓存队列钩子的数据
         _queueHooks: function (elem, type) {
             var key = type + 'queueHooks';
             return jQuery._data(elem, key) || jQuery._data(elem, key, {
                 empty: jQuery.Callbacks('once memory').add(function () {
                     jQuery._removeData(elem, type + 'queue');
                     jQuery._removeData(elem, key);
                 })
             });
         }
     });

     jQuery.fn.extend({
         queue: function (type, data) {
             var setter = 2;

             if (typeof type !== 'string') {
                 data = type;
                 type = 'fx';
                 setter--;
             }

             /*
             当满足这个条件的有以下几个情况：
             1.没有参数
             2.参数只有一个，且type是字符串
              */
             if (arguments.length < setter) {
                 return jQuery.queue(this[0], type);
             }

             // 其他情况
             return data === undefined ?
                 this :
                 this.each(function () {
                     var queue = jQuery.queue(this, type, data);

                     jQuery._queueHooks(this, type);

                     // 如果是动画队列且第一个元素不是"inprogres",
                     // 就出列并执行下一个元素
                     if (type === 'fx' && queue[0] !== 'inprogress') {
                         jQuery.dequeue(this, type);
                     }
                 });
         },
         dequeue: function (type) {
             return this.each(function () {
                 jQuery.dequeue(this, type);
             });
         },
         // TODO
         delay: function (time, type) {
             time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
             type = type || 'fx';

             return this.queue(type, function (next, hooks) {
                 var timeout = setTimeout(next, time);
                 hooks.stop = function () {
                     clearTimeout(timeout);
                 };
             });
         },
         clearQueue: function (type) {
             return this.queue(type || 'fx', []);
         },
         promise: function (type, obj) {
             var tmp,
                 count = 1,
                 defer = jQuery.Deferred(),
                 elements = this,
                 i = this.length,
                 resolve = function () {
                     if (!(--count)) {
                         defer.resolveWith(elements, [elements]);
                     }
                 };

             if (typeof type !== 'string') {
                 obj = type;
                 type = undefined;
             }
             type = type || 'fx';

             while (i--) {
                 tmp = jQuery._data(elements[i], type + 'queueHooks');
                 if (tmp && tmp.empty) {
                     count++;
                     tmp.empty.add(resolve);
                 }
             }
             resolve();
             return defer.promise(obj);
         }
     });