Operadores de comparação

Esta tradução está incompleta. Ajude a traduzir este artigo em inglês

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.

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ão false.
  • 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.
Nota: Os objetos String são do Tipo Objeto, não String! Os objetos de string raramente são usados, portanto, os seguintes resultados podem ser surpreendentes:
// 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. Please contribute data for "javascript.operators.comparison" (depth: 1) to the MDN compatibility data repository.

Consulte também