//对外接口
jQuery.extend({
    queue: function( elem, type, data ) {//入队。元素、队列名字、存进去的函数
    //jQuery.queue( this, type, function( next, hooks ) {})
        var queue;

        if ( elem ) {
            type = ( type || "fx" ) + "queue";//不写队列名字就是fx
            //    $.queue( document , ‘q1‘ , aaa||[aaa,bbb] ); 
            queue = data_priv.get( elem, type );//get方法var cache = this.cache[ this.key( elem ) ];return type === undefined ? cache : cache[ type ];key方法return unlock = elem[ this.expando ];根据元素的唯一标识expando获取在data_priv对象中缓存中的1,2,3,4这个unlock数字，根据unlock这个数字获取cache中的json,根据type获取json中的值
            /*
            data_priv = {
                1(document.203089541586732714850=1):{
                    name(type):‘哈哈‘(queue),
                    q1queue(type)：...(queue数组),
                }
            }
            */

            // Speed up dequeue by getting out quickly if this is just a lookup
            if ( data ) {//函数名
                if ( !queue || jQuery.isArray( data ) ) {//queue没有（函数是不是数组）或者queue有但是函数是数组,注意是数组就会把之前的全部覆盖。
                    /*
                    $.queue( document , ‘q1‘ , aaa ); 
                    $.queue( document , ‘q1‘ , bbb );
                    $.queue( document , ‘q1‘ , [ccc] );
                    */
                    queue = data_priv.access( elem, type, jQuery.makeArray(data) );
                } else {//queue有(说明q1队列之前加过)并且函数不是数组直接push，注意queue没有的时候queue始终存的是一个数组
                    queue.push( data );
                }
            }
            return queue || [];
        }
    },

    dequeue: function( elem, type ) {
        type = type || "fx";
//只能写jQuery.queue()，不能写queue(),queue()是jQuery类的静态方法，只能通过静态方式调用。
/*
jQuery.extend(  {a:function(){alert(1)},b:function(){jQuery.a();}}    )
$.b();
*/
        var queue = jQuery.queue( elem, type ),//得到type对应的值，是一个数组，
            startLength = queue.length,
            fn = queue.shift(),//去除数组第一个
            hooks = jQuery._queueHooks( elem, type ),
            next = function() {
                jQuery.dequeue( elem, type );//下一个，不能直接写dequeue，这行语句还没执行完时dequeue是不存在的
            };

        // If the fx queue is dequeued, always remove the progress sentinel
        if ( fn === "inprogress" ) {
            fn = queue.shift();
            startLength--;
        }

        if ( fn ) {

            // Add a progress sentinel to prevent the fx queue from being
            // automatically dequeued
            if ( type === "fx" ) {
                queue.unshift( "inprogress" );//inprogress添进去
            }

            // clear up the last queue stop function
            delete hooks.stop;
            fn.call( elem, next, hooks );//出队的函数执行，
        }

        if ( !startLength && hooks ) {
            hooks.empty.fire();
        }
    },

    /*
    data_priv = {
        1(elem:document.203089541586732714850=1):{
            name(type):‘哈哈‘(queue),
            q1queue(type)：...(queue数组),
        }
    }
    */
    _queueHooks: function( elem, type ) {
        var key = type + "queueHooks";
        //有就获取，没有key,value都存在value是json就追加
        return data_priv.get( elem, key ) || data_priv.access( elem, key, {
            empty: jQuery.Callbacks("once memory").add(function() {
                data_priv.remove( elem, [ type + "queue", key ] );
            })
        });
    }
});

jQuery.fn.extend({
    //this.queue( type, function( next, hooks ) {
    //$(‘#div‘).queue(‘q1‘,bbb);
    queue: function( type, data ) {
        var setter = 2;
        //$(‘#div‘).queue(bbb);
        if ( typeof type !== "string" ) {//只传了一个函数，没有type
            data =http://www.mamicode.com/ type;
            type = "fx";
            setter--;
        }
///console.log( $(‘#div‘).queue(‘q1‘) );  查看
        if ( arguments.length < setter ) {
            return jQuery.queue( this[0], type );//静态方法调用
        }

        return data =http://www.mamicode.com/== undefined ?"color: #0000ff">this :
            this.each(function() {//$(‘#div‘)是一个数组，对每一个设置
                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 );//每一个出队
        });
    },
    
    //.delay(2000)
    /*
    jQuery.fx.speeds = {
        slow: 600,
        fast: 200,
        // Default speed
        _default: 400
    };
    */
    //jQuery.fx = Tween.prototype.init;
    delay: function( time, type ) {
        time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
        type = type || "fx";
//queue第二个参数是匿名函数，也添加进去
        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 = data_priv.get( elements[ i ], type + "queueHooks" );
            if ( tmp && tmp.empty ) {
                count++;
                tmp.empty.add( resolve );
            }
        }
        resolve();
        return defer.promise( obj );
    }
});