Exam-Lib: Utiliser les Numéros en JavaScript | Exam-Lib
  1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

Utiliser les Numéros en JavaScript

abdelouafiNov 6, 2018

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      3,055
      Likes Received:
      14
      Trophy Points:
      38
      Joined
      Sep 13, 2016
      JavaScript n'a qu'un seul type de numéro. Les nombres peuvent être écrits avec ou sans décimales.

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Les nombres peuvent être écrits avec ou sans décimales: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 3,14;
      var y = 3;
      document.getElementById ("demo"). innerHTML = x + "<br>" + y;
      </ script>
      
      </ body>
      </ html>
      Des nombres très grands ou très petits peuvent être écrits avec une notation scientifique (exposant):

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Des nombres très grands ou très petits peuvent être écrits avec une notation scientifique (exposant): </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 123e5;
      var y = 123e-5;
      document.getElementById ("demo"). innerHTML = x + "<br>" + y;
      </ script>
      
      </ body>
      </ html>
      Les nombres JavaScript sont toujours en virgule flottante 64 bits
      Contrairement à beaucoup d'autres langages de programmation, JavaScript ne définit pas différents types de nombres, tels que des entiers, des nombres courts, des nombres longs, des nombres à virgule flottante, etc.

      Les nombres JavaScript sont toujours stockés sous forme de nombres à virgule flottante double précision, conformément à la norme internationale IEEE 754.

      Ce format stocke les nombres sur 64 bits, le nombre (la fraction) étant stocké sur les bits 0 à 51, l’exposant sur les bits 52 à 62 et le bit de connexion 63:
      upload_2018-11-6_10-50-43.png


      Précision
      Les entiers (nombres sans notation de points ou d'exposants) ont une précision allant jusqu'à 15 chiffres.

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Les entiers (nombres sans notation de points ou d'exposants) sont précis jusqu'à 15 chiffres: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 999999999999999;
      var y = 9999999999999999;
      document.getElementById ("demo"). innerHTML = x + "<br>" + y;
      </ script>
      
      </ body>
      </ html>
      Le nombre maximal de décimales est 17, mais l'arithmétique en virgule flottante n'est pas toujours précise à 100%:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> L'arithmétique en virgule flottante n'est pas toujours précise à 100%. </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 0,2 + 0,1;
      document.getElementById ("demo"). innerHTML = "0.2 + 0.1 =" + x;
      </ script>
      
      </ body>
      </ html>
      Pour résoudre le problème ci-dessus, il est utile de multiplier et diviser:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> L'arithmétique en virgule flottante n'est pas toujours précise à 100%: </ p>
      <p id = "demo1"> </ p>
      
      <p> Mais il est utile de multiplier et diviser: </ p>
      
      <p id = "demo2"> </ p>
      
      <script>
      var x = 0,2 + 0,1;
      document.getElementById ("demo1"). innerHTML = "0.2 + 0.1 =" + x;
      var y = (0,2 * 10 + 0,1 * 10) / 10;
      document.getElementById ("demo2"). innerHTML = "0.2 + 0.1 =" + y;
      </ script>
      
      </ body>
      </ html>
      Ajouter des chiffres et des chaînes

      Si vous ajoutez deux nombres, le résultat sera un nombre:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Si vous ajoutez deux nombres, le résultat sera un nombre: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 10;
      var y = 20;
      var z = x + y;
      document.getElementById ("demo"). innerHTML = z;
      </ script>
      
      </ body>
      </ html>
      Si vous ajoutez deux chaînes, le résultat sera une concaténation de chaîne:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Si vous ajoutez deux chaînes numériques, le résultat sera une chaîne concaténée: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = "10";
      var y = "20";
      var z = x + y;
      document.getElementById ("demo"). innerHTML = z;
      </ script>
      
      </ body>
      </ html>
      Si vous ajoutez un nombre et une chaîne, le résultat sera une concaténation de chaîne:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Si vous ajoutez un nombre et une chaîne numérique, le résultat sera une chaîne concaténée: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 10;
      var y = "20";
      var z = x + y;
      document.getElementById ("demo"). innerHTML = z;
      </ script>
      
      </ body>
      </ html>
      Si vous ajoutez une chaîne et un nombre, le résultat sera une concaténation de chaîne:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Si vous ajoutez une chaîne numérique et un nombre, le résultat sera une chaîne concaténée: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = "10";
      var y = 20;
      document.getElementById ("demo"). innerHTML =
      "Le résultat est:" + x + y;
      </ script>
      
      </ body>
      </ html>
      Une erreur courante est de s’attendre à ce que le résultat soit 30:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Une erreur courante est de s’attendre à ce que le résultat soit 30: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 10;
      var y = 20;
      document.getElementById ("demo"). innerHTML =
      "Le résultat est:" + x + y;
      </ script>
      
      </ body>
      </ html>
      Une erreur courante est de s’attendre à ce que le résultat soit 102030:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Une erreur courante est de s’attendre à ce que le résultat soit 102030: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 10;
      var y = 20;
      var z = "30";
      var résultat = x + y + z;
      document.getElementById ("demo"). innerHTML = result;
      </ script>
      
      </ body>
      </ html>
      Remarque:
      Le compilateur JavaScript fonctionne de gauche à droite.

      Les premiers 10 + 20 sont ajoutés car x et y sont tous deux des nombres.

      Ensuite, 30 + "30" est concaténé car z est une chaîne.


      Les chaînes Numériques
      Les chaînes JavaScript peuvent avoir un contenu numérique:
      Code:
      var x = 100; // x est un nombre
      
      var y = "100"; // y est une chaîne
      JavaScript va essayer de convertir les chaînes en nombres dans toutes les opérations numériques:

      Cela fonctionnera:
      Code:
      var x = "100";
      var y = "10";
      var z = x / y;       // z will be 10
      Cela fonctionnera également:
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> JavaScript tentera de convertir les chaînes en nombres lors de la multiplication: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = "100";
      var y = "10";
      var z = x * y;
      document.getElementById ("demo"). innerHTML = z;
      </ script>
      
      </ body>
      </ html>
      Et cela fonctionnera:
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> JavaScript tentera de convertir les chaînes en nombres lors de la soustraction: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = "100";
      var y = "10";
      var z = x - y;
      document.getElementById ("demo"). innerHTML = z;
      </ script>
      
      </ body>
      </ html>
      Mais cela ne fonctionnera pas:
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> JavaScript ne convertira PAS les chaînes en nombres lors de l'ajout: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = "100";
      var y = "10";
      var z = x + y;
      document.getElementById ("demo"). innerHTML = z;
      </ script>
      
      </ body>
      </ html>
      Remarque: Dans le dernier exemple, JavaScript utilise l'opérateur + pour concaténer les chaînes.

      NaN - Pas un nombre
      NaN est un mot réservé de JavaScript indiquant qu'un numéro n'est pas un nombre légal.

      Essayer de faire de l'arithmétique avec une chaîne non numérique donnera NaN (pas un nombre):
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Un nombre divisé par une chaîne non numérique devient NaN (pas un nombre): </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      document.getElementById ("demo"). innerHTML = 100 / "Apple";
      </ script>
      
      </ body>
      </ html>
      Cependant, si la chaîne contient une valeur numérique, le résultat sera un nombre:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Un nombre divisé par une chaîne numérique devient un nombre: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      document.getElementById ("demo"). innerHTML = 100 / "10";
      </ script>
      
      </ body>
      </ html>
      Vous pouvez utiliser la fonction JavaScript globale isNaN () pour savoir si une valeur est un nombre:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Vous pouvez utiliser la fonction JavaScript globale isNaN () pour savoir si une valeur est un nombre: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 100 / "Apple";
      document.getElementById ("demo"). innerHTML = isNaN (x);
      </ script>
      
      </ body>
      </ html>
      Attention à NaN. Si vous utilisez NaN dans une opération mathématique, le résultat sera également NaN:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Si vous utilisez NaN dans une opération mathématique, le résultat sera également NaN: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = NaN;
      var y = 5;
      document.getElementById ("demo"). innerHTML = x + y;
      </ script>
      
      </ body>
      </ html>
      Ou le résultat pourrait être une concaténation:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Si vous utilisez NaN dans une opération mathématique, le résultat peut être une concaténation: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = NaN;
      var y = "5";
      document.getElementById ("demo"). innerHTML = x + y;
      </ script>
      
      </ body>
      </ html>
      NaN est un nombre: typeof NaN renvoie le nombre:

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Le type de NaN est le numéro: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = NaN;
      document.getElementById ("demo"). innerHTML = typeof x;
      </ script>
      
      </ body>
      </ html>
      Infini
      Infinity (ou -Infinity) est la valeur que JavaScript retournera si vous calculez un nombre hors du plus grand nombre possible.

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> L'infini est renvoyé si vous calculez un nombre hors du plus grand nombre possible: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var myNumber = 2;
      var txt = "";
      while (myNumber! = Infinity) {
          myNumber = myNumber * myNumber;
          txt = txt + myNumber + "<br>";
      }
      document.getElementById ("demo"). innerHTML = txt;
      </ script>
      
      </ body>
      </ html>
      La division par 0 (zéro) génère également l'infini:

      Exemple
      Code:
      var x = 2/0; // x sera l'infini
      var y = -2 / 0; // y sera - l'infini
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> La division par zéro génère l'infini; </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 2/0;
      var y = -2/0;
      document.getElementById ("demo"). innerHTML = x + "<br>" + y;
      </ script>
      
      </ body>
      </ html>
      Infinity est un nombre: typeof Infinity renvoie un nombre.

      Exemple
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Numbers</h2>
      
      <p>Infinity is a number:</p>
      
      <p id="demo"></p>
      
      <script>
      var x = Infinity;
      document.getElementById("demo").innerHTML = typeof x;
      </script>
      
      </body>
      </html>

      Hexadécimal
      JavaScript interprète les constantes numériques en hexadécimales si elles sont précédées de 0x.

      Exemple
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Les constantes numériques, précédées de 0x, sont interprétées comme étant hexadécimales: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 0xFF;
      document.getElementById ("demo"). innerHTML = "0xFF =" + x;
      </ script>
      
      </ body>
      </ html>
      Remarque:
      N'écrivez jamais un nombre avec un zéro (comme 07).
      Certaines versions de JavaScript interprètent les nombres comme des octaux s’ils sont écrits avec un zéro non significatif.

      Par défaut, JavaScript affiche les nombres sous forme de décimales de base 10.

      Mais vous pouvez utiliser la méthode toString () pour générer des nombres de la base 2 à la base 36.

      Hexadécimal est la base 16. Décimal est la base 10. Octal est la base 8. Binary est la base 2.

      Exemple:
      Code:
      var myNumber = 32;
      myNumber.toString(10);  // returns 32
      myNumber.toString(32);  // returns 10
      myNumber.toString(16);  // returns 20
      myNumber.toString(8);   // returns 40
      myNumber.toString(2);   // returns 100000

      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Numbers</h2>
      
      <p>The toString() method can output numbers from base 2 to 36:</p>
      
      <p id="demo"></p>
      
      <script>
      var myNumber = 32;
      document.getElementById("demo").innerHTML =
      "32 = " + "<br>" +
      " Decimal " + myNumber.toString(10) + "<br>" +
      " Hexadecimal " + myNumber.toString(16) + "<br>" +
      " Octal " + myNumber.toString(8) + "<br>" +
      " Binary " + myNumber.toString(2);
      </script>
      
      </body>
      </html>
      

      Les nombres peuvent être des objets
      Normalement, les nombres JavaScript sont des valeurs primitives créées à partir de littéraux:

      var x = 123;

      Mais les nombres peuvent aussi être définis comme des objets avec le mot-clé new:
      Code:
      var y = new Number(123);
      
      
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Numéros JavaScript </ h2>
      
      <p> Un nombre peut être un objet, mais il n'est pas nécessaire de créer un nombre en tant qu'objet. </ p>
      
      <p id = "demo"> </ p>
      <script>
      var x = 123;
      var y = new Number(123);
      document.getElementById("demo").innerHTML = typeof x + "<br>" + typeof y;
      </script>
      
      </body>
      </html>
      
      Remarque:
      Ne créez pas d'objets Number. Cela ralentit la vitesse d'exécution.
      Le nouveau mot-clé complique le code. Cela peut produire des résultats inattendus:

      Lors de l'utilisation de l'opérateur ==, des nombres égaux sont égaux:

      Exemple
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Numbers</h2>
      
      <p>Never create numbers as objects.</p>
      <p>Numbers and objects cannot be safely compared.</p>
      
      <p id="demo"></p>
      
      <script>
      var x = 500;              // x is a number
      var y = new Number(500);  // y is an object
      document.getElementById("demo").innerHTML = (x==y);
      </script>
      
      </body>
      </html>
      

      Lors de l'utilisation de l'opérateur ===, des nombres égaux ne sont pas égaux, car l'opérateur === s'attend à une égalité de type et de valeur.

      Exemple
      Code:
      var x = 500;             
      var y = new Number(500);
      
      // (x === y) is false because x and y have different types
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Numbers</h2>
      
      <p>Never create numbers as objects.</p>
      <p>Numbers and objects cannot be safely compared.</p>
      
      <p id="demo"></p>
      
      <script>
      var x = 500;              // x is a number
      var y = new Number(500);  // y is an object
      document.getElementById("demo").innerHTML = (x===y);
      </script>
      
      </body>
      </html>
      
      Ou même pire. Les objets ne peuvent pas être comparés:

      Exemple
      Code:
      var x = new Number(500);             
      var y = new Number(500);
      
      // (x == y) is false because objects cannot be compared
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Numbers</h2>
      
      <p>Never create numbers as objects.</p>
      <p>JavaScript objects cannot be compared.</p>
      
      <p id="demo"></p>
      
      <script>
      var x = new Number(500);  // x is an object
      var y = new Number(500);  // y is an object
      document.getElementById("demo").innerHTML = (x==y);
      </script>
      
      </body>
      </html>
      
      Remarque:
      Note the difference between (x==y) and (x===y).
      Comparing two JavaScript objects will always return false.
       
      Latest Threads
      Related Threads
      Loading...

      Merci de partager ce post sur facebook

    2. Merci d'aimer notre facebook page

Share This Page