Function : méthode toString()

Baseline Widely available *

Cette fonctionnalité est bien établie et fonctionne sur de nombreux appareils et versions de navigateurs. Elle est disponible sur tous les navigateurs depuis juillet 2015.

* Certaines parties de cette fonctionnalité peuvent bénéficier de prise en charge variables.

La méthode toString() des instances de Function retourne une chaîne de caractères représentant le code source de la fonction.

Exemple interactif

function sum(a, b) {
  return a + b;
}

console.log(sum.toString());
// Résultat attendu : "function sum(a, b) {
//                      return a + b;
//                    }"

console.log(Math.abs.toString());
// Résultat attendu : "function abs() { [native code] }"

Syntaxe

toString()

Valeur de retour

Une chaîne de caractères qui représente le code source de la fonction.

L'objet Function remplace la méthode toString() héritée de Object ; il n'hérite pas de Object.prototype.toString. Pour les objets Function définis par l'utilisateur, la méthode toString retourne une chaîne contenant le segment de texte source utilisé pour définir la fonction.

JavaScript appelle automatiquement la méthode toString lorsqu'une Function doit être représentée comme une valeur textuelle, par exemple lorsqu'une fonction est concaténée avec une chaîne.

La méthode toString() lèvera une exception TypeError ("Function.prototype.toString called on incompatible object"), si l'objet this n'est pas un objet Function.

Function.prototype.toString.call("toto"); // throws TypeError

Si la méthode toString() est appelée sur des objets fonction intégrés, une fonction créée par Function.prototype.bind(), ou d'autres fonctions non JavaScript, alors toString() retourne une chaîne de fonction native qui ressemble à

function someName() { [native code] }

Pour les méthodes et fonctions des objets intrinsèques, someName est le nom initial de la fonction ; sinon, son contenu peut être défini par l'implémentation, mais sera toujours dans la syntaxe du nom de propriété, comme [1 + 1], someName ou 1.

Note : Cela signifie que l'utilisation de eval() sur des chaînes de fonctions natives est une erreur de syntaxe garantie.

Si la méthode toString() est appelée sur une fonction créée par le constructeur Function, toString() retourne le code source d'une déclaration de fonction synthétisée nommée "anonymous" en utilisant les paramètres et le corps de fonction fournis. Par exemple, Function("a", "b", "return a + b").toString() retournera :

function anonymous(a,b
) {
return a + b
}

Depuis ES2018, la spécification exige que la valeur de retour de toString() soit exactement le même code source que celui utilisé lors de la déclaration, y compris les espaces et/ou les commentaires — ou, si l'hôte n'a pas le code source disponible pour une raison quelconque, il doit retourner une chaîne de fonction native. La prise en charge de ce comportement révisé peut être trouvée dans le tableau de compatibilité.

Exemples

Comparer le code source réel et les résultats de toString

function test(fn) {
  console.log(fn.toString());
}

function f() {}
class A {
  a() {}
}
function* g() {}

test(f); // "function f() {}"
test(A); // "class A { a() {} }"
test(g); // "function* g() {}"
test((a) => a); // "(a) => a"
test({ a() {} }.a); // "a() {}"
test({ *a() {} }.a); // "*a() {}"
test({ [0]() {} }[0]); // "[0]() {}"
test(Object.getOwnPropertyDescriptor({ get a() {} }, "a").get); // "get a() {}"
test(Object.getOwnPropertyDescriptor({ set a(x) {} }, "a").set); // "set a(x) {}"
test(Function.prototype.toString); // "function toString() { [native code] }"
test(function f() {}.bind(0)); // "function () { [native code] }"
test(Function("a", "b")); // function anonymous(a\n) {\nb\n}

Notez qu'après la révision de Function.prototype.toString(), lorsque toString() est appelé, les implémentations ne sont jamais autorisées à synthétiser le code source d'une fonction qui n'est pas une chaîne de fonction native. La méthode retourne toujours le code source exact utilisé pour créer la fonction — y compris les exemples d'accesseur et de mutateur ci-dessus. Le constructeur Function lui-même a la capacité de synthétiser le code source de la fonction (et est donc une forme implicite de la méthode eval()).

Obtenir le texte source d'une fonction

Il est possible d'obtenir le texte source d'une fonction en la forçant à être une chaîne de caractères — par exemple, en l'enveloppant dans un littéral de modèle :

function toto() {
  return "truc";
}
console.log(`${toto}`);
// function toto() {
//   return "truc";
// }

Cette source est exacte, y compris les commentaires intercalés (qui ne seront pas stockés par la représentation interne du moteur autrement).

function toto /* un commentaire */() {
  return "truc";
}
console.log(toto.toString());
// function toto /* un commentaire */() {
//   return "truc";
// }