Types de données JavaScript

Introduction aux types de données JavaScript

JavaScript est un langage à typage dynamique : vous ne déclarez jamais le type d'une variable, et une variable peut contenir une valeur de n'importe quel type — même un type différent par la suite. Comme c'est le moteur, et non vous, qui suit les types à l'exécution, connaître précisément le comportement de chaque type est ce qui sépare le code prévisible des bugs déconcertants.

let x = 42;        // x is now a number
x = "forty-two";   // the same variable now holds a string — perfectly legal

Le langage définit huit types de données : sept primitifs et un non-primitif (object). La page ci-dessous couvre chacun d'eux, comment le vérifier avec typeof, et les règles de coercition qui piègent la plupart des débutants.

Types de données primitifs

Un primitif est une valeur qui n'est pas un object et ne possède pas de méthodes propres. Les primitifs sont immuables — vous ne pouvez jamais modifier une valeur primitive, seulement remplacer la variable qui la contient.

• Number : Valeurs entières ou à virgule flottante, ainsi que les valeurs spéciales Infinity, -Infinity et NaN (Not a Number). Voir Numbers.
• String : Données textuelles, entourées de guillemets doubles, simples ou de backticks. Voir Strings.
• Boolean : L'une des deux valeurs logiques, true ou false.
• Undefined : Une variable qui a été déclarée mais à laquelle aucune valeur n'a été attribuée.
• Null : L'absence intentionnelle de toute valeur d'object.
• BigInt : Entiers dépassant la limite sécurisée du type Number. Voir BigInt.
• Symbol : Un identifiant garanti unique, principalement utilisé comme clé d'object. Voir Symbol type.

Type de données non-primitif

• Object : Une collection de propriétés clé/valeur utilisée pour modéliser des données complexes. Les tableaux, les fonctions, les dates et la plupart des types intégrés sont tous des objects sous le capot. Voir Objects.

Vérifier un type avec typeof

Pour connaître le type d'une valeur, JavaScript fournit l'opérateur typeof. Il retourne une string telle que "number", "string" ou "boolean".

Deux résultats surprennent les débutants :

• typeof null retourne "object". Il s'agit d'un bug de la toute première version de JavaScript qui ne peut jamais être corrigé sans casser le web — mémorisez-le simplement.
• typeof sur une fonction retourne "function". Les fonctions sont en réalité des objects, mais typeof les traite spécialement afin de pouvoir détecter les callables.

Travailler avec les types de données primitifs

Ci-dessous, chaque primitif est illustré par un exemple minimal que vous pouvez exécuter.

Number : le socle des opérations mathématiques

let age = 25;       // Integer
let price = 99.99;  // Floating-point
console.log(typeof age);   // "number"
console.log(0.1 + 0.2);    // 0.30000000000000004  (floating-point rounding)

Un seul type number couvre à la fois les entiers et les décimaux. Parce que les nombres utilisent la virgule flottante 64 bits, les calculs fractionnaires ne sont pas toujours exacts — 0.1 + 0.2 en est l'exemple classique. Les nombres incluent également Infinity et NaN ; NaN n'est, de manière notoire, pas égal à lui-même, il faut donc utiliser Number.isNaN(x) pour le tester.

String : bien plus que du texte

let greeting = "Hello, world!";
let name = 'Ada';
let response = `Hi, ${name}!`; // template literal with interpolation
console.log(typeof greeting); // "string"
console.log(response);        // "Hi, Ada!"

Les strings sont immuables : des méthodes comme toUpperCase() retournent une nouvelle string au lieu de modifier l'originale. Les strings entre backticks (template literals) permettent d'intégrer des ${expressions} et de s'étendre sur plusieurs lignes. Explorez la boîte à outils complète dans Strings.

Boolean : le décideur binaire

let isAvailable = true;
let age = 25;
let isAdult = age >= 18; // comparisons produce booleans
console.log(typeof isAvailable); // "boolean"
console.log(isAdult);            // true

Les booleans pilotent chaque condition et chaque boucle. N'importe quelle valeur peut également être convertie en boolean — consultez le tableau truthy/falsy ci-dessous.

Undefined et Null : l'absence de valeur

let notAssigned;          // declared but never given a value
let emptyOnPurpose = null; // deliberately "nothing"
console.log(typeof notAssigned);  // "undefined"
console.log(typeof emptyOnPurpose); // "object" (the typeof null quirk)
console.log(null == undefined);   // true  (loose equality)
console.log(null === undefined);  // false (strict equality — different types)

Utilisez undefined pour « pas encore de valeur » (c'est ce que JavaScript assigne automatiquement), et null pour « intentionnellement vide ». Ils sont égaux au sens large (==) mais pas au sens strict (===).

BigInt : gérer les grands nombres

const big = 9007199254740991n; // note the trailing n
console.log(typeof big);     // "bigint"
console.log(big + 1n);       // 9007199254740992n

Number ne peut représenter en toute sécurité que des entiers jusqu'à Number.MAX_SAFE_INTEGER (environ 9 quadrillions). Pour tout ce qui dépasse — cryptographie, identifiants haute précision — utilisez BigInt, écrit avec un n en suffixe. Vous ne pouvez pas mélanger BigInt et Number dans la même opération arithmétique sans conversion explicite. Plus de détails dans BigInt.

Symbol : garantir l'unicité

Chaque appel à Symbol() retourne une valeur entièrement nouvelle et unique, même si le texte de description correspond. Les Symbols sont utilisés comme clés d'object à l'épreuve des collisions, par exemple pour attacher des métadonnées sans conflit avec les clés string normales. Voir Symbol type.

Objects : les blocs de construction des structures complexes

En JavaScript, les objects stockent des collections de données liées sous forme de paires clé/valeur et constituent le fondement des tableaux, des fonctions et de la plupart des types intégrés.

let person = {
  name: "John",
  age: 30,
  isStudent: false
};
console.log(typeof person);     // "object"
console.log(typeof [1, 2, 3]);  // "object"  (arrays are objects)
console.log(Array.isArray([1])); // true — the reliable way to detect arrays

Les objects sont mutables — contrairement aux primitifs, vous pouvez ajouter, modifier et supprimer leurs propriétés. Ils sont également comparés par référence, et non par valeur : deux objects au contenu identique ne sont pas === égaux.

Coercition et conversion de types

Parce que JavaScript est à typage dynamique, il convertit souvent une valeur d'un type à un autre lors d'une opération. C'est pratique, mais c'est une source fréquente de surprises.

En cas de doute, convertissez explicitement avec Number(), String() ou Boolean() plutôt que de vous fier à la coercition automatique.

Valeurs truthy et falsy

Lorsqu'une valeur est utilisée là où un boolean est attendu (un if, &&, ||), elle est convertie. Exactement six valeurs sont falsy ; tout le reste est truthy :

// falsy: false, 0, "", null, undefined, NaN
if ("") console.log("won't run");      // "" is falsy
if ("0") console.log("this runs");     // non-empty string is truthy
if ([]) console.log("this runs too");  // empty array is truthy!

Un piège fréquent : un array vide [] et un object vide {} sont truthy, alors que "" et 0 sont falsy.

Résumé

JavaScript possède huit types de données — sept primitifs (number, string, boolean, undefined, null, bigint, symbol) et l'object. typeof indique le type, avec les quirks bien connus que typeof null vaut "object" et que les fonctions retournent "function". Les primitifs sont immuables et comparés par valeur ; les objects sont mutables et comparés par référence. Maîtrisez la coercition et les règles truthy/falsy, et la plupart des « bizarreries JavaScript » disparaissent. Ensuite, découvrez comment les valeurs sont stockées dans Variables.

Pratique