Types de données en JavaScript

Cet article explique les types de données en JavaScript.

YouTube Video

Types de données en JavaScript

JavaScript dispose de types de données pour classer les valeurs, qui peuvent être globalement divisés en types primitifs et types d'objets. Les types de données déterminent quel type de données est stocké dans une variable et influencent la façon dont elle peut être manipulée.

Types Primitifs

Les types primitifs sont des types de données simples qui représentent une seule valeur. JavaScript possède les 7 types primitifs suivants.

number

1let num = 42;
2let pi = 3.14;
3
4console.log("Value of num:", num);
5console.log("Value of pi:", pi);

• number est un type utilisé pour gérer des valeurs numériques, y compris des entiers et des nombres à virgule flottante (décimaux). La gestion de valeurs qui dépassent certaines limites entraîne un résultat de Infinity ou NaN (Not-a-Number).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

• En JavaScript, les nombres sont représentés sous forme de nombres à virgule flottante. En conséquence, certains nombres décimaux (en particulier ceux qui ne peuvent pas être précisément représentés en binaire) peuvent ne pas être exprimés avec précision.
• Lorsque des calculs précis sont nécessaires, comme pour les valeurs monétaires, il est important d'éviter de telles erreurs d'arrondi. Par exemple, vous pouvez utiliser BigInt ou ajuster le nombre de décimales avec toFixed().

string

1let greeting = "Hello, world!";
2let char = 'A';
3const message = `"${greeting}" in JavaScript`;
4
5console.log("Value of greeting:", greeting);
6console.log("Value of char:", char);
7console.log("Value of message:", message);

• string est un type de données utilisé pour gérer du texte, représentant une séquence de caractères. Il est représenté en entourant le texte avec des guillemets simples (') ou doubles ("). À partir d'ES6, les littéraux de gabarit permettent d'intégrer facilement des variables en utilisant les accents graves (``). Pour intégrer une variable, utilisez la syntaxe ${}`.

boolean

1let isAvailable = true;
2let hasError = false;
3
4console.log("Value of isAvailable:", isAvailable);
5console.log("Value of hasError:", hasError);

• boolean représente une valeur logique et ne peut avoir que deux valeurs : true ou false. Il est utilisé comme résultat d'expressions conditionnelles ou comme indicateur.

null

1let result = null;
2
3console.log("Value of result:", result);

• null est un type de données qui indique explicitement 'pas de valeur.'. null est défini par les développeurs pour indiquer un vide intentionnel.

undefined

1let score;
2let subject = undefined;
3
4console.log("Value of score:", score);     // undefined
5console.log("Value of subject:", subject);

• undefined est un type de données signifiant 'indéfini.'. undefined est automatiquement attribué lorsqu'une variable est déclarée mais qu'aucune valeur ne lui est attribuée.

bigint

1let bigIntValue = 9007199254740991n;
2let anotherBigInt = 123456789012345678901234567890n;
3
4console.log("Value of bigIntValue:", bigIntValue);
5console.log("Value of anotherBigInt:", anotherBigInt);

• bigint est un type de données permettant de gérer de grands entiers. bigint permet une représentation précise des grands entiers qui ne peuvent pas être représentés par le type number. Les littéraux bigint sont représentés en ajoutant n à la fin d’un nombre.
• bigint est un type permettant de gérer des entiers de taille arbitraire, sans limitation de plage. Cependant, bigint et number ne peuvent pas être utilisés directement ensemble, donc une certaine prudence est nécessaire.

Symbol

1let sym1 = Symbol('id');
2let sym2 = Symbol('id');
3
4console.log("sym1 === sym2:", sym1 === sym2); // false

• Symbol est un type de données utilisé pour créer des identifiants uniques. Il est créé en utilisant Symbol() et peut être utilisé comme propriété d'un objet. Contrairement aux autres types primitifs, Symbol a des valeurs uniques, donc même avec le même contenu, il est traité comme un Symbol différent.

Types d'objets

Les types d'objets sont des structures de données capables de stocker plusieurs valeurs. Un objet est une collection de paires clé-valeur et peut avoir des propriétés et des méthodes.

Object

1let person = {
2    name: "John",
3    age: 30,
4    isEmployee: true
5};
6console.log(person.name); // John

• Object est une collection de propriétés (paires clé-valeur) pouvant stocker divers types de données. Les objets sont représentés par des accolades {}, et chaque propriété est reliée par : entre la clé et la valeur.

Array

1let numbers = [10, 20, 30];
2console.log(numbers[0]); // 10
3console.log(numbers[1]); // 20
4console.log(numbers[2]); // 30
5console.log(numbers[3]); // undefined

• Array est une liste qui contient plusieurs valeurs de manière ordonnée. Les tableaux sont représentés par des crochets [], et les valeurs sont séparées par des virgules ,. Chaque élément est accessible à l'aide d'un index commençant à 0.

Function

1function greet(name) {
2    return "Hello, " + name;
3}
4console.log(greet("Alice")); // Hello, Alice

• Les fonctions sont un type d'objet et des blocs de code réutilisables. Les fonctions peuvent être définies en utilisant le mot clé function.

Autres types d'objets

• JavaScript dispose également de types d'objets intégrés tels que Date, RegExp, Map et Set. Ces objets gèrent les données en fonction de cas spécifiques.

Conversion de type

Les conversions de type implicites et explicites sont fréquemment effectuées en JavaScript.

Conversion de type implicite

• JavaScript peut convertir automatiquement les types lors de l'exécution d'opérations entre différents types.

1let result = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

• Dans cet exemple, le nombre 5 est implicitement converti en une chaîne de caractères, donnant la chaîne "55".

Conversion de type explicite

• Les développeurs peuvent également effectuer des conversions de type explicitement.

1let num = "123";
2let convertedNum = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

• Dans cet exemple, la fonction Number() est utilisée pour convertir explicitement la chaîne "123" en le nombre 123.

Vérification de type

En JavaScript, vous pouvez utiliser l'opérateur typeof pour vérifier le type de données d'une variable.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

Conclusion

• Les types primitifs incluent number, string, boolean, null, undefined et symbol.
• Les types d'objets incluent Object, Array, Function, entre autres.
• Étant donné que des conversions de type automatiques et explicites se produisent, il est important de comprendre l'utilisation appropriée des types de données.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video