Function.prototype.toString()

Keine.

Eine Zeichenkette, die den Quellcode der Funktion darstellt.

Das Function-Objekt überschreibt die toString()-Methode, die von Object geerbt wird; es erbt nicht Object.prototype.toString. Bei benutzerdefinierten Function-Objekten gibt die toString-Methode eine Zeichenkette zurück, die das Quelltextsegment enthält, das zur Definition der Funktion verwendet wurde.

JavaScript ruft die toString-Methode automatisch auf, wenn ein Function-Objekt als Textwert dargestellt werden soll, z.B. wenn eine Funktion mit einer Zeichenkette verkettet wird.

Die toString()-Methode wirft eine TypeError-Ausnahme ("Function.prototype.toString called on incompatible object"), wenn das this-Wertobjekt kein Function-Objekt ist.

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

Wenn die toString()-Methode auf eingebauten Funktionsobjekten, einer durch Function.prototype.bind() erstellten Funktion oder anderen Nicht-JavaScript-Funktionen aufgerufen wird, gibt toString() eine native function string zurück, die folgendermaßen aussieht:

function someName() { [native code] }

Für Methoden und Funktionen von intrinsischen Objekten ist someName der ursprüngliche Name der Funktion; andernfalls kann ihr Inhalt durch die Implementierung definiert werden, wird aber immer in der Syntax für Eigenschaftsnamen sein, wie [1 + 1], someName oder 1.

Wenn die toString()-Methode auf eine Funktion aufgerufen wird, die durch den Function-Konstruktor erstellt wurde, gibt toString() den Quellcode einer synthetisierten Funktionsdeklaration mit dem Namen "anonymous" unter Verwendung der bereitgestellten Parameter und des Funktionskörpers zurück. Zum Beispiel gibt Function("a", "b", "return a + b").toString() zurück:

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

Seit ES2018 verlangt die Spezifikation, dass der Rückgabewert von toString() genau der Quellcode ist, wie er deklariert wurde, einschließlich aller Leerzeichen und/oder Kommentare — oder, falls der Host den Quellcode aus irgendeinem Grund nicht verfügbar hat, dass eine native Funktionszeichenfolge zurückgegeben werden muss. Unterstützung für dieses überarbeitete Verhalten finden Sie in der Kompatibilitätstabelle.

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}

Beachten Sie, dass nach der Überarbeitung von Function.prototype.toString(), wenn toString() aufgerufen wird, Implementierungen niemals erlaubt sind, den Quellcode einer Funktion zu synthetisieren, der keine native Funktionszeichenfolge ist. Die Methode gibt stets den exakten Quellcode zurück, der zur Erstellung der Funktion verwendet wurde — einschließlich der Getter und Setter-Beispiele oben. Der Function-Konstruktor selbst hat die Fähigkeit, den Quellcode für die Funktion zu synthetisieren (und ist daher eine Form von implizitem eval()).

Es ist möglich, den Quelltext einer Funktion zu erhalten, indem man sie in eine Zeichenkette umwandelt — zum Beispiel, indem man sie in ein Template Literal einbettet:

function foo() {
  return "bar";
}
console.log(`${foo}`);
// function foo() {
//   return "bar";
// }

Dieser Quelltext ist exakt, einschließlich aller eingefügten Kommentare (die ansonsten nicht durch die interne Darstellung der Engine gespeichert werden).

function foo /* a comment */() {
  return "bar";
}
console.log(foo.toString());
// function foo /* a comment */() {
//   return "bar";
// }

• Object.prototype.toString()