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

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

Eh bien, ils sont sémantiquement différents , le Numberconstructeur appelé en tant que fonction effectue une conversion de type et parseInteffectue une 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 parseIntdétecte un zéro de tête sur la chaîne, il analysera le nombre en base octale, cela a changé sur ECMAScript 5, la nouvelle version de la norme, mais cela prendra beaucoup de temps pour entrer dans les implémentations du navigateur (c'est une incompatibilité avec ECMAScript 3), parseIntignorera également les caractères de fin qui ne correspondent à aucun chiffre de la base actuellement utilisée.

Le Numberconstructeur 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 des 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 l' opérateur unaire +(p. 72) , elle équivaut à utiliser le Numberconstructeur en tant que fonction:

+"2e1";   // 20
+"0xF";   // 15
+"010";   // 10

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 ils retournent une primitive au lieu d'un objet.

Si vous recherchez des performances, vous obtiendrez probablement les meilleurs résultats avec un décalage à droite au niveau du bit "10">>0. Multipliez également ( "10" * 1) ou non ( ~~"10"). Tous sont beaucoup plus rapides de Numberet parseInt. Ils ont même "fonction" renvoyant 0 pour un argument non numérique. Voici des tests de performances .

J'ai trouvé deux liens de performances comparables entre plusieurs façons de convertir stringen 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

Une différence mineure est ce qu'ils convertissent undefinedou null,

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

tandis que

parseInt() Or parseInt(null) // returns NaN

Résumé:

parseInt():

• Prend une chaîne comme premier argument, le radix (Un entier qui est la base d'un système numérique, par exemple décimal 10 ou binaire 2) comme deuxième argument
• La fonction renvoie un nombre entier, si le premier caractère ne peut pas être converti en nombre NaN sera retourné.
• Si la parseInt() fonction 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 le radix est undefinedou 0, JS supposera ce qui suit:
  • Si la chaîne d'entrée commence par "0x" ou "0X", le radix est 16 (hexadécimal), le reste de la chaîne est analysé en un nombre.
  • Si la valeur d'entrée commence par un 0, le radix peut être 8 (octal) ou 10 (décimal). La radix choisie dépend de la mise en œuvre du moteur JS. ES5spécifie que 10 doit alors être utilisé. Cependant, cela n'est pas pris en charge par tous les navigateurs, donc spécifiez toujours radix si vos chiffres peuvent commencer par un 0.
  • Si la valeur d'entrée commence par un nombre quelconque, la radix sera 10

Number():

• Le Number()constructeur peut convertir n'importe quel argument saisi en nombre. Si le Number()constructeur ne peut pas convertir l'entrée en nombre, NaNsera retourné.
• Le Number()constructeur peut également gérer le nombre hexadécimal, ils doivent 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

J'utilise toujours parseInt, mais méfiez-vous des zéros de tête qui le forceront en mode octal .

parseInt() -> Analyse un nombre en redix spécifié.

Number()-> Convertit la valeur spécifiée en son équivalent numérique ou NaN s'il ne le fait pas.

Par conséquent, pour convertir une valeur non numérique en nombre, nous devons 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

Il existe différents cas de coin pour les parseInt()fonctions comme pour la conversion de redix, nous devons donc éviter d'utiliser la fonction parseInt () à des fins de conversion.

Maintenant, pour vérifier la météo, la valeur fournie est numérique ou non, nous devons utiliser la isNaN()fonction native

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

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'un hex ou d'un octal. Les deux peuvent utiliser des chaînes. Pourquoi en rester éloigné?

parseInt(0.001, 10)
0

parseInt(-0.0000000001, 10)
-1

parseInt(0.0000000001, 10)
1

parseInt(4000000000000000000000, 10)
4

Il dépeint complètement de très gros ou très petits nombres. 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 de trouver des bogues avec ceci et les autres problèmes mentionnés, j'éviterais simplement parseInt à moins que vous n'ayez besoin d'analyser autre chose que la base 10. Number, Math.round, Math.foor et .toFixed (0) peuvent tous faire les mêmes choses que parseInt peut être utilisé sans avoir ces types de bogues.

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