Types primitifs en JavaScript : les 7 valeurs de base

Sept primitifs, et tout le reste

En JavaScript, les valeurs se répartissent en deux camps. D'un côté, sept types primitifs : des valeurs simples et immuables. De l'autre, les objets : tout ce qui est composite, modifiable ou appelable. Voilà, c'est tout le système de types au niveau des valeurs.

Les sept types primitifs javascript :

Tout ce qui ne figure pas dans cette liste — tableaux, fonctions, dates, expressions régulières, ou un simple {} — est un objet. typeof te renvoie le type à l'exécution, et tu vas vite repérer la fameuse bizarrerie sur la dernière ligne. typeof null renvoie 'object' depuis 1995, et ça ne sera jamais corrigé : trop de code existant s'appuie là-dessus.

Un type primitif, c'est une valeur, pas un conteneur

Le modèle mental qui aide le plus : un primitif est sa valeur. Le nombre 3 n'est pas une boîte qui contient 3 — c'est juste 3. Deux variables qui valent 3 contiennent la même valeur, pas deux copies pointant vers quelque chose de partagé :

Les primitifs se comparent par valeur. Les objets, eux, se comparent par référence. Cette distinction à elle seule explique pas mal de moments « mais pourquoi ça renvoie false ?! » plus tard, surtout quand on compare des tableaux ou des objets avec ===.

Les valeurs immuables en JavaScript

Un primitif ne se modifie pas. Chaque opération qui ressemble à une mutation produit en réalité une nouvelle valeur :

Le premier appel crée une nouvelle chaîne puis la jette à la poubelle, parce que personne ne récupère la valeur de retour. Le second, lui, réassigne name. Le "ada" d'origine n'a jamais été modifié — et c'était tout simplement impossible. Pareil pour les nombres : x + 1 produit un nouveau nombre, ça ne modifie pas x.

C'est pour ça que const sur une chaîne ou un nombre est vraiment fiable. La valeur ne peut pas changer, et const t'empêche de réassigner la variable.

Number et BigInt : pourquoi deux types numériques en JavaScript ?

En JavaScript, le type number est un flottant 64 bits. Résultat : des calculs rapides, mais un plafond — les entiers ne sont exacts que jusqu'à Number.MAX_SAFE_INTEGER (2^53 - 1) :

Au-delà de ce seuil, les entiers commencent à se marcher dessus. Le type bigint est là pour les entiers qui doivent rester exacts quelle que soit leur taille. On en crée un en ajoutant le suffixe n :

bigint et number ne se mélangent pas dans les opérations arithmétiques — sinon tu perdrais tout l'intérêt de la précision supplémentaire. On sort le bigint pour les IDs de base de données, les timestamps en nanosecondes ou la crypto. Pour le calcul de tous les jours, on reste sur number.

Les chaînes aussi sont des primitifs

En JavaScript, une chaîne de caractères est un type primitif, pas un objet — même si elle expose des méthodes comme .length, .slice ou .toUpperCase :

En coulisses, quand vous appelez une méthode sur une chaîne, JavaScript l'enveloppe brièvement dans un objet String pour que l'appel fonctionne, puis se débarrasse de l'emballage. Pas besoin de vous préoccuper de ce wrapper — retenez simplement que les chaînes se comportent comme des valeurs (immuables, comparées par valeur), même si elles exposent tout un tas de méthodes.

Les guillemets simples, les guillemets doubles et les backticks produisent tous le même type. Les backticks offrent en plus l'interpolation et les chaînes multilignes, un sujet traité dans le prochain document.

null et undefined : quelle différence en javascript

Deux types primitifs expriment l'idée « aucune valeur », et ils ne sont pas interchangeables.

undefined, c'est ce que vous obtenez quand rien n'a été assigné — une variable déclarée mais non initialisée, un argument de fonction manquant, une propriété qui n'existe pas :

null, c'est ce que vous écrivez vous-même pour indiquer « volontairement vide » :

La convention habituelle : undefined, c'est la façon qu'a le langage de dire « il n'y a rien ici », alors que null est la façon qu'a le développeur de l'exprimer. Les deux sont falsy, les deux échouent à l'égalité avec des valeurs normales, et chacun aura droit à sa propre page plus loin.

Les symbols : uniques par construction

symbol est le type primitif le moins utilisé. Chaque symbol que tu crées est unique, même si deux d'entre eux partagent la même description :

Les Symbol sont pratiques comme clés d'objet qui ne peuvent entrer en collision avec d'autres : une bibliothèque peut attacher des métadonnées à tes objets via un symbole, avec la certitude qu'aucun autre code ne viendra les écraser. Tu les recroiseras du côté des itérateurs et des symboles bien connus comme Symbol.iterator.

Vérifier les types à l'exécution avec typeof

typeof couvre la plupart des cas. Garde simplement ces petites bizarreries en tête :

Pour null, on compare directement : value === null. Pour les tableaux, on utilise Array.isArray(value). Pour répondre à « est-ce une primitive, peu importe laquelle ? », il n'existe pas de méthode native unique, mais l'idiome reste assez parlant :

Primitives vs objets : le piège de l'affectation

Avant de passer à la suite, il y a un dernier point à bien voir. Comme les primitives sont des valeurs alors que les objets sont des références, l'affectation ne se comporte pas de la même façon :

Avec les types primitifs, b = a copie la valeur. Avec les objets, y = x copie la référence — les deux noms pointent vers le même objet sous-jacent. Muter via l'un affecte l'autre. C'est la première source de bugs du genre « attends, pourquoi ça a changé ? » en JavaScript.

Ce qu'il faut retenir

• Sept types primitifs : string, number, bigint, boolean, null, undefined, symbol. Tout le reste est un objet.
• Les primitifs sont immuables et comparés par valeur ; les objets sont mutables et comparés par référence.
• typeof renvoie le type à l'exécution, avec deux bizarreries à garder en tête : typeof null === "object" et typeof function === "function".
• number est un flottant 64 bits avec un plafond de sécurité pour les entiers ; bigint existe pour représenter des entiers exacts au-delà de ce plafond.

La suite : chaînes et littéraux de gabarit

Les chaînes sont le type primitif que tu manipuleras le plus, et les littéraux de gabarit (ces chaînes entre backticks) rendent leur construction indolore : interpolation, texte multi-ligne, gabarits étiquetés. C'est au programme de la prochaine page.