AND lógico (&&)

Baseline Widely available

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

O operador lógico AND (&&) (conjunção lógica) para um conjunto de operandos booleanos será true se e somente se todos os operandos forem true. Caso contrário, será false.

Geralmente, o operador retorna o valor do primeiro operando falsy encontrado ao avaliar da esquerda para a direita ou retorna o valor do último operando se todos forem truthy.

Exemplo

Experimente

const a = 3;
const b = -2;

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

Sintaxe

js
expr1 && expr2

Descrição

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:

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

Avaliação de curto-circuito

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 expr nunca é 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:

js
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

Operador precedente

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

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

Exemplos

Usando AND

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

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

Regras de conversão para booleanos

Convertendo AND para OR

A seguinte operação envolvendo booleanos:

js
bCondition1 && bCondition2

é sempre igual a:

js
!(!bCondition1 || !bCondition2)

Convertendo OR para AND

A seguinte operação envolvendo booleanos:

js
bCondition1 || bCondition2

é sempre igual a:

js
!(!bCondition1 && !bCondition2)

Removendo parênteses aninhados

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:

js
bCondition1 || (bCondition2 && bCondition3)

é sempre igual a:

js
bCondition1 || bCondition2 && bCondition3

Especificações

Specification
ECMAScript® 2025 Language Specification
# prod-LogicalANDExpression

Compatibilidade com navegadores

Report problems with this compatibility data on GitHub
desktopmobileserver
Chrome
Edge
Firefox
Opera
Safari
Chrome Android
Firefox for Android
Opera Android
Safari on iOS
Samsung Internet
WebView Android
WebView on iOS
Deno
Node.js
Logical AND (&&)

Legend

Tip: you can click/tap on a cell for more information.

Full support
Full support

Veja também