Descubriendo la magia de las Guard Clauses
Tags: webdev, beginners, programming, spanish
Published: 2024-02-05 11:21:08

No me di cuenta de cómo el desarrollo Backend había cambiado mi forma de programar hasta el Jueves 1 de Febrero de 2024.

## El momento de la revelación

No fue sino durante una conversación con mi profesor que me di cuenta de que no estaba utilizando la clásica estructura de if-else. Este episodio me desconcertó por completo e instigó una investigación sobre el tema. Nunca me había cuestionado el uso de esta estructura de manera consciente; simplemente la aplicaba de forma automática al verla en los ejemplos.

## ¿Qué estaba usando?

Descubrí que en una estructura básica de código, colocaba las negaciones al principio y cancelaba el flujo de la función con un return. A continuación, te muestro cómo lo estaba utilizando en una función para registrar a un usuario:

```js
const singInUser = async (req, res) => {
  try {
    const { email, password } = req.body;
    const user = await Users.findOne({ email });

    if (!user) return res.status(404).json({ error: 'Usuario no encontrado' });

    const isMatch = await user.comparePassword(password);
    if (!isMatch) return res.status(401).json({ error: 'Contraseña incorrecta' });

    const token = generateToken(user.email, user.name);
    return res.status(200).json({ token });
  } catch (error) {
    console.log(error);
    return res.status(500).json({ error: 'Ocurrió un error durante la solicitud' });
  }
};
```

Transformar esto en un conjunto de if-else anidados crearía un laberinto de condiciones difícil de mantener. Al inicio de mi investigación no encontraba nada al respecto; sólo encontraba formas de devolver varios elementos dentro de una función, lo que se aleja completamente del objetivo.

> Necesitaba un Rescate

No fue hasta que pude hablar sobre el tema con [@programacon_es](https://github.com/pedrovelasquez9) que me sugirió que buscara por las "Guard Clauses", y aquí comienza mi aventura.

## ¿Qué són las Guard clauses?

Las Guard Clauses, también conocidas como "early returns" o "return early", son estructuras de control de flujo en programación que se utilizan para mejorar la legibilidad y simplicidad del código al evitar anidaciones excesivas de condicionales. En concepto, estas estructuras se utilizan para evitar el uso de anidaciones excesivas y mejorar la simplicidad y legibilidad del código.

## Pongamos un ejemplo teórico

Podemos escribir las cláusulas de error y negativas al principio, no solo mejorando la legibilidad sino también interrumpiendo el resto del código, lo que contribuye a una mejor optimización del mismo.

```js
function validarContrasena(contrasena) {
  
  if (!contrasena) {
    return "La contraseña no puede estar vacía.";
  }

  if (contrasena.length < 8) {
    return "La contraseña debe tener al menos 8 caracteres.";
  }

  if (!/\d/.test(contrasena)) {
    return "La contraseña debe contener al menos un número.";
  }

  return "La contraseña es válida. ¡Bien hecho!";
}
```

Veamos una alternativa con if-else.

```js
function validarContrasena(contrasena) {
  
  if (!contrasena) {
    return "La contraseña no puede estar vacía.";
  } else {
    
    if (contrasena.length < 8) {
      return "La contraseña debe tener al menos 8 caracteres.";
    } else {
      
      if (!/\d/.test(contrasena)) {
        return "La contraseña debe contener al menos un número.";
      } else {
        return "La contraseña es válida. ¡Bien hecho!";
      }
    }
  }
}

```
Aunque observamos un cambio evidente, no siempre es lo más indicado. Como en todo en programación, el abuso de estas cláusulas puede ser contraproducente y generar fácilmente el efecto contrario, generando un código sucio. Veamos también un ejemplo.

```js
function calculateScore(player) {
  if (!player) {
    console.error("Jugador no especificado");
    return null;
  } else {
    if (!player.score) {
      console.error("Puntuación del jugador no encontrada");
      return null;
    } else {
      if (player.score < 0) {
        console.error("Puntuación del jugador negativa");
        return null;
      } else {
        return player.score * 100;
      }
    }
  }
}
```

## ¿Entonces en que casos podemos usarlo?

Es importante darle un uso moderado, en casos simples y directos teniendo en cuenta siempre el uso de otras estructuras, recuerda el uso de los comentarios en caso de ser necesario. 

**¿Has experimentado con Guard Clauses en tus proyectos? ¡Comparte tu experiencia en los comentarios!**

## Referencias

- https://refactoring.guru/replace-nested-conditional-with-guard-clauses
- https://dev.to/homolibere/guard-clauses-in-c-30d0
- https://tech.jotform.com/making-code-more-robust-with-guard-clauses-tips-and-tricks-d8d3d1940bce
- https://www.codementor.io/@clintwinter/use-guard-clauses-for-cleaner-code-1rrsczgwxp
- https://www.linkedin.com/pulse/guard-clauses-vs-statements-j%C3%A1n-hor%C5%88%C3%A1k
- https://medium.com/@basuraratnayake/clean-code-guard-clauses-796225c83c3e
- https://refactoring.com/catalog/replaceNestedConditionalWithGuardClauses.html