Warum wird ("foo" === neuer String ("foo")) in JavaScript als falsch ausgewertet?

Ich wollte die ganze Zeit === (Triple Equals, strenger Vergleich) verwenden, wenn ich String-Werte vergleiche, aber jetzt finde ich das

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

ist falsch und dasselbe damit:

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

Natürlich:

f == g; // true

Wird also empfohlen, immer == für den Zeichenfolgenvergleich zu verwenden oder Variablen vor dem Vergleich immer in Zeichenfolgen zu konvertieren?

"foo"ist ein String- Primitiv . (Dieses Konzept existiert nicht in C # oder Java)

new String("foo") ist ein Boxed-String-Objekt.

Der ===Operator verhält sich bei Grundelementen und Objekten unterschiedlich .
Beim Vergleich von Grundelementen (desselben Typs) ===wird true zurückgegeben, wenn beide denselben Wert haben.

Wird beim Vergleichen von Objekten ===nur dann true zurückgegeben, wenn sie sich auf dasselbe Objekt beziehen (Vergleich nach Referenz). Also , new String("a") !== new String("a").

In Ihrem Fall wird ===false zurückgegeben, da die Operanden unterschiedlichen Typs sind (einer ist ein Grundelement und der andere ein Objekt).

Primitive sind überhaupt keine Objekte.
Der typeofOperator wird nicht "object"für Grundelemente zurückkehren.

Wenn Sie versuchen, auf eine Eigenschaft eines Grundelements zuzugreifen (indem Sie es als Objekt verwenden), wird es von der Javascript-Sprache in ein Objekt eingefügt und jedes Mal ein neues Objekt erstellt. Dies ist in der Spezifikation beschrieben .

Aus diesem Grund können Sie Primitiven keine Eigenschaften zuweisen:

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

Jedes Mal, wenn Sie schreiben x.property, wird ein anderes Boxobjekt Stringerstellt.

Verwenden von ===,

• Ein Objekt ist niemals gleich etwas anderem als einem anderen Verweis auf sich selbst.

• Ein Grundelement ist im Vergleich zu einem anderen Grundelement gleich, wenn Typ und Wert gleich sind.

Das newWort ist hier ein Verbrecher ( wie üblich , darf ich sagen) ...

Wenn Sie verwenden new, drücken Sie ausdrücklich Ihren Wunsch aus, mit Objekten zu arbeiten . Es mag für Sie überraschend sein, aber dies:

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

... wird dir einen mächtigen geben false. Es ist ganz einfach: Im Vergleich werden nicht die Innenseiten der Objekte, sondern die Referenzen der Objekte verglichen. Und sie sind natürlich nicht gleich, da zwei verschiedene Objekte erstellt wurden.

Was Sie wahrscheinlich verwenden möchten, ist die Konvertierung :

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

... und das wird Ihnen erwartungsgemäß truedas Ergebnis geben, damit Sie sich für immer freuen und mit Ihrem Gleichen gedeihen können foos. )

fooist die reine Zeichenfolge und new String("foo")ist die Objektzeichenfolge

Aus der Datei node.js REPL ("Knoten" in der Befehlszeile, falls installiert):

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