mozilla
Vos résultats de recherche

    parseInt()

    Résumé

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

    Syntaxe

    parseInt(string, base);

    Paramètres

    string
    La valeur qu'on souhaite analyser et convertir. Si string n'est pas une chaîne de caractères, elle sera convertie en une chaîne. Les blancs en début de chaîne sont ignorés.
    base
    Un entier compris entre 2 et 36 qui représente la base 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 donc 10 dans ce cas pour ce paramètre. 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.

    Description

    La fonction parseInt() convertit le premier argument en une chaîne, l'analyse et renvoie un entier ou NaN. Si la valeur renvoyée n'est pas NaN, 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 seront utilisées pour représenter les chiffres supérieurs à 9. Par exemple, pour la base hexadécimale, on utilisera les lettres A à 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. Les espaces en début et en fin de chaîne sont autorisés.

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

    • Si l'argument string 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'argument string 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 faut toujours spécifier une base lorsqu'on utilise parseInt().
    • Si l'argument string 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() renverra NaN.

    Pour des raisons arithmétiques, la valeur NaN n'est un nombre pour aucune base. La fonction isNaN() peut être utilisée pour déterminer si le résultat obtenu par parseInt() vaut NaN. Si NaN est utilisé dans une opération arithmétique, le résultat de cette opération sera aussi NaN (on dit que NaN est une valeur « toxique »).

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

    Exemples

    Utiliser parseInt()

    The following examples all return 15:

    parseInt(" 0xF", 16);
    parseInt(" F", 16);
    parseInt("17", 8);
    parseInt(021, 8);
    parseInt("015", 10);
    parseInt(15.99, 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 représentation
                           // binaire
    

    Les exemples suivant 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);
    

    L'exemple suivant renvoie  224 :

    parseInt("0e0", 16);
    

    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 par 0 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"); // 0
    parseInt("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 fonction parseInt(), que les valeurs commençant par 0 ne doivent plus être considérées comme des valeurs octales. ECMAScript 5 indique :

    La fonction parseInt 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 est 0, la base décimale sera prise en compte sauf si le nombre représenté commence par la paire de caractères 0x ou 0X auquel cas la base 16 sera prise en compte. Si la base spécifiée vaut 16, le nombre fourni peut éventuellement débuter avec les paires 0x ou 0X.

    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 faut toujours 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(/^(\-|\+)?([0-9]+|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
    

    Spécifications

    Spécification Statut Commentaires
    Première édition d'ECMAScript. Standard Définition initiale.
    ECMAScript 5.1 (ECMA-262)
    La définition de 'parseInt' dans cette spécification.
    Standard  
    ECMAScript 6 (ECMA-262)
    La définition de 'parseInt' dans cette spécification.
    Draft  

    Compatibilité des navigateurs

    Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Support simple (Oui) (Oui) (Oui) (Oui) (Oui)
    Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Support simple (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)

    Voir aussi

    Étiquettes et contributeurs liés au document

    Étiquettes : 
    Contributors to this page: Jeremie, teoli, BenoitL, Mgjbot, SphinxKnight, darul75, ClementBourgoin
    Dernière mise à jour par : SphinxKnight,
    Masquer la barre latérale