java的dequeue_queue(),dequeue()

jQuery.extend({

queue: function( elem, type, data ) {

var queue;

if ( elem ) {

type = ( type || "fx" ) + "queue";

queue = jQuery._data( elem, type );

// Speed up dequeue by getting out quickly if this is just a lookup

if ( data ) {

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(),

//取出钩子对象，如果存在直接从cache中取，没有的话，新存入一个，并返回

hooks = jQuery._queueHooks( elem, type ),

//写死的next函数，调用next()意味着执行dequeue一次

next = function() {

jQuery.dequeue( elem, type );

};

// If the fx queue is dequeued, always remove the progress sentinel

if ( fn === "inprogress" ) {

fn = queue.shift();

startLength--;

}

hooks.cur = fn;

if ( fn ) {

// Add a progress sentinel to prevent the fx queue from being

// automatically dequeued

if ( type === "fx" ) {

queue.unshift( "inprogress" );

}

// clear up the last queue stop function

delete hooks.stop;

//重点说一下这里，elem域调用fn(queue的第一个函数),同时传递next函数(jQuery.dequeue( elem, type ))以及hooks

//这个钩子对象平时没啥用就是清理key的时候调用empty返回的callback对象的fire方法，

//第二个作用就是用在延迟定义里面，大家可以看一下下面的源码，它把这个钩子对象又添加了一个stop函数，意味着，这个队列可以清除定时的设置，清除之后，后面的就不执行了

fn.call( elem, next, hooks );

}

if ( !startLength && hooks ) {

hooks.empty.fire();

}

},

// not intended for public consumption - generates a queueHooks object, or returns the current one

_queueHooks: function( elem, type ) {

var key = type + "queueHooks";

return jQuery._data( elem, key ) || jQuery._data( elem, key, {

//这里利用了callbacks对象的add方法，将来fire的时候可以直接把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;

// 如果遇到这样的参数: $().queue( function(){} );

// 则重置下参数

if ( typeof type !== "string" ) {

data = type;

type = "fx";

setter--;

}

if ( arguments.length < setter ) {

return jQuery.queue( this[0], type );

}

return data === undefined ?

this :

this.each(function() {

var queue = jQuery.queue( this, type, data );

// ensure a hooks for this queue

jQuery._queueHooks( this, type );

if ( type === "fx" && queue[0] !== "inprogress" ) {

jQuery.dequeue( this, type );

}

});

},

dequeue: function( type ) {

return this.each(function() {

jQuery.dequeue( this, type );

});

},

// Based off of the plugin by Clint Helfers, with permission.

// http://blindsignals.com/index.php/2009/07/jquery-delay/

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", [] );

},

// Get a promise resolved when queues of a certain type

// are emptied (fx is the type by default)

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 );

}

});