If a jQuery function calls itself in its completion callback, is that a recursive danger to the stack?

Question

Hi,

I'm writing a little jQuery component that animates in response to button presses and also should go automatically as well. I was just wondering if this function recursive or not, I can't quite work it out.

function animate_next_internal() {

  $('#sc_thumbnails').animate(
    { top: '-=106' }, 
    500, 
    function() {
      animate_next_internal();
    }
  ); 
}  

My actual function is more complicated to allow for stops and starts, this is just a simplified example.

EDIT It could either overflow the stack or not, depending on how the events are handled internally. Possibilities:

1. animate() directy calls the done callback, in which case an overflow is inevitable.

2. animate() schedules the callback for calling by some external dispatching mechanism and then terminates, in which case it will never overflow.

Answer 1

I would expect that such an implementation will overflow the call stack. Unless you simplified it out, you should have some kind of terminal condition that causes the function to back out of the recursion. You probably need something like this:

function animate_next_internal() {

  if ( some_condition ) return;

  $('#sc_thumbnails').animate(
    { top: '-=106' }, 
    500, 
    function() {
      animate_next_internal();
    }
  ); 
}  

Where *some_condition* is something related to the recursion -- maybe when #*sc_thumbnails* actual top reaches some limit like 0 on the page or within its parent.

Answer 2

I initially suspected that it would overflow the memory, but I wrote a short test to confirm

function test(){
  $(".logo img").css("position", "absolute");
  $(".logo img").css("top", "100px");
  $(".logo img").animate({top:0}, 500, function(){
  test();
  console.log("exits here");
});
}

test();

and surprisingly, I saw

exits here
exits here
exits here
exits here
exits here
...

in my logs. Looks like "animate() schedules the callback for calling by some external dispatching mechanism and then terminates, in which case it will never overflow." is the right answer