Operadores de comparação

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