Exam-Lib: Conversion de type 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

Conversion de type JavaScript

abdelouafiNov 7, 2018

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      3,055
      Likes Received:
      14
      Trophy Points:
      38
      Joined
      Sep 13, 2016
      Number () converti en nombre, String () converti en chaîne, Boolean () converti en Boolean.


      Types de données JavaScript
      En JavaScript, 5 types de données différents peuvent contenir des valeurs:
      • string
      • number
      • boolean
      • object
      • function
      Il y a 3 types d'objets:

      • Objet
      • Date3
      • Tableau

      Et 2 types de données qui ne peuvent pas contenir de valeurs:

      • nul
      • indéfini
      L'opérateur "typeof"
      Vous pouvez utiliser l'opérateur typeof pour rechercher le type de données d'une variable JavaScript.

      Exemple
      Code:
      typeof "John"                 // Returns "string"
      typeof 3.14                   // Returns "number"
      typeof NaN                    // Returns "number"
      typeof false                  // Returns "boolean"
      typeof [1,2,3,4]              // Returns "object"
      typeof {name:'John', age:34}  // Returns "object"
      typeof new Date()             // Returns "object"
      typeof function () {}         // Returns "function"
      typeof myCar                  // Returns "undefined" *
      typeof null                   // Returns "object"

      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>The JavaScript typeof Operator</h2>
      
      <p>The typeof operator returns the type of a variable, object, function or expression.</p>
      
      <p id="demo"></p>
      
      <script>
      document.getElementById("demo").innerHTML =
          typeof "john" + "<br>" +
          typeof 3.14 + "<br>" +
          typeof NaN + "<br>" +
          typeof false + "<br>" +
          typeof [1,2,3,4] + "<br>" +
          typeof {name:'john', age:34} + "<br>" +
          typeof new Date() + "<br>" +
          typeof function () {} + "<br>" +
          typeof myCar + "<br>" +
          typeof null;
      </script>
      
      </body>
      </html>
      
      
      

      S'il vous plaît observer:

      • Le type de données de NaN est le nombre
      • Le type de données d'un tableau est object
      • Le type de données d'une date est object
      • Le type de données de null est object
      • Le type de données d'une variable non définie est non défini *
      • Le type de données d'une variable à laquelle aucune valeur n'a été affectée est également indéfini *
      Remarque: Vous ne pouvez pas utiliser typeof pour déterminer si un objet JavaScript est un tableau (ou une date).


      Le type de données de typeof
      L'opérateur typeof n'est pas une variable. C'est un opérateur. Les opérateurs (+ - * /) n'ont aucun type de données.

      Mais l'opérateur typeof retourne toujours une chaîne (contenant le type de l'opérande).

      La propriété constructeur
      La propriété constructeur renvoie la fonction constructeur pour toutes les variables JavaScript.

      Exemple
      Code:
      "John".constructor                // Returns function String()  {[native code]}
      (3.14).constructor                // Returns function Number()  {[native code]}
      false.constructor                 // Returns function Boolean() {[native code]}
      [1,2,3,4].constructor             // Returns function Array()   {[native code]}
      {name:'John',age:34}.constructor  // Returns function Object()  {[native code]}
      new Date().constructor            // Returns function Date()    {[native code]}
      function () {}.constructor        // Returns function Function(){[native code]}

      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>The JavaScript constructor Property</h2>
      
      <p>The constructor property returns the constructor function for a variable or an
      object.</p>
      
      <p id="demo"></p>
      
      <script>
      document.getElementById("demo").innerHTML =
          "john".constructor + "<br>" +
          (3.14).constructor + "<br>" +
          false.constructor + "<br>" +
          [1,2,3,4].constructor + "<br>" +
          {name:'john', age:34}.constructor + "<br>" +
          new Date().constructor + "<br>" +
          function () {}.constructor;
      </script>
      
      </body>
      </html>
      
      
      

      Vous pouvez vérifier la propriété constructeur pour savoir si un objet est un tableau (contient le mot "tableau"):

      Exemple
      Code:
      function isArray(myArray) {
          return myArray.constructor.toString().indexOf("Array") > -1;
      }
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Arrays</h2>
      
      <p>This "home made" isArray() function returns true when used on an array:</p>
      
      <p id="demo"></p>
      
      <script>
      var fruits = ["Banana", "Orange", "Apple", "Mango"];
      document.getElementById("demo").innerHTML = isArray(fruits);
      
      function isArray(myArray) {
          return myArray.constructor.toString().indexOf("Array") > -1;
      }
      </script>
      
      </body>
      </html>
      

      Ou encore plus simple, vous pouvez vérifier si l’objet est une fonction Array:

      Exemple
      Code:
      function isArray(myArray) {
          return myArray.constructor === Array;
      }
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Array Object</h2>
      <p>This "home made" isArray() function returns true when used on an array:</p>
      
      <p id="demo"></p>
      
      <script>
      var fruits = ["Banana", "Orange", "Apple", "Mango"];
      document.getElementById("demo").innerHTML = isArray(fruits);
      
      function isArray(myArray) {
          return myArray.constructor === Array;
      }
      </script>
      
      </body>
      </html>
      
      Vous pouvez vérifier la propriété constructeur pour savoir si un objet est une date (contient le mot "date"):

      Exemple
      Code:
      function isDate(myDate) {
          return myDate.constructor.toString().indexOf("Date") > -1;
      }

      Ou encore plus simple, vous pouvez vérifier si l’objet est une fonction Date:

      Exemple
      Code:
      function isDate(myDate) {
          return myDate.constructor === Date;
      }
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Date Object</h2>
      <p>This "home made" isDate() function returns true when used on an date:</p>
      
      <p id="demo"></p>
      
      <script>
      var myDate = new Date();
      document.getElementById("demo").innerHTML = isDate(myDate);
      
      function isDate(myDate) {
          return myDate.constructor === Date;
      }
      </script>
      
      </body>
      </html>
      

      Conversion de type JavaScript
      Les variables JavaScript peuvent être converties en une nouvelle variable et un autre type de données:

      • En utilisant une fonction JavaScript
      • Automatiquement par JavaScript lui-même

      Conversion de nombres en chaînes
      La méthode globale String () peut convertir des nombres en chaînes.

      Il peut être utilisé sur tout type de nombres, littéraux, variables ou expressions:

      Exemple
      Code:
      String(x)         // returns a string from a number variable x
      String(123)       // returns a string from a number literal 123
      String(100 + 23)  // returns a string from a number from an expression
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>The JavaScript String() Method</h2>
      
      <p>The String() method can convert a number to a string.</p>
      
      <p id="demo"></p>
      
      <script>
      var x = 123;
      document.getElementById("demo").innerHTML =
        String(x) + "<br>" +
        String(123) + "<br>" +
        String(100 + 23);
      </script>
      </body>
      </html>
      
      La méthode Number toString () fait la même chose.

      Exemple
      Code:
      x.toString()
      (123).toString()
      (100 + 23).toString()
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Number Methods</h2>
      
      <p>The toString() method converts a number to a string.</p>
      
      <p id="demo"></p>
      
      <script>
      var x = 123;
      document.getElementById("demo").innerHTML =
          x.toString() + "<br>" +
         (123).toString() + "<br>" +
         (100 + 23).toString();
      </script>
      
      </body>
      </html>
      

      Quelques méthodes qui peuvent être utilisées pour convertir des nombres en chaînes:
      • toExponential () Retourne une chaîne, avec un nombre arrondi et écrit en utilisant une notation exponentielle.
      • toFixed () Retourne une chaîne, avec un nombre arrondi et écrit avec un nombre spécifié de décimales.
      • toPrecision () Retourne une chaîne, avec un nombre écrit avec une longueur spécifiée

      Conversion de booléens en chaînes
      La méthode globale String () peut convertir des booléens en chaînes.

      Code:
      String(false)        // returns "false"
      String(true)         // returns "true"

      La méthode booléenne toString () fait la même chose.
      Code:
      false.toString()     // returns "false"
      true.toString()      // returns "true"

      Conversion de dates en chaînes
      La méthode globale String () peut convertir des dates en chaînes.
      Code:
      String(Date())      // returns "Thu Jul 17 2014 15:38:19 GMT+0200 (W. Europe Daylight Time)"
      

      La méthode Date toString () fait la même chose.

      Exemple
      Code:
      Date().toString()   // returns "Thu Jul 17 2014 15:38:19 GMT+0200 (W. Europe Daylight Time)"
      

      Quelques méthodes qui peuvent être utilisées pour convertir les dates en chaînes:

      • getDate () Récupère le jour sous forme de nombre (1-31)
      • getDay () Obtient un numéro (0-6) pour le jour de la semaine
      • getFullYear () Obtenir l'année à quatre chiffres (aaaa)
      • getHours () Obtenez l'heure (0-23)
      • getMilliseconds () Récupère les millisecondes (0 à 999)
      • getMinutes () Obtenir les minutes (0-59)
      • getMonth () Récupère le mois (0-11)
      • getSeconds () Récupère les secondes (0-59)
      • getTime () Récupère le temps (millisecondes depuis le 1er janvier 1970)

      Conversion de chaînes en nombres
      La méthode globale Number () peut convertir des chaînes en nombres.

      Les chaînes contenant des nombres (comme "3.14") sont converties en nombres (comme 3.14).

      Les chaînes vides sont converties en 0.

      Tout le reste est converti en NaN (pas un nombre).
      Code:
      Number("3.14")    // returns 3.14
      Number(" ")       // returns 0
      Number("")        // returns 0
      Number("99 88")   // returns NaN


      Certaines méthodes peuvent être utilisées pour convertir des chaînes en nombres:

      • parseFloat () Analyse une chaîne et retourne un nombre à virgule flottante
      • parseInt () Analyse une chaîne et retourne un entier

      L'opérateur unaire +
      L'opérateur unaire + peut être utilisé pour convertir une variable en nombre:

      Exemple
      Code:
      var y = "5";      // y is a string
      var x = + y;      // x is a number
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>The JavaScript typeof Operator</h2>
      
      <p>The typeof operator returns the type of a variable or expression.</p>
      
      <button onclick="myFunction()">Try it</button>
      
      <p id="demo"></p>
      
      <script>
      function myFunction() {
          var y = "5";
          var x = + y;
          document.getElementById("demo").innerHTML =
          typeof y + "<br>" + typeof x;
      }
      </script>
      
      </body>
      </html>
      
      
      

      Si la variable ne peut pas être convertie, elle deviendra quand même un nombre mais avec la valeur NaN (Pas un nombre):

      Exemple
      Code:
      var y = "John";   // y is a string
      var x = + y;      // x is a number (NaN)
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>The JavaScript typeof Operator</h2>
      
      <p>The typeof operator returns the type of a variable or expression.</p>
      
      <button onclick="myFunction()">Try it</button>
      
      <p id="demo"></p>
      
      <script>
      function myFunction() {
          var y = "John";
          var x = + y;
          document.getElementById("demo").innerHTML =
          typeof x + "<br>" + x;
      }
      </script>
      
      </body>
      </html>
      
      
      


      Conversion de booléens en nombres
      La méthode globale Number () peut également convertir des booléens en nombres.
      Code:
      Number(false)     // returns 0
      Number(true)      // returns 1

      Conversion de dates en nombres
      La méthode globale Number () peut être utilisée pour convertir des dates en nombres.
      Code:
      d = new Date();
      Number(d)          // returns 1404568027739
      La méthode de date getTime () fait la même chose.

      Code:
      d = new Date();
      d.getTime()        // returns 1404568027739


      Conversion de type automatique
      Lorsque JavaScript tente d'opérer sur un type de données "incorrect", il tente de convertir la valeur en un type "correct".

      Le résultat n'est pas toujours ce que vous attendez:
      Code:
      5 + null    // returns 5         because null is converted to 0
      "5" + null  // returns "5null"   because null is converted to "null"
      "5" + 2     // returns "52"      because 2 is converted to "2"
      "5" - 2     // returns 3         because "5" is converted to 5
      "5" * "2"   // returns 10        because "5" and "2" are converted to 5 and 2
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <p id="demo"></p>
      
      <script>
      var x = [];
      document.getElementById("demo").innerHTML =
      (5 + null) + "<br>"  +
      ("5" + null) + "<br>" +
      ("5" + 2) + "<br>" +
      ("5" - 2) + "<br>" +
      ("5" * "2") + "<br>" +
      ("5" / "2") + "<br>"
      </script>
      
      </body>
      </html>
      
      
      


      Conversion automatique de chaîne
      JavaScript appelle automatiquement la fonction toString () de la variable lorsque vous essayez de "générer" un objet ou une variable:
      Code:
      document.getElementById("demo").innerHTML = myVar;
      
      // if myVar = {name:"Fjohn"}  // toString converts to "[object Object]"
      // if myVar = [1,2,3,4]       // toString converts to "1,2,3,4"
      // if myVar = new Date()      // toString converts to "Fri Jul 18 2014 09:08:55 GMT+0200"

      Les nombres et les booléens sont également convertis, mais ce n'est pas très visible:

      Code:
      // if myVar = 123             // toString converts to "123"
      // if myVar = true            // toString converts to "true"
      // if myVar = false           // toString converts to "false"

      Table de conversion de type JavaScript
      Ce tableau montre le résultat de la conversion de différentes valeurs JavaScript en nombres, chaînes et booléens:
      upload_2018-11-7_19-32-6.png

      Les valeurs entre guillemets indiquent les valeurs de chaîne.

      Les valeurs en rouge indiquent des valeurs (certains) que les programmeurs peuvent ne pas attendre.
       
      Latest Threads
      Related Threads
      Loading...

      Merci de partager ce post sur facebook

    2. Merci d'aimer notre facebook page

Share This Page