Operador lógico AND (&&) - JavaScript | MDN

Toggle sidebar

Theme

OS default
Light
Dark

Español

Remember language Learn more

Operador lógico AND (&&)

Baseline Widely available

This feature is well established and works across many devices and browser versions. It’s been available across browsers since julio de 2015.

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

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

Pruébalo

const a = 3;
const b = -2;

console.log(a > 0 && b > 0);
// Expected output: false

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:

js
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.

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 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:

js
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 || (vea precedencia de operadores).

js
true || false && false; // true
true && (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 (&&).

js
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

Help improve MDN

Was this page helpful to you?

Yes No

Learn how to contribute

This page was last modified on 20 jun 2025 by MDN contributors.

View this page on GitHub • Report a problem with this content

Operador lógico AND (&&)

In this article

Pruébalo

Sintaxis

Descripción

Evaluación de cortocircuito (Short-circuit)

Precedencia de operadores

Ejemplos

Usando el operador lógico AND

Reglas de conversión para booleanos

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

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

Removiendo paréntesis anidados

Especificaciones

Compatibilidad con navegadores

Véase también

Help improve MDN