queue(),dequeue()

这两个方法，一个是往里面添加队列，一个是执行队列 也是分静态方法和实例方法，

同样，实例方法最后调用静态方法 源码主要分析一下延迟delay方法，如何起作用的，写的有点仓促，先记录一下

在这里参照了网络上的文章，给推荐一下，介绍的很详细了，作者比较用心：

http://www.html-js.com/card/1083，他是基于1.7的，我这边运行的是1.9的，但是核心思想是一样的

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

下面引用网络上的一个例子，大家有兴趣可以运行一下，主要对delay的理解

var obj = {};
			$.queue(obj, 'say', function(next) {
				document.write('hello ');
				next();
			});
			$.queue(obj, 'say', function() {
				document.write('world');
			});
			$.dequeue(obj, 'say');
			document.write("...............");
			var elem = {};
　　　　　　　　　　　　　　//这里没用链式表达式本意是debug用的，这里的function传参也是参照dequeue中的fn.call( elem, next, hooks );这样就可以连着调用2次queue了
			var e = $(elem).queue('handle', function(next) {
				document.write('first handle');
				next();
			});
			e.delay("1000", 'handle');
			e.queue('handle', function() {
				document.write('second handle');
			});
			e.dequeue('handle');
			/*
			 *
				dequeue中有一段话
				var fn = queue.shift();
				if ( fn ) {
					delete hooks.stop;
					fn.call( elem, next, hooks );
				}
				如果第一个函数是delay进去的函数的话，则赋予了elem.handleququeHooks.stop
				fn.call()这个函数把hooks传入，next原封不动，只是用setTimeout定时了
				var next = function() {
					jQuery.dequeue( elem, type );
				};
				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 );
						};
					});
				}
			 *
			 *
			 *
			 *
			 */
 
			var stopFn = $._data(elem, "handlequeueHooks").stop;
			 // function () { clearTimeout( timeout ); }
			console.log(stopFn);
			 // 停止运行
			//stopFn();
			 // 手动运行后续处理函数
			 // 这里如果注释掉的话,第二个处理函数就不会执行,
			 // 这里我们也看到了关于第二个参数: hooks 的使用方式。
			//$(elem).dequeue('handle');