Feda /dev/

Hombre, un comparador && que sea true a la izquierda siempre va a evaluar la derecha y si es false a la izquierda pues ya hemos terminado porque deben cumplirse las 2 condiciones. Eso creo que es así en casi todos los lenguajes. Java y C# al menos.

#19864 #19868 si, lo hacen también otros lenguajes y se llama lazy evaluation.

Casos útiles en los que lo utilizo bastante:

if (obj && obj.property && obj.property.nested) {
  // en lugar de obj.property.nested, que petaria en caso de no estar definido
}

// poner las funciones computacionalmente caras a la derecha hace
// que sólamente se ejecuten cuando sea realmente necesario. 
if (cheapFunction() || expensiveFunction()) {
  // en este caso, expensiveFunction sólo se ejecutará cuándo
  // cheapFunction retorne un valor falso
}
if (cheapFunction() && expensiveFunction()) {
  // en este caso, expensiveFunction sólo se ejecutará cuándo
  // cheapFunction retorne un valor verdadero
}

Esto entra en combinación con el hecho que javascript evalúa las condiciones directamente con el valor de las variables/expresiones, sin hacerles ningún cast, y que además retornará el valor de la última variable/expresión evaluada. Es por eso que puedes usarlo tal y cómo se explica en el tutorial de react.

Ejemplos más sencillos serían:

// evalúa si value es truthy y lo retorna automáticamente
// si es falsy, retorna 'default value'
const foo = value => value || 'default value';

foo('hola'); // 'hola'
foo(null); // 'default value'
foo(''); // 'default value'

Cabe decir que esto puede llegar a provocar bastantes bugs así que no es del todo seguro usarlo.

Por ejemplo, típico caso de bug producido por utilizar este pattern con números:

const bar = value => value || 100;

bar(1); // 1
bar(null); // 100
bar(0); // 100

Un saludo!