Diffusion en chaîne en JavaScript

J'ai trouvé trois façons de convertir une variable Stringen JavaScript.
J'ai recherché ces trois options dans le code source de jQuery, et elles sont toutes utilisées .
J'aimerais savoir s'il y a des différences entre eux:

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

DEMO

Ils produisent tous le même résultat, mais l'un d'eux est-il meilleur que les autres?
Je dirais que le + ""a l'avantage de sauver certains personnages, mais ce n'est pas ce gros avantage, autre chose?

Ils se comportent différemment quand ils le valuesont null.

• null.toString()renvoie une erreur - Impossible d'appeler la méthode 'toString' de null
• String(null)renvoie - "null"
• null + ""renvoie également - "null"

Un comportement très similaire se produit si valuec'est undefined(voir la réponse de jbabey ).

En dehors de cela, il existe une différence de performance négligeable qui, à moins que vous ne les utilisiez dans d'énormes boucles, ne vaut pas la peine de s'inquiéter.

Il existe des différences, mais elles ne sont probablement pas pertinentes pour votre question. Par exemple, le prototype toString n'existe pas sur des variables non définies, mais vous pouvez convertir undefined en chaîne à l'aide des deux autres méthodes:

​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/

Ils se comportent de la même manière mais toStringfournissent également un moyen de convertir un nombre de chaînes binaires, octales ou hexadécimales:

Exemple:

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

Selon ce test JSPerf , ils diffèrent en vitesse. Mais à moins que vous ne les utilisiez en grande quantité, n'importe lequel d'entre eux devrait fonctionner correctement.

Par souci d' exhaustivité: comme un avocat l'a déjà mentionné, vous pouvez également utiliser la .toString()méthode.

En plus de tout ce qui précède, il faut noter que, pour une valeur définie v:

• String(v) appels v.toString()
• '' + vappels v.valueOf()avant tout autre type de diffusion

Nous pourrions donc faire quelque chose comme:

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

Testé dans FF 34.0 et Node 0.10

si vous êtes d'accord avec null, undefined, NaN, 0 et false, tout cast en «» (s ? s+'' : '')est alors plus rapide.

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

Remarque - il existe actuellement des différences significatives entre les navigateurs.

Exemple concret: J'ai une fonction de journal qui peut être appelé avec un nombre arbitraire de paramètres: log("foo is {} and bar is {}", param1, param2). Si un DEBUGindicateur est défini sur true, les crochets sont remplacés par les paramètres donnés et la chaîne est passée à console.log(msg). Les paramètres peuvent être et seront des chaînes, des nombres et tout ce qui peut être retourné par les appels JSON / AJAX, peut-être même null.

• arguments[i].toString()n'est pas une option, à cause des nullvaleurs possibles (voir la réponse de Connell Watkins)
• JSLint se plaindra arguments[i] + "". Cela peut ou non influencer une décision sur ce qu'il faut utiliser. Certaines personnes adhèrent strictement à JSLint.
• Dans certains navigateurs, concaténer des chaînes vides est un peu plus rapide que d'utiliser une fonction de chaîne ou un constructeur de chaîne (voir le test JSPerf dans la réponse Sammys S.). Dans Opera 12 et Firefox 19, la concaténation de chaînes vides est ridiculement plus rapide (95% dans Firefox 19) - ou du moins JSPerf le dit.

Sur cette page, vous pouvez tester vous-même les performances de chaque méthode :)

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

ici, sur toutes les machines et tous les navigateurs, ' "" + str ' est le plus rapide, (String) str est le plus lent