Operadores de comparação

Os operadores de comparação comparam os valores de dois operandos e avaliam se o da instrução formada é true ou false. O exemplo a seguir usa Operador strict equality (===) para comparar dois operandos: a expressão. 2 + 2 e o valor 4. Como o resultado da expressão e o número valores 4 forem iguais, esta expressão será 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 flexível. e === para igualdade total. O == realiza uma comparação flexível entre dois valores forçando os operandos a tipos de dados correspondentes, se possível. Para 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 acontece com !=, que retorna true somente se os operandos que estão sendo comparados não são igualmente iguais.

2 != 3
> true

2 != "2"
> false

Comparações rigorosas usando === ou !== não fazem coerção de tipo. Para um comparação estrita para avaliar com true, os valores que estão sendo comparados devem 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 sempre que possível.

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

Veracidade e falsidade

Todos os valores em JavaScript são implicitamente true ou false e podem ser forçados a o valor booleano correspondente, por exemplo, usando a expressão "loosely equal" comparador. Um conjunto limitado de valores força a false:

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

Todos os outros valores forçam a true, incluindo qualquer string que contenha um ou mais caracteres e todos os números diferentes de zero. Elas costumam ser chamadas de "verdades", e "falsa" e a distribuição dos valores dos dados.

"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 (!) anula o valor verdadeiro ou falso 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

Usar o operador lógico NOT (!) na frente de outro tipo de dados, como uma número ou string, força esse valor para um booleano e inverte o verdadeiro 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 para sua valor booleano correspondente:

!!"string"
> true

!!0
> false

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

A lógica AND (&&) retorna o primeiro dos dois operandos somente se esse operando. avalia como false e o segundo operando, caso contrário. Em comparações que seja avaliada em valores booleanos, ela retornará true somente se os operandos em ambos os lados da lógica AND é avaliada como true. Se 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. inalterado se puder ser forçado para false. Se o primeiro operando puder ser forçado como 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"

A lógica OR (||) retorna o primeiro dos dois operandos somente se ele avalia como true e o segundo operando, caso contrário. Em comparações que avaliar como valores booleanos, isso significa que ele retorna true se um dos operandos é avaliado como true e, se nenhum lado for avaliado como true, ele retorna 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. inalterada se pudesse ser forçada para true. Se o primeiro operando puder ser forçado como 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 coalescente nulo

Introduzido em ES2020, o "operador de coalescência nulo" (??) retorna o primeiro operando somente se esse operando tem um valor diferente de null ou undefined. Caso contrário, 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 restrito na forma como o primeiro operando é avaliado. || retorna o segundo operando de qualquer expressão que possa ser for convertido para false, incluindo undefined e null. ?? retorna o segundo operando quando o primeiro operando for qualquer coisa menos null ou undefined, mesmo que ele pode ser forçado para false:

0 ?? "My string";
> 0

false ?? "My string";
> false

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

Operadores de atribuição lógicos

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

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

O operador lógico de atribuição AND (&&=) avalia o segundo operando e atribui ao primeiro operando se apenas se o primeiro operando for avaliado como true — efetivamente, "se o primeiro operando for verdadeiro, atribua a ele o valor de o segundo operando em vez disso:"

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 antes da avaliação ser realizada. No entanto, tentar avaliar o primeiro operando usando uma comparação resulta em um booleano true ou false, que não pode ter um :

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 atribuir 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