Por que (“foo” === new String (“foo”)) é avaliado como falso em JavaScript?

Eu ia começar a usar === (triple equals, comparação estrita) o tempo todo quando comparando valores de string, mas agora eu acho que

"foo" === new String("foo") 

é falso, e mesmo com isto:

 var f = "foo", g = new String("foo"); f === g; // false 

Claro:

 f == g; // true 

Então, é recomendável usar sempre == para comparação de strings, ou sempre converter variables ​​em strings antes de comparar?

"foo" é uma string primitiva . (este conceito não existe em C # ou Java)

new String("foo") é um object string encaixotado.

O operador === se comporta de maneira diferente em primitivos e objects .
Ao comparar primitivos (do mesmo tipo), === retornará verdadeiro se ambos tiverem o mesmo valor.

Ao comparar objects, === retornará verdadeiro somente se eles se referirem ao mesmo object (comparando por referência). Assim, new String("a") !== new String("a") .

No seu caso, === retorna false porque os operandos são de tipos diferentes (um é primitivo e o outro é um object).


Primitivos não são objects de todo.
O operador typeof não retornará "object" para primitivos.

Quando você tenta acessar uma propriedade de uma primitiva (usando-a como um object), a linguagem Javascript irá encaixá-la em um object, criando um novo object todas as vezes. Isso é descrito na especificação .

É por isso que você não pode colocar propriedades em primitivos:

 var x = "a"; x.property = 2; alert(x.property) //undefined 

Cada vez que você escreve x.property , um object String Boxed diferente é criado.

Usando === ,

  • Um object nunca é igual a nada, exceto outra referência a si mesmo.

  • uma primitiva é igual quando comparada a outra primitiva se seu tipo e valor forem os mesmos.

A new palavra é um criminoso aqui ( como de costume , posso dizer) …

Quando você usa o new , você expressa expressamente o seu desejo de trabalhar com o object . Pode ser surpreendente para você, mas isso:

 var x = new String('foo'); var y = new String('foo'); x === y; 

… lhe dará um poderoso false . É simples: comparados não são os interiores dos objects, mas as referências dos objects. E eles, claro, não são iguais, pois dois objects diferentes foram criados.

O que você provavelmente quer usar é conversão :

 var x = String('foo'); var y = String('foo'); x === y; 

… e isso lhe dará, como esperado, true como resultado, para que você possa se alegrar e prosperar com seus iguais para sempre. )

foo é a string pura e new String("foo") é a string de object

A partir do node.js REPL (“node” na linha de comando, se instalado):

 > "foo" === (new String("foo")).valueOf() true > "foo" === new String("foo") false > typeof("foo") 'string' > typeof(new String("foo")) 'object' > typeof((new String("foo")).valueOf()) 'string' 
Intereting Posts