Function: name

Ein String.

Die name Eigenschaft einer Funktion kann verwendet werden, um die Funktion in Debugging-Tools oder Fehlermeldungen zu identifizieren. Sie hat keine semantische Bedeutung für die Sprache selbst.

Die name Eigenschaft ist schreibgeschützt und kann nicht mit dem Zuweisungsoperator geändert werden:

function someFunction() {}

someFunction.name = "otherFunction";
console.log(someFunction.name); // someFunction

Um sie zu ändern, verwenden Sie Object.defineProperty().

Die name Eigenschaft wird typischerweise davon abgeleitet, wie die Funktion definiert ist. In den folgenden Abschnitten werden wir die verschiedenen Möglichkeiten beschreiben, wie sie abgeleitet werden kann.

Die name Eigenschaft gibt den Namen einer Funktionsdeklaration zurück.

function doSomething() {}
doSomething.name; // "doSomething"

Eine export default Deklaration exportiert die Funktion als Deklaration anstelle eines Ausdrucks. Ist die Deklaration anonym, lautet der Name "default".

// -- someModule.js --
export default function () {}

// -- main.js --
import someModule from "./someModule.js";

someModule.name; // "default"

Funktionen, die mit dem Function() Konstruktor erstellt wurden, haben den Namen "anonymous".

new Function().name; // "anonymous"

Wenn der Funktionsausdruck benannt ist, wird dieser Name als name Eigenschaft verwendet.

const someFunction = function someFunctionName() {};
someFunction.name; // "someFunctionName"

Anonyme Funktionsausdrücke, die mit dem Schlüsselwort function oder Pfeilfunktionen erstellt werden, hätten "" (einen leeren String) als ihren Namen.

(function () {}).name; // ""
(() => {}).name; // ""

Solche Fälle sind jedoch selten — normalerweise ist ein Funktionsausdruck mit einem Bezeichner verbunden, um woanders darauf zu verweisen (wie etwa in einer Variablendeklaration). In solchen Fällen kann der Name abgeleitet werden, wie die folgenden paar Unterabschnitte zeigen.

Ein praktischer Fall, in dem der Name nicht abgeleitet werden kann, ist eine Funktion, die von einer anderen Funktion zurückgegeben wird:

function getFoo() {
  return () => {};
}
getFoo().name; // ""

Variablen und Methoden können den Namen einer anonymen Funktion aus ihrer syntaktischen Position ableiten.

const f = function () {};
const object = {
  someMethod: function () {},
};

console.log(f.name); // "f"
console.log(object.someMethod.name); // "someMethod"

Dasselbe gilt für die Zuweisung:

let f;
f = () => {};
f.name; // "f"

Funktionen in Initialisierern (Standardwerten) von Destructuring, Standardparameter, Klassenfeldern, etc., werden den Namen des gebundenen Bezeichners als ihren name übernehmen.

const [f = () => {}] = [];
f.name; // "f"

const { someMethod: m = () => {} } = {};
m.name; // "m"

function foo(f = () => {}) {
  console.log(f.name);
}
foo(); // "f"

class Foo {
  static someMethod = () => {};
}
Foo.someMethod.name; // someMethod

Function.prototype.bind() erzeugt eine Funktion, deren Name "bound " plus der Funktionsname ist.

function foo() {}
foo.bind({}).name; // "bound foo"

Bei Verwendung von get und set Accessor-Eigenschaften erscheint "get" oder "set" im Funktionsnamen.

const o = {
  get foo() {},
  set foo(x) {},
};

const descriptor = Object.getOwnPropertyDescriptor(o, "foo");
descriptor.get.name; // "get foo"
descriptor.set.name; // "set foo";

Der Name einer Klasse folgt demselben Algorithmus wie Funktionsdeklarationen und -ausdrücke.

class Foo {}
Foo.name; // "Foo"

Wenn ein Symbol als Funktionsname verwendet wird und das Symbol über eine Beschreibung verfügt, ist der Methodenname die Beschreibung in eckigen Klammern.

const sym1 = Symbol("foo");
const sym2 = Symbol();

const o = {
  [sym1]() {},
  [sym2]() {},
};

o[sym1].name; // "[foo]"
o[sym2].name; // "[]"

Private Felder und private Methoden haben das Rautezeichen (#) als Teil ihrer Namen.

class Foo {
  #field = () => {};
  #method() {}
  getNames() {
    console.log(this.#field.name);
    console.log(this.#method.name);
  }
}

new Foo().getNames();
// "#field"
// "#method"

Sie können obj.constructor.name verwenden, um die "Klasse" eines Objekts zu überprüfen.

function Foo() {} // Or: class Foo {}

const fooInstance = new Foo();
console.log(fooInstance.constructor.name); // "Foo"

Da statische Mitglieder jedoch zu eigenen Eigenschaften der Klasse werden, können wir den Klassennamen für praktisch jede Klasse mit einer statischen Methodeneigenschaft name() nicht ermitteln:

class Foo {
  constructor() {}
  static name() {}
}

Mit einer static name() Methode ist Foo.name nicht länger der tatsächliche Klassenname, sondern eine Referenz auf das name() Funktionsobjekt. Der Versuch, die Klasse von fooInstance über fooInstance.constructor.name zu ermitteln, gibt uns nicht den Klassennamen, sondern eine Referenz auf die statische Klassenmethode. Beispiel:

const fooInstance = new Foo();
console.log(fooInstance.constructor.name); // ƒ name() {}

Aufgrund der Existenz von statischen Feldern könnte name auch keine Funktion sein.

class Foo {
  static name = 123;
}
console.log(new Foo().constructor.name); // 123

Hat eine Klasse eine statische Eigenschaft namens name, wird sie auch beschreibbar. Die eingebaute Definition ist in Abwesenheit einer benutzerdefinierten statischen Definition schreibgeschützt:

Foo.name = "Hello";
console.log(Foo.name); // "Hello" if class Foo has a static "name" property, but "Foo" if not.

Daher können Sie sich nicht darauf verlassen, dass die eingebaute name Eigenschaft immer den Namen einer Klasse enthält.

Quellcode wie:

function Foo() {}
const foo = new Foo();

if (foo.constructor.name === "Foo") {
  console.log("'foo' is an instance of 'Foo'");
} else {
  console.log("Oops!");
}

kann komprimiert werden zu:

function a() {}
const b = new a();
if (b.constructor.name === "Foo") {
  console.log("'foo' is an instance of 'Foo'");
} else {
  console.log("Oops!");
}

In der unkomprimierten Version läuft das Programm in den wahrheitsgemäßen Zweig und protokolliert "'foo' ist eine Instanz von 'Foo'" — während es in der komprimierten Version anders funktioniert und in den anderen Zweig geht. Wenn Sie sich auf die name Eigenschaft verlassen, wie im obigen Beispiel, stellen Sie sicher, dass Ihre Build-Pipeline die Funktionsnamen nicht ändert, oder gehen Sie nicht davon aus, dass eine Funktion einen bestimmten Namen hat.

• Polyfill für Function: name in core-js
• es-shims Polyfill von Function.prototype.name
• Function