parseInt()

Exemple interactif

console.log(parseInt("123"));
// 123 (base 10 par défaut)
console.log(parseInt("123", 10));
// 123 (base 10 définie explicitement)
console.log(parseInt("   123 "));
// 123 (les espaces blancs sont ignorés)
console.log(parseInt("077"));
// 77 (les zéros initiaux sont ignorés)
console.log(parseInt("1.9"));
// 1 (la partie décimale est tronquée)
console.log(parseInt("ff", 16));
// 255 (hexadécimal en minuscules)
console.log(parseInt("0xFF", 16));
// 255 (hexadécimal en majuscules avec le préfixe "0x")
console.log(parseInt("xyz"));
// NaN (l'entrée ne peut pas être convertie en entier)

Syntaxe

parseInt(string)
parseInt(string, radix)

Paramètres

string

Une chaîne de caractères commençant par un entier. Les espaces blancs en début de cette chaîne de caractères sont ignorés.

radix Facultatif

Un entier compris entre 2 et 36 qui représente la base (le système de numération) 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] après conversion, la fonction retourne toujours NaN. Si 0 ou non fourni, la base est déduite de la valeur de string. Soyez prudent — cela ne correspond pas toujours à la valeur par défaut 10 ! La description ci-dessous explique plus en détail ce qui se passe lorsque radix n'est pas fourni.

Valeur de retour

Un entier obtenu à partir de la chaîne de caractères string fournie, ou NaN lorsque

• la base (radix) en tant qu'entier sur 32 bits est inférieure à 2 ou supérieure à 36, ou
• le premier caractère non blanc ne peut pas être converti en nombre.

Description

La fonction parseInt convertit son premier argument en chaîne de caractères, analyse cette chaîne de caractères, puis retourne un entier ou NaN.

Si la valeur retournée n'est pas NaN, elle correspond à l'entier obtenu en interprétant le premier argument comme un nombre selon la base radix définie. (Par exemple, une base radix égale à 10 correspond à un nombre décimal, 8 à un nombre octal, 16 à un nombre hexadécimal, 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'entrée string, avec suppression des espaces blancs et des signes +/- éventuels en début de ligne, commence par 0x ou 0X (un zéro suivi d'un X minuscule ou majuscule), la base radix est supposée être 16 et le reste de la chaîne de caractères est analysé comme un nombre hexadécimal.
2. Si l'entrée string commence par n'importe quelle autre valeur, la base est 10 (décimale).

Si la base est 16, parseInt() permet à la chaîne de caractères d'être éventuellement préfixée par 0x ou 0X après le caractère de signe optionnel (+/-).

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

Pour les bases supérieures à 10, les lettres de l'alphabet indiquent des chiffres supérieurs à 9. Par exemple, pour les nombres hexadécimaux (base 16), on utilise A à F. Les lettres ne sont pas sensibles à la casse.

parseInt comprend exactement deux signes : + pour positif et - pour négatif. Cela se fait comme première étape de l'analyse après la suppression des espaces blancs. Si aucun signe n'est trouvé, l'algorithme passe à l'étape suivante ; sinon, il supprime le signe et exécute l'analyse du nombre sur le reste de la chaîne de caractères.

Si parseInt rencontre un caractère dans la chaîne de caractères d'entrée qui n'est pas un chiffre valide dans la base radix définie, il l'ignore ainsi que tous les caractères suivants et retourne la valeur entière analysée jusqu'à ce point. Par exemple, parseInt("2", 2) retourne NaN, car 2 n'est pas un chiffre valide dans le système binaire. De même, 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 caractère ne peut pas être converti en nombre avec la base radix en cours d'utilisation, parseInt retourne NaN. Les espaces blancs en début de chaîne de caractères sont autorisés.

Pour les opérations arithmétiques, la valeur NaN n'est un nombre dans aucune base. Vous pouvez appeler la fonction Number.isNaN pour déterminer si le résultat de parseInt est NaN. Si NaN est utilisé dans des opérations arithmétiques, le résultat de l'opération est également NaN.

Comme les grands nombres utilisent le caractère e dans leur représentation sous forme de chaîne de caractères (par exemple, 6.022e23 pour 6.022 × 10²³), utiliser parseInt pour tronquer les nombres produit des résultats inattendus lorsqu'il est utilisé sur des nombres très grands ou très petits. parseInt ne doit pas être utilisé comme substitut de Math.trunc().

Pour convertir un nombre en sa représentation sous forme de chaîne de caractères dans une base particulière, utilisez thatNumber.toString(radix).

Comme parseInt() retourne un nombre, il peut souffrir d'une perte de précision si l'entier représenté par la chaîne de caractères est en dehors de la plage sûre. La fonction BigInt() permet d'analyser avec précision 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 représentation
// 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'arrête au caractère n et traite la chaîne de caractères qui précède comme un entier normal, ce qui peut entraîner une perte de précision.

parseInt("900719925474099267n");
// 900719925474099300

Vous devez plutôt transmettre la chaîne de caractères à la fonction BigInt(), sans le caractère n final.

BigInt("900719925474099267");
// 900719925474099267n

parseInt ne fonctionne pas avec les séparateurs numériques :

parseInt("123_456"); // 123

Utiliser parseInt() sur des valeurs qui ne sont pas des chaînes de caractères

parseInt() peut donner des résultats intéressants lorsqu'on travaille sur des valeurs qui ne sont pas des chaînes de caractères combinées à une base élevée ; par exemple, 36 (ce qui rend tous les caractères alphanumériques des chiffres valides).

parseInt(null, 36); // 1112745 : La chaîne de caractères "null" est 1112745 en base 36
parseInt(undefined, 36); // 86464843759093 : La chaîne de caractères "undefined" est 86464843759093 en base 36

En général, il est déconseillé d'utiliser parseInt() sur des valeurs qui ne sont pas des chaînes de caractères, 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 représentation sous forme de chaîne de caractères de ces nombres utilise une notation fractionnaire de base ("15.99", "-15.1"), où parseInt() s'arrête au niveau du point décimal. Les nombres supérieurs ou égaux à 1e+21 ou inférieurs ou égaux à 1e-7 utilisent une notation exponentielle ("1.5e+22", "1.51e-8") dans leur représentation sous forme de chaîne de caractères, et parseInt() s'arrête au niveau du caractère e ou du point décimal, qui vient toujours après 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 très grand devient 4
parseInt(0.00000000000434, 10); // Un nombre très 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

Spécifications

Compatibilité des navigateurs

Voir aussi

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