Replace Nested Conditional with Guard Clauses

A guard clause handles a special case immediately, often by returning or throwing. Replace Nested Conditional with Guard Clauses uses those early exits to leave the normal case outside unnecessary nesting. 1

Original version: the useful result is inside two conditions

An order label reports a missing order first, a cancelled order second, and otherwise prints its number.

public static class Orders
{
    public static string Label(string? number, bool cancelled)
    {
        if (number != null)
        {
            if (!cancelled)
            {
                return "Order " + number;
            }
            else
            {
                return "Cancelled";
            }
        }
        else
        {
            return "Missing order";
        }
    }
}

def label(number, cancelled):
    if number is not None:
        if not cancelled:
            return "Order " + number
        else:
            return "Cancelled"
    else:
        return "Missing order"

To read the normal result, we mentally carry both conditions: a number exists and the order is not cancelled.

Refactored version: finish the special cases first

public static class Orders
{
    public static string Label(string? number, bool cancelled)
    {
        if (number == null) return "Missing order";
        if (cancelled) return "Cancelled";
        return "Order " + number;
    }
}

def label(number, cancelled):
    if number is None:
        return "Missing order"
    if cancelled:
        return "Cancelled"
    return "Order " + number

After the guards, the remaining path has a number and is not cancelled. The final line can express the ordinary result without further indentation.

The order of guards is part of behavior

A missing number combined with cancelled = true still returns Missing order, because that check remains first. Reversing the guards would change the precedence of two conditions that can both hold.

Also examine side effects and code after the original conditional. An early return must not skip work that previously ran for every case. Prefer structured cleanup rather than relying on readers to notice which return bypasses a resource release.

Guard clauses are most useful when several cases clearly terminate the operation. Nested conditionals can still communicate a genuine decision tree well. The aim is to make the path easy to follow, not to enforce zero nesting in every method.

Sources

1. Martin Fowler — Replace Nested Conditional with Guard Clauses.