Question

I do not see how this recursive function works:

function f(n) { g(n-1) }

function g(n) {
   alert("before: " + n);

   if(n > 0) f(n);

   alert("after: " + n);
}

f(2)​;​

I have tried to understand this code works and I saw how “before 1”, “before 0”, and “after 0” execute but… how does “after 1” come from this?

I see it executing as this… f(2) calls g which subtracts 1 so ‘n’ becomes 1. Alert(“before: ” + n) is executed, 1 is greater than 0 so it will recall itself and subtract 1. Alert(“before:” + n) is executed once again, 0 is not greater than 0 so it will execute Alert(“after:” + n) and the function ends?…

Edit: Thank @FlorianMargaine and @Cyrille for helping me understand the logic behind this. =)

Answer 1

after 1 comes from the fact that in Javascript, parameters are passed by value instead of by reference. So on the first iteration, calling if(n > 0) f(n); which calls g(n-1) does NOT decrement n. Its value is kept for when if(n > 0) f(n) returns, and remains at its value of 1.

Here’s a call graph:

f(2) calls f(n) with n=2
├─ calls g(n-1), which is g(2-1) = g(1)
│   ├─ g(1) alerts "before: 1"
│   ├─ g(1), n > 0 ==> call f(1)
│   │   ├─ f(1) calls f(n) with n=1, but it's not the same "n"
│   │   │  as we're in another call (see the call tree?)
│   │   │   ├─ calls g(n-1), which is g(1-1) = g(0)
│   │   │   │   ├─ g(0) alerts "before: 0"
│   │   │   │   ├─ n == 0 ==> don't call f(n)
│   │   │   │   └─ g(0) alerts "after: 0"
│   │   └─ and that's all for f(1)
│   └─ g(1) alerts "after: 1"
└─ and that's all