Qual è la differenza tra String (valore) vs value.toString()

Question

Javascript ha molti "trucchi" intorno a tipi e conversioni di tipi quindi mi chiedo se questi 2 metodi sono uguali o se c'è qualche caso angolare che rende loro diversi?

Answer 1

Essi non sono completamente lo stesso, e in realtà, the String constructor called as a function (il vostro primo esempio), sarà alla fine, chiamare il metodo toString dell'oggetto passato, ad esempio:

var o = { toString: function() { return "foo"; } }; 
String(o); // "foo" 

D'altra parte, se un identificatore si riferisce a null o undefined, non è possibile utilizzare, ovviamente, il metodo toString, che vi darà un'eccezione TypeError:

var value = null; 
String(null); //  "null" 
value.toString(); // TypeError 

Il String costruttore chiamato come una funzione sarebbe meno equivalente a:

regole di conversione

value+''; 

Il tipo di oggetto -a-- Primitive sono dettagliate descritte nella specifica, il [[DefaultValue]] funzionamento interno.

In breve, la conversione da Object -a-- String, vengono adottate le seguenti fasi:

1. Se disponibile, eseguire il metodo toString.
   • Se il result è non un primitivo, passare al punto 2, altrimenti restituire il result
2. Se disponibile, eseguire il metodo valueOf.
   • Se il resultè un primitivo, tornare result, altro passo 3.
3. tiro TypeError.

Date le regole di cui sopra, possiamo fare un esempio della semantica coinvolte:

var o = { 
    toString:function() { return "foo"; }, 
    valueOf: function() { return "bar"; } 
}; 

String(o); // "foo" 

// Make the toString method unavailable: 
o.toString = null; 

String(o); // "bar" 

// Now make the valueOf method also unavailable: 
o.valueOf = null; 

try { 
    String(o); 
} catch (e) { 
    alert(e); // TypeError! 
} 

Se si vuole digg-in più in questo meccanismo ti consiglierei di dare uno sguardo al ToPrimitive e le operazioni interne ToString.

Anche io consiglierei di questo articolo:

• Object-to-Primitive Conversions in JavaScript

Answer 2

value.toString() causerà un errore se value è nullo. String(value) non dovrebbe.

Ad esempio:

var value = null; 
alert(value.toString()); 

non riuscirà perché value == null.

var value = null; 
alert(String(value)); 

dovrebbe visualizzare un messaggio di lettura "null" (o simile), ma non si arresta in modo anomalo.

Answer 3

String(value) dovrebbero avere lo stesso risultato value.toString() in tutti i casi, eccetto per valori senza immobili come null o undefined. ''+value produrrà lo stesso risultato.

Answer 4

String() [la chiamata costruttore] è fondamentalmente chiamando il .toString()

.toString() e String() può essere chiamato su valori primitivi (numero, booleano, stringa) e fondamentalmente non farà nulla di speciale:

vero => 'true'

falsa => 'false'

17 => '17'

'ciao' => 'ciao'

Ma chiamando queste funzioni su oggetti è dove le cose si fa interessante:

se l'oggetto ha la sua propria funzione .toString() verrà chiamato quando mai avete bisogno di questo oggetto di essere trattato come una stringa (in modo esplicito/implicito)

let obj = { 
      myName:"some object", 
      toString:function(){ return this.myName; } 
      } 

//implicitly treating this obj as a string 
"hello " + obj; //"hello some object" 

//OR (explicitly) 
"hello " + String(obj) //calling the existent toString function 

//OR 
"hello " + obj.toString(); //calling toString directly 

Tra l'altro, se si vuole trattare questo oggetto come un numero si deve ha un .valueOf() funzione definita in esso.

cosa succede se abbiamo entrambi in un oggetto?

se vogliamo trattare questo oggetto come una stringa => utilizzare .toString()

se vogliamo trattare questo oggetto come un numero => utilizzare .valueOf()

cosa succede se abbiamo solo .valueOf() definito?

.valueOf() definita all'interno dell'oggetto verrà chiamato se vogliamo gestire l'oggetto come una stringa o come numero