Dfyjkt

I have been looking at this code and scratching my head at it for too long and was hoping to gain insight into how exactly the value 33 is the end result.

I know that this code goes through the conditionals to the else and decrements the value of b until it reaches the else if conditional where the b ==1 condition is met.

What I don't understand, is how within that else if, the value of b is incremented and from then on, so too does the value of 'a' until the final value of 33 is reached.

The other strange feature of this code is that after the else if has made those changes, only the else runs and the other conditionals are no longer checked.

For someone relatively new to recursion, this behavior is truly weird.

function mlt(a, b) 

 debugger;

 if(!(a && b)) 
 return 0;
 else if (b == 1) 
 return a;
 else 
 return (a + mlt(a, b - 1));
 
 

 console.log(mlt(3, 11));

Copying this in the browser console and running through the loops will give insight into what I am on about.

This is not an example of closure, but of recursion.

In order to understand how recursion can bring the correct result, it can help to assume for a moment that the recursive call returns the correct result and see if that makes the overall return value correct as well.

Let's take for example this main call:

mlt(20, 4)

The execution will go to the else part and perform the recursive call:

return (a + mlt(a, b - 1));

As you can derive, the recursive call comes down to mlt(20, 3). Now let's just for a moment assume that this recursive call returns the correct result, i.e. 60. See what happens in the above expression:

return (20 + 60);

This is 80, which indeed is the correct result for our original call mlt(20, 4). So we can get a feel of how this function will return the correct product for any given b if we can assume the function does it right for b-1 also.

What happens when b = 1? Then the function returns a. We can also see that this is correct. So with the previous conclusion we now can be sure that if b >= 1 the result will be correct.

Note that the function will also do it right for b = 0 as then the first if kicks in. Also note that this function does not cope well with negative values of b: in that case the function will keep recurring with b-1 and will eventually bump into a stack capacity error.