Perché ("foo" === new String ("foo")) restituisce false in JavaScript?

Stavo per iniziare a usare === (triplo uguale, confronto rigoroso) tutto il tempo durante il confronto dei valori di stringa, ma ora lo trovo

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

è falso, e lo stesso con questo:

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

Ovviamente:

f == g; // true

Quindi è consigliabile usare sempre == per il confronto tra stringhe o convertire sempre le variabili in stringhe prima del confronto?

"foo"è una stringa primitiva . (questo concetto non esiste in C # o Java)

new String("foo") è un oggetto stringa in scatola.

L' ===operatore si comporta in modo diverso su primitive e oggetti .
Quando si confrontano primitive (dello stesso tipo), ===restituirà true se entrambe hanno lo stesso valore.

Quando si confrontano oggetti, ===restituirà true solo se si riferiscono allo stesso oggetto (confronto per riferimento). Così, new String("a") !== new String("a").

Nel tuo caso, ===restituisce false perché gli operandi sono di tipi diversi (uno è primitivo e l'altro è un oggetto).

Le primitive non sono affatto oggetti.
L' typeofoperatore non tornerà "object"per le primitive.

Quando si tenta di accedere a una proprietà di una primitiva (usandola come un oggetto), il linguaggio Javascript lo inscatolerà in un oggetto, creando ogni volta un nuovo oggetto. Questo è descritto nelle specifiche .

Questo è il motivo per cui non puoi mettere proprietà sulle primitive:

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

Ogni volta che scrivi x.property, viene creato un diversoString oggetto in scatola .

Utilizzando ===,

• un oggetto non è mai uguale a nulla tranne che a un altro riferimento a se stesso.

• una primitiva è uguale rispetto a un'altra primitiva se il loro tipo e valore sono gli stessi.

La newparola qui è un criminale ( come al solito , posso dire) ...

Quando usi new, esprimi esplicitamente il tuo desiderio di lavorare con l' oggetto . Potrebbe essere sorprendente per te, ma questo:

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

... ti darà un potente false. È semplice: a confronto non sono gli interni degli oggetti, ma i riferimenti degli oggetti. E, ovviamente, non sono uguali, poiché sono stati creati due oggetti diversi.

Quello che probabilmente vuoi usare è la conversione :

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

... e questo ti darà, come previsto, truecome risultato, così potrai gioire e prosperare con il tuo pari foosper sempre. )

fooè la stringa pura ed new String("foo")è la stringa dell'oggetto

Da node.js REPL ("node" sulla riga di comando se installato):

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