En JavaScript, transformer des données en chaîne de caractères est une opération quotidienne. Le langage propose plusieurs approches, chacune adaptée à des contextes spécifiques. Voici les principales techniques avec leurs particularités.

1. La fonction String()

String() est une fonction globale qui convertit n'importe quelle valeur en chaîne.

String(123);          // "123"
String(45.67);        // "45.67"
String(true);         // "true"
String(false);        // "false"
String(null);         // "null"
String(undefined);    // "undefined"
String([1, 2, 3]);    // "1,2,3"
String({});           // "[object Object]"

Usage typique : lorsqu'on ne connaît pas le type exact de la donnée et qu'on souhaite une conversion fiable.
Avantage : syntaxe claire et support universel.
Inconvénient : pour un objet simple, on obtient seulement "[object Object]".

2. La méthode .toString()

Presque tous les types (sauf null et undefined) possèdent une méthode .toString().

(123).toString();          // "123"
(45.67).toString();        // "45.67"
true.toString();           // "true"
false.toString();          // "false"
(10n).toString();          // "10" (BigInt)
[1, 2, 3].toString();      // "1,2,3"
({}).toString();           // "[object Object]"

Attention : null.toString() et undefined.toString() génèrent une erreur TypeError.

null.toString();        // TypeError
undefined.toString();   // TypeError

Usage typique : obtenir la représentation par défaut d’un nombre, d’un tableau, d’une date, etc.

3. L'opérateur + (concaténation)

L'opérateur + convertit implicitement les valeurs en chaînes lors d’une concaténation.

123 + "";        // "123"
45.67 + "";      // "45.67"
true + "";       // "true"
false + "";      // "false"
null + "";       // "null"
undefined + "";  // "undefined"
[1, 2, 3] + "";  // "1,2,3"

Usage typique : insérer une valeur dans une chaîne de manière concise, par exemple var msg = "Le total est " + total + " €";.

4. Les gabartis de chaînes (template literals)

Introduits avec ES6, ils permettent d’incorporer des expressions via ${}, avec conversion automatique en chaîne.

`${123}`;         // "123"
`${45.67}`;       // "45.67"
`${true}`;        // "true"
`${false}`;       // "false"
`${null}`;        // "null"
`${undefined}`;   // "undefined"
`${[1, 2, 3]}`;   // "1,2,3"

Usage typique : formatage de chaînes complexes, multilignes ou avec interpolation.

5. JSON.stringify()

Cette méthode sérialise un objet ou un tableau au format JSON (chaîne).

JSON.stringify(123);       // "123"
JSON.stringify(45.67);     // "45.67"
JSON.stringify(true);      // "true"
JSON.stringify([1, 2, 3]); // "[1,2,3]"
JSON.stringify({ nom: "Dupont", age: 30 }); // '{"nom":"Dupont","age":30}'
JSON.stringify(null);      // "null"

Particularité : undefined, function, symbol sont ignorés ou convertis en null.

JSON.stringify(undefined);       // undefined
JSON.stringify(function() {});    // undefined

Usage typique : échange de données (API, stockage local, etc.).

6. Object.prototype.toString.call()

Cette technique renvoie le type interne de l'objet sous forme "[object Type]".

Object.prototype.toString.call(123);       // "[object Number]"
Object.prototype.toString.call(true);      // "[object Boolean]"
Object.prototype.toString.call([1, 2, 3]); // "[object Array]"
Object.prototype.toString.call({});        // "[object Object]"
Object.prototype.toString.call(null);      // "[object Null]"
Object.prototype.toString.call(undefined); // "[object Undefined]"

Usage typique : vérification fine du type dans du code générique ou des bibliothèques.

7. Points à retenir

• null et undefined : String() donne "null" et "undefined" ; .toString() lève une exception.
• Booléen : true → "true", false → "false".
• Nombre spécial NaN → "NaN".
• Tableau : .toString() produit une liste séparée par des virgules ; JSON.stringify() donne une chaîne JSON entre crochets.

8. Synthèse