Recursion is the method by which a problem gets solved through iteration.

In other words, a **recursive function** is a function that *repetitively invokes itself infinitely* (or until something stops it).

This article will use an example to illustrate how a recursive function works.

**Note:**

- A recursive function is different from an
*Immediately Invoking function Expression*(IIFE).

An IIFE automatically invokes itself once. However, a recursive function automatically invokes itself repeatedly for an unlimited amount of time or until something stops its reinvocation. - The code written to discontinue the reinvocation of a recursive function is called a
*base case*. - It is always important to define a base case when creating a recursive function — so that the recursion function will not run endlessly, thereby crashing the browser.

## Example of a recursive function

Below is a JavaScript code that outputs a concatenation of all the values returned through the

`countDown()`

function’s recursive invocation.

```
// Create a recursive function:
function countDown(num) {
// Define the base case of this recursive function:
if (num < 0) {
return "Recursion Stopped!";
}
// Define the recursive case (recursion statement):
return num + ", " + countDown(num - 1);
};
// Invoke the countDown() recursive function:
countDown(2);
// The invocation above will return:
"2, 1, 0, Recursion Stopped!"
```

**Note:** In the recursive algorithm above, the

`countDown(num - 1)`

code makes the whole function a recursion because it is the code that makes

`countDown()`

recall itself repeatedly.

## A look at the events behind the scenes

When we invoked the

`countDown`

function and passed in the value

`2`

(that is,

`countDown(2)`

), the algorithm started running as follows:

**Step 1: Check if **

**2**

** is less than **

**0**

The computer checked if the value

`2`

— that we passed to the

`num`

parameter of the

`countDown`

function — is less than

`0`

.

Since

`2`

is not less than

`0`

, the computer did not execute the

`if`

statement’s code. Instead, it skipped to the next code after the

`if`

statement — which is the *recursion code*.

**Step 2: Execute the **

**return**

** statement**

After skipping the

`if`

statement, the computer executed the

`return num + " " + countDown(num - 1)`

code — but substituted the

`num`

parameter with the parameter’s value (that is,

`2`

) like so:

```
return num + ", " + countDown(num - 1);
return 2 + ", " + countDown(2 - 1);
return 2 + ", " + countDown(1);
```

**Step 3: Execute only the recursion code**

In step 2’s code above, notice that the

`return`

command cannot return any value because the

`return`

statement includes a recursion code (

`countDown(1)`

) recalling the

`countDown`

function.

Therefore, while retaining the other parts of the

`return`

statement (that is,

`2 + ", " +`

), the computer will execute *only* the recursion code (

`countDown(1)`

).

In other words, the

`countDown(1)`

code will automatically invoke the

`countDown`

function while passing-in the value

`1`

. Then, the algorithm will start running again by checking if

`1`

is less than

`0`

.

Since

`1`

is not less than

`0`

, the computer skipped to the recursion code like so:

```
return 2 + ", " + num + ", " + countDown(num - 1);
return 2 + ", " + 1 + ", " + countDown(1 - 1);
return 2 + ", " + 1 + ", " + countDown(0);
```

**Step 4: Invoke only the recursion code**

Again, notice that the

`return`

command (in step 3) cannot return any value because the

`return`

statement includes a recursion code (

`countDown(0)`

) that recalls the

`countDown`

function.

Therefore, while retaining the other parts of the

`return`

statement (that is,

`2 + ", " + 1 + ", " +`

), the computer will execute *only* the recursion code (

`countDown(0)`

). So, the

`countDown(0)`

code will automatically invoke the

`countDown`

function while passing in the value

`0`

.

Then, the function will start running again by checking if

`0`

is less than

`0`

.

Since

`0`

is not less than

`0`

, the computer skipped to the recursion code like so:

```
return 2 + ", " + 1 + ", " + num + ", " + countDown(num - 1);
return 2 + ", " + 1 + ", " + 0 + ", " + countDown(0 - 1);
return 2 + ", " + 1 + ", " + 0 + ", " + countDown(-1);
```

**Step 5: Execute only the recursion code**

Yet again, the

`return`

command (in step 4) cannot return any value because the

`return`

statement includes a recursion code (

`countDown(-1)`

) recalling the

`countDown`

function.

Therefore, while retaining the other parts of the

`return`

statement (that is,

`2 + ", " + 1 + ", " + 0 + ", " +`

), the computer will execute *only* the recursion code (

`countDown(-1)`

). So, the

`countDown(-1)`

code will automatically invoke the

`countDown`

function while passing in the value

`-1`

.

Then, the function will start running again by checking if

`-1`

is less than

`0`

.

At this point,

`-1`

is less than

`0`

. Therefore, the computer will execute the code of the

`if`

statement by returning the value

`“Recursion Stopped!”`

like so:

`return 2 + ", " + 1 + ", " + 0 + ", " + "Recursion Stopped!";`

At last, the

`return`

statement now has values it can validly concatenate and return. Therefore, the returned value from the

`countDown`

recursion function will be:

`"2, 1, 0, Recursion Stopped!"`

## Conclusion

All in all, a **recursive function** is a function that repeatedly recalls itself until something stops the recall.

*Previously published at – **CodeSweetly*