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

Eu ia começar a usar === (triplo igual, comparação estrita) o tempo todo ao comparar valores de string, mas agora acho que

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

é falso e o mesmo com este:

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

Claro:

f == g; // true

Portanto, é recomendado sempre usar == para comparação de strings ou sempre converter variáveis ​​em strings antes de comparar?

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

new String("foo") é um objeto de string em caixa.

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

Ao comparar objetos, ===retornará verdadeiro somente se eles se referirem ao mesmo objeto (comparação por referência). Assim new String("a") !== new String("a"),.

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

Os primitivos não são objetos de forma alguma.
O typeofoperador não retornará "object"para primitivas.

Quando você tenta acessar uma propriedade de um primitivo (usando-o como um objeto), a linguagem Javascript irá encaixotá-lo em um objeto, criando um novo objeto a cada vez. 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 objeto de caixa diferenteString é criado.

Usando ===,

• um objeto 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 iguais.

A newpalavra é criminosa aqui ( como sempre , posso dizer) ...

Ao usar new, você expressa explicitamente seu desejo de trabalhar com objeto . 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 objetos, mas as referências dos objetos. E eles, é claro, não são iguais, pois dois objetos diferentes foram criados.

O que você provavelmente deseja usar é a conversão :

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

... e isso lhe dará, como esperado, truecomo resultado, para que você possa se alegrar e prosperar com seu igual foospara sempre. )

fooé a string pura e new String("foo")é a String do objeto

No REPL node.js ("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'