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. Für benutzerdefinierte Function-Objekte 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 eine Function 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-Wert-Objekt kein Function-Objekt ist.

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

Wenn die toString()-Methode auf eingebauten Funktionsobjekten, einer Funktion, die durch Function.prototype.bind() erstellt wurde, 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 in intrinsischen Objekten ist someName der ursprüngliche Name der Funktion; andernfalls kann sein Inhalt implementierungsdefiniert sein, wird aber immer in der Eigenschaftsnamenssyntax wie [1 + 1], someName oder 1 dargestellt.

Wenn die toString()-Methode auf einer 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 wird Function("a", "b", "return a + b").toString() Folgendes zurückgeben:

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

Seit ES2018 erfordert die Spezifikation, dass der Rückgabewert von toString() exakt der gleiche Quellcode ist, wie er deklariert wurde, einschließlich jeglichen Leerzeichens und/oder Kommentars – oder, wenn der Host aus irgendeinem Grund den Quellcode nicht zur Verfügung hat, die Rückgabe eines native function string erfordert. 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, der nicht ein native function string ist. Die Methode gibt immer 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 stellt daher eine Form von implizitem eval() dar).

Es ist möglich, den Quelltext einer Funktion zu erhalten, indem man sie in eine Zeichenkette umwandelt – zum Beispiel, indem man sie in einem Template-Literal umschließt:

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

Dieser Quelltext ist exakt, einschließlich aller dazwischen gestreuten Kommentare (die sonst nicht in der internen 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()