How to determine what one to use - next(); or dequeue();? [duplicate]

Question

Is there any difference if I do:

$queue.queue(function(next){
   //...
   next();
}).queue(function(next){
   //...
   next();
});

versus

$queue.queue(function(){
   //...
   $(this).dequeue();
}).queue(function(){
   //...
   $(this).dequeue();
});

Do they do the same thing?

What are the differences and which should I use?

It's weird cause the jQuery docs does not really mention .next(), they always say to use .dequeue() but at my workplace people use the .next() function so this has got me rather confused.

Answer 1

That I know of, there is no difference. I'm not sure why one would be preferable to the other or why they are both mentioned as that is confusing to me.

Looking at http://code.jquery.com/jquery-1.9.1.js we see:

1915 next = function() {
         jQuery.dequeue( elem, type );
     };

...in the jQuery.dequeue method. This is called a bit later on (on line 1936) as fn.call(elem, next, hooks). You see that next is the first parameter in the queue callback, and fn is queue at that time.

Looking ahead, we see

1983 dequeue: function( type ) {
         return this.each(function() {
             jQuery.dequeue( this, type );
         });
     },

This is defined on jQuery.fn, so that is the function called by $(this).dequeue. However, this does exactly the same thing. The only difference is the element that is dequeued. In fn.dequeue it loops over the collection, but that will only be one element for $(this).

If we look back, we see what elem is though:

1908 dequeue: function( elem, type ) {

...hey, wait a second .. it's this (when called from $(this).dequeue)! Thus you can see that they do exactly the same thing. $("some other collection").dequeue would work differently, though.

Calling next() saves you an additional .each call, so I guess that would be faster.

By the way, you don't have to call it next in the callback since you can rename parameters to whatever you want.

EDIT: Per my mini-discussion with my illustrious colleague @FabrícioMatté, there can actually be a difference in functionality between next() and $(this).dequeue(), specifically when not using the standard fx queue. When the next function is created, it is set to call $.dequeue with the type acquired from the queue already, but $.fn.dequeue takes the type as an argument. This is possibly even more motivation to stick with next(), although I've never actually seen someone use anything other than the standard effects queue practically.