Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
JavaScript

Les types de données (String, Number, Boolean, BigInt, Symbol, null, undefined, Object)

Les types de données (String, Number, Boolean, BigInt, Symbol, null, undefined, Object). Dans cette leçon du cours JavaScript, vous apprendrez à : connaître les 7 types primitifs et le type objet ; co...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Les types de données (String, Number, Boolean, BigInt, Symbol, null, undefined, Object). Dans cette leçon du cours JavaScript, vous apprendrez à : connaître les 7 types primitifs et le type objet ; connaître le type d'une valeur avec typeof et ses pièges ; comprendre les particularités des nombres (décimaux, NaN, Infinity, BigInt) ; distinguer undefined et null, valeur primitive et référence.

Chapitre 3 — Les variables, les types et les opérateurs · Les types de données (String, Number, Boolean, BigInt, Symbol, null, undefined, Object)

🎯 Objectifs de la leçon
• connaître les 7 types primitifs et le type objet ;
• connaître le type d'une valeur avec typeof et ses pièges ;
• comprendre les particularités des nombres (décimaux, NaN, Infinity, BigInt) ;
• distinguer undefined et null, valeur primitive et référence.

1. Un langage à typage dynamique

Chaque valeur a un type, mais une variable n'en a pas : la même variable let peut contenir un nombre puis une chaîne. On dit que JavaScript est dynamiquement typé. Il faut donc savoir reconnaître le type d'une valeur, notamment quand elle vient d'une saisie (toujours une chaîne) ou d'un serveur.

Les types de données
Figure 1 — Les 7 types primitifs, les objets, et ce que renvoie typeof (attention à null).

Pour afficher plusieurs cas d'un coup, cet exemple utilise une boucle for (chapitre 7) : concentrez-vous sur les résultats affichés.

// Les 7 types primitifs et les objets
const exemples = [
  ["chaîne", "ISTA"],
  ["nombre entier", 42],
  ["nombre décimal", 3.14],
  ["booléen", true],
  ["non défini", undefined],
  ["vide (null)", null],
  ["grand entier", 12345678901234567890n],
  ["symbole", Symbol("id")],
  ["objet", { nom: "Amina" }],
  ["tableau", [1, 2, 3]],
  ["fonction", function () {}],
];
for (const [description, valeur] of exemples) {
  console.log(description.padEnd(15), "typeof →", typeof valeur);
}
// typeof null donne "object" : c'est une erreur historique du langage.
console.log("null === null :", null === null, "| Array.isArray([1]) :", Array.isArray([1]));

Résultat dans la console

chaîne          typeof → string
nombre entier   typeof → number
nombre décimal  typeof → number
booléen         typeof → boolean
non défini      typeof → undefined
vide (null)     typeof → object
grand entier    typeof → bigint
symbole         typeof → symbol
objet           typeof → object
tableau         typeof → object
fonction        typeof → function
null === null : true | Array.isArray([1]) : true

2. Les nombres

// Un seul type « number » pour les entiers et les décimaux
console.log(7 / 2, 10 / 3, 2 ** 10);

// Les décimaux sont stockés en binaire : de petites erreurs d'arrondi
console.log("0.1 + 0.2 =", 0.1 + 0.2, "| égal à 0.3 ?", 0.1 + 0.2 === 0.3);
console.log("arrondi à 2 décimales :", Math.round((0.1 + 0.2) * 100) / 100, "| affichage :", (0.1 + 0.2).toFixed(2));

// Valeurs spéciales
console.log("1 / 0 =", 1 / 0, "| -1 / 0 =", -1 / 0, "| 'abc' * 2 =", "abc" * 2);
console.log("NaN === NaN :", NaN === NaN, "| Number.isNaN(NaN) :", Number.isNaN(NaN), "| typeof NaN :", typeof NaN);

// Limite des entiers exacts
console.log("MAX_SAFE_INTEGER :", Number.MAX_SAFE_INTEGER);
console.log("2**53 + 1 =", 2 ** 53 + 1, "(faux) | avec BigInt :", 2n ** 53n + 1n);
try { console.log(10n + 1); } catch (e) { console.log("10n + 1 →", e.name); }

// Écrire les grands nombres lisiblement
const population = 37_000_000;
console.log("population :", population, "| en français :", population.toLocaleString("fr-FR"));

Résultat dans la console

3.5 3.3333333333333335 1024
0.1 + 0.2 = 0.30000000000000004 | égal à 0.3 ? false
arrondi à 2 décimales : 0.3 | affichage : 0.30
1 / 0 = Infinity | -1 / 0 = -Infinity | 'abc' * 2 = NaN
NaN === NaN : false | Number.isNaN(NaN) : true | typeof NaN : number
MAX_SAFE_INTEGER : 9007199254740991
2**53 + 1 = 9007199254740992 (faux) | avec BigInt : 9007199254740993n
10n + 1 → TypeError
population : 37000000 | en français : 37 000 000
  • Il n'y a qu'un type number pour les entiers et les décimaux. Les décimaux sont stockés en binaire, d'où 0.1 + 0.2 = 0.30000000000000004: pour de l'argent, arrondissez au centime (Math.round(x * 100) / 100) ou calculez en centimes entiers.
  • NaN (Not a Number) est le résultat d'un calcul impossible, comme "abc" * 2. Il est de type number et n'est égal à rien, pas même à lui-même : testez-le avec Number.isNaN(x).
  • Infinity résulte d'une division par 0 ; les entiers ne sont exacts que jusqu'à Number.MAX_SAFE_INTEGER (environ 9 millions de milliards). Au-delà, le type bigint (suffixe n) calcule exactement, mais ne se mélange pas avec les number.
  • Le séparateur _ rend les grands nombres lisibles dans le code : 37_000_000.

3. Chaînes, booléens, undefined et null

// Trois façons d'écrire une chaîne
const simple = 'L\'ISTA';
const double = "Le \"TP\" de JavaScript";
const gabarit = `Bonjour ${"Amina"}, vous avez ${12 + 3} ans`;
console.log(simple, "|", double, "|", gabarit);

// Les gabarits acceptent plusieurs lignes
const adresse = `ISTA NTIC
Avenue Hassan II
Rabat`;
console.log(adresse);

// Longueur et accès à un caractère
const mot = "JavaScript";
console.log(mot.length, mot[0], mot.at(-1));

// Le + concatène dès qu'une chaîne est présente
console.log("3" + 4, "|", 3 + 4 + "5", "|", "3" + 4 + 5);

// Booléens, undefined et null
let connecte = false;
let telephone;                 // pas encore de valeur → undefined
let tuteur = null;             // « pas de tuteur », choisi volontairement
console.log(connecte, telephone, tuteur, "| null == undefined :", null == undefined, "| null === undefined :", null === undefined);

Résultat dans la console

L'ISTA | Le "TP" de JavaScript | Bonjour Amina, vous avez 15 ans
ISTA NTIC
Avenue Hassan II
Rabat
10 J t
34 | 75 | 345
false undefined null | null == undefined : true | null === undefined : false
  • Une chaîne (string) est une suite de caractères ; length donne sa longueur, [0] son premier caractère. Le chapitre 5 lui est consacré.
  • Le + concatène dès qu'une chaîne est présente, et se lit de gauche à droite : 3 + 4 + "5" donne "75".
  • Un booléen vaut true ou false: c'est le résultat des comparaisons (leçon 3.7).
  • undefined: « pas encore de valeur » (variable non initialisée, propriété absente). null: « vide », affecté volontairement par le programmeur.
  • symbol crée un identifiant unique ; il sert surtout dans des usages avancés.

4. Valeurs primitives et objets

// Les primitifs sont copiés…
let prix = 100;
let prixPromo = prix;
prixPromo = 80;
console.log("prix :", prix, "| prixPromo :", prixPromo);

// …les objets sont partagés (référence)
const panier = ["pain"];
const memePanier = panier;
memePanier.push("lait");
console.log("panier :", panier);

// Une chaîne ne se modifie pas : on en crée une nouvelle
let nom = "amina";
nom[0] = "A";                  // ignoré
console.log(nom, "→", nom[0].toUpperCase() + nom.slice(1));

Résultat dans la console

prix : 100 | prixPromo : 80
panier : [ 'pain', 'lait' ]
amina → Amina

Les primitifs sont copiés et non modifiables: on ne change pas une lettre d'une chaîne, on crée une nouvelle chaîne. Les objets (dont les tableaux et les fonctions) sont manipulés par référence: deux variables peuvent désigner le même objet.

⚠️ Attention
typeof null renvoie "object" (erreur historique, jamais corrigée pour ne pas casser le Web) et typeof [1, 2] renvoie aussi "object". Testez valeur === null et Array.isArray(valeur).
✅ Correction par rapport à l'ancienne version
Nouvelle leçon : présentation des 8 types avec typeof exécuté, particularités des nombres (arrondi, NaN, Infinity, limite des entiers, BigInt), undefined et null, primitifs et références ; schéma et deux activités.
ℹ️ À retenir
• 7 primitifs : string, number, boolean, undefined, null, bigint, symbol ; tout le reste est objet.
• typeof null → "object"; tableau : Array.isArray; NaN : Number.isNaN.
• 0.1 + 0.2 !== 0.3: arrondir les montants.
• undefined = pas encore de valeur ; null = vide volontaire.
• Primitifs copiés, objets partagés par référence.

🛠 Activité 9 — Le détective des types

Mission : Prévoyez, puis vérifiez avec typeof.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Donnez le type de : "42", 42, 42n, 4.2, true, "false", null, undefined, [], {}, NaN. Lesquels vous ont surpris ?
  2. Une variable reponse contient la saisie de l'utilisateur "18". Quel est son type ? Que donnent reponse + 2 et reponse * 2? Pourquoi ces deux résultats sont-ils différents ?
  3. Comment testez-vous qu'une variable contient null? Un tableau ? NaN? Pourquoi typeof ne suffit-il pas ?
  4. Déclarez let x;, puis let y = null;. Affichez les deux et leur type. Dans quelle situation réelle utiliseriez-vous chacune de ces valeurs ?

Je vérifie / je rends :

  • ☐ Le tableau de prédictions et de résultats, et les réponses 2 et 3.

🛠 Activité 10 — Calculer juste avec des décimaux

Mission : Un panier contient trois articles à 0,10 DH, 0,20 DH et 19,99 DH.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Calculez le total en additionnant les trois prix. Le résultat affiché est-il exact ? Pourquoi ?
  2. Proposez deux façons d'obtenir un total exact au centime : en arrondissant, puis en calculant en centimes entiers.
  3. Que donnent 1 / 0, 0 / 0 et "prix" * 3? Quel est le type de chaque résultat ?
  4. Calculez 9007199254740993 en number, puis en BigInt. Que constatez-vous ? Dans quel domaine ces grands nombres sont-ils utiles ?

Je vérifie / je rends :

  • ☐ Le fichier et la sortie console.

← Le hoisting (remontée des déclarations)Les opérateurs en JavaScript (arithmétiques, affectation, incrémentation) →

Cet article vous a-t-il aidé ?