Réponses:
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.
null foo
ne renvoie pas d'erreur.
À 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.
null
, undefined
) qui ne fonctionnent pas avec cette réponse la rend à peine «dangereuse».
null
ou undefined
car il est spécifique à l'application, alors que j'imagine que (n || defaultNumber).toString()
c'est ce que la plupart des gens voudraient dans une telle situation, je suis fortement en désaccord que nous devrions l'intégrer dans toutes les questions. Il s'agissait de convertir des nombres en chaînes, une bonne architecture et d'autres conversions de type si nécessaire sont des leçons séparées.
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 n
est nul ou non défini.
null
, ou undefined
. Si n
c'est null
ou en undefined
raison d'un bogue dans mon programme, je préférerais que mon programme échoue dans cet état, pour me donner une meilleure chance de trouver et de corriger le bogue. Les plantages de programmes sont des cadeaux pour le programmeur, pour l'aider à trouver les bugs :-). L'alternative est de fournir un logiciel qui ne fonctionne pas comme prévu, après avoir soigneusement ignoré les bogues. Donc, je ne suis pas fan de l'utilisation String(n)
pour masquer une erreur.
String(n)
est bon pour une utilisation dans un style fonctionnel, par exemple avec la combinaison de soulignement _.compose(funcThatNeedsAStringParam, String)
.
... 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 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}`;
'' + number
méthode. Cela dit, les résultats de ces benchmarks varient beaucoup lors de leur exécution plusieurs fois, donc je ne sais pas s'ils doivent être pris trop au sérieux.
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 .
n.toString()
alors, n'est-ce pas?
n
est, undefined
il générera une erreur de syntaxe en utilisant.toString()
String(n)
dans tous les cas? La seule différence est que c'est moins clair.
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'
(5.41 + '')
pour utiliser les méthodes String comme .substring()
et d'autres
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.
.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.
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.
'' + x
appelle .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.
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
" + num
dans le navigateur populaire Google Chrome.
La méthode toFixed()
résoudra également le but.
var n = 8.434332;
n.toFixed(2) // 8.43
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é.
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
'' + 123e-50
retourne"1.23e-48"
.