Types de données JavaScript
Une variable JavaScript peut contenir 8 types de données.
7 types de données primitifs et 1 type de données objet .
Le type de données objet peut contenir de nombreux types d'objets différents.
| Type | Description |
|---|---|
| Number | Un nombre représentant une valeur mathématique |
| Bigint | Un nombre représentant un grand entier |
| String | Une chaîne de caractères entourée de guillemets |
| Boolean | Un type de données représentant vrai ou faux |
| Undefined | Une variable primitive sans valeur assignée |
| Null | Une valeur primitive représentant l'absence d'objet |
| Symbol | Un identifiant unique et primitif |
| Object | Une collection de paires clé-valeur de données |
Exemples
// Number
let length = 16;
let weight = 7.5;
// BigInt
let x = 1234567890123456789012345n;
let y = BigInt(1234567890123456789012345)
// Strings
let color = "Yellow";
let lastName = "Johnson";
// Boolean
let x = true;
let y = false;
// Undefined
let x;
let y;
// Null
let x = null;
let y = null;
// Symbol
const x = Symbol();
const y = Symbol();
// Object
const person = {firstName:"John", lastName:"Doe"};
// Array Object
const cars = ["Saab", "Volvo", "BMW"];
// Date Object
const date = new Date("2022-03-25");
Le concept des types de données
En programmation, les types de données sont un concept important.
Pour pouvoir travailler avec des variables, il est essentiel de connaître leur type.
Sans types de données, un ordinateur ne peut pas résoudre cela en toute sécurité :
let x = 16 + "Volvo"; A-t-il un sens d'ajouter "Volvo" à seize ? Cela produira-t-il une erreur ou un résultat ?
JavaScript traitera l'exemple ci-dessus comme :
let 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
let x = 16 + "Volvo"; Exemple
let x = "Volvo" + 16; JavaScript évalue les expressions de gauche à droite. Différentes séquences peuvent produire des résultats différents :
JavaScript :
let x = 16 + 4 + "Volvo"; Résultat :
20Volvo JavaScript :
let x = "Volvo" + 16 + 4; Résultat :
Volvo164 Dans le premier exemple, JavaScript traite 16 et 4 comme des nombres, jusqu'à ce qu'il atteigne "Volvo".
Dans le deuxième exemple, puisque le premier opérande est 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
let x; // Maintenant x est indéfini
x = 5; // Maintenant x est un Nombre
x = "John"; // Maintenant x est une Chaîne 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
// Utilisation de guillemets doubles :
let carName1 = "Volvo XC60";
// Utilisation de guillemets simples :
let carName2 = 'Volvo XC60'; Vous pouvez utiliser des guillemets à l'intérieur d'une chaîne, tant qu'ils ne correspondent pas aux guillemets entourant la chaîne :
Exemple
// Guillemets simples à l'intérieur de guillemets doubles :
let answer1 = "C'est bon";
// Guillemets simples à l'intérieur de guillemets doubles :
let answer2 = "Il s'appelle 'Johnny'";
// Guillemets doubles à l'intérieur de guillemets simples :
let answer3 = 'Il s\'appelle "Johnny"'; En savoir plus :
Nombres JavaScript
Tous les nombres JavaScript sont stockés sous forme de nombres décimaux (flottants).
Les nombres peuvent être écrits avec ou sans décimales :
Exemple
// Avec décimales :
let x1 = 34.00;
// Sans décimales :
let x2 = 34; Notation exponentielle
Des nombres très grands ou très petits peuvent être écrits avec une notation scientifique (exponentielle) :
Exemple
let y = 123e5; // 12300000
let z = 123e-5; // 0.00123 Types de nombres
La plupart des langages de programmation ont de nombreux types de nombres :
Nombres entiers (entiers) :
byte (8 bits), short (16 bits), int (32 bits), long (64 bits)
Nombres réels (flottants) :
float (32 bits), double (64 bits).
Les nombres JavaScript sont toujours des doubles (flottants 64 bits).
BigInt JavaScript
Tous les nombres JavaScript sont stockés dans un format flottant de 64 bits.
BigInt JavaScript est un nouveau type de données ( ES2020 ) qui peut être utilisé pour stocker des valeurs entières trop grandes pour être représentées par un nombre JavaScript normal.
Exemple
let x = BigInt("123456789012345678901234567890"); En savoir plus :
Booléens JavaScript
Les booléens ne peuvent avoir que deux valeurs : true ou false .
Exemple
let x = 5;
let y = 5;
let z = 6;
(x == y) // Renvoie true
(x == z) // Renvoie false Les booléens sont souvent utilisés dans les tests conditionnels.
En savoir plus :
Objets JavaScript
Les objets JavaScript représentent des structures de données complexes et des fonctionnalités au-delà des types de données primitifs (chaîne, nombre, booléen, null, indéfini, symbole, bigint).
Les objets JavaScript sont écrits avec des accolades { } .
Les objets JavaScript contiennent une collection de différentes propriétés .
Les propriétés d'objet sont écrites sous forme de paires nom:valeur , séparées par des virgules.
Exemple
Créez un objet personne avec 4 propriétés : firstName, lastName, age et eyeColor :
const person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
Types d'objets intégrés
Un objet JavaScript peut représenter un objet JavaScript ou un objet défini par l'utilisateur .
Les types d'objets intégrés JavaScript peuvent être :
| Object | Le bloc de construction fondamental pour des données complexes |
| Array | Objet de valeurs accessibles par un index numérique |
| Date | Objet pour travailler avec des dates et des heures |
| RegExp | Objet pour travailler avec des expressions régulières |
| Map | Objet de paires clé-valeur où les clés peuvent être de n'importe quel type de données |
| Set | Objet de valeurs où chaque valeur ne peut apparaître qu'une seule fois |
| Error | Objet représentant des conditions d'erreur lors de l'exécution du programme |
| Promise | Objet représentant l'achèvement ou l'échec d'une opération asynchrone |
| Int8Array | Tableau pour stocker des valeurs entières de taille fixe de 8 bits |
| Int16Array | Tableau pour stocker des valeurs entières de taille fixe de 16 bits |
| Int32Array | Tableau pour stocker des valeurs entières de taille fixe de 32 bits |
| Float16Array | Tableau pour stocker des valeurs flottantes de taille fixe de 16 bits |
| Float32Array | Tableau pour stocker des valeurs flottantes de taille fixe de 32 bits |
| Float64Array | Tableau pour stocker des valeurs flottantes de taille fixe de 64 bits |
| BigInt64Array | Tableau pour stocker des valeurs entières grandes de taille fixe de 64 bits |
Remarque
La liste ci-dessus n'est pas complète, car JavaScript propose d'autres types d'objets intégrés comme Math pour les méthodes et valeurs mathématiques, et divers autres objets spécialisés pour des tâches spécifiques.
L'opérateur typeof
Vous pouvez utiliser l'opérateur JavaScript typeof pour trouver le type d'une variable JavaScript.
L'opérateur typeof renvoie le type d'une variable ou d'une expression :
Exemple
typeof "" // Renvoie "string"
typeof "John" // Renvoie "string"
typeof "John Doe" // Renvoie "string" Exemple
typeof 0 // Renvoie "number"
typeof 314 // Renvoie "number"
typeof 3.14 // Renvoie "number"
typeof (3) // Renvoie "number"
typeof (3 + 4) // Renvoie "number" En savoir plus :
Tableaux JavaScript
Les tableaux JavaScript sont un type spécial d'objets JavaScript.
Les tableaux JavaScript sont écrits avec des crochets carrés [ ] .
Les éléments du 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
const cars = ["Saab", "Volvo", "BMW"]; Les index de tableau commencent à zéro, ce qui signifie que le premier élément est [0], le deuxième est [1], et ainsi de suite.
En savoir plus :
Tutoriel sur les tableaux JavaScript
Méthodes de tableau JavaScript
Indéfini
En JavaScript, une variable sans valeur a la valeur undefined . Le type est également undefined .
Exemple
let car; // La valeur est indéfinie, le type est indéfini Toute variable peut être vidée en définissant la valeur sur undefined . Le type sera également undefined .
Exemple
car = undefined; // La valeur est indéfinie, le type est indéfini 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
let car = ""; // La valeur est "", le type est "string" Type de données null
En JavaScript, une variable ou une expression peut obtenir le type de données null de plusieurs manières.
Une fonction peut renvoyer null ou une variable peut être assignée à la valeur null :
Exemple
let carName = null; Remarque
L'opérateur typeof renvoie object pour null.
C'est une particularité historique en JavaScript et cela n'indique pas que null est un objet.
L'opérateur d'égalité stricte (===) compare à la fois la valeur et le type des opérandes.
Il renvoie true uniquement si les valeurs et les types des opérandes sont null .
L'opérateur d'égalité lâche (==) renvoie également true pour une valeur null , mais il renvoie également true si la valeur est undefined .
L'utilisation de == n'est pas recommandée lors de la vérification de null .