Lesson 11 of 30

Recursion: A Function That Calls Itself

Q: Explain in your own words what recursion is, and what a base case does.

A strong answer covers: Describes recursion as a function calling itself on a smaller version of the problem; Explains the base case as the condition that stops the calls; Mentions what happens without a base case (infinite calls / stack overflow).

If the word 'recursion' makes you tense up, that's a completely normal first reaction — here's the idea, stripped down to something small enough to actually follow.

12 min read

Check your understanding

Every option explains itself — why the right one is right, and why each wrong one is wrong. Miss one and it comes back later on a spaced-repetition schedule.

No quiz for this one — it's a practical topic

This topic is about judgment and practical tradeoffs more than a single right answer — a mock interview is the better way to test yourself on it.

Be interviewed on this →

Stuck? Ask the AI tutor

Hints without spoilers, and a plain explanation of why a wrong answer was wrong — answered only from this lesson. Free account, no card.

Interview questions on Recursion: A Function That Calls Itself

What interviewers actually ask about this, and what a strong answer has to cover.

Explain in your own words what recursion is, and what a base case does.

A strong answer covers

Describes recursion as a function calling itself on a smaller version of the problem
Explains the base case as the condition that stops the calls
Mentions what happens without a base case (infinite calls / stack overflow)

Likely follow-ups

In the countdown example, what would happen if the base case checked `n === 0` instead of `n <= 0`, and countdown was called with a negative number?
Does each recursive call share variables with the others, or does each get its own?

Practice these with the AI interviewer →

The plain-language idea

If the word "recursion" makes your stomach drop a little, you're not alone. Most people's first reaction to recursion is confusion, not understanding — and that's normal, not a sign you're bad at this. It genuinely feels strange the first time. It stops feeling strange with practice, not with talent.

Here's the plain version: recursion is a function that calls itself, working on a smaller piece of the problem each time, until the piece is so small there's nothing left to do — at which point it stops.

Think of a set of Russian nesting dolls. You open the big doll, and inside is a slightly smaller doll. You open that one, and inside is a smaller one still. You keep going until you reach the smallest doll — the one that doesn't open, because there's nothing inside it. That smallest doll is the signal to stop.

A recursive function works the same way. Every call opens up a slightly smaller version of the same problem, and hands that smaller version to itself. Eventually you reach the smallest version — simple enough to answer directly, with no further calls needed. That stopping point has a name: the base case. Without one, the dolls never stop opening, and the function would call itself forever (until it crashes).

See it in a real thing: counting down

function countdown(n) {
  // The base case: the smallest doll. No more opening required.
  if (n <= 0) {
    console.log("Liftoff!");
    return;
  }

  console.log(n);

  // The function calls ITSELF, with a smaller number.
  // This is the "open the next, smaller doll" step.
  countdown(n - 1);
}

countdown(3);
// logs: 3, 2, 1, Liftoff!

What people usually miss

Watch out

Forgetting the base case is the #1 bug. Without one, countdown would call itself forever, going to -1, -2, -3... until the program runs out of memory and crashes with a "stack overflow." That name isn't a coincidence — it's the call stack from the last lesson, filling up.
Every call gets its own n. People often picture one shared n being edited. It's not — countdown(3) and the countdown(2) it calls each have their own separate copy of n, sitting on the call stack, waiting.
You don't have to trace every call in your head to trust it works. That's genuinely hard and not how experienced developers read recursion either. The next lesson is entirely about the shortcut that replaces mental tracing.

The genealogy: it's still just a function call

Recursion doesn't need any new JavaScript syntax — it's an ordinary function, the same kind from the JavaScript track, that happens to call itself. What's new isn't the mechanism. It's learning to trust the pattern, which the next lesson tackles head-on.