Las cláusulas de guarda son una expresión booleana que nos permite cortar la ejecución de un método en el caso de que no se cumpla una condición.
Cada guarda es un punto de decisión en el que vamos a retornar algún valor o vamos a emitir algún error o evento.
Las ventajas de usar cláusulas de guarda son:
- Evita la indentación excesiva: si nuestro código tiene varios niveles de estructuras de control puede ser algo complejo para leer.
- Hace nuestro código más legible: convertimos varios if-else en puntos de decisión en los que vamos “filtrando” a medida que vamos bajando por el flujo de ejecución.
Ejemplo de Cláusulas de Guarda
Pongamos como ejemplo una función que va a recibir un parámetro y tenemos que determinar si es par o impar. Como requisito se nos pide comprobar que sea un número y, en caso de no serlo, que lance un error para que lo reciba el método que ha llamado.
def even_or_odd?(number)
if !(number.is_a? Numeric)
raise 'not a number'
elsif if number.even?
return 'even'
else
return 'odd'
end
end
return go(f, seed, [])
}Como se puede apreciar, se hace bastante complejo leer este método para lo simple del caso, porque primero tenemos que comprobar que efectivamente es un número, y en el caso de serlo, entonces comprobar si es par o impar.
Veamos una reescritura del mismo método con cláusulas de guarda:
def even_or_odd?(number)
raise 'not a number' unless number. is_a? Numeric
return 'even' if number. even?
return 'odd'
endEn este caso, tenemos dos guardas:
- En la primera se comprueba si el argumento que llega a la función es numérico o no y, en el caso de no serlo, levanta una excepción con un mensaje
not a number - En la segunda, devuelve
evenen el caso de que el número que hemos pasado sea par.
Si llega un número que es impar, la primera guarda no cumple la condición, por lo tanto la ejecución sigue hasta la segunda. Aquí, al comprobar si es par o impar, de nuevo no cumple la condición, así que la ejecución sigue hasta el final, donde simplemente se retorna odd.
Como se puede comprobar, hemos reducido la dificultad para leer nuestro código y se hace mucho más fácil de revisar en caso de que surja alguna incidencia con poco esfuerzo.
