O JavaScript possui comparações estritas e conversão de tipos. Uma comparação estrita (e.g., ===) somente é verdade se os operandos forem do mesmo tipo e de conteúdo correspondente. A comparação abstrata mais comumente utilizada (e.g. ==) converte os operandos no mesmo tipo antes da comparação. Para comparações abstratas relacionais (e.g., <=), os operandos são primeiro convertidos em primitivos, depois para o mesmo tipo, depois comparados.
Strings são comparadas baseadas na ordenação lexicografica padrão, usando valores Unicode.
Os fontes para este exemplo interativo estão em um repositório no GitHub. Se você gostaria de contribuir com projetos de exemplos interativos, por favor clone https://github.com/mdn/interactive-examples e envie para nós um pull request.
Características de comparação:
true ou ambos são false.O operador de igualdade converte o operando se ele não for do mesmo tipo, então aplica a comparação estrita. Se ambos os operandos são objetos, então o JavaScript compara referencias internas que são iguais quando os operandos se referem ao mesmo objeto em memória.
x == y
1 == 1 // verdade
'1' == 1 // verdade
1 == '1' // verdade
0 == false // verdade
0 == null // falso
var object1 = {'key': 'value'}, object2 = {'key': 'value'};
object1 == object2 // falso
0 == undefined // falso
null == undefined // verdade
O operador de desigualdade retorna true (verdade) se os operandos não são iguais. Se os dois operandos não são do mesmo tipo, o JavaScript tenta converter os operandos para o tipo apropriado para a comparação. Se ambos os operandos são objetos, então o JavaScript compara referências internas que não são iguais quando os operandos se referem a objetos diferentes na memória.
x != y
1 != 2 // verdade 1 != '1' // falso 1 != "1" // falso 1 != true // falso 0 != false // falso
O operador de identidade retorna true (verdade) se os operandos são estritamente iguais (veja acima) sem conversão de tipo.
x === y
3 === 3 // verdade
3 === '3' // falso
var object1 = {'key': 'value'}, object2 = {'key': 'value'};
object1 === object2 //f also
O operador desigualdade estrita (Non-identity) retorna verdadeiro se os operandos não são iguais e / ou não são do mesmo tipo.
x !== y
3 !== '3' // verdade 4 !== 3 // verdade
Cada um desses operadores chamará a função valueOf () em cada operando antes que uma comparação seja feita.
O operador de Maior retorna true se o operando da esquerda for maior que o operando da direita.
x > y
4 > 3 // verdade
O operador maior ou igual retorna true se o operando da esquerda for maior ou igual ao operando da direita.
x >= y
4 >= 3 // verdade 3 >= 3 // verdade
O operador menor retorna true (verdadeiro) se o operando da esquerda for menor que o operando da direita.
x < y
3 < 4 // verdade
O operador menor ou igual retorna true (verdadeiro) se o operando da esquerda for menor ou igual ao operando da direita.
x <= y
3 <= 4 // verdade
Os operadores de igualdade padrão (== e! =) Usam o Algoritmo de Comparação de Igualdade Abstrata
para comparar dois operandos. Se os operandos forem de tipos diferentes, ele tentará convertê-los para o mesmo tipo antes de fazer a comparação. Por exemplo, na expressão 5 == '5', a sequência à direita é convertida em {{jsxref ("Number" )}} antes da comparação ser feita.
Os operadores de igualdade estrita (=== e! ==) usam o Algoritmo de comparação estrita de igualdade e se destinam a executar comparações de igualdade em operandos do mesmo tipo. Se os operandos são de tipos diferentes, o resultado é sempre falso, então 5! == '5'.
Use operadores de igualdade estrita se os operandos precisarem ser de um tipo específico e também de valor ou se o tipo exato dos operandos for importante. Caso contrário, use os operadores de igualdade padrão, que permitem comparar a identidade de dois operandos, mesmo que não sejam do mesmo tipo.
Quando a conversão de tipos está envolvida na comparação (por exemplo, comparação não estrita), o JavaScript converte os tipos {{jsxref ("String")}}, {{jsxref ("Number")}}, {{jsxref ("Booleano" )}} ou {{jsxref ("Object")}}) operandos da seguinte forma:
// true, pois ambos os operandos são do tipo String (ou seja, primitivos de string):
'foo' === 'foo'
var a = new String('foo');
var b = new String('foo');
// falso (false) pois a e b, embora do tipo "Objeto", são instâncias diferentes
a == b
// falso (false) pois a e b, embora do tipo "Objeto", são instâncias diferentes
a === b
// verdadeiro (true) pois o objeto a e 'foo' (String) são de tipos diferentes e, o Objeto (a)
// é convertido para String ('foo') antes da comparação
a == 'foo'
| Especificação | Status | Comentário |
|---|---|---|
| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição Inicial. Implementado em JavaScript 1.0 |
| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Adicionandos os operadores === e !== . Implementado em JavaScript 1.3 |
| {{SpecName('ES5.1', '#sec-11.8')}} | {{Spec2('ES5.1')}} | Definidos em várias seções das especificações: Operadores Relacionais , Operadores de Igualdade |
| {{SpecName('ES6', '#sec-relational-operators')}} | {{Spec2('ES6')}} | Definidos em várias seções das especificações: Operadores Relacionais , Operadores de Igualdade |
| {{SpecName('ESDraft', '#sec-relational-operators')}} | {{Spec2('ESDraft')}} | Definidos em várias seções das especificações: Operadores Relacionais , Operadores de Igualdade |
{{Compat("javascript.operators.comparison")}}