À propos de ce cours
Chapitre 3 — Les variables, les types et les opérateurs · Les types de données (String, Number, Boolean, BigInt, Symbol, null, undefined, Object)
• 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.

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
numberpour 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 typenumberet n'est égal à rien, pas même à lui-même : testez-le avecNumber.isNaN(x).Infinityré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 typebigint(suffixen) calcule exactement, mais ne se mélange pas avec lesnumber.- 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 ;lengthdonne 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
trueoufalse: 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.symbolcré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.
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). 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.• 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) :
- Donnez le type de :
"42",42,42n,4.2,true,"false",null,undefined,[],{},NaN. Lesquels vous ont surpris ? - Une variable
reponsecontient la saisie de l'utilisateur"18". Quel est son type ? Que donnentreponse + 2etreponse * 2? Pourquoi ces deux résultats sont-ils différents ? - Comment testez-vous qu'une variable contient
null? Un tableau ?NaN? Pourquoitypeofne suffit-il pas ? - Déclarez
let x;, puislet 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) :
- Calculez le total en additionnant les trois prix. Le résultat affiché est-il exact ? Pourquoi ?
- Proposez deux façons d'obtenir un total exact au centime : en arrondissant, puis en calculant en centimes entiers.
- Que donnent
1 / 0,0 / 0et"prix" * 3? Quel est le type de chaque résultat ? - Calculez
9007199254740993en 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é ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !