AND lógico (&&)

O AND lógico (&&) avalia operandos da esquerda para a direita, retornando imediatamente com o valor do primeiro operando falsy que encontrar; se todos os valores forem truthy, o valor do último operando é retornado.

Se um valor puder ser convertido em true, o valor é denominado como truthy. Se um valor puder ser convertido em false, então valor será denominado falsy.

Exemplos de expressões que podem ser convertidas em false são:

• false;
• null;
• NaN;
• 0;
• string vazia ("" ou '' ou ``);
• undefined.

O operador AND lógico (&&) preserva valores não booleanos e os retorna como estão:

result = "" && "foo"; // result retorna "" (string vazia) result = 2 && 0; // result retorna 0 result = "foo" && 4; // result retorna 4 

Mesmo que o operador && possa ser usado com operandos não booleanos, ele ainda é considerado um operador booleano, pois seu valor de retorno sempre pode ser convertido em um boolean primitive. Para converter explicitamente seu valor de retorno (ou qualquer expressão em geral) para o valor booleano correspondente, use um double operador NOT ou o construtor Boolean.

A expressão AND lógica é um operador de curto-circuito. Ou seja, à medida que cada operando é convertido em um booleano, se o resultado de uma conversão for false, o operador AND para e retorna o valor original desse operando falso; ele não avalia nenhum dos operandos restantes.

Considere o pseudocódigo abaixo.

(alguma expressao falsa aqui) && expr 

A exprnunca é avaliada porque o primeiro operando (alguma expressao falsa aqui) é avaliado como falsy. Se expr for uma função, a função nunca será chamada. Veja o exemplo abaixo:

function A() { console.log("chamou A"); return false; } function B() { console.log("chamou B"); return true; } console.log(A() && B()); // registra "chamou A" no console devido à chamada da função A, // && é avaliado como false (porque a função A retorna false), então false é registrado no console; // o operador AND entra em curto-circuito aqui e ignora a função B 

O operador AND tem uma precedência maior que o operador OR, o que significa que o operador && é executado antes do operador || (consulte precedência de operadores).

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

O código a seguir mostra exemplos do operador && (AND lógico).

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 

Convertendo AND para OR

A seguinte operação envolvendo booleanos:

bCondition1 && bCondition2 

é sempre igual a:

!(!bCondition1 || !bCondition2) 

Convertendo OR para AND

A seguinte operação envolvendo booleanos:

bCondition1 || bCondition2 

é sempre igual a:

!(!bCondition1 && !bCondition2) 

Como as expressões lógicas são avaliadas da esquerda para a direita, sempre é possível remover os parênteses de uma expressão complexa desde que certas regras sejam seguidas.

A seguinte operação composta envolvendo booleanos:

bCondition1 || (bCondition2 && bCondition3) 

é sempre igual a:

bCondition1 || bCondition2 && bCondition3 

• Boolean
• Truthy
• Falsy