¿Qué es el "Early return" y porque deberías usarlo?

Contexto

Todos desarrollador en algún momento crea o presencia el código spaghetti, y esto es sobre todo porque nadie te enseña a escalar, en la universidad, el bootcamp, el tutorial de Youtube solo te enseñan a programar lo básico, siempre nos topamos con la función de suma como uno de los primeros ejemplos:

function sum($a, $b)
{
    return $a + $b;
}

Después vas ganando un poco más de experiencia y te das cuenta que deberías validar los argumentos de tus funciones ¿Y si no son números?

use Exception;

function sum($a, $b)
{
    if(is_numeric($a) && is_numeric($b)) {
        return $a + $b;
    }
    else {
        throw new Exception("The numbers should be numeric");
    }
}

¿Y si lo números solo pueden ser negativos?

function sum($a, $b)
{
    if(is_numeric($a) && is_numeric($b)) {
        if($a > 0 && $b > 0) {
            return $a + $b;
        }
        else {
            throw new Exception("The numbers should be greater than 0");
        }

    }
    else {
        throw new Exception("The numbers should be numeric");
    }

}

¿Y si los números solo pueden ser menores que 100?

function sum($a, $b)
{
    if(is_numeric($a) && is_numeric($b)) {
        if($a > 0 && $b > 0) {

            if($a < 100 && $b < 100) {
                return $a + $b;
            }
            else {
                throw new Exception("The numbers should be lower than 100");
            }
        }
        else {
            throw new Exception("The numbers should be greater than 0");
        }

    }
    else {
        throw new Exception("The numbers should be numeric");
    }

}

Y quiza ya te vas dando cuenta por donde va, mientras más condiciones tenga nuestra función, más niveles de if/else tendremos, y dirás, "bueno, hay que deshacernos de los else", me parece una excelente idea:

function sum($a, $b)
{
    if(is_numeric($a) && is_numeric($b)) {
        if($a > 0 && $b > 0) {
            if($a < 100 && $b < 100) {
                return $a + $b;
            }
            throw new Exception("The numbers should be lower than 100");
        }
        throw new Exception("The numbers should be greater than 0");

    }
    throw new Exception("The numbers should be numeric");

}

Al fin y al cabo el else no hacia más que continuar con el proceso, algo que de por sí ya se cumplia en la función y es por ello que podemos prescindir de los else.

Sin embargo aún tenemos el mismo problema, demasiados niveles de if, ahí es donde entra el early return.

¿Qué es el early return?

El early return es un patrón de diseño, aunque yo diría que es más una filosofía de programación, ya que es una principio bastante simple: "mientras antes caiga, mejor", es decir intentar manejar primero esos edge cases, y te preguntarás ¿cómo?, lo más sencillo es invertir las condiciones.

En vez de evaluar para resolver, evaluar para fallar, retomando nuestra función:

function sum($a, $b)
{
    return $a + $b;
}

¿Y si no son números?

use Exception;

function sum($a, $b)
{
    if(!is_numeric($a) || !is_numeric($b)) {
        throw new Exception("The numbers should be numeric");
    }

    return $a + $b;
}

¿Y si lo números solo pueden ser negativos?

function sum($a, $b)
{
    if(!is_numeric($a) || !is_numeric($b)) {
        throw new Exception("The numbers should be greater than 0");
    }

    if(!($a > 0) || !($b > 0)) {
        throw new Exception("The numbers should be numeric");
    }

    return $a + $b;
}

¿Y si los números solo pueden ser menores que 100?

function sum($a, $b)
{
    if(!is_numeric($a) || !is_numeric($b)) {
        throw new Exception("The numbers should be greater than 0");
    }

    if(!($a > 0) || !($b > 0)) {
        throw new Exception("The numbers should be numeric");
    }

    if(!($a < 100) || !($b < 100)) {
        throw new Exception("The numbers should be lower than 100");
    }

    return $a + $b;
}

Y así de sencillo es como puedes dejar tu código validado sin necesidad de agregar tantos niveles de if.

Desventajas

Demasiadas salidas

Aunque el código tiene mejor legibilidad, aún puede ser un poco complicado saber exactamente en que partes de la función es la salida, sobre todo en aquellas funciones largas, aunque este tiende a ser más un problema de no seguir el principio de single responsability.

Debug

Tener tantos returns en una función puede ser más díficil hacer debug en la salida, ya que no sabes exactamente donde se esta evaluando.

Subjetividad del código

Aunque es una muy buena práctica, todo depende de quién cree el código, pues hay desarrolladores que evaluan a lo positivo así como programadores que evaluan a lo negativo:

Evaluación negativa:

use Exception;

function sum($a, $b)
{
    if(!is_numeric($a) || !is_numeric($b)) {
        throw new Exception("The numbers should be numeric");
    }

    return $a + $b;
}

Evaluación positiva:

use Exception;

function sum($a, $b)
{
    if(is_numeric($a) && is_numeric($b)) {
        return $a + $b;
    }

    throw new Exception("The numbers should be numeric");
}

Yo tiendo a ser más de evaluación positiva, pero todo depende del caso de uso.

Sin embargo aún con estas desventajas es díficil decirte que no uses este patrón, ya que aún asi por cada paso hacia atrás, son como 30 hacia delante en cuestión de legibilidad y funcionalidad.

Espero te sirva este acercamiento a conceptos un poco más avanzados de diseño y codificación.