Operadores de comparação

Eles comparam os valores de dois operandos e avaliam se a instrução deles é true ou false. O exemplo a seguir usa o operador strict equality (===) para comparar dois operandos: a expressão 2 + 2 e o valor 4. Como o resultado da expressão e o valor de número 4 são os mesmos, essa expressão é avaliada como true:

2 + 2 === 4
> true

Coerção e igualdade de tipo

Dois dos operadores de comparação mais usados são == para igualdade livre e === para igualdade estrita. == executa uma comparação flexível entre dois valores forçando os operandos a tipos de dados correspondentes, se possível. Por exemplo, 2 == "2" retorna true, mesmo que a comparação esteja sendo feita entre um valor numérico e um valor de string.

2 == 2
> true

2 == "2"
> true

O mesmo vale para !=, que retorna true somente se os operandos que estão sendo comparados não são vagamente iguais.

2 != 3
> true

2 != "2"
> false

Comparações estritas usando === ou !== não executam coerção de tipo. Para que uma comparação seja avaliada como true, os valores comparados precisam ter o mesmo tipo de dados. Por isso, 2 == "2" retorna true, mas 2 === "2" retorna false:

2 === 3
> false

2 === "2"
> false

Para remover qualquer ambiguidade que possa resultar da coerção automática, use === sempre que possível.

Operador	Descrição	Uso	Resultado
===	Estritamente igual	2 === 2	verdadeiro
!==	Não estritamente igual	2 !== "2"	verdadeiro
==	Igual (ou "parcialmente igual")	2 == "2"	verdadeiro
!=	Diferente	2 != "3"	verdadeiro
>	Maior que	3 > 2	verdadeiro
>=	Maior ou igual a	2 >= 2	verdadeiro
<	Menor que	2 < 3	verdadeiro
<=	Menor ou igual a	2 <= 3	verdadeiro

Verdade e falsy

Todos os valores em JavaScript são implicitamente true ou false e podem ser convertidos para o valor booleano correspondente, por exemplo, usando o comparador "parcialmente igual". Um conjunto limitado de valores é convertido para false:

• 0
• null
• undefined
• NaN
• Uma string vazia ("")

Todos os outros valores são convertidos para true, incluindo qualquer string que contenha um ou mais caracteres e todos os números diferentes de zero. Eles são comumente chamados de valores "verdadeiros" e "falsos".

"My string" == true
> true

100 == true
> true

0 == true
> false

Operadores lógicos

Use os operadores lógicos AND (&&), OR (||) e NOT (!) para controlar o fluxo de um script com base na avaliação de duas ou mais instruções condicionais:

2 === 3 || 5 === 5;
> true

2 === 2 && 2 === "2"
> false

2 === 2 && !"My string."
> false

Uma expressão lógica NOT (!) nega o valor true ou false de um operando, avaliando como true se o operando for avaliado como false e false se o operando for avaliado como true:

true
> true

!true
> false

!false
> true

O uso do operador lógico NOT (!) na frente de outro tipo de dados, como um número ou uma string, força esse valor para um booleano e inverte o valor true ou false do resultado.

"string"
> "string"

!"string"
> false

0
> 0

!0
> true

É uma prática comum usar dois operadores NOT para forçar rapidamente os dados a seu valor booleano correspondente:

!!"string"
> true

!!0
> false

Os operadores lógicos AND e OR não realizam nenhuma coerção sozinhos. Eles retornam o valor de um dos dois operandos que estão sendo avaliados, com o operando escolhido determinado por essa avaliação.

AND lógico (&&) retorna o primeiro dos dois operandos somente se ele for avaliado como false. Caso contrário, o segundo operando será retornado. Em comparações que são avaliadas como valores booleanos, ele retornará true somente se os operandos em ambos os lados da lógica AND forem avaliados como true. Se qualquer um dos lados for avaliado como false, ele retorna false.

true && false
> false

false && true
> false

false && false
> false

true && true
> true

Quando && é usado com dois operandos não booleanos, o primeiro operando é retornado sem alteração se puder ser forçado para false. Se o primeiro operando puder ser forçado para true, o segundo operando será retornado inalterado:

false && "My string"
> false

null && "My string"
> null

"My string" && false
> false

"My string" && "My second string"
> "My second string"

2 === 2 && "My string"
> "My string"

O OR lógico (||) retorna o primeiro dos dois operandos somente se ele for avaliado como true. Caso contrário, o segundo operando será retornado. Em comparações que avaliam como valores booleanos, isso significa que ele retorna true se um dos operandos for avaliado como true e, se nenhum dos lados for avaliado como true, retornará false:

true || false
> true

false || true
> true

true || true
> true

false || false
> false

Ao usar || com dois operandos não booleanos, ele retorna o primeiro operando inalterado se puder ser forçado para true. Se o primeiro operando puder ser forçado para false, o segundo operando será retornado inalterado:

false || "My string"
> "My string"

null || "My string"
> "My string"

"My string" || false
> "My string"

"My string" || "My second string"
> "My string"

2 === 2 || "My string"
> true

Operador de coalescência nulo

Introduzido no ES2020, o "operador de coalescência nulo" (??) retorna o primeiro operando somente se esse operando tiver qualquer valor diferente de null ou undefined. Caso contrário, ela retorna o segundo operando.

null ?? "My string"
> "My string"

undefined ?? "My string"
> "My string"

true ?? "My string";
> true

?? é semelhante a um OR lógico, mas é mais rígido na forma como o primeiro operando é avaliado. || retorna o segundo operando para qualquer expressão que possa ser forçada para false, incluindo undefined e null. ?? retorna o segundo operando quando o primeiro é qualquer coisa, menos null ou undefined, mesmo que ele possa ser forçado para false:

0 ?? "My string";
> 0

false ?? "My string";
> false

undefined ?? "My string";
> "My string"

Operadores de atribuição lógica

Use operadores de atribuição para atribuir o valor de um segundo operador a um primeiro operador. O exemplo mais comum é o sinal de igual (=), usado para atribuir um valor a uma variável declarada.

Use operadores lógicos de atribuição para atribuir condicionalmente um valor a uma variável com base no valor true ou false dessa variável.

O operador lógico de atribuição AND (&&=) avalia o segundo operando e atribui ao primeiro operando se somente se o primeiro operando avaliar como true. De fato, "se o primeiro operando for verdadeiro, atribua a ele o valor do segundo operando:"

let myVariable = false;
myVariable &&= 2 + 2;
> false

myVariable = true;
myVariable &&= 2 + 2;
> 4

O valor true ou false do primeiro operando determina se uma atribuição será realizada. No entanto, tentar avaliar o primeiro operando usando um operador de comparação resulta em um booleano true ou false, que não pode receber um valor:

let myVariable = 5;
myVariable > 2 &&= "My string"
> SyntaxError: Invalid left-hand side in assignment

O operador lógico de atribuição OR (||=) avalia o segundo operando e atribui ao primeiro operando se o primeiro operando for avaliado como false, efetivamente "se o primeiro operando for falso, atribua a ele o valor do segundo operando:"

let myVariable = false;
myVariable ||= 2 + 2;
> 4

myVariable = true;
myVariable ||= 2 + 2;
> true

Teste seu conhecimento