Operador lógico AND (&&)
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 (en-US) encontrado cuando evalúa de izquierda a derecha, o el valor del último operando si todos ellos son truthy.
Pruébalo
Sintaxis
x && y
Descripción
El operador lógico AND (&&
) evalúa operandos de izquierda a derecha, regresando inmediatamente el valor del primer operando falsy (en-US) 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 (en-US).
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 (en-US)) 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 (en-US).
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
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).
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 (&&
).
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
Specification |
---|
ECMAScript Language Specification # prod-LogicalANDExpression |
Compatibilidad con navegadores
BCD tables only load in the browser