¿Qué es el Principio de Retorno Temprano (Early Return)?

Escribir código sostenible no depende de grandes arquitecturas, sino de las micro-decisiones que tomamos en cada línea. Una de las más efectivas para reducir la complejidad es aplicar el Principio de Retorno Temprano (Early Return) [1]. Esta técnica consiste en salir de una función lo antes posible en cuanto se cumple una condición, de esta forma se evita que la lógica principal quede enterrada en capas de complejidad innecesaria.

El enfoque tradicional: Single Entry, Single Exit

Hace unos años, con la programación estructurada tradicional, Edsger Dijkstra popularizó el principio de un punto de entrada, un punto de salida, también llamado Single Entry, Single Exit (SESE)[2]. Este principio defendía que una función debía tener un único camino de inicio y un único punto de retorno. Uno de los objetivos era facilitar el rastreo del flujo lógico. Este enfoque clásico lo podemos ver en el siguiente ejemplo:

public buy(user: User, product: Product): string {
    const minimumAllowedStock = 1;
    let message: string;

    if (user.isActive) {
      if (user.amount >= product.price) {
        if (product.stock >= minimumAllowedStock) {
          //logic of the method
          message = "Payment made successfully";
        } else {
          message = "Error: Product out of stock";
        }
      } else {
        message = "Error: Not enough balance";
      }
    } else {
      message = "Error: Inactive user";
    }

    return message;
}

Este estilo de programación nos obliga a anidar if's dentro de if's. Para cuando llegamos a la lógica principal, estamos a 4 niveles de indentación de distancia. Hay que tener en cuenta la elevada carga cognitiva para que podamos entender el código. Para llegar al “happy path”, tenemos que descifrar todas las condiciones anteriores.

Antes de nada, hacemos las pruebas unitarias para asegurarnos de que no hemos cambiado el comportamiento observable.

import { describe, it, expect, beforeAll } from "vitest";
import { User } from "./user";
import { Product } from "./product";
import { BuyService } from "./buyService";

describe("when buying is requested", () => {
  let buyService: BuyService;

  beforeAll(() => {
    buyService = new BuyService();
  });

  it("buys", () => {
    const user = new User(100, true);
    const product = new Product(12, 1);

    const result = buyService.buy(user, product);

    expect(result).toBe("Payment made successfully");
  });

  it("returns an error if user is not active", () => {
    const user = new User(100, false);
    const product = new Product(12, 1);

    const result = buyService.buy(user, product);

    expect(result).toBe("Error: Inactive user");
  });

  it("returns and error if there is not enough stock", () => {
    const user = new User(100, true);
    const product = new Product(12, 0);

    const result = buyService.buy(user, product);

    expect(result).toBe("Error: Product out of stock");
  });

  it("returns and error if user has not enough balance", () => {
    const user = new User(100, true);
    const product = new Product(120, 2);

    const result = buyService.buy(user, product);

    expect(result).toBe("Error: Not enough balance");
  });
});

Cómo aplicar Early Return con un ejemplo en TypeScript

Aplicando el principio que estamos hablando, obtenemos el siguiente código:

public buy(user: User, product: Product): string {
	const minimumAllowedStock = 1;
    if (!user.isActive) return "Error: Inactive user";
    if (user.amount < product.price) return "Error: Not enough balance";
    if (product.stock < minimumAllowedStock) return "Error: Product out of stock";

    //logic of the method
    
    return "Payment made successfully";
}

Como se puede observar, se reduce la indentación y el código se vuelve más lineal; por lo tanto, la carga cognitiva es mucho menor. De este modo, el ‘happy path’ queda relegado al final, totalmente visible y sin distracciones.

Cuándo seguir usando el principio SESE

No obstante, es importante recordar que el principio SESE sigue siendo útil cuando la limpieza de recursos es crítica (por ejemplo, al cerrar una conexión o liberar memoria manualmente), ya que asegura un punto común de salida. En este aspecto, lenguajes modernos como TypeScript, C# o Java ofrecen el bloque try … finally, que nos permite disfrutar de las ventajas de los Early Returns garantizando la limpieza de recursos al mismo tiempo.

Conclusión El principio de retorno temprano es una técnica valiosa para mejorar la claridad del código, evitando que las funciones se compliquen con múltiples niveles de anidamiento.

---

Referencias [1] Código Sostenible por Carlos Blé Jurado pag. 263 [2] https://en.wikipedia.org/wiki/Single-entry_single-exit