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

Stavo per iniziare a usare === (triple equals, strict comparison) per tutto il tempo quando si confrontano i valori di stringa, ma ora trovo che

"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 delle stringhe, o sempre convertire le variabili in stringhe prima di confrontarle?

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

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

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

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

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


    I primitivi non sono affatto oggetti.
    L’operatore typeof non restituirà "object" per le primitive.

    Quando si tenta di accedere a una proprietà di una primitiva (utilizzandola come object), la lingua Javascript la imposterà su un object, creando ogni volta un nuovo object. Questo è descritto nelle specifiche .

    Questo è il motivo per cui non puoi mettere le proprietà sui primitivi:

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

    Ogni volta che scrivi x.property , viene creato un object String box diverso .

    Utilizzando === ,

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

    • un primitivo è uguale se confrontato con un altro primitivo se il loro tipo e valore sono gli stessi.

    La new parola è un criminale qui ( come al solito , posso dire) …

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

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

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

    Quello che probabilmente vorrai usare è la conversione :

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

    … e questo ti darà, come previsto, true come risultato, in modo da poter gioire e prosperare con il tuo pari per sempre. )

    foo è la pura stringa e la new String("foo") è la stringa dell’object

    Da node.js REPL (“nodo” 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'