Operadores de comparação

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Os operadores de comparação comparam os valores de dois operandos e avaliam se a instrução que eles formam é 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 numérico 4 são iguais, esta expressão é avaliada como true:

2 + 2 === 4 > true 

Coerção de tipo e igualdade

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

2 == 2 > true  2 == "2" > true 

O mesmo acontece com !=, que retorna true apenas se os operandos que estão sendo comparados não forem vagamente iguais.

2 != 3 > true  2 != "2" > false 

Comparações estritas usando === ou !== não realizam coerção de tipo. Para que uma comparação estrita 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.

Verdadeiro e falso

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

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

Todos os outros valores são convertidos em 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 verdadeiro ou falso de um operando, avaliando true se o operando for false e false se o operando for true:

 true > true  !true > false  !false > true  

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

!!"string" > true  !!0 > false 

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

A operação lógica AND (&&) retorna o primeiro dos dois operandos somente se esse operando for avaliado como false. Caso contrário, o segundo operando será retornado. Em comparações que são avaliadas como valores booleanos, ele retorna true somente se os operandos em ambos os lados do E lógico forem avaliados como true. Se qualquer lado for avaliado como false, ele retornará 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 a 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 operação OR lógica (||) retorna o primeiro dos dois operandos somente se esse operando for avaliado como true. Caso contrário, o segundo operando será retornado. Em comparações que são avaliadas como valores booleanos, isso significa que o método retorna true se um dos operandos for avaliado como true. Se nenhum lado for avaliado como true, ele 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 ele puder ser forçado para true. Se o primeiro operando puder ser forçado a 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 ele tiver qualquer valor diferente de null ou undefined. Caso contrário, ele retorna o segundo operando.

null ?? "My string" > "My string"  undefined ?? "My string" > "My string"  true ?? "My string"; > true 

?? é semelhante a uma operação lógica OR, mas é mais rigoroso 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 somente quando o primeiro é estritamente igual a null ou undefined, mesmo que possa ser forçado a 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 é um único sinal de igual (=), usado para atribuir um valor a uma variável declarada.

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

O operador de atribuição lógica E (&&=) avalia o segundo operando e o atribui ao primeiro se o primeiro for avaliado como true. Ou seja, "se o primeiro operando for verdadeiro, atribua o valor do segundo operando:"

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

O valor verdadeiro ou falso do primeiro operando determina se uma atribuição é 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 ser atribuído a um valor:

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

O operador de atribuição lógica OR (||=) avalia o segundo operando e o atribui ao primeiro se ele for false. Ou seja, "se o primeiro operando for falso, atribua o valor do segundo operando:"

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

Teste seu conhecimento