Refactoring Spaghetti Code: Strategies for Complex if‑else Structures

Many developers encounter deeply nested if‑else statements when maintaining legacy projects, which quickly leads to unreadable and hard‑to‑maintain code. This article introduces three common refactoring techniques to tame such spaghetti code.

What Is Spaghetti Code?

Spaghetti code is characterized by lengthy, chaotic, and deeply nested structures. It often appears as a series of intertwined if statements that increase control‑flow complexity exponentially.

if…if Type

An example of the if…if pattern:

function demo(a, b, c) {
  if (f(a, b, c)) {
    if (g(a, b, c)) {
      // ...
    }
    // ...
    if (h(a, b, c)) {
      // ...
    }
  }

  if (j(a, b, c)) {
    // ...
  }

  if (k(a, b, c)) {
    // ...
  }
}

The flow diagram (shown below) illustrates how each nested if multiplies possible execution paths. With six independent if blocks, there are 2⁶ = 64 possible states, making debugging exponentially harder.

else if…else if Type

The same logic expressed with else if :

function demo(a, b, c) {
  if (f(a, b, c)) {
    if (g(a, b, c)) {
      // ...
    } else if (h(a, b, c)) {
      // ...
    }
    // ...
  } else if (j(a, b, c)) {
    // ...
  } else if (k(a, b, c)) {
    // ...
  }
}

Only one branch is taken, but deep nesting still yields high complexity. For three else if statements across three levels, there are 3³ = 27 possible exit paths, violating the Single‑Responsibility Principle.

Refactoring Strategies

1. Function Extraction for if…if : Split large functions into smaller ones, each handling a specific condition. This reduces exponential growth to linear growth in complexity.

2. Lookup Table for else if…else if :

const rules = {
  x: function (a, b, c) { /* ... */ },
  y: function (a, b, c) { /* ... */ },
  z: function (a, b, c) { /* ... */ }
};

function demo(a, b, c) {
  const action = determineAction(a, b, c);
  return rules[action](a, b, c);
}

This replaces a chain of else if statements with a key‑value map, delegating each branch to its own function.

3. Responsibility Chain Pattern for more complex conditions:

const rules = [
  {
    match: function (a, b, c) { /* ... */ },
    action: function (a, b, c) { /* ... */ }
  },
  {
    match: function (a, b, c) { /* ... */ },
    action: function (a, b, c) { /* ... */ }
  },
  {
    match: function (a, b, c) { /* ... */ },
    action: function (a, b, c) { /* ... */ }
  }
  // ...
];

function demo(a, b, c) {
  for (let i = 0; i < rules.length; i++) {
    if (rules[i].match(a, b, c)) {
      return rules[i].action(a, b, c);
    }
  }
}

The array of {match, action} objects acts as a chain; the first matching rule executes, mirroring the semantics of else if .

Conclusion

Spaghetti code often results from rushed development practices. By applying function extraction, lookup tables, or the responsibility‑chain pattern, developers can transform tangled if‑else logic into modular, maintainable structures, dramatically reducing complexity and improving readability.