Quelle est la meilleure façon de convertir un nombre en chaîne en JavaScript?

Quelle est la "meilleure" façon de convertir un nombre en une chaîne (en termes d'avantage de vitesse, de clarté, de mémoire, etc.)?

Quelques exemples:

1. String(n)

2. n.toString()

3. ""+n

4. n+""

comme ça:

var foo = 45;
var bar = '' + foo;

En fait, même si je le fais généralement comme ça pour plus de commodité, sur plus de 1 000 itérations, il semble que la vitesse brute présente un avantage pour.toString()

Voir les tests de performance ici (pas par moi, mais trouvés quand je suis allé écrire le mien): http://jsben.ch/#/ghQYR

Le plus rapide basé sur le test JSPerf ci-dessus: str = num.toString();

Il convient de noter que la différence de vitesse n'est pas trop importante si l'on considère qu'elle peut effectuer la conversion de quelque manière que ce soit 1 million de fois en 0,1 seconde .

Mise à jour: la vitesse semble différer considérablement selon le navigateur. Dans Chrome num + ''semble être le plus rapide basé sur ce test http://jsben.ch/#/ghQYR

Mise à jour 2: Encore une fois sur la base de mon test ci-dessus, il convient de noter que Firefox 20.0.1 exécute .toString()environ 100 fois plus lentement que l' '' + numéchantillon.

À mon avis, n.toString()prend le prix pour sa clarté, et je ne pense pas qu'il entraîne des frais généraux supplémentaires.

Les conversions explicites sont très claires pour quelqu'un qui est nouveau dans la langue. L'utilisation de la coercition de type, comme d'autres l'ont suggéré, conduit à une ambiguïté si un développeur n'est pas au courant des règles de coercition. En fin de compte, le temps de développement est plus coûteux que le temps CPU, donc j'optimiserais pour le premier au détriment du second. Cela étant dit, dans ce cas, la différence est probablement négligeable, mais sinon je suis sûr qu'il existe des compresseurs JavaScript décents qui optimiseront ce genre de chose.

Donc, pour les raisons ci-dessus, j'irais avec: n.toString()ou String(n). String(n)est probablement un meilleur choix car il n'échouera pas s'il nest nul ou non défini.

... L'analyseur JavaScript tente d'analyser la notation par points sur un nombre comme un littéral à virgule flottante.

2..toString(); // the second point is correctly recognized
2 .toString(); // note the space left to the dot
(2).toString(); // 2 is evaluated first

La source

La langue en joue évidemment:

var harshNum = 108;
"".split.call(harshNum,"").join("");

Ou dans ES6, vous pouvez simplement utiliser des chaînes de modèle :

var harshNum = 108;
`${harshNum}`;

D'autres réponses couvraient déjà d'autres options, mais je préfère celle-ci:

s = `${n}`

Court, succinct, déjà utilisé dans de nombreux autres endroits (si vous utilisez une version framework / ES moderne), il est donc fort à parier que tout programmeur le comprendra.

Non pas que cela (généralement) compte beaucoup, mais il semble également être parmi les plus rapides par rapport à d' autres méthodes .

La façon la plus simple de convertir une variable en chaîne consiste à ajouter une chaîne vide à cette variable.

5.41 + ''    // Result: the string '5.41'
Math.PI + '' // Result: the string '3.141592653589793'

Si vous devez formater le résultat en un nombre spécifique de décimales, par exemple pour représenter la devise, vous avez besoin de quelque chose comme la toFixed()méthode.

number.toFixed( [digits] )

digits est le nombre de chiffres à afficher après la décimale.

J'ai utilisé https://jsperf.com pour créer un cas de test pour les cas suivants:

number + ''
`${number}`
String(number)
number.toString()

https://jsperf.com/number-string-conversion-speed-comparison

Au 24 juillet 2018, les résultats indiquent que number + ''c'est le plus rapide dans Chrome, dans Firefox qui est lié aux littéraux de chaîne de modèle.

Les deux String(number), et number.toString()sont environ 95% plus lents que l'option la plus rapide.

J'aime les deux premiers car ils sont plus faciles à lire. J'ai tendance à utiliser String(n)mais c'est juste une question de style que toute autre chose.

C'est à moins que vous ayez une ligne comme

var n = 5;
console.log ("the number is: " + n);

ce qui est très explicite

Je pense que cela dépend de la situation mais de toute façon vous pouvez utiliser la .toString()méthode car elle est très claire à comprendre.

.toString () est la fonction de transtypage intégrée, je ne suis pas spécialiste de ces détails, mais chaque fois que nous comparons des méthodologies explicites de transtypage de type intégrées, les solutions de contournement intégrées sont toujours préférées.

Si je devais tout prendre en considération, je vous proposerais de suivre

var myint = 1;
var mystring = myint + '';
/*or int to string*/
myint = myint + ''

À mon humble avis, c'est le moyen le plus rapide de convertir en chaîne. Corrigez-moi si je me trompe.

La seule solution valable pour presque tous les cas existants et futurs possibles (entrée est nombre, null, non défini, symbole, toute autre chose) est String(x). N'utilisez pas 3 méthodes pour un fonctionnement simple, en vous basant sur des hypothèses de type valeur, comme "ici, je convertis définitivement le nombre en chaîne et ici définitivement le booléen en chaîne".

Explication:

String(x)gère les valeurs nulles, non définies, les symboles, [n'importe quoi] et appelle les .toString()objets.

'' + xappelle .valueOf()x (transtypage en nombre), lance des symboles, peut fournir des résultats dépendants de l'implémentation.

x.toString() jette sur null et indéfini.

Remarque: String(x)échouera toujours sur les objets sans prototype comme Object.create(null).

Si vous n'aimez pas les chaînes comme «Bonjour, non défini» ou si vous souhaitez prendre en charge des objets sans prototype, utilisez la fonction de conversion de type suivante:

/**
 * Safely casts any value to string. Null and undefined are converted to ''.
 * @param  {*} value
 * @return {string}
 */
function string (str) {
  return value == null ? '' : (typeof value === 'object' && !value.toString ? '[object]' : String(value));
}

Avec les littéraux numériques, le point d'accès à une propriété doit être distingué du point décimal. Cela vous laisse les options suivantes si vous souhaitez invoquer String () sur le littéral numérique 123:

123..toString()
123 .toString() // space before the dot 123.0.toString()
(123).toString()

Voici les méthodes pour convertir un entier en chaîne dans JS

Les méthodes sont classées par ordre décroissant de performances.

(Les résultats des tests de performance sont donnés par @DarckBlezzer dans sa réponse)

var num = 1

Méthode 1:

num = `$ {num}`

Méthode 2:

num = num + ''

Méthode 3:

num = chaîne (num)

Méthode 4:

num = num.toString ()

Remarque: vous ne pouvez pas appeler directement tostring () à partir d'un numéro

Par exemple: 2.toString () lancera Uncaught SyntaxError : jeton invalide ou inattendu

Si vous êtes curieux de savoir lequel est le plus performant, vérifiez ceci où je compare toutes les différentes conversions Number -> String.

Ressemble 2+''ou 2+""est le plus rapide.

https://jsperf.com/int-2-string

Nous pouvons également utiliser le constructeur String . Selon cette référence, c'est le moyen le plus rapide de convertir un nombre en chaîne dans Firefox 58, même s'il est plus lent que " + numdans le navigateur populaire Google Chrome.

La méthode toFixed()résoudra également le but.

var n = 8.434332;
n.toFixed(2)  // 8.43

Vous pouvez appeler Numberobjet, puis appeler toString().

Number.call(null, n).toString()

Vous pouvez utiliser cette astuce pour un autre objet natif javascript.

Je viens de découvrir cela récemment, les méthodes 3 et 4 ne sont pas appropriées car la façon dont les chaînes sont copiées puis assemblées. Pour un petit programme, ce problème est insignifiant, mais pour toute application Web réelle, cette action où nous devons faire face à des manipulations de chaînes de fréquence peut affecter les performances et la lisibilité.

Voici le lien à lire .

Je vais rééditer cela avec plus de données quand j'en aurai le temps, car pour l'instant ça va ...

Test dans nodejs v8.11.2: 2018/06/06

let i=0;
    console.time("test1")
    for(;i<10000000;i=i+1){
    	const string = "" + 1234;
    }
    console.timeEnd("test1")
    
    i=0;
    console.time("test1.1")
    for(;i<10000000;i=i+1){
    	const string = '' + 1234;
    }
    console.timeEnd("test1.1")
    
    i=0;
    console.time("test1.2")
    for(;i<10000000;i=i+1){
    	const string = `` + 1234;
    }
    console.timeEnd("test1.2")
    
    i=0;
    console.time("test1.3")
    for(;i<10000000;i=i+1){
    	const string = 1234 +  '';
    }
    console.timeEnd("test1.3")
    
    
    i=0;
    console.time("test2")
    for(;i<10000000;i=i+1){
    	const string = (1234).toString();
    }
    console.timeEnd("test2")
    
    
    i=0;
    console.time("test3")
    for(;i<10000000;i=i+1){
    	const string = String(1234);
    }
    console.timeEnd("test3")
    
    
    i=0;
    console.time("test4")
    for(;i<10000000;i=i+1){
    	const string = `${1234}`;
    }
    console.timeEnd("test4")
    
    i=0;
    console.time("test5")
    for(;i<10000000;i=i+1){
    	const string = 1234..toString();
    }
    console.timeEnd("test5")
    
    i=0;
    console.time("test6")
    for(;i<10000000;i=i+1){
    	const string = 1234 .toString();
    }
    console.timeEnd("test6")

production

test1: 72.268ms
test1.1: 61.086ms
test1.2: 66.854ms
test1.3: 63.698ms
test2: 207.912ms
test3: 81.987ms
test4: 59.752ms
test5: 213.136ms
test6: 204.869ms

Il semble des résultats similaires lors de l'utilisation de node.js. J'ai exécuté ce script:

let bar;
let foo = ["45","foo"];

console.time('string concat testing');
for (let i = 0; i < 10000000; i++) {
    bar = "" + foo;
}
console.timeEnd('string concat testing');


console.time("string obj testing");
for (let i = 0; i < 10000000; i++) {
    bar = String(foo);
}
console.timeEnd("string obj testing");

console.time("string both");
for (let i = 0; i < 10000000; i++) {
    bar = "" + foo + "";
}
console.timeEnd("string both");

et a obtenu les résultats suivants:

❯ node testing.js
string concat testing: 2802.542ms
string obj testing: 3374.530ms
string both: 2660.023ms

Des temps similaires chaque fois que je l'ai couru