A function can solve a task by calling other functions or itself. It is a chalk of tasks that is split into smaller or several tasks of the same kind.

Every function solves a task.

See the example below:

const pow = (x, y) => {
  if (y === 1) {
    return x;
  }

  return pow(x, y - 1) * x;
};

console.log( pow(2, 4) ); // 16

---

Iterative thinking

const pow = (x, y) => {
  let result = 1; // y = 0 => x⁰ = 1

  for (let i = 0; i < y; i++) {
    result *= x;  // result = result * x; from Y = (i0 < y) to Y = y-1 
    // at constant x of 2
    // result(i0) = result * 2 = 2; for Y = y - 4 (y=4, Y=0)
    // result(i1) = result * 2; => result(i0) * 2 = 4; for Y = y - 3 (y=4, Y=1)
    // result(i2) = result * 2; => result(i1) * 2 = 8; for Y = y - 2 (y=4, Y=2)
    // result(i3) = result * 2; => result(i2) * 2 = 16; for Y = y - 1 (y=4, Y=3)
  } 

  return result;
  // result(y) = result * 2; => 16
  // (2⁴ = 2 * 2 * 2 * 2 =  (2 * 2 * 2) * 2 = 2³ * 2 )
  // where y = 4; y - 1 = 3
};

console.log( pow(2, 4) ); // 16

---

Recursive thinking

In the example above, what if the result from i0 to i2 is the repeated calling function. It is obvious also that x¹ is x. This means at let result = 1, we can make let y = 1 has the base recursion.

See the example below:

const pow = (x, y) => {
  if (y === 1) {
    return x; // base => x¹ = x
  }
  // Alternatively
  /* 
  if (y === 0) {
    return 1; // base => x⁰ = 1
  }
  */
  else {
    return pow( x, (y-1) ) * x; // x(y) = x(y-1) * x
  }
};

console.log( pow(2, 4) ); // 16

The proof above is x^y = x or x^y = x^y-1 * x

The above example can be re-written as shown below:

const pow = (x, y) => {
  return (y === 1) ? x : ( pow(x, y - 1) * x );
};

console.log( pow(2, 4) ); // 16

In the example above pow(x, y) === pow( x, (y-1) ) * x i.e. x<sup>y</sup> === x<sup>y - 1</sup> * x. In math it is called recursive step. The step continues still y = 1. That is still pow(x, y) === pow( x, (1 - 1) ) * x

The expression pow(x, y) === pow( x, (0) ) * x is the same as x⁰ * x which is x. In math x⁰ = 1.

Every recursive function must have a base.

In each step of the recursive function, we have the following calls

pow(2, 4) = pow(2, 3) * 2 // first step
pow(2, 3) = pow(2, 2) * 2 // second step
pow(2, 2) = pow(2, 1) * 2 // third step
pow(2, 1) = pow(2, 0) * 2 = 2 // forth step

For iterative thinking, the steps are in reverse.

pow(2, 1) = pow(2, 0) * 2 = 2 // first step
pow(2, 2) = pow(2, 1) * 2 // second step
pow(2, 3) = pow(2, 2) * 2 // third step
pow(2, 4) = pow(2, 3) * 2 // forth step

The total number of nesting calls above is y = 4. The total recursive nesting calls is termed recursion depth.

The recursion function has its limitation:

The recursion depth is a factor to consider in the recursive function because the maximum should be less than 100000 in the JavaScript engine. It is recommended to target a max of 1000 though for better optimization.

There are tail calls optimizations that improve the limitation but not yet supported everywhere and work only in simple cases.

It is recommended to use recursive thinking than iterative thinking often for easier and maintainable code

See another example below:

const factorial = num => {
  if (num === 0) {
    return 1; // base => 0! = 1
  } else if (num > 0) {
    // 4! = 4 * (3 * 2 * 1) === 4 * 3! === num * (num - 1)!
    return ( num * factorial(num - 1) )
  } else {
    return -1;
  }
};

console.log( factorial(4) ); // 24

In the example above, factorial(num) === num * factorial(num - 1)

Since 0! = 1 or 1! = 0, the base can be as shown below:

...    ...    ...
  if (num === 0 || num === 1) {
    return 1; // base => 0! = 1
  }
...    ...    ...
...    ...    ...
...    ...    ...

---

Conclusion

With recursion, all you need is to pull out a constant and iterate till the count i = y or i === num

---

---