What is short-circuit evaluation?

Q: What is short-circuit evaluation?

**Target Audience:** Engineers preparing for JavaScript fundamentals interviews. **Difficulty:** Easy > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every call-count claim below was actually run in Node, using a real counter, not an assumption about laziness. ## 1. Why This Even Matters — A Story First A security checkpoint that requires two separate approvals in sequence does not bother calling the second approver at all if the first one already says no — there is no point, since the overall outcome is already decided. `&&` and `||` behave exactly like that checkpoint: once the outcome is already certain from the left-hand side alone, the right-hand side is never even contacted, let alone evaluated. ## 2. The Core Idea 📌 **Interview term:** `&&` stops and returns the left value as soon as it is falsy (the overall result is already `false`-ish); `||` stops and returns the left value as soon as it is tr

The problem

Question presented to candidate: "If I write someCondition && doSomethingExpensive(), and someCondition is false, does doSomethingExpensive() actually get called? Walk me through exactly why or why not."

What a strong answer should cover:

📌 Interview term: short-circuit evaluation — && and || evaluate their left-hand side first, and stop entirely — never evaluating the right-hand side at all — as soon as the overall result is already determined.
📌 Interview term: the direct, verified answer to the prompt — verified directly with a real call counter: false && sideEffect() genuinely left the counter at 0 — sideEffect() was never actually called, not just its return value ignored. true && sideEffect() genuinely called it (counter became 1).
📌 Interview term: ||'s mirrored rule — verified directly: true || sideEffect() genuinely left the counter at 0 (short-circuited on the first truthy value), while false || sideEffect() genuinely called it.
A precise answer names the real, common practical use: a guard pattern like user && user.name — verified directly, this genuinely avoids a real TypeError that user.name alone would throw when user is null, because the short-circuit never even attempts to evaluate user.name at all.
📌 Interview term: the classic real pitfall — verified directly: count || 10 used as a "default value" pattern genuinely returns 10 even when count is the legitimately valid value 0, because 0 is falsy; the real, correct fix for exactly this case is the nullish coalescing operator ??, which verified directly correctly preserved 0.

Clarifying questions expected:

None — this is a definitional/technical question; directly answering whether the expensive function call actually happens (with real proof it is skipped entirely, not just its result discarded) is the strong signal.

Code / implementation expected: Yes — a real call-counter proof that the right-hand side is never even invoked is the clearest, most convincing demonstration.

short-circuit

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals interviews. Difficulty: Easy

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every call-count claim below was actually run in Node, using a real counter, not an assumption about laziness.

1. Why This Even Matters — A Story First

A security checkpoint that requires two separate approvals in sequence does not bother calling the second approver at all if the first one already says no — there is no point, since the overall outcome is already decided. && and || behave exactly like that checkpoint: once the outcome is already certain from the left-hand side alone, the right-hand side is never even contacted, let alone evaluated.

2. The Core Idea

📌 Interview term: && stops and returns the left value as soon as it is falsy (the overall re

The solution is hidden so you can try first

6 min read · 8 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal proof with a call counter: the right-hand side of && and || is never evaluated when short-circuited, plus the classic 0-default pitfall