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.

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ã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.

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

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

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

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

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.

Sintaxe

x > y

Exemplos

4 > 3 // verdade

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

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

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

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'

• Object.is()
• Math.sign()
• Comparações de igualdade e similaridades