parseInt()

Exemple interactif

console.log(parseInt("123"));
// 123 (default base-10)
console.log(parseInt("123", 10));
// 123 (explicitly specify base-10)
console.log(parseInt("   123 "));
// 123 (whitespace is ignored)
console.log(parseInt("077"));
// 77 (leading zeros are ignored)
console.log(parseInt("1.9"));
// 1 (decimal part is truncated)
console.log(parseInt("ff", 16));
// 255 (lower-case hexadecimal)
console.log(parseInt("0xFF", 16));
// 255 (upper-case hexadecimal with "0x" prefix)
console.log(parseInt("xyz"));
// NaN (input can't be converted to an integer)

Syntaxe

parseInt(string, base);

Paramtres

string

La valeur qu'on souhaite analyser et convertir. Si l'argument string n'est pas une chane de caractres, elle sera convertie en une chane (grce l'opration abstraite ToString) . Les blancs contenus au dbut de l'argument sont ignors.

base

Un entier compris entre 2 et 36 qui reprsente la base utilise pour la valeur reprsente dans la chane. La base communment utilise est la base dcimale et on utilisera donc 10 dans ce cas pour ce paramtre.

Attention : La base par dfaut n'est pas 10. Ce paramtre doit toujours tre utilis, en effet s'il n'est pas spcifi, le comportement de la fonction n'est pas garanti et peut varier d'une plate-forme une autre.

Voir cependant la description ci-aprs qui explicite le comportement par dfaut attendu.

Valeur de retour

Un entier obtenu partir de l'analyse de la chane de caractres. Si le premier caractre ne permet d'obtenir un nombre d'aprs la base fournie, ce sera NaN qui sera renvoy.

Description

La fonction parseInt() convertit le premier argument en une chane, l'analyse et renvoie un entier ou NaN. Si la valeur renvoye n'est pas NaN, ce sera l'entier reprsentant le nombre contenu dans la chane dans la base donne. Une base 10 est utilise pour la base dcimale, 8 pour la base octale, 16 pour la base hexadcimale. Pour les bases suprieures 10, les lettres de l'alphabet latin seront utilises pour reprsenter les chiffres suprieurs 9. Par exemple, pour la base hexadcimale, on utilisera les lettres A F.

Si, lors de l'analyse de la chane, parseInt() rencontre un caractre qui n'est pas un chiffre dans la base donne, ce caractre, ainsi que les suivants seront ignors. parseInt() tronque les nombres fournies en valeurs entires (attention donc lorsque les chanes utilisent une notation scientifique : "4e2" donnera la valeur 4 en base 10 et pas 400). Les espaces en dbut et en fin de chane sont autoriss.

Si la base fournie vaut undefined ou 0 (ou si elle n'est pas utilise comme paramtre), le moteur JavaScript procdera comme suit :

• Si l'argument string commence avec "0x" ou "0X", la base considre sera la base 16 (hexadcimale) et le reste de la chane sera analys et converti.
• Si l'argument string commence avec "0", la base considre sera la base 8 (octale) ou la base 10 (dcimale). La base exacte qui sera choisie dpendra de l'implmentation. ECMAScript 5 dfinit que la base 10 doit tre utilise. Cependant, cela n'est pas support par tous les navigateurs. C'est pour cette raison qu'il faut toujours spcifier une base lorsqu'on utilise parseInt().
• Si l'argument string commence avec une autre valeur, la base considre sera la base 10.

Si le premier caractre de la chane de caractres ne peut pas tre converti, parseInt() renverra NaN.

Pour des raisons arithmtiques, la valeur NaN n'est un nombre pour aucune base. La fonction isNaN() peut tre utilise pour dterminer si le rsultat obtenu par parseInt() vaut NaN. Si NaN est utilis dans une opration arithmtique, le rsultat de cette opration sera aussi NaN (on dit que NaN est une valeur toxique ).

Pour convertir un nombre en une chane de caractres dans une base donne, on utilisera monEntier.toString(base).

parseInt convertira les valeurs BigInt en Number et de la prcision sera perdue lors de ce traitement.

Exemples

Les exemples suivants renvoient tous 15 :

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt(021, 8);
parseInt("015", 10); // attention parseInt(015, 10); renvoie 13
parseInt(15.99, 10);
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15*3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

Les exemples suivants renvoient NaN :

parseInt("Coucou", 8); // Ce sont des lettres et pas des chiffres
parseInt("546", 2); // Ces chiffres ne sont pas valides pour une reprsentation
// binaire

Les exemples suivants renvoient tous -15 :

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt(-15.1, 10);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

Les exemples suivants renvoient tous 4 :

parseInt("4e2", 10);
parseInt("4.7", 10);

L'exemple suivant renvoie 224 :

parseInt("0e0", 16);

On perdra en prcision si on manipule un grand entier (BigInt) :

parseInt(900719925474099267n); // 900719925474099300

Interprter une base octale quand aucun paramtre de base n'est fourni

Bien que cela soit fortement dconseill par ECMAScript 3 et que cela soit interdit par ECMAScript 5, de nombreuses implmentations interprtent une chane numrique qui commence par 0 comme une valeur exprime dans la base octale. Les instructions qui suivent peuvent avoir un rsultat octal ou dcimal selon les implmentations. Pour cette raison, il faut toujours dfinir une base lorsqu'on utilise cette fonction.

parseInt("0e0"); // 0
parseInt("08"); // 0, '8' n'est pas un chiffre octal.

ECMAScript 5 supprime l'interprtation octale

La spcification ECMAScript 5 indique, au sujet de la fonction parseInt(), que les valeurs commenant par 0 ne doivent plus tre considres comme des valeurs octales. ECMAScript 5 indique :

La fonction parseInt produit une valeur entire dfinie par le contenu de la chane selon la base fournie. Les blancs en dbut de chane sont ignors. Si la base spcifie est 0, la base dcimale sera prise en compte sauf si le nombre reprsent commence par la paire de caractres 0x ou 0X auquel cas la base 16 sera prise en compte.

Sur cet aspect, ECMAScript 3 diffre car il permet l'interprtation octale (bien qu'il la dconseille).

De nombreuses implmentations n'ont pas adopt ce comportement en 2013. Pour cette raison (les anciens environnements et navigateurs doivent tre supports), il faut toujours dfinir le paramtre pour la base.

Une fonction plus stricte

Il est parfois utile d'avoir une fonction de conversion plus stricte. Pour cela, on peut utiliser une expression rationnelle :

filterInt = function (value) {
  if (/^(-|\+)?(\d+|Infinity)$/.test(value)) return Number(value);
  return NaN;
};

console.log(filterInt("421")); // 421
console.log(filterInt("-421")); // -421
console.log(filterInt("+421")); // 421
console.log(filterInt("Infinity")); // Infinity
console.log(filterInt("421e+0")); // NaN
console.log(filterInt("421hop")); // NaN
console.log(filterInt("hop1.61803398875")); // NaN
console.log(filterInt("1.61803398875")); // NaN

Spcifications

Compatibilit des navigateurs

Voir aussi

• parseFloat()
• Number.parseFloat()
• Number.parseInt()
• isNaN()
• Number.toString()
• Object.valueOf