Dlaczego ("foo" === nowy ciąg ("foo")) ocenia na false w JavaScript?

Question

miałem zamiar rozpocząć korzystanie === (potrójne równymi ścisłe porównanie) cały czas przy porównywaniu wartości ciągów, ale teraz uważam, że

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

jest fałszywa, a sama z tym:

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

przedmiotu:

f == g; // true 

Więc jest to zalecane, aby zawsze używać == dla porównania ciągów, lub zawsze konwertować zmienne ciągi przed porównaniem?

Answer 1

"foo" to ciąg pierwotny prymitywny. (ta koncepcja nie istnieje w języku C# lub Java)

new String("foo") to obiekt w ramkach.

Operator ===behaves differently on primitives and objects.
Porównując prymitywy (tego samego typu), === zwróci wartość true, jeśli obie mają tę samą wartość.

Porównując obiekty, === zwróci true tylko wtedy, gdy odnoszą się do tego samego obiektu (porównywanie przez odniesienie). Tak więc, new String("a") !== new String("a").

W twoim przypadku === zwraca wartość false, ponieważ operandy są różnych typów (jeden jest prymitywny, a drugi jest obiektem).

---

Primenty nie są wcale obiektami.
Operator typeof nie zwróci "object" dla elementów pierwotnych.

Podczas próby uzyskania dostępu do właściwości obiektu pierwotnego (używając go jako obiektu), język JavaScript spowoduje umieszczenie go w obiekcie, tworząc za każdym razem nowy obiekt. Jest to opisane w specification.

To dlaczego nie można umieścić na właściwości prymitywów:

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

każdym razem piszesz x.property, A inny zapakowane String obiekt jest tworzony.

Answer 2

foo jest czysty łańcuch i new String("foo") jest String Object

Answer 3

Korzystanie ===,

• obiekt jest równy nigdy do niczego innego poza odniesieniem do siebie.

• prymityw jest równy w porównaniu z innym prymitywem, jeśli jego typ i wartość są takie same.

Answer 4

new słowo jest przestępcą tutaj (jak zwykle, mogę powiedzieć) ...

Podczas korzystania new, jawnie wyrazić swoją chęć do pracy z obiektu. To może być zaskakujące dla ciebie, ale:

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

... daje potężny false. To proste: porównywane nie są obiekty wewnątrz obiektów, ale odniesienia obiektów. I oczywiście nie są równe, ponieważ powstały dwa różne przedmioty.

Co prawdopodobnie chcesz użyć jest konwersja:

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

... i że da wam, jak się spodziewano, true jako rezultat, dzięki czemu można cieszyć się i rozwijać z równym foos zawsze.)

Answer 5

Z node.js REPL ("węzeł" w linii poleceń, jeśli jest zainstalowany):

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