Evitar niveles de anidación de sentencias condicionales con guard clauses

Al escribir el código de un método es habitual hacer algunas comprobaciones sobre los parámetros, por ejemplo, para comprobar que el parámetro tiene una referencia, si es nulo o cumple alguna condición, si es una lista que no esté vacía o para validar mediante alguna otra regla. Estas validaciones o aserciones se realizan al inicio del método con sentencias if que añaden un nivel de tabulación al código si se anidan. Estos niveles de tabulación con sentencias if anidadas hacen poco legible el código.

Este código que comprueba algunos parámetros no es tan sencillo de entender por los varios niveles de anidación.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

...

public BigDecimal getValue(Car car) {
   BigDecimal result;
   if (car.isNew()) {
       result = car.getNewValue();
   } else {
       if (!car.isOlderThanYears(1) && car.hasLessKilimetersThan(10000))
          result = car.getAlmostNewValue();
       else {
           if (!car.isOlderThanYears(5))
              result = car.getSemiNewValue();
           else 
              result = car.getOldValue();    
       }
   }
   return result;
};

...

En vez de crear este nivel de anidación y crear varios flujos distintos por donde se bifurca el código, con aserciones, sentencias if o guard clauses el código queda más legible. Después de cada cláusula if es seguro que la aserción que realiza se cumple.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

...

public BigDecimal getValue(Car car) {
    if (car.isNew()) return car.getNewValue();
    if (!car.isOlderThanYears(1) && car.hasLessKilimetersThan(10000)) return car.getAlmostNewValue();
    if (!car.isOlderThanYears(5)) return car.getSemiNewValue();
    return car.getOldValue();
}; 

...

También es una recomendación que los métodos solo tengan una sentencia return, de hecho en la enseñanza de programación se explica pero para estos casos de comprobaciones la ventaja de no tener varios if anidados es justificable tener varios return, el código queda más legible.

Las guard clauses son una de algunas buenas prácticas sencillas a utilizar en el código fuente, otras son utilizan un único nivel de indentación, encapsular los datos primitivos en clases, un único punto por línea de código, evitar abreviaturas, mantener las clases pequeñas, evitar los métodos getter y setter, revisar las dependencias de las clases y segregar los cambios en los commits.