parseInt()

Exemple interactif

console.log(parseInt("123"));
// 123 (base 10 par dfaut)
console.log(parseInt("123", 10));
// 123 (base 10 dfinie explicitement)
console.log(parseInt("   123 "));
// 123 (les espaces blancs sont ignors)
console.log(parseInt("077"));
// 77 (les zros initiaux sont ignors)
console.log(parseInt("1.9"));
// 1 (la partie dcimale est tronque)
console.log(parseInt("ff", 16));
// 255 (hexadcimal en minuscules)
console.log(parseInt("0xFF", 16));
// 255 (hexadcimal en majuscules avec le prfixe "0x")
console.log(parseInt("xyz"));
// NaN (l'entre ne peut pas tre convertie en entier)

Syntaxe

parseInt(string)
parseInt(string, radix)

Paramtres

string

Une chane de caractres commenant par un entier. Les espaces blancs en dbut de cette chane de caractres sont ignors.

radix Facultatif

Un entier compris entre 2 et 36 qui reprsente la base (le systme de numration) de la string. Il est converti en un entier sur 32 bits ; s'il est non nul et en dehors de l'intervalle [2, 36] aprs conversion, la fonction retourne toujours NaN. Si 0 ou non fourni, la base est dduite de la valeur de string. Soyez prudent cela ne correspond pas toujours la valeur par dfaut 10 ! La description ci-dessous explique plus en dtail ce qui se passe lorsque radix n'est pas fourni.

Valeur de retour

Un entier obtenu partir de la chane de caractres string fournie, ou NaN lorsque

• la base (radix) en tant qu'entier sur 32 bits est infrieure 2 ou suprieure 36, ou
• le premier caractre non blanc ne peut pas tre converti en nombre.

Description

La fonction parseInt convertit son premier argument en chane de caractres, analyse cette chane de caractres, puis retourne un entier ou NaN.

Si la valeur retourne n'est pas NaN, elle correspond l'entier obtenu en interprtant le premier argument comme un nombre selon la base radix dfinie. (Par exemple, une base radix gale 10 correspond un nombre dcimal, 8 un nombre octal, 16 un nombre hexadcimal, et ainsi de suite.)

L'argument radix est converti en nombre. S'il n'est pas fourni, ou si sa valeur devient 0, NaN ou Infinity (undefined est converti en NaN), JavaScript suppose ce qui suit :

1. Si l'entre string, avec suppression des espaces blancs et des signes +/- ventuels en dbut de ligne, commence par 0x ou 0X (un zro suivi d'un X minuscule ou majuscule), la base radix est suppose tre 16 et le reste de la chane de caractres est analys comme un nombre hexadcimal.
2. Si l'entre string commence par n'importe quelle autre valeur, la base est 10 (dcimale).

Si la base est 16, parseInt() permet la chane de caractres d'tre ventuellement prfixe par 0x ou 0X aprs le caractre de signe optionnel (+/-).

Si la valeur de la base (convertie si ncessaire) n'est pas comprise dans l'intervalle [2, 36] (inclus), parseInt retourne NaN.

Pour les bases suprieures 10, les lettres de l'alphabet indiquent des chiffres suprieurs 9. Par exemple, pour les nombres hexadcimaux (base 16), on utilise A F. Les lettres ne sont pas sensibles la casse.

parseInt comprend exactement deux signes : + pour positif et - pour ngatif. Cela se fait comme premire tape de l'analyse aprs la suppression des espaces blancs. Si aucun signe n'est trouv, l'algorithme passe l'tape suivante ; sinon, il supprime le signe et excute l'analyse du nombre sur le reste de la chane de caractres.

Si parseInt rencontre un caractre dans la chane de caractres d'entre qui n'est pas un chiffre valide dans la base radix dfinie, il l'ignore ainsi que tous les caractres suivants et retourne la valeur entire analyse jusqu' ce point. Par exemple, parseInt("2", 2) retourne NaN, car 2 n'est pas un chiffre valide dans le systme binaire. De mme, bien que 1e3 encode techniquement un entier (et est correctement analys en entier 1000 par parseFloat()), parseInt("1e3", 10) retourne 1, car e n'est pas un chiffre valide en base 10. Comme . n'est pas non plus un chiffre, la valeur de retour est toujours un entier.

Si le premier caractre ne peut pas tre converti en nombre avec la base radix en cours d'utilisation, parseInt retourne NaN. Les espaces blancs en dbut de chane de caractres sont autoriss.

Pour les oprations arithmtiques, la valeur NaN n'est un nombre dans aucune base. Vous pouvez appeler la fonction Number.isNaN pour dterminer si le rsultat de parseInt est NaN. Si NaN est utilis dans des oprations arithmtiques, le rsultat de l'opration est galement NaN.

Comme les grands nombres utilisent le caractre e dans leur reprsentation sous forme de chane de caractres (par exemple, 6.022e23 pour 6.022 1023), utiliser parseInt pour tronquer les nombres produit des rsultats inattendus lorsqu'il est utilis sur des nombres trs grands ou trs petits. parseInt ne doit pas tre utilis comme substitut de Math.trunc().

Pour convertir un nombre en sa reprsentation sous forme de chane de caractres dans une base particulire, utilisez thatNumber.toString(radix).

Comme parseInt() retourne un nombre, il peut souffrir d'une perte de prcision si l'entier reprsent par la chane de caractres est en dehors de la plage sre. La fonction BigInt() permet d'analyser avec prcision des entiers de longueur arbitraire, en retournant un BigInt.

Exemples

Utiliser la fonction parseInt()

Les exemples suivants retournent tous 15 :

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 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 retournent 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 retournent tous -15 :

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

Les exemples suivants retournent tous 4 :

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

L'exemple suivant retourne 224 :

parseInt("0e0", 16);

La fonction parseInt() ne prend pas en charge les valeurs BigInt. Elle s'arrte au caractre n et traite la chane de caractres qui prcde comme un entier normal, ce qui peut entraner une perte de prcision.

parseInt("900719925474099267n");
// 900719925474099300

Vous devez plutt transmettre la chane de caractres la fonction BigInt(), sans le caractre n final.

BigInt("900719925474099267");
// 900719925474099267n

parseInt ne fonctionne pas avec les sparateurs numriques :

parseInt("123_456"); // 123

Utiliser parseInt() sur des valeurs qui ne sont pas des chanes de caractres

parseInt() peut donner des rsultats intressants lorsqu'on travaille sur des valeurs qui ne sont pas des chanes de caractres combines une base leve ; par exemple, 36 (ce qui rend tous les caractres alphanumriques des chiffres valides).

parseInt(null, 36); // 1112745 : La chane de caractres "null" est 1112745 en base 36
parseInt(undefined, 36); // 86464843759093 : La chane de caractres "undefined" est 86464843759093 en base 36

En gnral, il est dconseill d'utiliser parseInt() sur des valeurs qui ne sont pas des chanes de caractres, en particulier pour l'utiliser comme substitut de Math.trunc(). Cela peut fonctionner sur de petits nombres :

parseInt(15.99, 10); // 15
parseInt(-15.1, 10); // -15

Cependant, cela ne fonctionne que parce que la reprsentation sous forme de chane de caractres de ces nombres utilise une notation fractionnaire de base ("15.99", "-15.1"), o parseInt() s'arrte au niveau du point dcimal. Les nombres suprieurs ou gaux 1e+21 ou infrieurs ou gaux 1e-7 utilisent une notation exponentielle ("1.5e+22", "1.51e-8") dans leur reprsentation sous forme de chane de caractres, et parseInt() s'arrte au niveau du caractre e ou du point dcimal, qui vient toujours aprs le premier chiffre. Cela signifie que pour les nombres grands et petits, parseInt() retourne un entier un chiffre :

parseInt(4.7 * 1e22, 10); // Un nombre trs grand devient 4
parseInt(0.00000000000434, 10); // Un nombre trs petit devient 4

parseInt(0.0000001, 10); // 1
parseInt(0.000000123, 10); // 1
parseInt(1e-7, 10); // 1
parseInt(1000000000000000000000, 10); // 1
parseInt(123000000000000000000000, 10); // 1
parseInt(1e21, 10); // 1

Spcifications

Compatibilit des navigateurs

Voir aussi

• La fonction native parseFloat()
• Le constructeur Number()
• La mthode statique Number.parseFloat()
• La mthode statique Number.parseInt()
• La fonction native isNaN()
• La mthode Number.prototype.toString()
• La mthode Object.prototype.valueOf()
• Le constructeur BigInt()