Function.prototype.toString()

Keine.

Ein String, der den Quellcode der Funktion darstellt.

Das Function-Objekt überschreibt die toString()-Methode, die von Object geerbt wurde; es erbt nicht Object.prototype.toString. Für benutzerdefinierte Function-Objekte gibt die toString-Methode einen String zurück, der das Quelltextsegment enthält, das zur Definition der Funktion verwendet wurde.

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

Die toString()-Methode wird eine TypeError-Ausnahme auslösen ("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() einen nativem Funktionsstring zurück, der so aussieht:

function someName() { [native code] }

Für Methoden und Funktionen von intrinsischen Objekten ist someName der ursprüngliche Name der Funktion; ansonsten kann ihr Inhalt implementationsspezifisch sein, wird aber immer in einer Eigenschaftsnamensyntax sein, wie [1 + 1], someName oder 1.

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

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

Seit ES2018 verlangt die Spezifikation, dass der Rückgabewert von toString() genau derselbe Quellcode ist, wie er deklariert wurde, einschließlich aller Leerzeichen und/oder Kommentare — oder, wenn der Host den Quellcode aus irgendeinem Grund nicht verfügbar hat, muss ein nativer Funktionsstring zurückgegeben werden. Die 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 den Quellcode einer Funktion synthetisieren dürfen, die kein nativer Funktionsstring ist. Die Methode gibt immer den genauen 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 einen String zwingt — zum Beispiel, indem man sie in einen Template-String einschließt:

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

Dieser Quelltext ist genau, einschließlich aller eingestreuten Kommentare (die sonst nicht durch die interne Darstellung der Engine gespeichert würden).

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

• Object.prototype.toString()