Pourquoi ("foo" === new String ("foo")) est-il évalué à faux en JavaScript?

J'allais commencer à utiliser === (triple égal, comparaison stricte) tout le temps lors de la comparaison des valeurs de chaîne, mais maintenant je trouve que

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

est faux, et pareil avec ceci:

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

Bien sûr:

f == g; // true

Il est donc recommandé de toujours utiliser == pour la comparaison de chaînes, ou de toujours convertir les variables en chaînes avant de comparer?

"foo"est une chaîne primitive . (ce concept n'existe pas en C # ou Java)

new String("foo") est un objet de chaîne encadré.

L' ===opérateur se comporte différemment sur les primitives et les objets .
Lors de la comparaison de primitives (du même type), ===retournera true si les deux ont la même valeur.

Lors de la comparaison d'objets, ===retournera vrai uniquement s'ils font référence au même objet (comparaison par référence). Ainsi, new String("a") !== new String("a").

Dans votre cas, ===renvoie false car les opérandes sont de types différents (l'un est une primitive et l'autre est un objet).

Les primitives ne sont pas du tout des objets.
L' typeofopérateur ne reviendra pas "object"pour les primitives.

Lorsque vous essayez d'accéder à une propriété d'une primitive (en l'utilisant comme objet), le langage Javascript l'encadrera dans un objet, créant à chaque fois un nouvel objet. Ceci est décrit dans la spécification .

C'est pourquoi vous ne pouvez pas mettre de propriétés sur les primitives:

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

Chaque fois que vous écrivez x.property, un objet encadré différentString est créé.

En utilisant ===,

• un objet n'est jamais égal à rien sauf à une autre référence à lui-même.

• une primitive est égale par rapport à une autre primitive si leur type et leur valeur sont identiques.

Le newmot est un criminel ici ( comme d'habitude , puis-je dire) ...

Lorsque vous utilisez new, vous exprimez explicitement votre désir de travailler avec un objet . Cela peut être surprenant pour vous, mais ceci:

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

... vous donnera un puissant false. C'est simple: comparés ne sont pas les intérieurs des objets, mais les références des objets. Et ils, bien sûr, ne sont pas égaux, car deux objets différents ont été créés.

Ce que vous souhaitez probablement utiliser est la conversion :

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

... et cela vous donnera, comme prévu, truecomme résultat, afin que vous puissiez vous réjouir et prospérer avec votre égal foospour toujours. )

fooest la chaîne pure et new String("foo")est la chaîne d'objet

Depuis le REPL node.js ("node" sur la ligne de commande s'il est installé):

> "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'