Guard clauses and flattening nested checks

Understanding Guard clauses and flattening nested checks

Nesting costs you memory, not lines. Every `if` that wraps the rest of a function adds a condition you must keep holding while you read downward, so by the time you reach the interesting line you are mentally tracking "the order exists, and it has items, and the country is NL". A guard clause inverts the check and leaves the function immediately, which lets you discard the condition instead of carrying it: once `if (!order) return 'no order';` has run, `order` is simply not something you think about again.

The rewrite is mechanical. When an `if`/`else` is the last thing in a function, take the outer condition, negate it, return whatever the `else` branch returned, and unindent the rest. That equivalence depends on the branch really being the tail of the function; if a statement after the block has to run for every input, an early return silently skips it, and you must move that statement into the guard or pull the tail into its own function. Inside a loop the same move uses `continue`, and for input that is genuinely broken rather than merely uninteresting, `throw` plays the same role.

Guards create facts. Each one narrows the set of states the following lines can be in, which is why their order is part of the logic and not a style preference: existence first, because reading a property of `null` throws instead of quietly evaluating to `false`, then shape, then business rules. When two guards could both match the same input, the earlier one decides the result, so a banned owner answering "account banned" instead of "ok" is something you choose by placing that line above the ownership test.

function shipNested(order) {
  if (order) {
    if (order.items.length > 0) {
      if (order.country === 'NL') {
        return order.items.length * 4;
      } else {
        return 'no shipping to ' + order.country;
      }
    } else {
      return 'empty order';
    }
  } else {
    return 'no order';
  }
}

function shipGuarded(order) {
  if (!order) return 'no order';
  if (order.items.length === 0) return 'empty order';
  if (order.country !== 'NL') return 'no shipping to ' + order.country;
  return order.items.length * 4;
}

const cases = [
  null,
  { items: [], country: 'NL' },
  { items: ['pen', 'ink'], country: 'DE' },
  { items: ['pen', 'ink', 'pad'], country: 'NL' }
];

for (const order of cases) {
  console.log(shipNested(order) + ' | ' + shipGuarded(order));
}

Worked examples

const rows = [
  { name: 'ada', score: 91 },
  null,
  { name: 'grace', score: -4 },
  { name: 'alan', score: 84 },
  { name: 'bob', score: 61 }
];

const passed = [];

for (const row of rows) {
  if (!row) continue;
  if (row.score < 0) continue;
  if (row.score < 80) continue;
  passed.push(row.name);
}

console.log(passed.join(', '));

const names = ['', 'ada', 'grace'];

function firstNameBroken(list) {
  list.forEach(function (n) {
    if (n === '') return;
    return n;
  });
  return 'none';
}

function firstName(list) {
  for (const n of list) {
    if (n === '') continue;
    return n;
  }
  return 'none';
}

console.log(firstNameBroken(names));
console.log(firstName(names));

function canEdit(user, doc) {
  if (!user) return 'sign in first';
  if (!doc) return 'no such document';
  if (user.banned) return 'account banned';
  if (doc.locked) return 'document locked';
  if (doc.ownerId !== user.id && user.role !== 'admin') return 'not your document';
  return 'ok';
}

console.log(canEdit(null, { ownerId: 7 }));
console.log(canEdit({ id: 3, banned: true }, { ownerId: 3 }));
console.log(canEdit({ id: 7 }, { ownerId: 7, locked: true }));
console.log(canEdit({ id: 2, role: 'admin' }, { ownerId: 7 }));
console.log(canEdit({ id: 9 }, { ownerId: 7 }));

Important notes

Common mistakes

Try it yourself