ReviseAlgo Logo

JS Fundamentals

Conditional Statements

Master flow control in JavaScript. Explore if-else blocks, switch statements, and ternary operators, and write clean, readable branching code.

Last Updated: July 15, 2026 10 min read

1. Introduction

Programs must make decisions based on inputs and state. JavaScript provides conditional statements to execute different branches of code depending on whether expressions evaluate to truthy or falsy values.

2. Why It Matters

Writing clean conditionals ensures your application handles business logic paths correctly, avoids deeply nested "pyramids of doom", and simplifies maintenance.

3. Real-World Analogy

Think of a Highway Toll Booth:

  • if-else (Simple Gate): If you have an electronic pass (Fastag/EZPass), the gate opens automatically. Otherwise, you must pull into the cash lane.
  • switch (Multi-Lane Junction): Signs route trucks to Lane 1, passenger cars to Lane 2, motorcycles to Lane 3, and emergency vehicles to Lane 4. Everyone goes to their designated lane immediately.

4. How It Works

JavaScript offers three primary branching patterns:

1. if / else-if / else:

Evaluates boolean expressions sequentially from top to bottom.

2. switch Statement:

Performs strict quality checks (===) against multiple case values. Needs break keywords to prevent falling through to subsequent cases.

3. Ternary Operator:

Shorthand inline conditional expression returning one of two values: condition ? valueIfTrue : valueIfFalse.

5. Internal Architecture

The JS runtime evaluates branching conditions dynamically. When using if-else, conditions are tested sequentially, which can lead to O(N) execution checks. When using switch, many JS engines build a jump table internally to optimize execution, providing direct jumps to matching branches (O(1) efficiency) when there are many cases.

6. Practical Example

Here is an example demonstrating clean conditional handling and early return patterns:

7. Common Mistakes

  • Missing breaks in switch statements: Forgetting the break statement causes execution to fall through into subsequent case blocks, running unintended code.
  • Deep nesting: Nesting multiple layers of if statements makes code unreadable. Refactor code using guard clauses or early returns.

8. Quick Quiz

Q1: What comparison standard does the switch statement use to match case expressions?

A) Loose equality (==)

B) Strict equality (===)

Answer: B — Case comparisons in a switch block always use strict equality (===).

9. Scenario-Based Challenge

The Multi-Tiered Billing Gate:

An API needs to assign bandwidth quotas based on subscription level: "free" gets 10GB, "pro" gets 100GB, "enterprise" gets 1TB, and any undefined type defaults to 5GB. Write a clean implementation using both switch and object literal lookup mapping to compare performance and readability.

10. Debugging Exercise

Find and fix the logical flaw in this code block:

function getAccessLevel(user) {
  if (user.isAdmin || user.isModerator) {
    if (user.isSuspended) {
      console.log('Blocked');
    }
    console.log('Admin access granted'); // prints this even if suspended!
  }
}
View Solution

Diagnosis: The check for suspension runs inside the parent block, but doesn't halt execution, letting the "granted" log run anyway.

Fix: Use a guard clause at the very beginning to handle suspended users:

function getAccessLevel(user) {
  if (user.isSuspended) {
    console.log('Blocked');
    return; // Exit early!
  }

if (user.isAdmin || user.isModerator) { console.log('Admin access granted'); } }

11. Interview Questions

🟢 Q1: What is the benefit of using "guard clauses" over nested if-else statements?

Answer: Guard clauses check for failure or boundary cases at the top of a function and exit immediately. This removes the need for nested code blocks, flattens the execution structure, and makes the code significantly easier to read, test, and maintain.

12. Production Considerations

  • Lookup Tables: When dealing with mapping actions or mapping states (e.g., config types to components), use object literals or ES Maps instead of multi-case switch statements to make code modular and extendable.