One of the first imperative programming concepts I ever learned was if/else. With this relatively simple power tool I could make decisions in my code based on any number of factors.
Of course, my early programs were… a little hard to read. I hadn’t yet learned one of the maxims of programming that I try to live by today: write code first for humans to read, then for computers.
Using if for conditions is pretty important. There’s other ways to code, but as a concept it’s usually extremely readable. On the other hand, the seemingly harmless else can add a world of problems. I’d like to talk a bit about why I feel this way, and explore some alternatives.
(note: these examples are in PHP, but the concepts are the same for javascript and other languages.)
Cognitive Load
The biggest issue I have with else is… “what’s the condition?” An else statement prefaces an arbitrarily large block of code, but unless I happen to have just written the code, I have to read upward past another arbitrarily large block of code before I can figure out the conditions on which that block will execute.
Many if/else statements start off with each block holding just one or two lines, and surely that’s not an issue, right? Who could complain about this innocent code?
if ($wantSomeToast) {
butterBread();
} else {
makeASandwich();
}
The problem arises when those code blocks grow. And they will grow. Without careful pruning, code only gets bigger. Perhaps not every if block will get to be 300 lines long, but at least some of them will, and in my opinion there’s really no need to take that risk.
When you’re debugging some issue and a diff or your editor only shows something like the following, who knows what’s really going on here?
// ...
bakeCake();
$frosting = new Frosting();
engageFroster($frosting);
} else {
drillHole();
$jam = Jam::fetchStrawberry();
$result injectJam(new JamInjector(), $jam);
if ($result !== 'ok') {
throw new \Exception('Jam is jammed');
}
//...
Parsing this means scrolling up until you find the if condition, and then holding that in your head while you work on the else block. And what if there’s else if statements, or nested conditions?
Alternatives
In short, I think that when else is used it needs to be as close to the if as possible. Within a few lines, really. Because, again, this is not a problem:
if ($wantSomeToast) {
butterBread();
} else {
makeASandwich();
}
But this is a problem:
//... many lines...
} else {
makeASandwich();
//... many lines...
To that end, any time you can easily avoid else, I’d argue that it’s worth the effort. Here’s some ways to do that:
The first thing I see a lot is a simple boolean return.
function isTostValid($toast): bool {
if (empty($toast->grain)) {
return false;
} else {
return true;
}
}
I know that this models the original developer’s thought process, but look how large it is, and remember that it’s far too easy for later developers to come in and add unrelated code to those blocks. What if we did this instead?
function isTostValid($toast): bool {
return ! empty($toast->grain);
}
Much easier to read. Another alternative is an early return. This set of conditions could grow very large after a while:
function getFavoriteJam($name): string {
$jam = null;
if ($name === 'joe') {
$jam = 'marmalade';
} elseif ($name === 'jane') {
$jam = 'raspberry';
} else {
$jam = 'strawberry';
}
return $jam;
}
But it could be easily turned into a version without else, by using early returns. The first conditions will still override later ones, but any time we follow code and see return we know that we can stop reading. It becomes a set of simple decision making tools rather than one complex multi-decision machine.
function getFavoriteJam($name): string {
if ($name === 'joe') {
return 'marmalade';
}
if ($name === 'jane') {
return 'raspberry';
}
return 'strawberry';
}
Sometimes you can turn an if/else into two if statements by repeating and inverting the first if condition. This may seem to violate the DRY (Don’t Repeat Yourself) principle, but in practice it grants a lot of clarity.
if ($name === 'joe') {
$jam = 'marmalade';
} else {
$jam = 'raspberry';
}
That else can just have its condition repeated to become:
if ($name === 'joe') {
$jam = 'marmalade';
}
if ($name !== 'joe') {
$jam = 'raspberry';
}
Another common pattern which this demonstrates is a condition being used to set a variable. In those cases, we can use null coalescing (or logical OR in Javascript), ternaries, or even function calls to make the assignment less likely to grow out of control later. Here’s a ternary version of the above.
$jam = ($name === 'joe') ? 'marmalade' : 'raspberry';
In this version it’s immediately clear that the whole line is about assigning $jam based on a condition, and the condition is the very next thing. In the first version it would take reading five lines and then drawing some conclusions to be able to be sure that’s all that’s happening, and just imagine how hard it would be when twenty other statements get added to those blocks!
If there’s a lot of computation or multiple decisions needed before the variable assignment, put all of that into its own small function and you end up with this, which is even more clear:
$jam = getJamFlavor($name);
There’s a lot of other ways we can avoid else in our code, and even if you’re skeptical, I’d like to recommend you give it a try! There’s no one best option, and it might just change how you think about coding entirely.
(Photo by Jens Lelie on Unsplash)
