TLDR; a guard clause is a premature return (early exit) that “guards” against the rest of your code from executing if it’s not necessary (based on criteria you specify).
Soon after I started my career as a Ruby on Rails developer I learned about guard clauses and how they can improve code readability.
Let’s take a look at an example method with a standard
In this method we’re doing something that’s common: evaluating a parameter and:
- executing some code if our expectations are met OR
- executing some other code if our expectations are not met.
In this case:
- if the parameter is
truewe execute some “awesome code”
- if not, we just return
This method can be shortened to only two lines of code by using a guard clause.
This was as short example to illustrate the concept of a guard clause. Now let’s look at an example where a guard clause can help eliminate a code smell: nested conditionals.
This code is hard to read and follow what’s happening in my opinion (just look at how many levels of indention are in the nested
Refactoring Nested Conditionals Using Guard Clauses
We can use guard clauses to refactor the nested
if/else statements and make the method more readable and easier to follow.
I like guard clauses for these reasons, but you should use them where it makes sense for you and your team.
For example, some languages require explicit resource management and having a single exit point from a method would make sense to prevent memory leaks. However Ruby has garbge collection to automatically collect unused objects.
Guard clauses guard (protect) the rest of your code from executing if not necessary (based on certain criteria) and are placed at the top of a method.