Function.prototype.toString()

Keine.

Ein String, der den Quellcode der Funktion repräsentiert.

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

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 wirft eine TypeError Ausnahme ("Function.prototype.toString called on incompatible object"), wenn ihr this Wert Objekt 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 nativen Funktionsstring zurück, der folgendermaßen aussieht:

function someName() { [native code] }

Für Methoden und Funktionen von intrinsischen Objekten ist someName der Anfangsname der Funktion; andernfalls kann ihr Inhalt implementierungsabhängig sein, wird jedoch immer in Eigenschaftsnamenssyntax sein, wie [1 + 1], someName oder 1.

Wird die toString()-Methode auf eine Funktion angewendet, die durch den Function-Konstruktor erstellt wurde, gibt toString() den Quellcode einer synthetisierten Funktionsdeklaration mit dem Namen "anonymous" zurück, die die angegebenen Parameter und den Funktionskörper verwendet. Beispielsweise 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() exakt der gleiche 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, erfordert die Spezifikation die Rückgabe eines nativen Funktionsstrings. 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 einen Funktionsquellcode synthetisieren dürfen, der kein nativer Funktionsstring ist. Die Methode gibt immer den exakten Quellcode zurück, der zur Erstellung der Funktion verwendet wurde — einschließlich der oben genannten getter und setter Beispiele. 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 umwandelt — z.B. indem man sie in einen Template-Literal einwickelt:

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

Dieser Quelltext ist exakt, einschließlich aller verstreuten 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()