web-dev-qa-db-fra.com

Quelle est la différence entre parseInt () et Number ()?

Comment parseInt() et Number() se comportent-ils différemment lors de la conversion de chaînes en nombres?

javascriptperformance
298
Mark

Bien, ils sont sémantiquement différents , le constructeur Number appelé en tant que fonction exécute le type conversion et parseInt effectue l'analyse , par exemple:

// parsing:
parseInt("20px");       // 20
parseInt("10100", 2);   // 20
parseInt("2e1");        // 2

// type conversion
Number("20px");       // NaN
Number("2e1");        // 20, exponential notation

Gardez à l'esprit que si parseInt détecte un zéro non significatif sur la chaîne, il analysera le nombre en base octale. Cela a changé sous ECMAScript 5, la nouvelle version de la norme, mais la mise en œuvre du navigateur prendra beaucoup de temps ( c'est une incompatibilité avec ECMAScript 3), parseInt ignorera également les caractères de fin qui ne correspondent à aucun chiffre de la base actuellement utilisée.

Le constructeur Number ne détecte pas les octaux:

Number("010");         // 10
parseInt("010");       // 8, implicit octal
parseInt("010", 10);   // 10, decimal radix used

Mais il peut gérer les nombres en notation hexadécimale, tout comme parseInt:

Number("0xF");   // 15
parseInt("0xF"); //15

De plus, une construction largement utilisée pour effectuer une conversion de type numérique est nary + Operator (p. 72) , elle revient à utiliser le constructeur Number en tant que fonction:

+"2e1";   // 20
+"0xF";   // 15
+"010";   // 10
417
CMS
typeof parseInt("123") => number
typeof Number("123") => number
typeof new Number("123") => object (Number primitive wrapper object)

les deux premiers vous donneront de meilleures performances car il retourne une primitive au lieu d'un objet.

21
letronje

Si vous recherchez des performances, alors vous obtiendrez probablement les meilleurs résultats avec le décalage binaire à droite "10">>0. Également multiplier ("10" * 1) ou non (~~"10"). Tous sont beaucoup plus rapides de Number et parseInt. Ils ont même "feature" renvoyant 0 pour l'argument non numérique. Voici tests de performance .

15
Saulius

J'ai trouvé deux liens de performances comparés entre plusieurs façons de convertir string en int.

parseInt(str,10)    
parseFloat(str)
str << 0
+str
str*1 
str-0
Number(str)

http://jsben.ch/#/zGJHM

http://phrogz.net/js/string_to_number.html

8
zangw

Une différence mineure est ce qu'ils convertissent de undefined ou null,

Number() Or Number(null) // returns 0

tandis que

parseInt() Or parseInt(null) // returns NaN
5
Naeem Shaikh

Sommaire:

parseInt():

  • Prend une chaîne en tant que premier argument, la base (un entier constituant la base d'un système numérique, par exemple, décimal 10 ou 2 binaire) en tant que second argument
  • La fonction retourne un nombre entier, si le premier caractère ne peut pas être converti en un nombre, NaN sera retourné.
  • Si la fonction parseInt() rencontre une valeur non numérique, elle coupera le reste de la chaîne d'entrée et analysera uniquement la partie jusqu'à la valeur non numérique.
  • Si la base est undefined ou 0, JS supposera ce qui suit:
    • Si la chaîne d'entrée commence par "0x" ou "0X", le nombre de radix est 16 (hexadécimal), le reste de la chaîne est analysé sous forme de nombre.
    • Si la valeur d'entrée commence par un 0, la base peut être 8 (octal) ou 10 (décimal). La base choisie est fonction de la mise en œuvre du moteur JS. ES5 spécifie que 10 doit être utilisé à ce moment-là. Cependant, ceci n'est pas supporté par tous les navigateurs, par conséquent, spécifiez toujours la base si vos nombres peuvent commencer par 0.
    • Si la valeur en entrée commence par un nombre, la base sera 10

Number():

  • Le constructeur Number() peut convertir n'importe quel argument en entrée en un nombre. Si le constructeur Number() ne peut pas convertir l'entrée en un nombre, NaN sera renvoyé.
  • Le constructeur Number() peut également gérer un nombre hexadécimal, il doit commencer par 0x.

Exemple:

console.log(parseInt('0xF', 16));  // 15

// z is no number, it will only evaluate 0xF, therefore 15 is logged
console.log(parseInt('0xFz123', 16));

// because the radix is 10, A is considered a letter not a number (like in Hexadecimal)
// Therefore, A will be cut off the string and 10 is logged
console.log(parseInt('10A', 10));  // 10

// first character isnot a number, therefore parseInt will return NaN
console.log(parseInt('a1213', 10));


console.log('\n');


// start with 0X, therefore Number will interpret it as a hexadecimal value
console.log(Number('0x11'));

// Cannot be converted to a number, NaN will be returned, notice that
// the number constructor will not cut off a non number part like parseInt does
console.log(Number('123A'));

// scientific notation is allowed
console.log(Number('152e-1'));  // 15.21
5
Willem van der Veen

J'utilise toujours parseInt, mais méfiez-vous des zéros non significatifs qui le forceront en mode octal.

5
Diodeus - James MacFarlane

parseInt() -> Analyse un nombre en fonction du redix spécifié. Number()-> Convertit la valeur spécifiée en son équivalent numérique ou en NaN si ce n'est pas le cas.

Par conséquent, pour convertir une valeur non numérique en nombre, nous devrions toujours utiliser la fonction Number ().

par exemple.

Number("")//0
parseInt("")//NaN

Number("123")//123
parseInt("123")//123

Number("123ac") //NaN,as it is a non numeric string
parsInt("123ac") //123,it parse decimal number outof string

Number(true)//1
parseInt(true) //NaN

parseInt() fonctionne de la même manière que la conversion redix. Par conséquent, nous devrions éviter d'utiliser la fonction parseInt () à des fins de coersion. Maintenant, pour vérifier si la valeur fournie est numérique ou non, nous devrions utiliser la fonction nativeisNaN()

1
Atishay Baid

parseInt est converti en un nombre entier, c'est-à-dire qu'il supprime les décimales. Le nombre ne convertit pas en entier.

1
Johan Rylander

C'est une bonne idée de rester à l'écart de parseInt et d'utiliser Number et Math.round sauf si vous avez besoin d'hex ou d'octal. Les deux peuvent utiliser des chaînes. Pourquoi rester loin de ça?

parseInt(0.001, 10)
0

parseInt(-0.0000000001, 10)
-1

parseInt(0.0000000001, 10)
1

parseInt(4000000000000000000000, 10)
4

Il abat complètement les bouchers très gros ou très petits. Curieusement, cela fonctionne normalement si ces entrées sont une chaîne.

parseInt("-0.0000000001", 10)
0

parseInt("0.0000000001", 10)
0

parseInt("4000000000000000000000", 10)
4e+21

Au lieu de risquer difficilement de trouver des bogues avec ceci et les autres pièges mentionnés, je voudrais simplement éviter l'analyse syntaxique sauf si vous devez analyser quelque chose d'autre que la base 10. Nombre, Math.round, Math.foor et .toFixed (0) peuvent tous faire les mêmes choses que parseInt peut être utilisé sans ces types de bogues.

Si vous voulez vraiment ou devez utiliser parseInt pour certaines de ses qualités, ne l'utilisez jamais pour convertir des floats en ints.

0
kagronick