Operadores lógicos

Este articulo necesita una revisión editorial. Cómo puedes ayudar.

Esta traducción está incompleta. Por favor, ayuda a traducir este artículo del inglés.

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:

Operador Uso Descripción
AND (&&) lógico expr1 && expr2

Regresa expr1 si tal puede convertirse a false; de lo contrario, regresa expr2. De esta forma, cuando se usa con valores Boolean, && regresa true si ambos operandos son verdaderos; de lo contrario regresa false.

OR (||) lógico expr1 || expr2

Regresa expr1 si tal puede convertirse a true; de lo contrario, regresa expr2. De esta forma, cuando se usa con valores Boolean, || regresa true si cualquier operando es verdadero; pero si ambos son falsos, regresa "false".

NOT (!) lógico !expr

Regresa false si su único operando puede convertirse a true; de lo contrario, regresa true.

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

Especificación Estado Comentarios
ECMAScript 1st Edition (ECMA-262) Standard Definición inicial.
ECMAScript 5.1 (ECMA-262) Standard

Definido en varias secciones de la especificación: Logical NOT Operator, Binary Logical Operators

ECMAScript 2015 (6th Edition, ECMA-262) Standard Definido en varias secciones de la especificación: Logical NOT Operator, Binary Logical Operators
ECMAScript 2016 Draft (7th Edition, ECMA-262) Draft Definido en varias secciones de la especificación: Logical NOT Operator, Binary Logical Operators

Compatibilidad entre navegadores

Característica Chrome Firefox (Gecko) Internet Explorer Opera Safari
AND (&&) lógico (Yes) (Yes) (Yes) (Yes) (Yes)
OR (||) lógico (Yes) (Yes) (Yes) (Yes) (Yes)
NOT (!) lógico (Yes) (Yes) (Yes) (Yes) (Yes)
Característica Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
AND (&&) lógico (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
OR (||) lógico (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
NOT (!) lógico (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)

Ver también

Etiquetas y colaboradores del documento

 Colaboradores en esta página: lifescripter
 Última actualización por: lifescripter,