Operadores de comparação
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.
The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.
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:
- Duas strings são estritamente iguals quando elas possuem a mesma sequência de caracteres, o mesmo tamanho, Duas string são estritamente iguals quando elas possuem a mesma sequência de caracteres, o mesmo tamanho, e os mesmos caracteres em posições correspondentes.
- Dois números são estritamente iguais quando eles são numericamente iguais (tem o mesmo valor numérico). NaN não é igual a nada, incluindo NaN. Zeros positivos e negativos são iguals entre si.
- Dois operadores Boleanos são estritamente iguais se ambos são
true
ou ambos sãofalse
. - Dois objetos distintos nunca são iguais para comparações estritas ou abstratas.
- Uma expressão comparando Objetos somente é verdadeira se os operandos referenciarem o mesmo Objeto.
- Os tipo Null e Undefined são estritamente iguais entre eles mesmos e abstratamente iguais entre si.
Operadores de Igualdade
Igualdade (==)
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.
Sintaxe
x == y
Exemplos
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
Desigualdade (!=)
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.
Sintaxe
x != y
Exemplos
1 != 2 // verdade
1 != '1' // falso
1 != "1" // falso
1 != true // falso
0 != false // falso
Identidade / igualdade estrita (===)
O operador de identidade retorna true (verdade) se os operandos são estritamente iguais (veja acima) sem conversão de tipo.
Sintaxe
x === y
Exemplos
3 === 3 // verdade
3 === '3' // falso
var object1 = {'key': 'value'}, object2 = {'key': 'value'};
object1 === object2 //f also
Non-identity / desigualdade estrita (!==)
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.
Sintaxe
x !== y
Exemplos
3 !== '3' // verdade
4 !== 3 // verdade
Operadores relacionais
Cada um desses operadores chamará a função valueOf () em cada operando antes que uma comparação seja feita.
Operador Maior (>)
O operador de Maior retorna true se o operando da esquerda for maior que o operando da direita.
Sintaxe
x > y
Exemplos
4 > 3 // verdade
Operador maior ou igual (>=)
O operador maior ou igual retorna true se o operando da esquerda for maior ou igual ao operando da direita.
Sintaxe
x >= y
Exemplos
4 >= 3 // verdade
3 >= 3 // verdade
Operador Menor (<)
O operador menor retorna true (verdadeiro) se o operando da esquerda for menor que o operando da direita.
Sintaxe
x < y
Exemplos
3 < 4 // verdade
Operador menor ou igual (<=)
O operador menor ou igual retorna true (verdadeiro) se o operando da esquerda for menor ou igual ao operando da direita.
Sintaxe
x <= y
Exemplos
3 <= 4 // verdade
Usando Operadores de Igualdade
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 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 String
, Number
, Booleano
ou Object
) operandos da seguinte forma:
- Ao comparar um número e uma string, a string é convertida em um valor numérico. JavaScript tenta converter o literal numérico de string em um valor de tipo Number. Primeiro, um valor matemático é derivado do literal numérico da string. Em seguida, esse valor é arredondado para o valor de tipo de número mais próximo.
- Se um dos operandos for booleano, o operando booleano é convertido em 1 se for verdadeiro e +0 se for falso.
- Se um objeto é comparado com um número ou string, o JavaScript tenta retornar o valor padrão para o objeto. Os operadores tentam converter o objeto em um valor primitivo, um valor String ou Number, usando os métodos valueOf e toString dos objetos. Se essa tentativa de converter o objeto falhar, será gerado um erro de tempo de execução.
- Observe que um objeto é convertido em primitivo se, e somente se, seu comparando for um primitivo. Se os dois operandos forem objetos, eles serão comparados como objetos, e o teste de igualdade será verdadeiro apenas se ambos fizerem referência ao mesmo objeto.
// 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ções
Especificação | Status | Comentário |
---|---|---|
ECMAScript 1st Edition (ECMA-262) | Padrão | Definição Inicial. Implementado em JavaScript 1.0 |
ECMAScript 3rd Edition (ECMA-262) | Padrão | Adicionandos os operadores === e !== . Implementado em JavaScript 1.3 |
ECMAScript 5.1 (ECMA-262) | Padrão | Definidos em várias seções das especificações: Operadores Relacionais , Operadores de Igualdade |
ECMAScript 2015 (6th Edition, ECMA-262) | Padrão | Definidos em várias seções das especificações: Operadores Relacionais , Operadores de Igualdade |
ECMAScript (ECMA-262) | Padrão em tempo real | Definidos em várias seções das especificações: Operadores Relacionais , Operadores de Igualdade |
Compatilidade entre navegadores
No compatibility data found for javascript.operators.comparison
.
Check for problems with this page or contribute missing data to mdn/browser-compat-data.