Méthodes des primitives en JavaScript

Introduction aux primitives et aux objets en JavaScript

En JavaScript, presque tout ce que vous écrivez implique soit une primitive, soit un object. Comprendre la différence — et l'astuce ingénieuse qui permet aux primitives de se comporter comme des objets — est l'un des fondements du langage.

Une primitive est la valeur la plus simple et indivisible qui soit. Il existe sept types primitifs : les nombres, les strings, les booleans, undefined, null, les symbols et les bigints. Un object est un ensemble de propriétés et de méthodes.

Voici l'énigme que cette page résout : une string est une primitive sans méthodes, pourtant "hello".toUpperCase() fonctionne. Comment une valeur dépourvue de méthodes peut-elle en appeler une ? La réponse tient aux enveloppes d'objets (object wrappers), et ce chapitre explique précisément leur fonctionnement.

Cette page couvre ce qui rend les primitives spéciales, la façon dont JavaScript les enveloppe brièvement pour permettre l'appel de méthodes, les méthodes disponibles pour chaque type primitif, ainsi que l'erreur courante consistant à utiliser new avec un constructeur de primitive.

Ce qui rend les primitives uniques

Les primitives se distinguent des objets par trois caractéristiques importantes.

1. Immutabilité. Une fois une valeur primitive créée, elle ne peut pas être modifiée. Une opération sur une string ne modifie jamais la string originale en place — elle retourne une toute nouvelle string. Essayer d'assigner un caractère ne fait rien (et lève une erreur en mode strict) :

2. Stockage par valeur. Une primitive est directement contenue dans la variable. Lorsque vous la copiez, vous copiez la valeur elle-même, de sorte que les deux variables sont totalement indépendantes :

Les objets, en revanche, sont stockés par référence — copier la variable ne copie qu'un pointeur vers le même object.

3. Simplicité et légèreté. Une primitive ne possède aucune propriété ni méthode propre, ce qui la rend rapide à créer et à comparer. Un boolean comme let flag = true; n'est qu'une valeur, sans aucune surcharge qu'un object impliquerait.

Les objets en JavaScript : un contraste

Les objets constituent la structure la plus complexe. Contrairement aux primitives, ils sont :

• Mutables — leur contenu peut être modifié après la création.
• Types référence — les objects sont stockés et copiés par référence, pas par valeur.
• Polyvalents — ils peuvent contenir des fonctions, des arrays et d'autres objets.

Comment les primitives appellent des méthodes : les enveloppes d'objets

Alors comment "hello".toUpperCase() fonctionne-t-il si la string n'a pas de méthodes ? Lorsque vous accédez à une propriété ou une méthode sur une primitive, JavaScript :

1. Crée un object enveloppe temporaire du type correspondant qui contient la valeur primitive.
2. Lit la méthode ou la propriété demandée depuis cet enveloppe.
3. L'exécute et retourne le résultat.
4. Supprime immédiatement l'object enveloppe.

Toute cette mécanique se déroule en coulisses et est fortement optimisée par le moteur, ce qui la rend pratiquement gratuite. Le point essentiel à retenir : la primitive elle-même n'est jamais modifiée et ne devient jamais définitivement un object — l'enveloppe n'existe que le temps de cette unique expression.

Les constructeurs d'enveloppes

Cinq types primitifs disposent d'un constructeur d'enveloppe intégré qui fournit leurs méthodes :

• String — pour les primitives de type string.
• Number — pour les valeurs numériques.
• Boolean — pour les valeurs boolean.
• Symbol — pour les symbols.
• BigInt — pour les bigints.

null et undefined n'ont pas d'enveloppe, donc accéder à une propriété sur eux lève une TypeError (par exemple null.toString() échoue).

Méthodes des strings

Les strings exposent un riche ensemble de méthodes via l'enveloppe String. Voici quelques-unes d'entre elles combinées pour mettre en majuscule la première lettre de chaque mot d'une phrase :

Notez que length est une propriété, pas une méthode, donc elle n'a pas de parenthèses. toUpperCase() retourne une nouvelle string et laisse greeting intact, conformément à la règle d'immutabilité évoquée plus haut.

Méthodes des nombres

Les nombres bénéficient de méthodes via l'enveloppe Number. Une méthode fréquemment utilisée est toFixed(), qui arrondit à un nombre fixe de décimales :

Deux points à surveiller. Premièrement, toFixed() retourne une string, pas un nombre — typeof (3.14159).toFixed(2) vaut "string". Deuxièmement, pour appeler une méthode directement sur un littéral numérique, vous avez besoin de parenthèses supplémentaires ou d'un espace : 255..toString(16) fonctionne aussi, mais 255.toString(16) est une erreur de syntaxe car l'analyseur interprète le premier point comme une virgule décimale.

Méthodes des booleans

Les booleans peuvent utiliser l'enveloppe Boolean, le plus souvent juste toString() :

Méthodes des symbols

Les symbols, un type primitif unique, bénéficient de méthodes via l'enveloppe Symbol :

Vous devez appeler toString() explicitement ici — les symbols ne se convertissent délibérément pas automatiquement en string dans les contextes de string (comme "" + sym), ce qui lèverait sinon une TypeError.

Méthodes des BigInts

BigInt, conçu pour les entiers trop grands pour le type Number standard, bénéficie de méthodes via l'enveloppe BigInt :

La valeur est passée ici sous forme de string car l'écrire comme un littéral numérique dépasserait la plage des entiers sûrs et perdrait de la précision avant que BigInt ne la reçoive.

Le piège : ne jamais utiliser new avec les enveloppes de primitives

JavaScript vous permet de construire vous-même un object enveloppe avec new Number(1), new String("x") ou new Boolean(false) — mais vous ne devriez presque jamais le faire. Un enveloppe créé avec new est un vrai object, et tout object est véridique (truthy), y compris celui qui enveloppe false :

C'est une source classique de bugs. Appeler le constructeur sans new est acceptable et utile — Number("42"), String(123) et Boolean(value) effectuent une simple conversion de type et retournent des primitives, pas des objets.

Résumé

• Les primitives sont des valeurs simples et immuables stockées par valeur ; les objets sont mutables et stockés par référence.
• Appeler une méthode sur une primitive fonctionne parce que JavaScript l'enveloppe dans un object temporaire, exécute la méthode, puis supprime l'enveloppe.
• String, Number, Boolean, Symbol et BigInt fournissent les méthodes ; null et undefined n'ont pas d'enveloppe et lèvent une erreur si vous accédez à une propriété.
• Utilisez les fonctions d'enveloppe sans new pour la conversion de type. N'utilisez jamais new pour créer des objects enveloppes dans le code courant — ils sont toujours truthy et se comportent de manière inattendue.

Ensuite, explorez les méthodes de chaque type en profondeur dans strings, numbers et bigint.

Pratique