Operador lógico AND (&&)

El operador lógico AND (&&) evalúa operandos de izquierda a derecha, regresando inmediatamente el valor del primer operando falsy que encuentre; si todos los valores son truthy, el valor del último operando es retornado.

Si un valor puede ser convertido a true, el valor es conocido como truthy. Si un valor puede ser convertido a false, el valor es conocido como falsy.

Ejemplos de expresiones que pueden ser convertidas a false son:

• false;
• null;
• NaN;
• 0;
• cadena vacía ("" o '' o ``);
• undefined.

El operador AND preserva valores no booleanos y los retorna como estén:

result = "" && "foo"; // "" (cadena vacía) es asignada a result
result = 2 && 0; // 0 es asignado a result
result = "foo" && 4; // 4 es asignado a result

Aunque el operador && puede ser usado con operandos que no son valores booleanos, aún puede ser considerado un operador booleano ya que su valor de retorno siempre puede ser convertido a un booleano primitivo. Para explícitamente convertir su valor de retorno (o cualquier expresión en general) al correspondiente valor booleano, se debe usar un doble (operador lógico NOT) o el contructor del objeto Boolean.

La expresión lógica AND es un operador de cortocircuito (short-circuit). Como cada operando es convertido a un booleano, si el resultado de una conversión es false, el operador AND se detiene y retorna el valor original del operando falsy; no evalúa ninguno de los operandos restantes.

Considere el siguiente pseudocódigo.

(alguna expresión _falsy_) && expresión

La parte de la expresión nunca es evaluada porque el primer operando (alguna expresión falsy) es evaluado como falsy. Si la expresión es una función, la función nunca es llamada. Veamos el siguiente ejemplo:

function A() {
  console.log("llamada a A");
  return false;
}
function B() {
  console.log("llamada a B");
  return true;
}

console.log(A() && B());
// Imprime "llamada a A" en la consola por la llamada a la función A,
// `&&` evalúa a `false` (la función A retorna `false`), después `false` es impreso en la consola;
// el operador AND realiza un cortocircuito aquí e ignora la función B

El operador AND tiene más alta precedencia que el operador OR, esto significa que el operador && es ejecutado antes del operador || (vea precedencia de operadores).

true || false && false; // true
true && (false || false); // false
(2 === 3) || (4 < 0) && (1 === 1); // false

El siguiente código muestra ejemplos del operador lógico AND (&&).

a1 = true && true; // t && t retorna `true`
a2 = true && false; // t && f retorna `false`
a3 = false && true; // f && t retorna `false`
a4 = false && 3 === 4; // f && f retorna `false`
a5 = "Cat" && "Dog"; // t && t retorna "Dog"
a6 = false && "Cat"; // f && t retorna `false`
a7 = "Cat" && false; // t && f retorna `false`
a8 = "" && false; // f && f retorna ""
a9 = false && ""; // f && f retorna `false`

Convirtiendo el operador lógico AND al operador lógico OR

La siguiente operación involucra booleanos:

bCondition1 && bCondition2

es siempre igual a:

!(!bCondition1 || !bCondition2)

Convirtiendo el operador lógico OR al operador lógico AND

La siguiente operación involucra booleanos:

bCondition1 || bCondition2

es siempre igual a:

!(!bCondition1 && !bCondition2)

Ya que las expresiones lógicas son evaluadas de izquierda a derecha, siempre es posible remover los paréntesis de una expresión compleja siguiendo las siguientes reglas.

La siguiente operación compuesta involucra booleanos:

bCondition1 || (bCondition2 && bCondition3)

es siempre igual a:

bCondition1 || bCondition2 && bCondition3

• Boolean
• Truthy
• Falsy