To eliminate the complexity of nested if statements, you should use the guard clause to return in advance, merge conditional expressions, replace branches with polymorphic or policy patterns, and use lookup table mapping values; 1. Use the guard clause to process boundary conditions in advance and exit; 2. Use logical operations to meet and related conditions; 3. Use polymorphic or policy patterns to replace complex type branches; 4. Use dictionaries and other data structures to replace simple conditional mapping; ultimately flatten and linearize the code, improving readability and maintainability.

Nested if statements—often called “arrow code” because of their rightward drift—can make even simple logic hard to follow. They're a common source of confusion, bugs, and maintenance headaches. The good news? You can reflect them into clean, readable code with a few practical strategies.

Here's how to flatten the pyramid and write clearer logic.

1. Use Guard Clauses to Exit Early

One of the most effective ways to reduce nesting is to reverse the logic and return (or continue) early when conditions aren't met.

Instead of:

 def process_user(user):
    if user:
        if user.is_active:
            if user.has_permission:
                # Main logic here
                return do_something(user)
        else:
            return "Inactive"
    else:
        return "No user"

Refactor with early returns:

 def process_user(user):
    if not user:
        return "No user"
    if not user.is_active:
        return "Inactive"
    if not user.has_permission:
        return "Unauthorized"

    return do_something(user)

This approach:

• Reduces nesting depth
• Makes error cases obvious
• Keeps the happy path clean and linear

2. Combine Conditions with Logical Operators

When nested if s check related conditions, combine them using and , or , or parentses for clarity.

Instead of:

 if user:
    if user.age >= 18:
        if user.verified:
            grant_access()

Combine:

 if user and user.age >= 18 and user.verified:
    grant_access()

Or extract to a well-named variable:

 is_eligible = user and user.age >= 18 and user.verified
if is_eligible:
    grant_access()

This reduces indentation and improves readability—especially when the logic is reused.

3. Replace Conditionals with Polymorphism or Strategy Pattern

For complex branching based on type or state, consider using objects or functions instead of nested if/elif chains.

Example: instead of:

 if user.role == "admin":
    send_admin_dashboard()
elif user.role == "editor":
    send_editor_dashboard()
elif user.role == "viewer":
    send_viewer_dashboard()
else:
    show_error()

Use a mapping or class hierarchy:

 dashboard_handlers = {
    "admin": send_admin_dashboard,
    "editor": send_editor_dashboard,
    "viewer": send_viewer_dashboard
}

handler = dashboard_handlers.get(user.role)
If handler:
    handler()
else:
    show_error()

Even better: encapsulate behavior in classes (polymorphism), so each role handles its own logic.

4. Use Lookup Tables or Dictionaries for Simple Mappings

When conditions map inputs to outputs or actions, a dictionary is often cleaner than a series of if/elif .

Instead of:

 if status == "pending":
    color = "yellow"
elif status == "approved":
    color = "green"
elif status == "rejected":
    color = "red"
else:
    color = "gray"

Use:

 status_colors = {
    "pending": "yellow",
    "approved": "green",
    "rejected": "red"
}
color = status_colors.get(status, "gray")

It's shorter, easier to test, and simpler to extend.

Bonus Tips

• Extract conditions to functions :

   if is_valid_user(user) and meets_criteria(user):
      process(user)

  This improves readability and reusability.

• Use match / case (in Python 3.10) :
  For multi-branch logic based on a value, match can be cleaner than long if/elif chains.

• Avoid deep nesting entirely :
  If you're more than 2–3 levels deep, it's a code smell. Step back and reflector.

---

Flattening arrow code isn't just about aesthetics—it makes logic easier to test, debug, and modify. Start with early returns, simplify conditions, and replace branching with data or objects where possible.

Basically: write code that reads like a story, not a maze.

The above is the detailed content of From Arrow Code to Clean Code: Strategies for Simplifying Nested Ifs. For more information, please follow other related articles on the PHP Chinese website!