Normalmente, cuando declaramos un condicional, solemos ubicar la expresión variable en el lado izquierdo seguida de la expresión constante en el lado derecho.

if ($nombre == "Wifft") {
    echo "Wifft";
}

Pero... ¿Y si intercambiamos ambas expresiones de lugar?

if ("Wifft" == $nombre) {
    echo "Wifft";
}

Esto es lo que en jerga de programación se conoce como "Yoda Conditions", por razones que no hace falta explicar 🤪

A priori, puede parecer lo mismo, ciñéndonos a que el orden de los factores no altera el producto. Pero eso no es del todo cierto, veamos un ejemplo:

Si nos equivocamos, y acabamos asignando el valor a una variable en lugar de someterlo a comparación... tenemos un problema.

$nombre = "ByPyroOo";
if ($nombre = "Wifft") { //Siempre devuelve true y ahora $nombre pasa a valer "Wifft"
    echo "Wifft";
}

//La variable ha cambiado de valor y ello sigue teniendo efecto por aquí
echo $nombre; //Imprime "Wifft"

Pero... ¿Y si cometemos el mismo error al utilizar una Yoda Condition?

$nombre = "ByPyroOo";
if ("Wifft" = $nombre) { //Excepción. Un valor constante no puede tener nada asignado.
    echo "Wifft";
}

echo $nombre;

Con ello nos evitamos:

• Un falso positivo al evaluar una condición.
• El resultado de que el contenido de dicha condición se ejecute cuando no debería.
• Una asignación accidental que puede repercutir negativamente en el código subsiguiente.

En otros lenguajes, como Java, donde algunos tipos de datos pueden contener métodos que se encarguen de evaluar condiciones, el uso de Yoda Conditions puede ayudar a evitar escenarios no deseados al lidiar con posibles valores nulos.

Veamos un ejemplo:

String nombre = null;
if (nombre.equals("Wifft")) {
    System.out.println("Wifft");
}
// Esto causa un NullPointerException en Java.

Sin embargo:

String nombre = null;
if ("Wifft".equals(nombre)) {
    System.out.println("Wifft");
}
// Devuelve falso, sin provocar una excepción, como debe ser.

Sin embargo, no todo son ventajas. Los críticos de la utilización de esta técnica argumentan que dificulta la legibilidad del código. Algunos lenguajes de programación, como Swift directamente no permiten la asignación de variables dentro de expresiones de condicionales, lo que provoca que su uso carezca de sentido.

En cuanto a la ventaja de evitar escenarios resultantes de lidiar con posibles valores nulos, también puede resultar una desventaja, ya que en lo único que se consigue es retrasar la aparición de la excepción durante la ejecución del programa, por ejemplo:

String nombre = null;
if ("Wifft".equals(nombre)) {
    System.out.println("Wifft");
}
// Devuelve falso, sin provocar una excepción, como debe ser.

System.out.println("Mi nombre es " + nombre.toLowerCase()); 
//Ooops. Houston, tenemos un NullPointerException :(

En otros lenguajes, como C++, que implementan el concepto de sobrecarga de operadores, puede resultar bastante enfarragoso.

En mi opinión, a pesar de sus desventajas en ciertos lenguajes, en otros como PHP (mi lenguaje habitual) no representan ninguna desventaja y en todos los permiten evitar comportamientos no deseados fruto de un error ortográfico. Por lo que yo, personalmente, aplico y recomiendo su puesta en práctica.