Cours IT Bases JavaScript 038_Types de Données

En JavaScript, les types de données sont utilisés pour représenter différents types de données, tels que les nombres, les chaînes, les valeurs booléennes, etc. Les types de données en JavaScript sont divisés en deux catégories principales : les types de données primitifs et les types de données d’objet.

Types de Données Primitifs

Les valeurs des types de données primitifs ne contiennent qu’un seul contenu (chaîne, nombre ou autre).

Number (Nombre)

Utilisé pour représenter les nombres, y compris les entiers et les nombres à virgule flottante. Par exemple : 5, 3.14, -10. Les nombres peuvent avoir de nombreuses opérations, telles que la multiplication *, la division /, l’addition +, la soustraction -, etc. En plus des nombres réguliers, il inclut également les “valeurs spéciales” qui appartiennent à ce type : Infinity, -Infinity et NaN. Le type Number est un type à virgule flottante, qui peut avoir des problèmes de précision lors de calculs précis, comme : 0.1 + 0.2. Vous pouvez utiliser la méthode parseInt() pour convertir des chaînes en entiers, et la méthode parseFloat() pour convertir des chaînes en nombres à virgule flottante.

Exemple :

1
let age = 25;

1
console.log(0.1 + 0.2);  // Sortie 0.30000000000000004

1
let result = 0.1 * 10 + 0.2 * 10;
2
result = result / 10;  // Convertit le résultat en nombre à virgule flottante
3
console.log(result);  // Sortie 0.3

BigInt (Grand Entier)

Un type de données qui représente des entiers de précision arbitraire (en relation avec les limitations de taille de mémoire). Il vous permet de représenter des valeurs entières plus grandes que la plage du type Number sans perte de précision. Utilisez le suffixe n ou appelez le constructeur BigInt() pour créer un BigInt. Gère les valeurs entières en dehors de la plage de Number, ne peut pas être mélangé avec des entiers réguliers, ne peut pas être converti via parseInt() ou parseFloat().

Exemple :

1
let bigIntLiteral = 123n;
2
let bigIntObject = BigInt(456);

String (Chaîne)

Utilisé pour représenter des données textuelles. Une chaîne est composée d’une série de caractères et peut contenir des lettres, des chiffres, des symboles, etc., par exemple : “Hello, World!”, “Bonjour”, ‘123’. Les chaînes doivent être entre guillemets, y compris : guillemets simples 'Hello', guillemets doubles "Hello", backticks `Hello`. Les guillemets simples et doubles sont des guillemets “simples”, les backticks sont des guillemets avec des fonctions étendues qui permettent de référencer directement des variables via ${…} et de préserver le format du texte. Saut de ligne \n, tabulation \t, barre oblique inverse elle-même \\, guillemet simple \' et guillemet double \", retour chariot \r

Exemple :

1
let text = "Hello, World!";

Boolean (Booléen)

Utilisé pour représenter des valeurs logiques, n’a que deux valeurs possibles : true ou false.

Exemple :

1
let isStudent = true;

Undefined (Indéfini)

Utilisé pour représenter des variables non initialisées, indéfinies, non assignées ou des fonctions sans valeurs de paramètres.

Exemple :

1
let undefinedVar;
2
alert(undefinedVar);

Null (Null)

Utilisé pour représenter une valeur spéciale “rien”, “vide” ou “valeur inconnue” ou une valeur d’objet inexistante.

Exemple :

1
let nullValue = null;

Symbol (Symbole)

Utilisé pour créer des identificateurs uniques et immuables. Couramment utilisé pour définir des propriétés privées d’objets, créer des constantes uniques ou servir d’identificateurs pour un comportement spécial. Chaque symbole créé via Symbol est unique, même s’ils ont la même description, ils sont différents.

Exemple :

1
const symbol1 = Symbol();
2
const symbol2 = Symbol();
3
console.log(symbol1 === symbol2); // Sortie false, chaque Symbol est unique

Types de Données d’Objet

Peuvent être utilisés pour stocker des collections de données ou du contenu plus complexe.

Object (Objet)

Utilisé pour stocker des paires clé-valeur, ou en d’autres termes, la relation de mappage entre les propriétés et les valeurs de propriétés. Les objets peuvent contenir des valeurs de différents types de données, y compris des nombres, des chaînes, des valeurs booléennes, des tableaux, d’autres objets, etc.

Exemple :

1
let person = {
2
  name: "Alice",
3
  age: 30,
4
  isStudent: false
5
};

Array (Tableau)

Un tableau est une structure de données ordonnée et mutable utilisée pour stocker un groupe de valeurs. Les tableaux peuvent contenir des éléments de différents types de données, et chaque élément a un index correspondant.

Exemple :

1
let numbers = [1, 2, 3, 4, 5];

Function (Fonction)

Une fonction est un bloc de code réutilisable qui peut accepter des paramètres d’entrée, effectuer une série d’opérations et renvoyer un résultat. Les fonctions sont des citoyens de première classe en JavaScript, elles peuvent être assignées à des variables, passées en tant que paramètres à d’autres fonctions ou utilisées comme valeurs de retour d’autres fonctions.

Exemple :

1
function greet(name) {
2
  console.log("Hello, " + name + "!");
3
}
4
greet("JavaScript");

typeof

typeof est un opérateur en JavaScript utilisé pour obtenir le type d’une variable donnée (donc pas besoin de parenthèses dans typeof). Il renvoie une chaîne représentant le type de variable.

Exemple :

1
let undefinedVariable;
2
let booleanVariable = true;
3
let numberVariable = 42;
4
let stringVariable = "Hello";
5
let objectVariable = { key: "value" };
6
let functionVariable = function() {};
7
let symbolVariable = Symbol("mySymbol");
8
let nullVariable = null;
9

10
console.log(typeof undefinedVariable);  // Sortie "undefined"
11
console.log(typeof booleanVariable);    // Sortie "boolean"
12
console.log(typeof numberVariable);     // Sortie "number"
13
console.log(typeof stringVariable);     // Sortie "string"
14
console.log(typeof objectVariable);     // Sortie "object"
15
console.log(typeof functionVariable);   // Sortie "function"
16
console.log(typeof symbolVariable);     // Sortie "symbol"
17
console.log(typeof nullVariable);     // Sortie "object"

L’utilisation de typeof x, x renverra le type de variable et la valeur de la variable. Exécute d’abord typeof x, puis exécute x, et produit les deux valeurs.

Exemple :

1
let x = 42;
2
console.log(typeof x, x);

• typeof x renvoie “number”, indiquant que le type de la variable x est un nombre.
• x renvoie la valeur de la variable x, soit 42.