Eloperador lógico AND (&&) (conjunción lógica) serátrue para un conjunto de operandos booleanos si y solo si todos los operandos sontrue. En caso contrario, seráfalse.

Generalmente, el operador retorna el valor del primer operandofalsy encontrado cuando evalúa de izquierda a derecha, o el valor del último operando si todos ellos sontruthy.

Pruébalo

const a = 3;const b = -2;console.log(a > 0 && b > 0);// Expected output: false

Sintaxis

x && y

Descripción

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

Si un valor puede ser convertido atrue, el valor es conocido comotruthy. Si un valor puede ser convertido afalse, el valor es conocido comofalsy.

Ejemplos de expresiones que pueden ser convertidas afalse 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 resultresult = 2 && 0; // 0 es asignado a resultresult = "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 unbooleano 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 objetoBoolean.

Evaluación de cortocircuito (Short-circuit)

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 esfalse, el operador AND se detiene y retorna el valor original del operandofalsy;no evalúa ninguno de los operandos restantes.

Considere el siguiente pseudocódigo.

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

La parte de laexpresiónnunca es evaluada porque el primer operando(alguna expresiónfalsy) es evaluado comofalsy.Si laexpresió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

Precedencia de operadores

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

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

Ejemplos

Usando el operador lógico AND

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`

Reglas de conversión para booleanos

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)

Removiendo paréntesis anidados

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

Especificaciones

Compatibilidad con navegadores

Véase también

• Boolean
• Truthy
• Falsy