I'm usando JSLint para passar pelo JavaScript, e it's retornando muitas sugestões para substituir ==
(dois sinais iguais) por ===
(três sinais iguais) quando se faz coisas como comparar idSele_UNVEHtype.value.length == 0
dentro de uma declaração if
.
Existe algum benefício de desempenho na substituição de ==`` por
====`?
Qualquer melhoria de desempenho seria bem-vinda, uma vez que existem muitos operadores de comparação.
Se não houver conversão de tipo, haveria um ganho de desempenho sobre `==``?
O operador de identidade (===``) comporta-se de forma idêntica ao operador de igualdade (
==`) excepto que não é feita nenhuma conversão de tipo, e os tipos devem ser os mesmos para serem considerados iguais.
Referência: Tutorial Javascript: Comparação de Operadores
O operador ==
irá comparar para igualdade após fazer quaisquer conversões de tipo necessárias. O operador ===
irá **não*** fazer a conversão, então se dois valores não forem do mesmo tipo ===
irá simplesmente retornar false
. Ambos são igualmente rápidos.
Para citar Douglas Crockford's excelente JavaScript: The Good Parts,
O JavaScript tem dois conjuntos de operadores de igualdade:
===`` e
!==, e os seus gémeos maus
==e
!=. Os bons funcionam da maneira que você esperaria. Se os dois operandos são do mesmo tipo e têm o mesmo valor, então
===produz
verdadeiroe
!==produz
falso`. Os gêmeos maus fazem a coisa certa quando os operandos são do mesmo tipo, mas se são de tipos diferentes, eles tentam coagir os valores. as regras pelas quais eles fazem isso são complicadas e imemoráveis. Estes são alguns dos casos interessantes:
''' == '0' // falso 0 == '' // verdadeiro 0 == '0' // verdadeiro
falso == 'falso' // falso falso == '0' // verdadeiro
falso == indefinido // falso falso === nulo // falso nulo == indefinido // verdadeiro
' \t\r\n ' == 0 // true
A falta de transitividade é alarmante. O meu conselho é que nunca uses os gémeos maus. Em vez disso, use sempre
===
e!==
. Todas as comparações mostradas apenas produzemfalse
com o operador===
.
Um bom ponto foi levantado por @Casebash nos comentários e em @Phillipe Laybaert's resposta sobre os tipos de referência. Para tipos de referência ==`` e
===` agem consistentemente uns com os outros (exceto em um caso especial).
var a = [1,2,3];
var b = [1,2,3];
var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };
var e = "text";
var f = "te" + "xt";
a == b // false
a === b // false
c == d // false
c === d // false
e == f // true
e === f // true
O caso especial é quando você compara um literal com um objeto que avalia com o mesmo literal, devido ao seu método toString
ou valueOf
. Por exemplo, considere a comparação de uma string literal com um objeto string criado pelo construtor String
.
"abc" == new String("abc") // true
"abc" === new String("abc") // false
Aqui o operador ==
está verificando os valores dos dois objetos e retornando true
, mas o ===`` está vendo que eles não são do mesmo tipo e retornando
false. Qual deles está correto? Isso realmente depende do que você está tentando comparar. O meu conselho é ignorar completamente a questão e simplesmente não utilizar o construtor
String` para criar objetos string.
**Referência*** http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3
Utilizando o operador ==
(Equalidade)
true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2; //true, because "2" is converted to 2 and then compared
Utilizando o operador ====
(Identidade)
true === 1; //false
"2" === 2; //false
Isto porque o operador de equalidade ==
digita coerção, o que significa que o intérprete tenta implicitamente converter os valores antes de comparar.
Por outro lado, o operador de identidade ===
não digita coerção, e portanto não converte os valores quando comparados, e por isso é mais rápido (como de acordo com Este JS benchmark teste), pois salta um passo.
É pouco provável que haja qualquer diferença de desempenho entre as duas operações no seu uso. Não há nenhuma conversão de tipo a ser feita porque ambos os parâmetros já são do mesmo tipo. Ambas as operações terão uma comparação de tipo seguida por uma comparação de valor.