Valeurs primitives : la copie par valeur

Objectifs

À la fin de cette leçon, vous saurez :

• distinguer valeurs primitives et objets ;
• prédire ce qui se passe quand on copie une primitive ;
• comprendre pourquoi b = 20 ne change jamais a.

🔗 Pour vous rafraîchir la mémoire : variables et types primitifs

L'observation de départ

let a = 10;
let b = a;

b = 20;

console.log(a);   // 10
console.log(b);   // 20

Modifier b n'a aucun effet sur a. Ce n'est pas un détail de langage : c'est la façon dont les valeurs primitives sont stockées.

Deux familles de valeurs

JavaScript range toutes les données dans deux familles :

Famille	Types	Comportement à la copie
Primitives	number, string, boolean, null, undefined, bigint, symbol	la valeur est dupliquée
Objets	object, array, function	l'adresse (référence) est partagée

Cette leçon traite des primitives. La suivante traitera des objets, où le comportement change complètement.

Pourquoi ça marche comme ça

Une variable primitive contient la valeur elle-même, pas un pointeur. Quand on écrit let b = a, JavaScript lit la valeur de a et en met une copie dans b. Il existe alors deux emplacements indépendants :

a → 10      (emplacement 1)
b → 10      (emplacement 2 : copie)

Puis b = 20 remplace le contenu de l'emplacement 2 :

a → 10      (inchangé)
b → 20

Aucun lien ne subsiste entre les deux variables.

Le cas particulier des chaînes

Même mécanisme pour les chaînes :

let salut = "bonjour";
let copie = salut;
copie = copie.toUpperCase();

console.log(salut);   // "bonjour"
console.log(copie);   // "BONJOUR"

Les chaînes sont dites immuables : on ne modifie jamais une chaîne existante, on en fabrique une nouvelle. toUpperCase() retourne une nouvelle chaîne ; l'originale reste intacte.

Vérifier avec typeof

Rappel du chapitre précédent : typeof révèle la nature d'une valeur.

console.log(typeof 42);          // "number"
console.log(typeof "42");        // "string"
console.log(typeof true);        // "boolean"
console.log(typeof undefined);   // "undefined"
console.log(typeof null);        // "object" (bug historique, à connaître)

Le cas de null est célèbre : typeof null répond "object" pour une raison historique que le standard ne peut plus corriger sans casser le web. Retenez-le comme piège d'examen, pas comme logique.

Exercice

Pour chaque extrait, écrivez d'abord le résultat attendu sans exécuter, puis vérifiez avec Node.

let x = 5;
let y = x;
y = y + 1;
console.log(x);
console.log(y);

const titre = "cours";
let autre = titre;
autre += " complet";
console.log(titre);

let compteur = 0;
let copieCompteur = compteur;
compteur = 100;
console.log(copieCompteur);

4. Expliquez avec vos propres mots la différence entre modifier et réaffecter.

Résumé

• Les primitives sont copiées par valeur : chaque variable possède son propre exemplaire.
• Modifier une copie n'affecte jamais l'original.
• Les chaînes sont immuables : toute transformation produit une nouvelle chaîne.
• Cette règle s'inverse complètement pour les objets : sujet de la prochaine leçon.