Propriétés et méthodes de l’objet global Number


Les propriétés de l’objet Number

L’objet Number gère les nombres. Le constructeur Number() possède une dizaine de propriétés et une dizaine de méthodes.
Lorsqu’on travaille avec les nombres en JavaScript nous préférerons, tout comme pour les chaînes de caractères, utiliser des valeurs primitives plutôt que de créer un nouvel objet avec le constructeur Number pour des raisons de performance.

Les propriétés à connaitre sont les suivantes :

• Les propriétés MIN_VALUE et MAX_VALUE représentent respectivement les plus petite valeur numérique positive et plus grand valeur numérique qu’il est possible de représenter en JavaScript
• Les propriétés MIN_SAFE_INTEGER et MAX_SAFE_INTEGER représentent respectivement le plus petit et le plus grand entiers représentables correctement ou de façon « sûre » en JavaScript. L’aspect « sûr » ici faire référence à la capacité du JavaScript à représenter exactement ces entiers et à les comparer entre eux. On peut représenter des entiers supérieurs à cette valeur avec le type BigInt
• Les propriétés NEGATIVE_INFINITY et POSITIVE_INFINITY servent respectivement à représenter l’infini côté négatif et côté positif
• La propriété NaN représente une valeur qui n’est pas un nombre (« NaN » est l’abréviation de « Not a Number ») et est équivalente à la valeur NaN.

    
    document.write("Valeur de Number.MIN_VALUE : " + Number.MIN_VALUE");
    document.write("Valeur de Number.MAX_VALUE : " + Number.MAX_VALUE);
    document.write("Valeur de Number.MIN_SAFE_INTEGER : " + Number.MIN_SAFE_INTEGER);
    document.write("Valeur de Number.MAX_SAFE_INTEGER : " + Number.MAX_SAFE_INTEGER);
    document.write("Valeur de Number.NEGATIVE_INFINITY : " + Number.NEGATIVE_INFINITY);
    document.write("Valeur de Number.POSITIVE_INFINITY : " + Number.POSITIVE_INFINITY);
    document.write("Valeur de Number.NaN : " + Number.NaN);
    document.write("Valeur de NaN : " + NaN);
    
    

Les méthodes de l’objet Number

Le constructeur Number() dispose également d’une dizaine de méthodes.

  1. La méthode isFinite() : permet de déterminer si une valeur fournie est un nombre fini. On va lui passer en argument la valeur à tester. Si l’argument passé est bien une valeur finie, isFinite() retournera le booléen true. Dans le cas contraire, cette méthode retournera la booléen false.
  2. La méthode isInteger() : permet de déterminer si une valeur fournie est un entier valide. Si la valeur testée est bien un entier, la méthode isInteger() retournera le booléen true. Dans le cas contraire, cette méthode retournera false. Notez que si la valeur testée est NaN ou l’infini, la méthode renverra également false.
  3. La méthode isNaN() : permet de déterminer si la valeur passée en argument est la valeur NaN (valeur qui appartient au type Number). On va lui passer en argument la valeur qui doit être comparée à NaN. Si la valeur passée est bien égale à NaN, notre méthode renverra le booléen true. Dans le cas contraire, le booléen false sera renvoyé.
  4. La méthode isSafeInteger() :permet de déterminer si une valeur est un entier sûr (un entier que le JavaScript peut représenter correctement). Cette méthode prend la valeur à tester en argument et retourne le booléen true si la valeur est bien un entier sûr ou false sinon.
  5. La méthode parseFloat() : permet de convertir une chaîne de caractères en un nombre décimal. Pour cela, on va lui passer la chaine à transformer en argument et la méthode renverra un nombre décimal en retour. L’analyse de la chaîne s’arrête dès qu’un caractère qui n’est pas +,-, un chiffre, un point ou un exposant est rencontré. Ce caractère et tous les suivants vont alors être ignorés. Si le premier caractère de la chaîne ne peut pas être converti en un nombre, parseFloat() renverra la valeur NaN.
  6. La méthode parseInt() : permet de convertir une chaine de caractères en un entier selon une base et va renvoyer ce nombre en base 10. On va lui passer deux arguments : la chaine de caractères à convertir et la base utilisée pour la conversion.
    Les autres types de bases qui peuvent nous intéresser sont :
    - 2 pour une base binaire
    - 8 pour une base octale
    - 16 pour une base hexadécimale
    Si la base n’est pas comprise entre 2 et 36, la méthode renverra NaN.
  7. La méthode toFixed() : permet de formater un nombre en indiquant le nombre de décimales (nombre de chiffres après la virgule) qu’on souhaite conserver. On va indiquer en argument de cette méthode le nombre de décimales souhaitées et notre méthode va renvoyer une chaine de caractères qui représente le nombre avec le nombre de décimales souhaitées.
    Dans le cas où on demande à toFixed() de renvoyer un nombre avec moins de décimales que le nombre de base, l’arrondi se fera à la décimale supérieure si la décimale suivant celle où le nombre doit être arrondi est 5 ou supérieure à 5.
  8. La méthode toString() : permet de transformer un nombre en une chaine de caractères. On va pouvoir lui passer une base en argument pour formater notre nombre. Elle renverra une chaine de caractères représentant notre nombre.
        let nb1 = 10;
        let nb2 = Number.POSITIVE_INFINITY;

        // isFinite()    
        if (isFinite(nb1)) {            
            document.write("isFinite(nb1) : " + isFinite(nb1));            
        }else{
            document.write("Le nombre est non fini");            
        }
        if (isFinite(nb2)) {            
            document.write("isFinite(nb2) : " + isFinite(nb2));            
        }else{
            document.write("Le nombre est non fini");            
        }
        
    let nb3 = 10;
    let nb4 = 10.5;    
       
    // isInteger()    
    if (Number.isInteger(nb3)) {            
        document.write("isInteger(nb3) : " + Number.isInteger(nb3));
    }else{
        document.write("Le nombre n'est pas un entier");            
    }
    if (Number.isInteger(nb4)) {            
        document.write("isInteger(nb4) : " + Number.isInteger(nb4));
    }else{
        document.write("Le nombre n'est pas un entier");            
    }    
    
    let nb5 = 10;
    let nb6 = NaN;    
       
    // isNaN()
    if (Number.isNaN(nb5)) {            
        document.write("isNaN(nb5) : " + Number.isNaN(nb5));
    }else{
        document.write("Le nombre n'est pas un NaN");            
    }
    if (Number.isNaN(nb6)) {            
        document.write("isNaN(nb6) : " + Number.isNaN(nb6));
    }else{
        document.write("Le nombre n'est pas un NaN");            
    }   

    
    let nb7 = 10;
    let nb8 = 1000000000000000000000000000000;
    let bigEntier = BigInt(1000000000000000000000000000000);       

    // isSafeInteger()
    if (Number.isSafeInteger(nb7)) {            
        document.write("isSafeInteger(nb7) : " + Number.isSafeInteger(nb7));
    }else{
        document.write("Le nombre nb7 n'est pas un entier sûr");            
    }
    if (Number.isSafeInteger(nb8)) {            
        document.write("isSafeInteger(nb8) : " + Number.isSafeInteger(nb8));
    }else{
        document.write("Le nombre nb8 n'est pas un entier sûr");            
    }
    if (Number.isSafeInteger(bigEntier)) {            
        document.write("isSafeInteger(bigEntier) : " + Number.isSafeInteger(bigEntier));
    }else{
        document.write("Le nombre bigEntier n'est pas un entier sûr");            
        document.write("Le nombre bigEntier est de type : " + typeof bigEntier);
    }
    
    let nb9 = "10 mètres";
    let nb10 = "10.5 mètres sur 15"; 
    let nb11 = "Encore 8";

    // parseFloat()
    document.write("parseFloat(nb9) : " + parseFloat(nb9));
    document.write("parseFloat(nb10) : " + parseFloat(nb10));
    document.write("parseFloat(nb11) : " + parseFloat(nb11));
    
    // parseInt()
    // 0*16 + 15*1 = 15 (0 1 2 3 4 5 6 7 8 9 A B C D E F)
    document.write("parseInt(nb9) : " + parseInt("0F", 16));  
    // 16*16*16-1 = 4095 
    document.write("parseInt(nb9) : " + parseInt("FFF", 16));  
    // 1*8 + 0*4 + 0*2 + 0*1 = 8   
    document.write("parseInt(nb9) : " + parseInt("1000", 2));   
    
    // toFixed()
    let nb12 = 10.123456789;
    document.write("nb12.toFixed(2) : " + nb12.toFixed(2));
    document.write("nb12.toFixed(5) : " + nb12.toFixed(5));
    document.write("nb12.toFixed(10) : " + nb12.toFixed(10));
    document.write("nb12.toFixed(15) : " + nb12.toFixed(15));       
    
    // toString()
    let nb13 = 10;
    // En base 10 par défaut
    document.write("nb13.toString() : " + nb13.toString());
    // En base 2 / binaire
    document.write("nb13.toString(2) : " + nb13.toString(2));
    // En base 16 / hexadécimal
    document.write("nb13.toString(6) : " + nb13.toString(16)); 
    // Affichage du type de la variable
    document.write(typeof nb13.toString(16));   
    

Plus d'infos sur MDN Web docs