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
Qual operador indica "estritamente igual"?
!=
==
=
===