parseInt()

Baseline Widely available

Cette fonctionnalité est bien établie et fonctionne sur de nombreux appareils et versions de navigateurs. Elle est disponible sur tous les navigateurs depuis ⁨juillet 2015⁩.

La fonctionparseInt() analyse une chaîne de caractère fournie en argument et renvoie un entier exprimé dans une base donnée.

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)

Attention :On veillera à bien utiliser le second paramètre de la fonction pour éviter toute ambiguité sur la base numérique utilisée.

La valeur qu'on souhaite analyser et convertir. Si l'argumentstring n'est pas une chaîne de caractères, elle sera convertie en une chaîne (grâce à l'opération abstraiteToString) . Les blancs contenus au début de l'argument sont ignorés.

base

Un entier compris entre 2 et 36 qui représente labase utilisée pour la valeur représentée dans la chaîne. La base communément utilisée est la base décimale et on utilisera donc10 dans ce cas pour ce paramètre.

Attention :La base par défaut n'est pas 10. Ce paramètre doit toujours être utilisé, en effet s'il n'est pas spécifié, le comportement de la fonction n'est pas garanti et peut varier d'une plate-forme à une autre.

Voir cependant la description ci-après qui explicite le comportement par défaut attendu.

Valeur de retour

Un entier obtenu à partir de l'analyse de la chaîne de caractères. Si le premier caractère ne permet d'obtenir un nombre d'après la base fournie, ce seraNaN qui sera renvoyé.

Description

La fonctionparseInt() convertit le premier argument en une chaîne, l'analyse et renvoie un entier ouNaN. Si la valeur renvoyée n'est pasNaN, ce sera l'entier représentant le nombre contenu dans la chaîne dans la base donnée. Une base 10 est utilisée pour la base décimale, 8 pour la base octale, 16 pour la base hexadécimale. Pour les bases supérieures à10, les lettres de l'alphabet latin seront utilisées pour représenter les chiffres supérieurs à9. Par exemple, pour la base hexadécimale, on utilisera les lettresA àF.

Si, lors de l'analyse de la chaîne,parseInt() rencontre un caractère qui n'est pas un chiffre dans la base donnée, ce caractère, ainsi que les suivants seront ignorés.parseInt() tronque les nombres fournies en valeurs entières (attention donc lorsque les chaînes utilisent une notation scientifique : "4e2" donnera la valeur 4 en base 10 et pas 400). Les espaces en début et en fin de chaîne sont autorisés.

Si la base fournie vautundefined ou 0 (ou si elle n'est pas utilisée comme paramètre), le moteur JavaScript procèdera comme suit :

Si l'argumentstring commence avec "0x" ou "0X", la base considérée sera la base 16 (hexadécimale) et le reste de la chaîne sera analysé et converti.
Si l'argumentstring commence avec "0", la base considérée sera la base 8 (octale) ou la base 10 (décimale). La base exacte qui sera choisie dépendra de l'implémentation. ECMAScript 5 définit que la base 10 doit être utilisée. Cependant, cela n'est pas supporté par tous les navigateurs. C'est pour cette raison qu'il fauttoujours spécifier une base lorsqu'on utiliseparseInt().
Si l'argumentstring commence avec une autre valeur, la base considérée sera la base 10.

Si le premier caractère de la chaîne de caractères ne peut pas être converti,parseInt() renverraNaN.

Pour des raisons arithmétiques, la valeurNaN n'est un nombre pour aucune base. La fonctionisNaN() peut être utilisée pour déterminer si le résultat obtenu parparseInt() vautNaN. SiNaN est utilisé dans une opération arithmétique, le résultat de cette opération sera aussiNaN (on dit queNaN est une valeur « toxique »).

Pour convertir un nombre en une chaîne de caractères dans une base donnée, on utiliseramonEntier.toString(base).

parseInt convertira les valeursBigInt enNumber et de la précision sera perdue lors de ce traitement.

Exemples

Les exemples suivants renvoient tous15 :

parseInt("0xF", 16);parseInt("F", 16);parseInt("17", 8);parseInt(021, 8);parseInt("015", 10); // attention parseInt(015, 10); renvoie 13parseInt(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 renvoientNaN :

parseInt("Coucou", 8); // Ce sont des lettres et pas des chiffresparseInt("546", 2); // Ces chiffres ne sont pas valides pour une représentation// 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 tous4 :

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

L'exemple suivant renvoie224 :

parseInt("0e0", 16);

On perdra en précision si on manipule un grand entier (BigInt) :

parseInt(900719925474099267n); // 900719925474099300

Interpréter une base octale quand aucun paramètre de base n'est fourni

Bien que cela soit fortement déconseillé par ECMAScript 3 et que cela soit interdit par ECMAScript 5, de nombreuses implémentations interprètent une chaîne numérique qui commence par0 comme une valeur exprimée dans la base octale. Les instructions qui suivent peuvent avoir un résultat octal ou décimal selon les implémentations.Pour cette raison, il faut toujours définir une base lorsqu'on utilise cette fonction.

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

ECMAScript 5 supprime l'interprétation octale

La spécification ECMAScript 5 indique, au sujet de la fonctionparseInt(), que les valeurs commençant par0 ne doivent plus être considérées comme des valeurs octales. ECMAScript 5 indique :

La fonctionparseInt produit une valeur entière définie par le contenu de la chaîne selon la base fournie. Les blancs en début de chaîne sont ignorés. Si la base spécifiée est0, la base décimale sera prise en compte sauf si le nombre représenté commence par la paire de caractères0x ou0X auquel cas la base 16 sera prise en compte.

Sur cet aspect, ECMAScript 3 diffère car il permet l'interprétation octale (bien qu'il la déconseille).

De nombreuses implémentations n'ont pas adopté ce comportement en 2013. Pour cette raison (les anciens environnements et navigateurs doivent être supportés), il fauttoujours définir le paramètre 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")); // 421console.log(filterInt("-421")); // -421console.log(filterInt("+421")); // 421console.log(filterInt("Infinity")); // Infinityconsole.log(filterInt("421e+0")); // NaNconsole.log(filterInt("421hop")); // NaNconsole.log(filterInt("hop1.61803398875")); // NaNconsole.log(filterInt("1.61803398875")); // NaN