Recursion in JavaScript

In JavaScript, recursion is when you call a function from within itself until or unless a condition is a met. Today, we’re going to look at how it works.

Let’s dig in!

Count up by one

Let’s say we have a number, and we want to increase its value by `1`. We have a helper function that takes a number, and returns that number plus `1`.

``````/**
* Add one to a number
* @param  {Number} num The number to increase
* @return {Number}     The new number
*/
function upByOne (num) {
return num + 1;
}
``````

To use it, you can do something like this.

``````// returns 42
let more = upByOne(41);
``````

This is an absurd example, of course. It would be faster and easier to just add `1` to the number.

But it will help illustrate how recursion works, so let’s roll with it.

Now, let’s say you wanted whatever number was returned to have a value of `10` or higher. If you passed in `7`, instead of getting `8` back, you want to get back `10`.

We can use recursion for that!

Inside our `upByOne()` function, we’ll add `1` to `num`. Then, we’ll check if it’s value is less than `10`. If so, we’ll pass it back into `upByOne()` and `return` the result. Otherwise, we’ll return the new number.

``````/**
* Add one to a number
* @param  {Number} num The number to increase
* @return {Number}     The new number
*/
function upByOne (num) {
let bigger = num + 1;
if (bigger < 10) {
return upByOne(bigger);
}
return bigger;
}
``````

If you passed in `7`, for example, `bigger` would have a value of `8`. The `if` statement would return `true`, and `8` would get passed into `upByOne()`.

The number would get increased to `9`, the check would run again, and the process would repeat, until `bigger` had a value of `10`.

``````// returns 10
let minOfTen = upByOne(7);
``````

Here’s a demo.