Qual operador é igual (== vs ===) para ser usado na comparação JavaScript?

Eu uso o JSLint para passar por JavaScript, e ele retorna um monte de sentenças para substituir == (dois sinais de igual) com === (três sinais de igual) quando você faz algo como uma comparação idSele_UNVEHtype.value.length == 0 dentro operador if .

Existe uma vantagem de desempenho para substituir == para === ?

Quaisquer melhorias de desempenho serão bem-vindas, pois há muitos operadores de comparação.

Se a conversão de tipo não ocorrer, o ganho será comparado a == ?

5673
11 дек. definir por bcasp 11 de dezembro 2008-12-11 17:19 '08 at 17:19 2008-12-11 17:19
ответ 51 respostas
  • 1
  • 2

O operador de identidade ( === ) se comporta de maneira idêntica ao operador de igualdade ( == ), exceto que a conversão de tipo não é executada e os tipos devem ser os mesmos para serem considerados iguais.

Referência: Javascript Tutorial: Comparison Operators

O operador == irá comparar a igualdade depois de realizar qualquer conversão de tipo necessária. O operador === não executará a conversão, portanto, se os dois valores não corresponderem, então === simplesmente retornará false . Ambos são igualmente rápidos.

Quote Douglas Crockford excelente javascript: good parts ,

Em JavaScript, existem dois conjuntos de operadores de igualdade: === e !== , e seus gêmeos malignos == e != . Os bons funcionam da maneira que você esperava. Se dois operandos do mesmo tipo tiverem o mesmo valor, então === cria true e !== produz false . Gêmeos maus fazem a coisa certa quando operandos são do mesmo tipo, mas se eles têm tipos diferentes, eles tentam impor valores. as regras pelas quais elas são complexas e intransponíveis. Aqui estão alguns dos casos interessantes:

 '' == '0' // false 0 == '' // true 0 == '0' // true false == 'false' // false false == '0' // true false == undefined // false false == null // false null == undefined // true ' \t\r\n ' == 0 // true 

A falta de transitividade é alarmante. Meu conselho é nunca usar gêmeos maus. Em vez disso, use sempre === e !== . Todas as comparações acima mostram false com o operador === .


Atualização:

Um bom ponto foi levantado pelo @Casebash nos comentários e no @Phillipe Laybaert em relação aos tipos de referência. Para tipos de referência, == e === agem consistentemente entre si (exceto no 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 

Um caso especial é a comparação de um literal com um objeto que avalia o mesmo literal por causa de seu toString ou valueOf . Por exemplo, considere a comparação de um literal de string com um objeto de string criado pelo construtor String .

 "abc" == new String("abc") // true "abc" === new String("abc") // false 

Aqui, o operador == verifica os valores de dois objetos e retorna true , mas === vê que eles não são do mesmo tipo e retornam false . Qual deles está correto? Isso realmente depende do que você está tentando comparar. Meu conselho é contornar completamente a questão e simplesmente não usar o construtor String para criar objetos string.

Referência
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

5840
11 дек. Resposta dada por Bill the Lizard em 11 de dezembro 2008-12-11 17:25 '08 em 5:25 pm 2008-12-11 17:25

Usando o operador == (igualdade)

 true == 1; //true, because 'true' is converted to 1 and then compared "2" == 2; //true, because "2" is converted to 2 and then compared 

Usando o operador === (Identity)

border=0
 true === 1; //false "2" === 2; //false 

Isso se deve ao fato de que o operador de igualdade == tem um tipo de coerção , o que significa que o interpretador tenta implicitamente converter os valores antes da comparação.

Por outro lado, o operador Identity === não executa um tipo de coerção e, portanto, não converte valores ao comparar.

1016
11 дек. A resposta é dada por Andreas Grech 11 dez. 2008-12-11 17:33 '08 at 17:33 2008-12-11 17:33

Nas respostas aqui, eu não li nada sobre o que significa igualdade . Alguns dirão que === significa igual e do mesmo tipo , mas não é. Na verdade, isso significa que os dois operandos se referem ao mesmo objeto ou, no caso de tipos de valor , têm o mesmo valor .

Então, vamos pegar o seguinte código:

 var a = [1,2,3]; var b = [1,2,3]; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 

Mesmo aqui:

 var a = { x: 1, y: 2 }; var b = { x: 1, y: 2 }; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 

Ou até mesmo:

 var a = { }; var b = { }; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 

Esse comportamento nem sempre é óbvio. Há mais na história do que ser igual e do mesmo tipo.

Regra:

Para tipos de valor (números):
a === b retorna verdadeiro se a e b tiverem o mesmo valor e tiverem o mesmo tipo

Para tipos de referência:
a === b retorna verdadeiro se b referirem-se ao mesmo objeto.

Para strings:
a === b retorna verdadeiro se a e b forem ambos strings e contiverem os mesmos caracteres.


Cordas: caso especial ...

Strings não são tipos de valor, mas em JavaScript eles se comportam como tipos de valor, então eles serão "iguais" quando os caracteres na string forem os mesmos e quando tiverem o mesmo tamanho (como explicado na terceira regra)

Agora fica interessante:

 var a = "12" + "3"; var b = "123"; alert(a === b); // returns true, because strings behave like value types 

Mas e quanto a isso?

 var a = new String("123"); var b = "123"; alert(a === b); // returns false !! (but they are equal and of the same type) 

Eu pensei que as cordas se comportam como tipos de valor? Bem, depende de quem você pergunta ... Neste caso, a e b não são do mesmo tipo. a é do tipo Object e b é do tipo string . Lembre-se de que criar um objeto de string usando o construtor de string cria algo como o tipo Object , que se comporta na maioria das vezes como uma string.

564
05 июня '09 в 22:11 2009-06-05 22:11 respondeu a Philippe Leybaert em 05 de junho de 2009 às 10:11 2009-06-05 22:11

Uma representação gráfica interessante da comparação de igualdade entre == e === .

Fonte: http://dorey.github.io/JavaScript-Equality-Table/


var1 === var2

Ao usar === para testar a igualdade do JavaScript, tudo está como está. Nada é convertido antes da avaliação.

2019

553
05 мая '14 в 8:21 2014-05-05 08:21 a resposta é dada por SNag em maio 05 '14 em 8:21 2014-05-05 08:21

Deixe-me adicionar esta dica:

Em caso de dúvida, leia a especificação !

O ECMA-262 é uma especificação de linguagem de script na qual o JavaScript é um dialeto. É claro que, na prática, é importante como os navegadores mais importantes se comportam, em vez da definição esotérica de como algo deve ser tratado. Mas é útil entender por que a nova String ("a")! == "a" .

Por favor, deixe-me explicar como ler a especificação para esclarecer este problema. Eu vejo que neste tópico muito antigo ninguém tem uma resposta para um efeito muito estranho. Então, se você puder ler a especificação, isso o ajudará muito em sua profissão. Esta é uma habilidade adquirida. Então vá em frente.

Encontrar um arquivo PDF para === me leva à página 56 da especificação: 11.9.4. O operador Strict Equals (===) , e depois de passar pela especificação, eu encontro:

11.9.6 Algoritmo para Comparação de Igualdade Estrita
Comparando x === y, onde x e y são valores, cria verdadeiro ou falso . Tal comparação é realizada da seguinte forma:
1. Se Type (x) for diferente de Type (y), retorne false .
2. Se type (x) for Undefined, retorne true .
3. Se o Tipo (x) for Nulo, retorne verdadeiro .
4. Se o Tipo (x) não for um número, pule para o passo 11.
5. Se x for NaN , retorne false .
6. Se y for NaN , retorne false .
7. Se x for o mesmo valor numérico que y, retorne true .
8. Se x for +0 e y for -0, retorne verdadeiro .
9. Se x for -0 e y for +0, retorne verdadeiro .
10. Retorne falso .
11. Se Type (x) for String, retorne true se xey forem exatamente a mesma seqüência de caracteres (o mesmo tamanho e os mesmos caracteres nas posições correspondentes); Caso contrário, retorne false .
12. Se Type (x) for booleano, retorne true se x e y forem ambos verdadeiros ou ambos falsos ; Caso contrário, retorne false .
13. Retorne true se xey pertencer ao mesmo objeto ou se relacionar a objetos conectados uns aos outros (ver 13.1.2). Caso contrário, retorne falso .

O estágio 11 é interessante, sim, as strings são tratadas como tipos de valor. Mas isso não explica porque o novo String ("a")! == "a" . Temos um navegador que não seja o ECMA-262?

Não tão rápido!

Verifique os tipos de operandos. Tente você mesmo, envolvendo-os em typeof () . Descobri que o novo String ("a") é um objeto, e o passo 1 é usado: return false se os tipos forem diferentes.

Se você está se perguntando por que o novo String ("a") não retorna uma string, que tal alguns exercícios que leem a especificação? Divirta-se!


Aidiakapi escreveu isto em um comentário abaixo:

A partir da especificação

11.2.2 Novo operador :

Se o tipo (construtor) não for um objeto, crie uma exceção TypeError.

Em outras palavras, se a String não for do tipo Object, ela não poderá ser usada com o novo operador.

new sempre retorna um objeto, mesmo para construtores de string . E ai! A semântica do valor para strings (consulte a Etapa 11) é perdida.

E isso finalmente significa: a nova String ("a")! == "a" .

254
28 нояб. A resposta é dada em 28 de novembro. 2009-11-28 21:18 '09 at 21:18 2009-11-28 21:18

Em PHP e JavaScript, este é um operador de igualdade estrito. Isso significa que ele irá comparar o tipo e os valores.

95
12 мая '10 в 15:58 2010-05-12 15:58 a resposta é dada por Shiki em 12 de maio de 2010 às 15:58 2010-05-12 15:58

Eu testei no Firefox usando o Firebug usando o seguinte código:

 console.time("testEquality"); var n = 0; while(true) { n++; if(n==100000) break; } console.timeEnd("testEquality"); 

e

 console.time("testTypeEquality"); var n = 0; while(true) { n++; if(n===100000) break; } console.timeEnd("testTypeEquality"); 

Meus resultados (verificados cinco vezes e média):

 ==: 115.2 ===: 114.4 

Então, eu diria que uma ligeira diferença (isto é, mais de 100.000 iterações, lembre-se) é insignificante. O desempenho não é a causa === . O tipo de segurança (bem, tão seguro quanto você está indo para javascript) e a qualidade do código.

91
25 дек. Resposta dada por Simon Scarfe 25 de dez 2008-12-25 14:17 '08 em 2:17 pm 2008-12-25 14:17

Em JavaScript, isso significa o mesmo valor e tipo.

Por exemplo

 4 == "4" // will return true 

mas

 4 === "4" // will return false 
88
12 мая '10 в 15:58 2010-05-12 15:58 a resposta é dada por Dimitar em 12 de maio de 2010 às 15:58 2010-05-12 15:58

O operador === é chamado de operador de comparação estrita, é diferente do operador == .

Tome 2 vars a e b.

Para "a == b" avaliar a verdade de a e b deve ser um valor .

No caso de "a ==" b, a e b devem ser o mesmo valor , assim como o mesmo tipo para avaliar a verdade.

Tome o seguinte exemplo

 var a = 1; var b = "1"; if (a == b) //evaluates to true as a and b are both 1 { alert("a == b"); } if (a === b) //evaluates to false as a is not the same type as b { alert("a === b"); } 

Em conclusão ; Usar o operador == pode ser classificado como verdadeiro em situações em que você não o deseja, portanto, usar o operador === será mais seguro.

No cenário de 90% de uso, não importa qual você usar, mas é útil saber a diferença quando você obtém algum comportamento inesperado um dia.

77
11 дек. A resposta é dada pelo Doutor Jones 11 de dezembro 2008-12-11 17:58 '08 at 5:58 pm 2008-12-11 17:58

Ele verifica se os mesmos lados são iguais em tipo e valor .

Exemplo:

 '1' === 1 // will return "false" because 'string' is not a 'number' 

Exemplo geral:

 0 == '' // will be "true", but it very common to want this check to be "false" 

Outro exemplo comum é:

 null == undefined // returns "true", but in most cases a distinction is necessary 
70
12 мая '10 в 15:58 2010-05-12 15:58 a resposta é dada por vsync em 12 de maio de 2010 às 15:58 2010-05-12 15:58

Por que == tão imprevisível?

O que você ganha quando compara a string vazia "" com o número 0 0 ?

<code> Truecode>

Sim, isso está correto de acordo com == seqüência vazia e zero numérico é o mesmo tempo.

E isso não termina aqui, outro:

  '0' == false//true Код> 

As coisas ficam muito estranhas com os arrays.

  [1] == true//true [] == false//true [[]] == false//true [0] == false//true Код> 

Então weerder com cordas

  [1,2,3] == '1,2,3'//true - ДЕЙСТВИТЕЛЬНО?! '\ r\n\t' == 0//true - Давай! Код> 

Ficando pior:

Quando não é igual a?

  let A = ''//пустая строка пусть В = 0//нуль пусть C = '0'//нулевая строка A == B//true - ok... B == C//true - пока что так хорошо... A == C//** FALSE ** - Закручивание сюжета! Код> 

Deixe-me dizer de novo:

  (A == B)(B == C)//true (A == C)//** FALSE ** Код> 

E isso é apenas o material maluco que você começa com primitivos.

Este é um novo nível de loucura quando você usa == com objetos.

Neste ponto, você provavelmente se pergunta ...

Por que isso está acontecendo?

Bom, porque ao contrário da "igualdade tripla" ( === ), que simplesmente verifica se os dois valores combinam.

== fazendo um monte de outras coisas .

Possui processamento especial para funções, processamento especial para zeros, indefinido, strings, que você chama.

Fica muito burro.

De fato, se você tentou escrever uma função que faz o que faz == , será algo como isto:

  function isEqual (x, y) {//если `==` были функцией   if (typeof y === typeof x) return y === x;   // обрабатываем null и undefined то же самое   var xIsNothing = (y === undefined) || (y === null);   var yIsNothing = (x === undefined) || (x === null);  если (xIsNothing || yIsNothing) возвращается (xIsNothing  yIsNothing);  if (typeof y === "function" || typeof x === "function" ) {   // если любое значение является строкой   // преобразовать функцию в строку и сравнить   if (typeof x === "string" ) {   return x === y.toString();   } else if (typeof y === "string" ) {   return x.toString() === y;   }   return false;   }  if (typeof x === "object" ) x = toPrimitive (x);   if (typeof y === "object" ) y = toPrimitive (y);   if (typeof y === typeof x) return y === x;  // конвертируем x и y в числа, если они еще не используют трюк +   if (typeof x! == "number" ) x = + x;   if (typeof y! == "number" ) y = + y;   // фактически реальный `==` еще более сложный, чем это, особенно в ES6   return x === y; } функция toPrimitive (obj) {   var value = obj.valueOf();   if (obj! == value) возвращаемое значение;   return obj.toString(); } Код> 

Então, o que isso significa?

Isso significa que == é complexo.

Como é difícil, é difícil entender o que acontecerá quando você usá-lo.

Isso significa que você pode ter erros.

Então a moral da história ...

Torne sua vida menos complicada.

Use === vez de == .

O fim.

68
09 авг. a resposta é dada por Luis Perez 09 ago. 2016-08-09 19:50 '16 às 7:50 pm 2016-08-09 19:50

Diagrama de seqüência de execução do Javascript para igualdade estrita / Comparação '==='

2019

05 сент. a resposta é dada Samar Panda 05 de setembro 2015-09-05 16:53 '15 às 16:53 2015-09-05 16:53

Javascript === vs == .

 0==false // true 0===false // false, because they are of a different type 1=="1" // true, auto type coercion 1==="1" // false, because they are of a different type 
52
03 июля '13 в 7:08 2013-07-03 07:08 a resposta é dada por user2496033 03 de julho '13 at 7:08 2013-07-03 07:08

Isso significa igualdade sem coerção de tipo.O tipo de coerção significa que o JavaScript não converte automaticamente nenhum outro tipo de dados em tipos de dados de string.

 0==false // true,although they are different types 0===false // false,as they are different types 2=='2' //true,different types,one is string and another is integer but javaScript convert 2 to string by using == operator 2==='2' //false because by using === operator ,javaScript do not convert integer to string 2===2 //true because both have same value and same types 
51
12 мая '10 в 15:59 2010-05-12 15:59 a resposta é dada por Pop Catalin em 12 de maio de 2010 às 15:59 2010-05-12 15:59

Em um roteiro típico, não haverá diferença no desempenho. Mais importante, o fato de que mil "==" é 1 kilobyte é mais pesado do que mil "==" :) Os profilers de JavaScript podem dizer se existe uma diferença de desempenho no seu caso.

Mas pessoalmente, eu faria o que o JSLint oferece. Essa recomendação não se deve a problemas de desempenho, mas devido a uma restrição de tipo ('\t\r\n' == 0) .

46
16 дек. resposta dada Constantin 16 dez. 2008-12-16 17:29 '08 em 5:29 pm 2008-12-16 17:29

Operador de comparação igual == é confuso e deve ser evitado.

Se você mora com o HAVE , lembre-se das 3 seguintes coisas:

  • Não é transitivo: (a == b) e (b == c) não resulta em (a == c)
  • Isso exclui mutuamente sua negação: (a == b) e (a! = B) sempre têm valores Booleanos opostos com todos aeb.
  • Em caso de dúvida, memorize a seguinte tabela de verdade:

TABELA DO OPERADOR CERTO EM JAVASCRIPT

  • Cada linha na tabela é um conjunto de 3 valores mutuamente "iguais", o que significa que quaisquer 2 valores deles são iguais usando o sinal igual == *

** STRANGE: observe que quaisquer dois valores na primeira coluna não são iguais nesse sentido. **

 '' == 0 == false // Any two values among these 3 ones are equal with the == operator '0' == 0 == false // Also a set of 3 equal values, note that only 0 and false are repeated '\t' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- '\r' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- '\n' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- '\t\r\n' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- null == undefined // These two "default" values are not-equal to any of the listed values above NaN // NaN is not equal to any thing, even to itself. 
42
16 сент. Resposta dada por CuongHuyTo Set 16 2011-09-16 17:25 '11 às 17:25 2011-09-16 17:25

Não há praticamente nenhuma diferença de desempenho entre as duas operações no seu uso. Não há conversão de tipo a ser executada, porque os dois parâmetros são do mesmo tipo. Ambas as operações terão uma comparação de tipo seguida por uma comparação de valor.

35
11 дек. resposta dada Sean 11 dez 2008-12-11 17:44 '08 at 17:44 2008-12-11 17:44

Sim Isso importa.

=== operador === no javascript verifica o valor, assim como o tipo , em que o operador == simplesmente verifica o valor (converte o tipo, se necessário) .

2019

35
14 нояб. Resposta dada por Aniket Thakur Nov 14 2014-11-14 09:02 '14 às 9:02 2014-11-14 09:02
Operador

=== verifica os valores, bem como os tipos de variáveis ​​para igualdade.

Operador

== apenas verifica o valor das variáveis ​​para igualdade.

32
12 мая '10 в 16:03 2010-05-12 16:03 a resposta é dada por Niraj Choubey em 12 de maio '10 às 16:03 2010-05-12 16:03

Este é um teste de teste rigoroso.

Isso é bom, especialmente se você marcar entre 0 e falso e nulo.

Por exemplo, se você tiver:

 $a = 0; 

Então:

 $a==0; $a==NULL; $a==false; 

Tudo retorna verdadeiro e você pode não querer. Suponha que você tenha uma função que possa retornar o índice da matriz 0 ou falso no erro. Se você marcar a caixa com "==" false, poderá obter um resultado confuso.

Então, com o mesmo que acima, mas um teste rigoroso:

 $a = 0; $a===0; // returns true $a===NULL; // returns false $a===false; // returns false 
30
12 мая '10 в 16:19 2010-05-12 16:19 Resposta é dada Daniel 12 de maio '10 às 16:19 2010-05-12 16:19

O JSLint às vezes dá razões irreais para alterar o material. === tem o mesmo desempenho que == se os tipos já corresponderem.

Isso é mais rápido somente se os tipos não corresponderem, caso em que não tenta converter tipos, mas retorna falso.

Assim, IMHO, o JSLint pode ser usado para escrever novos códigos, mas a otimização excessiva inútil deve ser evitada a todo custo.

Ou seja, não há razão para alterar == para === em um teste, por exemplo, if (a == 'test') , quando você sabe, porque um fato só pode ser uma String.

Modificar uma grande quantidade de código dessa maneira leva tempo dos desenvolvedores e revisores e não consegue nada.

29
05 июня '12 в 10:53 2012-06-05 10:53 resposta dada cinzas em 05 de junho '12 às 10:53 2012-06-05 10:53

Apenas

== significa uma comparação entre operandos com type conversion

=== significa uma comparação entre operandos sem type conversion

Conversão de tipo em javaScript significa que javaScript converte automaticamente quaisquer outros tipos de dados em tipos de dados de string.

Por exemplo:

 123=='123' //will return true, because JS convert integer 123 to string '123' //as we used '==' operator 123==='123' //will return false, because JS do not convert integer 123 to string //'123' as we used '===' operator 
28
20 марта '15 в 8:05 2015-03-20 08:05 resposta é dada Amit 20 de março de '15 às 8:05 2015-03-20 08:05

Um exemplo simples é

 2 == '2' -> true, values are SAME because of type conversion. 2 === '2' -> false, values are NOT SAME because of no type conversion. 
25
14 мая '15 в 17:45 2015-05-14 17:45 a resposta é dada por Vikas em 14 de maio '15 às 17:45 2015-05-14 17:45