Operadores lógicos

Los operadores lógicos se usan típicamente con valores Boolean. En tal caso, regresan un valor Boolean. Sin embargo, los operadores && y || regresan en realidad el valor de uno de los operandos especificados, por lo que si estos operadores se usan con valores no Boolean, posiblemente regresen un valor no Boolean.

Descripción

Los operadores lógicos se describen en la tabla siguiente:

Algunos ejemplos de expresiones que pueden convertirse a false son aquellas que evalúan a null, 0, un string vacío (""), o undefined.

A pesar de que los operadores && y ||  pueden ser usados con operandos que no son valores Boolean, aún pueden ser considerados como operadores Boolean porque sus valores de regreso siempre pueden convertirse a valores Boolean.

Evaluación contra "corto circuitos"

Ya que las expresiones lógicas son evaluadas de izquierda a derecha, se prueban con una evaluación contra posibles "cortos circuitos" usando las siguientes normas:

• false && (cualquier valor) evalúa a "false".
• true || (cualquier valor) evalúa a "true".

Las reglas de lógica garantizan que estas evaluaciones siempre son correctas. Se debe notar que la parte de "cualquier valor" en las expresiones anteriores no se evalúa, para que tal acción no afecte de ninguna forma. Además, es de notar que la parte de "cualquier valor" en las expresiones anteriores debe ser cualquier expresión lógica (lo que se indica con los paréntesis).

Por ejemplo, las siguientes dos expresiones son equivalentes.

function shortCircuitEvaluation() {
  doSomething() || doSomethingElse()
}

function equivalentEvaluation() {
  var flag = doSomething();
  if (!flag) {
    doSomethingElse();
  }
}

Sin embargo, las siguientes expresiones no son equivalentes debido a la precedencia de operadores, y con tal ejemplo se enfatiza la importancia de que la parte derecha sea una única expresión (agrupada en paréntesis si es necesario).

false && true  || true      // regresa true
false && (true || true)     // regresa false

AND (&&) lógico

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

a1 = true  && true      // t && t regresa true
a2 = true  && false     // t && f regresa false
a3 = false && true      // f && t regresa false
a4 = false && (3 == 4)  // f && f regresa false
a5 = "Cat" && "Dog"     // t && t regresa "Dog"
a6 = false && "Cat"     // f && t regresa false
a7 = "Cat" && false     // t && f regresa false

OR (||) lógico

El siguiente código muestra ejemplos del operador || (OR lógico).

o1 = true  || true       // t || t regresa true
o2 = false || true       // f || t regresa true
o3 = true  || false      // t || f regresa true
o4 = false || (3 == 4)   // f || f regresa false
o5 = "Cat" || "Dog"      // t || t regresa "Cat"
o6 = false || "Cat"      // f || t regresa "Cat"
o7 = "Cat" || false      // t || f regresa "Cat"

Logical NOT (!)

El siguiente código muestra ejemplos del operador ! (NOT lógico).

n1 = !true              // !t regresa false
n2 = !false             // !f regresa true
n3 = !"Cat"             // !t regresa false

Reglas de conversión

Convertir de AND a OR

la siguiente operación que involucra Booleans:

bCondition1 && bCondition2

siempre es igual a:

!(!bCondition1 || !bCondition2)

Convertir de OR a AND

la siguiente operación que involucra Booleans:

bCondition1 || bCondition2

siempre es igual a:

!(!bCondition1 && !bCondition2)

Convertir entre operadores NOT

la siguiente operación que involucra Booleans:

!!bCondition

siempre es igual a:

bCondition

Removiendo paréntesis anidados

Ya que las expresiones lógicas son evaluadas de izquierda a derecha, siempre es posible remover paréntesis en una expresión compleja, si se siguen ciertas reglas.

Removiendo operadores AND anidados

La siguiente operación compleja que involucra Booleans:

bCondition1 || (bCondition2 && bCondition3)

siempre es igual a:

bCondition1 || bCondition2 && bCondition3

Removiendo operadores OR anidados

La siguiente operación compleja que involucra Booleans:

bCondition1 && (bCondition2 || bCondition3)

siempre es igual a:

!(!bCondition1 || !bCondition2 && !bCondition3)

Especificaciones

Compatibilidad entre navegadores

Ver también

• Operaciones binarias
• Boolean