Qui est le meilleur, le nombre(x) ou parseFloat(x)?

Ce qui est mieux?

Je vous pose cette question juste pour le plaisir de gagner quelques octets, car je peux l'utiliser +x à la place de(x). Ne parsefloat faire quelque chose de mieux?

Seule la précision des nombres à virgule flottante occuper de 4 octets dans un système 32 bits ainsi que simple entiers. Je ne sais pas comment javascript poignées de flotte mais je suppose que c'est à peu près la même.
Tous les numéros sont en Javascript double précision flotteurs.
Je wouldve voté pour cette question si ce n'était pas pour le MODIFIER segment

InformationsquelleAutor Namanyay Goel | 2012-09-01

javascript optimization

258

La différence entre parseFloat et le Nombre

parseFloat/parseInt est pour l'analyse d'une chaîne de caractères, alors que Number/+ est pour le fait de contraindre une valeur à un certain nombre. Ils se comportent différemment. Mais d'abord, regardons où ils se comportent de la même:
```
parseFloat('3'); //=> 3
Number('3'); //=> 3
parseFloat('1.501'); //=> 1.501
Number('1.501'); //=> 1.501
parseFloat('1e10'); //=> 10000000000
Number('1e10'); //=> 10000000000
```
Donc, tant que vous avez de la norme d'entrée numérique, il n'y a pas de différence. Toutefois, si votre entrée commence par un nombre, puis contient d'autres caractères, parseFloat tronque le numéro de la chaîne, tandis que Number donne NaN (pas un nombre):
```
parseFloat('1x'); //=> 1
Number('1x'); //=> NaN
```
En outre, Number comprend hexadécimal d'entrée tout en parseFloat n':
```
parseFloat('0x10'); //=> 0
Number('0x10'); //=> 16
```
Mais Number actes bizarre avec des chaînes vides ou des chaînes de caractères ne contenant que des espaces blancs:
```
parseFloat(''); //=> NaN
Number(''); //=> 0
parseFloat(' \r\n\t'); //=> NaN
Number(' \r\n\t'); //=> 0
```
Sur l'ensemble, je trouve Number être plus raisonnable, j'ai donc presque toujours utiliser Number personnellement (et vous verrez que beaucoup de l'intérieur de fonctions JavaScript à utiliser Number ainsi). Si quelqu'un tape '1x' je préfère afficher une erreur plutôt que de les traiter comme si elles avaient tapé '1'. La seule fois où j'ai vraiment faire une exception, c'est quand je suis la conversion d'un style à un certain nombre, auquel cas parseFloat est utile parce que les styles viennent dans une forme comme '3px', auquel cas je souhaite supprimer le 'px' partie et qui vient d'obtenir l' 3, donc je trouve parseFloat utile ici. Mais vraiment celui que vous choisissez est à vous et les formes d'entrée que vous souhaitez accepter.

Notez que l'utilisation de l'unaire + opérateur est exactement le même que l'utilisation de Number en fonction:
```
Number('0x10'); //=> 16
+'0x10'; //=> 16
Number('10x'); //=> NaN
+'10x'; //=> NaN
Number('40'); //=> 40
+'40'; //=> 40
```
Donc j'ai l'habitude de simplement utiliser + pour faire court. Aussi longtemps que vous savez ce qu'il fait, je le trouve facile à lire.
- Aussi appel parseFloat sur un certain nombre convertit le nombre en premier dans une chaîne, puis analyse d'une chaîne. Number ignore que l'aller-retour. Peut-il y avoir un cas où un tel aller-retour sera une perte de précision? Je ne sais pas.
- il semble que vous avez raison. Je devine que je pensais de parseInt('1e10') (qui renvoie 1) et supposé parseFloat se comportaient de la même manière. Merci pour la correction!
- Je ne voudrais pas envisager de espace=>0 comportement de Number() comme "bizarre", je dirais même le considérer plus comme prévu, une espace est une valeur vide, mais il n'est pas null/undefined => 0 est un joli résultat. Gros (+) pour vous pour les vitrines de toute façon 🙂
- Pourriez mentionner que Number('Infinity') === Infinity alors que parseInt('Infinity') === NaN
- Je ne voudrais pas utiliser + (unaire plus) pour cela, parce que si vous oubliez un point-virgule à la ligne précédente, un ajout de l'expression peut être évaluée à la place.
- Pour le cas, ils se comportent de la même chose, j'ai trouvé que parseFloat est de 1% à 15% plus lent, devient plus lente lorsque le nombre de chiffres dans une chaîne augmente. Avec 1M exécuter dans mon système parseFloat('1.501') est de 5% plus lent que le Nombre('1.501') et parseFloat('1.50137585467') est de 15% plus lent que le Nombre('1.50137585467'). Donc, je vais pour le Nombre().
InformationsquelleAutor Nathan Wall
8

La différence de ce qui se passe lorsque l'entrée n'est pas un "bon numéro". Number retourne NaN tout parseFloat analyse "autant qu'il le peut". Si elle est appelée sur la chaîne vide Number retourne 0 tout parseFloat retourne NaN.

Par exemple:
```
Number("") === 0               //also holds for false
isNaN(parseFloat("")) === true //and null

isNaN(Number("32f")) === true
parseFloat("32f") === 32
```
- Notez que NaN != NaN si
- Oh vous ment que NaN != NaN évalue à TRUE - merci pour l'astuce !
- utiliser isNaN() pour tester la valeur NaN, isNaN(NaN) retourne true
InformationsquelleAutor Jon
4

Dans ces exemples, vous pouvez voir la différence:
```
Number('') = 0;
Number(false) = 0;
Number('1a') = NaN;

parseFloat('') = NaN;
parseFloat(false) = NaN;
parseFloat('1a') = 1;
```
parseFloat est un peu plus lent, car il recherche d'abord l'apparition d'un nombre en une chaîne de caractères, alors que le Nombre constuctor crée une nouvelle instance du numéro à partir de chaînes de caractères qui contient des valeurs numériques avec des espaces blancs ou qui contient de fausses valeurs.

P. S. Si vous êtes intéressé par certains universelle de conversion de type de solutions, vous pouvez lire le post sur la conversion de type dans mon blog: http://justsimplejs.blogspot.com/2012/08/data-type-conversion.html

InformationsquelleAutor micnic
2

Pour la chaîne vide, ils sont différents.

+"" et Number("") retourne 0, tandis que parseFloat("") renvoie NaN.
- J'irais même jusqu'à dire que parseFloat() a le droit de résultat comme une chaîne vide n'est PAS le nombre 0 (lire: NaN), tandis qu'une chaîne de caractères avec le caractère "0" EST 0;
- +x retourne 0 pas seulement pour une chaîne vide, mais aussi pour n'importe quel espace uniquement des chaînes de caractères. Exemples: +" ", +"\t\t\t", +"\n\n" - tous d'entre eux donnent des 0 la suite
InformationsquelleAutor xdazz
2

Autant que je sache, et ce n'est entendu de la part des collègues, donc peut être tout à fait mal informés, que parseFloat est légèrement plus rapide.

Bien que sur la poursuite de la recherche, il semblerait que cette différence de performances est un navigateur charge.

http://jsperf.com/parseint-vs-parsefloat/6

Un oeil à ces jsPerf résultats, et vous êtes à l'appel. (il comprend +x tests)

Comme indiqué dans @xdazz 's réponse, +"" et Number("") retour 0 tout parseFloat("") retourne NaN Encore une fois, je voudrais aller avec parseFloat, car une chaîne vide ne signifie PAS le nombre 0, seulement une chaîne de caractères avec le caractère "0" dans cela signifie 0;
- Voici un plus exhaustive test pêche pour un moyen plus rapide pour convertir... parseFloat() est toujours le gagnant.
InformationsquelleAutor Christopher

Vous devez vous connecter pour publier un commentaire.

La différence entre parseFloat et le Nombre