195 lines
6.8 KiB
Markdown
195 lines
6.8 KiB
Markdown
---
|
|
title: Comparison Operators
|
|
localeTitle: Operadores de Comparação
|
|
---
|
|
O JavaScript possui comparações de **conversão** **estrita** e de **tipo** .
|
|
|
|
* Uma comparação estrita (por exemplo, ===) só é verdadeira se os operandos forem do mesmo tipo.
|
|
|
|
* A comparação abstrata mais usada (por exemplo, ==) converte os operandos para o mesmo tipo antes de fazer a comparação.
|
|
|
|
* Para comparações abstratas relacionais (por exemplo, <=), os operandos são primeiro convertidos em primitivos, depois para o mesmo tipo, antes da comparação.
|
|
|
|
* As cadeias de caracteres são comparadas com base na ordem lexicográfica padrão, usando valores Unicode.
|
|
|
|
|
|
## Recursos de comparações:
|
|
|
|
* Duas strings são estritamente iguais quando possuem a mesma sequência de caracteres, o mesmo comprimento e os mesmos caracteres nas posições correspondentes.
|
|
|
|
* Dois números são estritamente iguais quando são numericamente iguais (possuem o mesmo valor numérico). NaN não é igual a nada, incluindo NaN. Zeros positivos e negativos são iguais entre si.
|
|
|
|
* Dois operandos booleanos são estritamente iguais se ambos forem verdadeiros ou se ambos forem falsos.
|
|
|
|
* Dois objetos distintos nunca são iguais para comparações estritas ou abstratas.
|
|
|
|
* Uma expressão comparando Objetos só é verdadeira se os operandos fizerem referência ao mesmo Objeto.
|
|
|
|
* Tipos nulos e indefinidos são estritamente iguais a si mesmos e abstratamente iguais entre si.
|
|
|
|
|
|
## Operadores de igualdade
|
|
|
|
### Igualdade (==)
|
|
|
|
O operador de igualdade converte os operandos, se eles **não** forem **do mesmo tipo** , e aplicará uma comparação estrita. Se **ambos os operandos são objetos** , então o JavaScript compara referências internas que são iguais quando operandos se referem ao mesmo objeto na memória.
|
|
|
|
#### Sintaxe
|
|
```
|
|
x == y
|
|
```
|
|
|
|
#### Exemplos
|
|
```
|
|
1 == 1 // true
|
|
"1" == 1 // true
|
|
1 == '1' // true
|
|
0 == false // true
|
|
0 == null // false
|
|
|
|
0 == undefined // false
|
|
null == undefined // true
|
|
```
|
|
|
|
### Desigualdade (! =)
|
|
|
|
O operador de desigualdade retorna verdadeiro se os operandos não forem iguais. Se os dois operandos **não** forem **do mesmo tipo** , o JavaScript tentará converter os operandos em um tipo apropriado para a comparação. Se os **dois operandos são objetos** , o JavaScript compara referências internas que não são iguais quando operandos se referem a objetos diferentes na memória.
|
|
|
|
#### Sintaxe
|
|
```
|
|
x != y
|
|
```
|
|
|
|
#### Exemplos
|
|
```
|
|
1 != 2 // true
|
|
1 != "1" // false
|
|
1 != '1' // false
|
|
1 != true // false
|
|
0 != false // false
|
|
```
|
|
|
|
### Identidade / igualdade estrita (===)
|
|
|
|
O operador de identidade retorna true se os operandos forem estritamente iguais **sem conversão de tipo** .
|
|
|
|
#### Sintaxe
|
|
```
|
|
x === y
|
|
```
|
|
|
|
#### Exemplos
|
|
```
|
|
3 === 3 // true
|
|
3 === '3' // false
|
|
```
|
|
|
|
### Não identidade / desigualdade estrita (! ==)
|
|
|
|
O operador não identificador retorna true se os operandos **não forem iguais e / ou não do mesmo tipo** .
|
|
|
|
#### Sintaxe
|
|
```
|
|
x !== y
|
|
```
|
|
|
|
#### Exemplos
|
|
```
|
|
3 !== '3' // true
|
|
4 !== 3 // true
|
|
```
|
|
|
|
## Operadores relacionais
|
|
|
|
### Maior que o operador (>)
|
|
|
|
O operador maior que retorna true se o operando esquerdo for maior que o operando direito.
|
|
|
|
#### Sintaxe
|
|
```
|
|
x > y
|
|
```
|
|
|
|
#### Exemplos
|
|
```
|
|
4 > 3 // true
|
|
```
|
|
|
|
### Operador maior que ou igual (> =)
|
|
|
|
O operador maior que ou igual retorna verdadeiro se o operando esquerdo for maior ou igual ao operando direito.
|
|
|
|
#### Sintaxe
|
|
```
|
|
x >= y
|
|
```
|
|
|
|
#### Exemplos
|
|
```
|
|
4 >= 3 // true
|
|
3 >= 3 // true
|
|
```
|
|
|
|
### Menos que o operador (<)
|
|
|
|
O operador menor que retorna true se o operando esquerdo for menor que o operando direito.
|
|
|
|
#### Sintaxe
|
|
```
|
|
x < y
|
|
```
|
|
|
|
#### Exemplos
|
|
```
|
|
3 < 4 // true
|
|
```
|
|
|
|
### Operador menor que ou igual (<=)
|
|
|
|
O operador menor que ou igual retorna verdadeiro se o operando esquerdo for menor ou igual ao operando direito.
|
|
|
|
#### Sintaxe
|
|
```
|
|
x <= y
|
|
```
|
|
|
|
#### Exemplos
|
|
```
|
|
3 <= 4 // true
|
|
```
|
|
|
|
_Você pode encontrar mais informações no [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators) ._
|
|
|
|
## Comparando null e undefined
|
|
|
|
Quando comparamos nulo e indefinido, vemos um comportamento diferente. Vamos verificar diferentes cenários através de exemplos
|
|
|
|
#### Exemplo - verificação de igualdade estrita (===)
|
|
|
|
console.log (null === indefinido); // O / P - falso
|
|
|
|
Otuput é falso e isso é correto porque sabemos que "nulo" e "indefinido" são tipos diferentes.
|
|
|
|
#### Exemplo - verificação de igualdade não estrita (==)
|
|
|
|
console.log (null == indefinido); // O / P: - true
|
|
|
|
Como? Isso ocorre porque existe uma regra especial para "null" e "undefined". Devido a que eles são iguais em caso de verificação não estrita (==), mas não são iguais a qualquer outro valor.
|
|
|
|
Se usarmos operadores de comparação como <,>, <=,> = etc., "nulo" e "indefinido" serão convertidos em números e, nesses casos, "nulo" se tornará 0 e "indefinido" será NaN. Vamos verificar alguns desses exemplos.
|
|
|
|
#### Exemplo - comparar nulo com 0 (zero)
|
|
|
|
console.log (nulo> 0); // O / P - falso console.log (null> = 0); // O / P - true console.log (null == 0); // O / P - falso
|
|
|
|
Estranho? De acordo com a primeira instrução, nulo não é maior que 0 e da segunda instrução nulo é maior ou igual a 0. Então, se pensarmos matematicamente e compararmos ambas as declarações, chegaremos ao resultado que nulo é igual a 0. Mas , conforme a terceira afirmação não é verdadeira. Por quê?
|
|
|
|
A razão é "comparação" e "verificação de igualdade" ambos funcionam de maneira diferente. Em comparação, "null / undefined" é primeiro convertido em number, portanto, nos dois primeiros casos, "null" se torna 0 e, portanto, case1) (null> 0) -> false e case2) (null> = 0) -> true. Mas, na verificação de igualdade (==), "null / undefined" funciona sem qualquer conversão e como explicado acima (regra especial), na verificação de igualdade "null / undefined" são apenas iguais entre si e não são iguais a qualquer outra coisa. Daí (null == 0) -> falso.
|
|
|
|
#### Exemplo - comparar indefinido com 0 (zero)
|
|
|
|
console.log (indefinido> 0); // O / P - falso console.log (indefinido> = 0); // O / P - falso console.log (indefinido == 0); // O / P - falso
|
|
|
|
Aqui, testamos os mesmos casos que fizemos para null, mas novamente o resultado é diferente. Por quê?
|
|
|
|
As razões são as seguintes. Nos dois primeiros casos, estamos comparando undefined com 0 e como mencionado acima na comparação undefined é convertido para NaN. NaN é um valor especial que sempre retorna falso quando comparado com qualquer número e é por isso que temos resultados falsos nos dois primeiros casos. Para a terceira instrução, a razão é a mesma mencionada para "null". Na verificação de igualdade, "null / undefined" são apenas iguais entre si e não iguais a qualquer outra coisa. Daí (indefinido == 0) -> falso. |