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^{0} * x which is x. In math x^{0} = 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`