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

Types de données JavaScript

abdelouafiNov 2, 2018

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      984
      Likes Received:
      14
      Trophy Points:
      38
      Joined
      Sep 13, 2016
      Types de données JavaScript
      Les variables JavaScript peuvent contenir de nombreux types de données: nombres, chaînes, objets, etc.:
      Code:
      var length = 16;                               // Number
      var lastName = "Johnson";                      // String
      var x = {firstName:"John", lastName:"Doe"};    // Object
      Le concept de types de données
      En programmation, les types de données sont un concept important.

      Pour pouvoir utiliser des variables, il est important de connaître le type.

      Sans types de données, un ordinateur ne peut résoudre ce problème en toute sécurité:
      Code:
      var x = 16 + "Volvo";
      Est-il judicieux d'ajouter "Volvo" à seize ans? Cela produira-t-il une erreur ou produira-t-il un résultat?

      JavaScript traitera l'exemple ci-dessus comme:
      Code:
      var x = "16" + "Volvo";
      Remarque: Lors de l'ajout d'un nombre et d'une chaîne, JavaScript traitera le nombre comme une chaîne.

      Exemple:
      Code:
      var x = 16 + "Volvo";
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> JavaScript </ h2>
      
      <p> Lors de l'ajout d'un nombre et d'une chaîne, JavaScript traitera le nombre comme une chaîne. </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 16 + "Volvo";
      document.getElementById ("demo"). innerHTML = x;
      </ script>
      
      </ body>
      </ html>
      Exemple 2:
      Code:
      var x = "Volvo" + 16;

      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> JavaScript </ h2>
      
      <p> Lors de l'ajout d'une chaîne et d'un nombre, JavaScript traitera ce nombre comme une chaîne. </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = "Volvo" + 16;
      document.getElementById ("demo"). innerHTML = x;
      </ script>
      
      </ body>
      </ html>
      JavaScript évalue les expressions de gauche à droite. Différentes séquences peuvent produire différents résultats:

      JavaScript:
      Code:
      var x = 16 + 4 + "Volvo";
      Résultat:
      Code:
      20Volvo
      
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> JavaScript </ h2>
      
      <p> JavaScript évalue les expressions de gauche à droite. Différentes séquences peuvent produire différents résultats: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 16 + 4 + "Volvo";
      document.getElementById ("demo"). innerHTML = x;
      </ script>
      
      </ body>
      </ html>
      JavaScript:

      Code:
      var x = "Volvo" + 16 + 4;
      Résultat:
      Code:
      Volvo164
      Dans le premier exemple, JavaScript traite 16 et 4 comme des nombres, jusqu'à atteindre "Volvo".

      Dans le deuxième exemple, le premier opérande étant une chaîne, tous les opérandes sont traités comme des chaînes.

      Les types JavaScript sont dynamiques
      JavaScript a des types dynamiques. Cela signifie que la même variable peut être utilisée pour contenir différents types de données:

      Exemple
      Code:
      var x; // Maintenant x est indéfini
      x = 5; // maintenant x est un nombre
      x = "John"; // Maintenant, x est une chaîne
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Types de données JavaScript </ h2>
      
      <p> JavaScript a des types dynamiques. Cela signifie que la même variable peut être utilisée pour contenir différents types de données: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x; // Maintenant x est indéfini
      x = 5; // maintenant x est un nombre
      x = "John"; // Maintenant, x est une chaîne
      
      document.getElementById ("demo"). innerHTML = x;
      </ script>
      
      </ body>
      </ html>
      Chaînes JavaScript
      Une chaîne (ou une chaîne de texte) est une série de caractères comme "John Doe".

      Les chaînes sont écrites avec des guillemets. Vous pouvez utiliser des guillemets simples ou doubles:
      Exemple
      Code:
      var carName = "Volvo XC60"; // Utiliser des guillemets doubles
      var carName = 'Volvo XC60'; // Utiliser des guillemets simples
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Chaînes JavaScript </ h2>
      
      <p> Les chaînes sont écrites avec des guillemets. Vous pouvez utiliser des guillemets simples ou doubles: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var carName1 = "Volvo XC60";
      var carName2 = 'Volvo XC60';
      
      document.getElementById ("demo"). innerHTML =
      carName1 + "<br>" +
      carName2;
      </ script>
      
      </ body>
      </ html>
      Vous pouvez utiliser des guillemets dans une chaîne, à condition qu'ils ne correspondent pas à ceux entourant la chaîne:

      Exemple
      Code:
      var answer = "ça va"; // guillemet simple entre guillemets doubles
      var answer = "Il s'appelle 'Johnny'"; // guillemets simples entre guillemets doubles
      var answer = 'Il s'appelle "Johnny"'; // Double guillemets dans des guillemets simples
      Vous en apprendrez plus sur les chaînes plus loin dans ce tutoriel.

      Numéros de JavaScript
      JavaScript n'a qu'un seul type de nombres.

      Les nombres peuvent être écrits avec ou sans décimales:

      Exemple
      Code:
      var x1 = 34,00; // écrit avec des décimales
      var x2 = 34; // écrit sans décimales
      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 x1 = 34,00;
      var x2 = 34;
      var x3 = 3,14;
      
      document.getElementById ("demo"). innerHTML =
      x1 + "<br>" + x2 + "<br>" + x3;
      </ script>
      
      </ body>
      </ html>
      Des nombres très grands ou très petits peuvent être écrits avec une notation scientifique (exponentielle):

      Exemple
      Code:
      var y = 123e5;      // 12300000
      var z = 123e-5;     // 0.00123
      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 (exponentielle): </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var y = 123e5;
      var z = 123e-5;
      
      document.getElementById ("demo"). innerHTML =
      y + "<br>" + z;
      </ script>
      
      </ body>
      </ html>
      Vous en apprendrez plus sur les chiffres plus loin dans ce tutoriel.

      Booléens JavaScript
      Les booléens ne peuvent avoir que deux valeurs: true ou false.

      Exemple:
      Code:
      var x = 5;
      var y = 5;
      var z = 6;
      (x == y)       // Returns true
      (x == z)       // Returns false
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Booléens JavaScript </ h2>
      
      <p> Les booléens peuvent avoir deux valeurs: true ou false: </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var x = 5;
      var y = 5;
      var z = 6;
      document.getElementById ("demo"). innerHTML =
      (x == y) + "<br>" + (x == z);
      </ script>
      
      </ body>
      </ html>
      Les booléens sont souvent utilisés dans les tests conditionnels.

      Vous en apprendrez plus sur les tests conditionnels plus loin dans ce tutoriel.

      Tableaux JavaScript
      Les tableaux JavaScript sont écrits entre crochets.

      Les éléments de tableau sont séparés par des virgules.

      Le code suivant déclare (crée) un tableau appelé cars, contenant trois éléments (noms de voitures):

      Exemple
      Code:
      var cars = ["Saab", "Volvo", "BMW"];
      
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Tableaux JavaScript </ h2>
      
      <p> Les index de tableau sont basés sur zéro, ce qui signifie que le premier élément est [0]. </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var cars = ["Saab", "Volvo", "BMW"];
      
      document.getElementById ("demo"). innerHTML = cars [0];
      </ script>
      
      </ body>
      </ html>
      Les index de tableau sont basés sur zéro, ce qui signifie que le premier élément est [0], le second est [1], etc.

      Vous en apprendrez plus sur les tableaux plus loin dans ce tutoriel.

      Objets JavaScript
      Les objets JavaScript sont écrits avec des accolades.

      Les propriétés d'objet sont écrites sous la forme nom: paires de valeurs, séparées par des virgules.

      Exemple
      Code:
      var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
      
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript Objects</h2>
      
      <p id="demo"></p>
      
      <script>
      var person = {
          firstName : "John",
          lastName  : "Doe",
          age       : 50,
          eyeColor  : "blue"
      };
      
      document.getElementById("demo").innerHTML =
      person.firstName + " is " + person.age + " years old.";
      </script>
      
      </body>
      </html>
      

      L'objet (personne) dans l'exemple ci-dessus a 4 propriétés: firstName, lastName, age et eyeColor.

      Vous en apprendrez plus sur les objets plus loin dans ce tutoriel.

      Le type d'opérateur
      Vous pouvez utiliser l'opérateur JavaScript typeof pour rechercher le type d'une variable JavaScript.

      L'opérateur typeof renvoie le type d'une variable ou d'une expression:

      Exemple
      Code:
      typeof ""                  // Returns "string"
      typeof "John"              // Returns "string"
      typeof "John Doe"          // Returns "string"
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Type de JavaScript </ h2>
      <p> L'opérateur typeof renvoie le type d'une variable ou d'une expression. </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      document.getElementById ("demo"). innerHTML =
      typeof "" + "<br>" +
      typeof "John" + "<br>" +
      type de "John Doe";
      </ script>
      </ body>
      </ html>
      Exemple:
      Code:
      typeof 0                   // Returns "number"
      typeof 314                 // Returns "number"
      typeof 3.14                // Returns "number"
      typeof (3)                 // Returns "number"
      typeof (3 + 4)             // Returns "number"
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> Type de JavaScript </ h2>
      <p> L'opérateur typeof renvoie le type d'une variable ou d'une expression. </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      document.getElementById ("demo"). innerHTML =
      typeof 0 + "<br>" +
      typeof 314 + "<br>" +
      typeof 3.14 + "<br>" +
      typeof (3) + "<br>" +
      typeof (3 + 4);
      </ script>
      
      </ body>
      </ html>
      Indéfini
      En JavaScript, une variable sans valeur a la valeur indéfinie. Le type est également indéfini.

      Exemple
      Code:
      var car; // La valeur est indéfinie, le type est indéfini
      Code:
      <! DOCTYPE html>
      <html>
      <body>
      
      <h2> JavaScript </ h2>
      
      <p> La valeur (et le type de données) d'une variable sans valeur est <b> non défini </ b>. </ p>
      
      <p id = "demo"> </ p>
      
      <script>
      var car;
      document.getElementById ("demo"). innerHTML =
      car + "<br>" + typeof car;
      </ script>
      
      </ body>
      </ html>
      Toute variable peut être vidée en définissant la valeur sur indéfinie. Le type sera également indéfini.

      Exemple
      Code:
      car = undefined;        // Value is undefined, type is undefined
      
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript</h2>
      
      <p>Variables can be emptied if you set the value to <b>undefined</b>.</p>
      
      <p id="demo"></p>
      
      <script>
      var car = "Volvo";
      car = undefined;
      document.getElementById("demo").innerHTML =
      car + "<br>" + typeof car;
      </script>
      
      </body>
      </html>
      
      Valeurs vides
      Une valeur vide n'a rien à voir avec undefined.

      Une chaîne vide a à la fois une valeur légale et un type.

      Exemple
      Code:
      var car = ""; // La valeur est "", le typeof est "string"
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript</h2>
      
      <p>An empty string has both a legal value and a type:</p>
      
      <p id="demo"></p>
      
      <script>
      var car = "";
      document.getElementById("demo").innerHTML =
      "The value is: " +
      car + "<br>" +
      "The type is: " + typeof car;
      </script>
      
      </body>
      </html>
      
      
      
      Null
      En JavaScript, null n'est "rien". C'est supposé être quelque chose qui n'existe pas.

      Malheureusement, en JavaScript, le type de données null est un objet.

      Remarque: Vous pouvez considérer comme un bogue en JavaScript que typeof null est un objet. Cela devrait être nul.

      Vous pouvez vider un objet en le mettant à null:

      Exemple:
      Code:
      var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
      person = null;        // Now value is null, but type is still an object
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript</h2>
      
      <p>Objects can be emptied by setting the value to <b>null</b>.</p>
      
      <p id="demo"></p>
      
      <script>
      var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
      person = null;
      document.getElementById("demo").innerHTML = typeof person;
      </script>
      
      </body>
      </html>
      
      Vous pouvez également vider un objet en le définissant sur non défini:

      Exemple
      Code:
      var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
      person = undefined;   // Now both value and type is undefined
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript</h2>
      
      <p>Objects can be emptied by setting the value to <b>undefined</b>.</p>
      
      <p id="demo"></p>
      
      <script>
      var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
      person = undefined;
      document.getElementById("demo").innerHTML = person;
      </script>
      
      </body>
      </html>
      
      Différence entre indéfini et nul
      Undefined et null sont égaux en valeur mais différents en type:
      Code:
      typeof undefined           // undefined
      typeof null                // object
      
      null === undefined         // false
      null == undefined          // true
      Données primitives
      Une valeur de données primitive est une valeur de donnée simple sans propriétés ni méthodes supplémentaires.

      L'opérateur typeof peut renvoyer l'un de ces types primitifs:

      • chaîne
      • nombre
      • booléen
      • indéfini

      Exemple
      Code:
      typeof "John"              // Returns "string"
      typeof 3.14                // Returns "number"
      typeof true                // Returns "boolean"
      typeof false               // Returns "boolean"
      typeof x                   // Returns "undefined" (if x has no value)
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript typeof</h2>
      <p>The typeof operator returns the type of a variable or an expression.</p>
      
      <p id="demo"></p>
      
      <script>
      document.getElementById("demo").innerHTML =
      typeof "john" + "<br>" +
      typeof 3.14 + "<br>" +
      typeof true + "<br>" +
      typeof false + "<br>" +
      typeof x;
      </script>
      
      </body>
      </html>
      
      
      
      Données complexes
      L'opérateur typeof peut renvoyer l'un des deux types complexes suivants:

      une fonction
      objet
      L'opérateur typeof renvoie un objet pour les deux objets, tableaux et null.

      L'opérateur typeof ne renvoie pas d'objet pour les fonctions.

      Exemple
      Code:
      typeof {name:'John', age:34} // Returns "object"
      typeof [1,2,3,4]             // Returns "object" (not "array", see note below)
      typeof null                  // Returns "object"
      typeof function myFunc(){}   // Returns "function"
      Code:
      <!DOCTYPE html>
      <html>
      <body>
      
      <h2>JavaScript typeof</h2>
      <p>The typeof operator returns object for both objects, arrays, and null.</p>
      <p>The typeof operator does not return object for functions.</p>
      
      <p id="demo"></p>
      
      <script>
      document.getElementById("demo").innerHTML =
      typeof {name:'john', age:34} + "<br>" +
      typeof [1,2,3,4] + "<br>" +
      typeof null + "<br>" +
      typeof function myFunc(){};
      </script>
      
      </body>
      </html>
      
      
      
      L'opérateur typeof renvoie "objet" pour les tableaux, car les tableaux JavaScript sont des objets.
       
      Latest Threads
      Related Threads
      Loading...

Share This Page

Share
  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