Casting su stringa in JavaScript

Ho trovato tre modi per trasmettere una variabile Stringin JavaScript.
Ho cercato queste tre opzioni nel codice sorgente di jQuery e sono tutte in uso .
Vorrei sapere se ci sono differenze tra loro:

value.toString()
String(value)
value + ""

DEMO

Tutti producono lo stesso risultato, ma uno di loro è migliore degli altri?
Direi che + ""ha il vantaggio di salvare alcuni personaggi, ma non è questo il grande vantaggio, nient'altro?

Si comportano diversamente quando lo valueè null.

• null.toString()genera un errore - Impossibile chiamare il metodo 'toString' di null
• String(null)restituisce - "null"
• null + ""restituisce anche - "null"

Un comportamento molto simile si verifica se lo valueè undefined(vedi la risposta di jbabey ).

Oltre a ciò, c'è una differenza di prestazioni trascurabile, che, a meno che non li si usi in loop enormi, non vale la pena preoccuparsi.

Ci sono differenze, ma probabilmente non sono rilevanti per la tua domanda. Ad esempio, il prototipo toString non esiste su variabili non definite, ma è possibile eseguire il cast non definito su una stringa utilizzando gli altri due metodi:

​var foo;

​var myString1 = String(foo); // "undefined" as a string

var myString2 = foo + ''; // "undefined" as a string

var myString3 = foo.toString(); // throws an exception

http://jsfiddle.net/f8YwA/

Si comportano allo stesso modo ma toStringforniscono anche un modo per convertire un numero di stringhe binarie, ottali o esadecimali:

Esempio:

var a = (50274).toString(16)  // "c462"
var b = (76).toString(8)      // "114"
var c = (7623).toString(36)   // "5vr"
var d = (100).toString(2)     // "1100100"

Secondo questo test JSPerf , differiscono in velocità. Ma a meno che non li userai in grandi quantità, nessuno di loro dovrebbe funzionare bene.

Per completezza: come già accennato in Asawyer , puoi anche usare il .toString()metodo.

Oltre a tutto quanto sopra, si dovrebbe notare che, per un valore definito v:

• String(v) chiamate v.toString()
• '' + vchiamate v.valueOf()prima di qualsiasi altro tipo cast

Quindi potremmo fare qualcosa del tipo:

var mixin = {
  valueOf:  function () { return false },
  toString: function () { return 'true' }
};
mixin === false;  // false
mixin == false;    // true
'' + mixin;       // "false"
String(mixin)     // "true"

Testato in FF 34.0 e Nodo 0.10

se stai bene con null, indefinito, NaN, 0 e false tutto il cast su '' allora (s ? s+'' : '')è più veloce.

vedi http://jsperf.com/cast-to-string/8

nota: al momento ci sono differenze significative tra i browser.

Esempio pratico: ho una funzione di log che può essere chiamata con un numero arbitrario di parametri: log("foo is {} and bar is {}", param1, param2). Se un DEBUGflag è impostato su true, le parentesi vengono sostituite dai parametri indicati e la stringa viene passata a console.log(msg). I parametri possono e saranno stringhe, numeri e qualsiasi cosa possa essere restituita dalle chiamate JSON / AJAX, forse anche null.

• arguments[i].toString()non è un'opzione, a causa dei possibili nullvalori (vedere la risposta di Connell Watkins)
• JSLint si lamenterà arguments[i] + "". Questo può o meno influenzare una decisione su cosa usare. Alcune persone aderiscono rigorosamente a JSLint.
• In alcuni browser, concatenare stringhe vuote è un po 'più veloce rispetto all'utilizzo della funzione stringa o del costruttore di stringhe (vedi test JSPerf nella risposta di Sammys S.). In Opera 12 e Firefox 19, concatenare stringhe vuote è ridicolmente più veloce (95% in Firefox 19) - o almeno lo dice JSPerf .

In questa pagina puoi testare tu stesso le prestazioni di ciascun metodo :)

http://jsperf.com/cast-to-string/2

qui, su tutte le macchine e i browser, " " "+ str " è il più veloce, (String) str è il più lento