What are nested conditions?

AlgorithmsJunior~2 min read

Short answer

Nested conditions are a situation where one conditional construct (for example, if/else, switch, or the ternary operator) is placed inside another, in order to make decisions in stages based on dependent checks.

Detailed answer

What it is and why it is needed

Nested conditions let you express tree-like logic: first one condition is checked, and only if it is true are the following ones evaluated. This is convenient when later checks only make sense once the earlier ones hold (for example, "the user exists → is active → has a role").

Example 1. Nested if/else

function canAccess(user, section) {
  if (user) {
    if (user.isActive) {
      if (user.role === 'admin') {
        return true;
      } else {
        if (section === 'public') {
          return true;
        } else {
          return false;
        }
      }
    } else {
      return false;
    }
  } else {
    return false;
  }
}

The logic is correct, but readability suffers because of the deep nesting.

The same thing with early returns (guard clauses)

function canAccess(user, section) {
  if (!user) return false;
  if (!user.isActive) return false;
  if (user.role === 'admin') return true;
  return section === 'public';
}

Early returns reduce the nesting depth, making the code easier to read and test.

Example 2. Nested switch

function priceFor(type, country) {
  switch (type) {
    case 'pro':
      switch (country) {
        case 'US': return 20;
        case 'EU': return 18;
        default:   return 22;
      }
    case 'basic':
      switch (country) {
        case 'US': return 10;
        case 'EU': return 9;
        default:   return 11;
      }
    default:
      return 0;
  }
}

This is a valid approach, but for a large matrix of values it is better to use a decision table (an object/map) to avoid nesting.

const prices = {
  pro:   { US: 20, EU: 18, default: 22 },
  basic: { US: 10, EU: 9,  default: 11 },
};

function priceFor(type, country) {
  const plan = prices[type];
  if (!plan) return 0;
  return plan[country] ?? plan.default ?? 0;
}

Example 3. A nested ternary operator

const label = isAuthenticated
  ? (isAdmin ? 'Admin' : 'User')
  : 'Guest';

Ternaries are acceptable for short expressions. Avoid more than 1 level of nesting - move the logic into a function or use plain if/else instead.

Where this comes up in practice

Checking access rights: first whether the user is logged in, then activity, then role/permissions.
Form validation: whether a field is present → its format → business rules.
Handling HTTP requests: method → headers → body.

Typical mistakes

Excessive nesting depth when early returns or a decision table would do.
Mixing checks and side effects inside branches, which makes testing harder.
Duplicating the same checks at different levels.
Missing a final branch (for example, a default in a switch), leaving some cases unhandled.
Overusing nested ternary operators, which hurts readability.

Style and architecture recommendations

Limit the nesting depth to 2 levels. If it goes deeper, refactor.
Use guard clauses for an early exit from the function and to remove "staircases" of if/else.
Move complex conditions into named predicates (functions, constants) to make the code self-documenting.
For matrices of rules, use decision tables (objects/maps) instead of nested switch/if.
Watch cyclomatic complexity: every new condition adds branching and increases the number of test cases.

Quick recap

Nested conditions are conditions inside conditions.
Use them when checks depend on each other.
Minimize the depth through early returns, decision tables, and extracting predicates.

Short Answer

Interview ready

Premium

A concise answer to help you respond confidently on this topic during an interview.