JavaScript Program to Find Factorial Using Recursion

You can find the factorial of a number in JavaScript using recursion by defining a function like function factorial(n) { return n <= 1 ? 1 : n * factorial(n - 1); } which calls itself until it reaches 1.

Examples

Input0

Output1

Input5

Output120

Input1

Output1

How to Think About It

To find the factorial of a number using recursion, think of the problem as multiplying the number by the factorial of the number just before it. Keep doing this until you reach 1, which is the stopping point. This way, the function calls itself with smaller numbers until it reaches the base case.

Algorithm

1

Get the input number n.

2

Check if n is less than or equal to 1; if yes, return 1 as factorial of 0 or 1 is 1.

3

Otherwise, multiply n by the factorial of n minus 1.

4

Return the result.

Code

javascript

function factorial(n) {
  if (n <= 1) {
    return 1;
  }
  return n * factorial(n - 1);
}

console.log(factorial(5));

Output

120

Dry Run

Let's trace factorial(5) through the code

1

Call factorial(5)

Since 5 > 1, return 5 * factorial(4)

2

Call factorial(4)

Since 4 > 1, return 4 * factorial(3)

3

Call factorial(3)

Since 3 > 1, return 3 * factorial(2)

4

Call factorial(2)

Since 2 > 1, return 2 * factorial(1)

5

Call factorial(1)

Since 1 <= 1, return 1

6

Calculate results

factorial(2) = 2 * 1 = 2 factorial(3) = 3 * 2 = 6 factorial(4) = 4 * 6 = 24 factorial(5) = 5 * 24 = 120

Call	Return Value
factorial(1)	1
factorial(2)	2
factorial(3)	6
factorial(4)	24
factorial(5)	120

Why This Works

Step 1: Base Case

The function stops calling itself when n is 1 or less, returning 1 to avoid infinite recursion.

Step 2: Recursive Call

For values greater than 1, the function calls itself with n - 1, breaking the problem into smaller parts.

Step 3: Multiplying Results

Each recursive call multiplies n by the factorial of n - 1, building the final factorial value step by step.

Alternative Approaches

Iterative approach

javascript

function factorialIterative(n) {
  let result = 1;
  for (let i = 2; i <= n; i++) {
    result *= i;
  }
  return result;
}
console.log(factorialIterative(5));

Uses a loop instead of recursion; often faster and avoids call stack limits.

Using ternary operator

javascript

const factorial = n => n <= 1 ? 1 : n * factorial(n - 1);
console.log(factorial(5));

Shorter syntax but same recursive logic.

Complexity: O(n) time, O(n) space

Time Complexity

The function calls itself n times, so the time grows linearly with the input number.

Space Complexity

Each recursive call adds a new layer to the call stack, so space used is proportional to n.

Which Approach is Fastest?

The iterative approach uses constant space and is generally faster, but recursion is easier to understand for factorial.

Approach	Time	Space	Best For
Recursive	O(n)	O(n)	Clear logic, educational purposes
Iterative	O(n)	O(1)	Performance and large inputs
Ternary Recursive	O(n)	O(n)	Concise code, same recursion tradeoffs