JavaScript/Objekte/Function/name

Jede JavaScript-Funktion besitzt eine Eigenschaft name, die den Namen der Funktion enthält. Bei Funktionen, die mit einem Namen definiert wurden, ist das genau dieser Name. Bei anonymen Funktionen gibt es mehrere Möglichkeiten, auf die im Folgenden noch eingegangen wird.

Die name-Eigenschaft der Konstruktorfunktion Function enthält die Zeichenkette "Function".

Syntax

name

Attribute

Writable	false
Enumerable	false
Configurable	true

Allgemeines

Die name-Eigenschaft ist für die Ausführbarkeit einer Funktion ohne Bedeutung. Sie dient hauptsächlich dazu, die Funktion in einem Debugger besser identifizieren zu können.

Natürlich könnten Sie auch Code schreiben, der ein Funktionsobjekt als Parameter erwartet und den Namen der Funktion abfragt, um die Verwendung der Funktion zu steuern. Zu empfehlen ist eine solche Vorgehensweise jedoch nicht, hier wäre eine objektorientiertes Redesign der Anwendung angebracht.

Zu den benannten Funktionen zählen die meisten eingebauten Funktionsobjekte, auch der Konstruktor Function, weshalb in der Eigenschaft name dieses Standardobjektes der String "Function" gespeichert ist.

Funktionsdeklarationen

Funktionen, die mit dem function-Statement definiert werden, enthalten in ihrer name</code>-Eigenschaft den Namen, der bei der Definition verwendet wurde.

Beispiel

function MarilynMonroe( ) {
  return 'Some Like It Hot';
}

console.info(MarilynMonroe.name); // MarilynMonroe

Die einzige Ausnahme von dieser Regel sind Funktionen, die als Standardexport eines Moduls deklariert werden (Export Declaration), denn auf diese Weise deklarierte Funktionen dürfen anonym sein. Wird bei einer solchen Funktionsdeklaration kein Bezeichner angegeben, dann wird als Wert der Eigenschaft name die Zeichenkette default hinterlegt, ansonsten wie üblich der Name der Funktion.

Funktionsausdrücke

Im Gegensatz zu Funktionsdeklarationen ist bei Funktionen die als Ausdruck notiert werden (Function Expressions) die Angabe eines Bezeichners optional. Wird dennoch ein Bezeichner angegeben, dann wird in der name</code>-Eigenschaft des Funktionsobjekts der Name hinterlegt, mit den die Funktion definiert wurde.

Eine weitere Möglichkeit ist, dass ein anonymer, also namenloser Funktionsausdruck direkt bei seiner Erzeugung einer Variablen zugewiesen wird, dann wird in name</code> der Name der Variablen, der die Funktion zugewiesen wurde, gespeichert. Dabei spielt es keine Rolle, ob die Variable in der gleichen Zeile deklariert wurde oder bereits vorhanden war. Das gleiche gilt bei der Speicherung in einer Objekteigenschaft, wenn sie in einem Objektliteral erzeugt wird, selbst dann, wenn der Name der Eigenschaft in diesem Moment aus einer Variablen geholt wird.

Benannter Funktionsausdruck oder gespeicherte anonyme Funktion

let wallace = null;
let pink = 'The Pink Panther';
const actress = function VeronicaLake( ) { return 'Die Blaue Dahlie'; };
wallace = function( ) { return 'Die Blaue Hand'; };
let obj = { 
   aardvark: function( ) { return 'Die Blaue Elise'; },
   [pink]: function( ) { return 'Inspector Cluseau'; }
};

console.info(actress.name);        // VeronicaLake
console.info(wallace.name);        // wallace
console.info(obj.aardvark.name);   // aardvark
console.info(obj[pink].name);      // The Pink Panther

Beachten Sie:

• Eine Funktion, die durch einen Funktionsausdruck erzeugt wird, erhält nur dann bei der Zuweisung den Namen der Variablen oder Eigenschaft, wenn die Funktion anonym war. Ein benannter Funktionsausdruck (z. B. VeronicaLake) behält seinen Namen.
• Eine anonyme Funktion erhält nur dann den Namen der Variablen oder Eigenschaft zugewiesen, wenn sie im gleichen Statement erzeugt und zugewiesen wird. Eine spätere Zuweisung setzt den Namen nicht mehr.

Wird eine anonyme Funktion hingegen direkt verwendet, ohne zugewiesen zu werden, dann bleibt ihr Name leer.

Anonyme Funktion ohne Speicherung

const LeeMarvin = (function( ) { return 'Point Blank'; }).name;
function showName( f ) { console.info(f.name); }

console.info( LeeMarvin );                            // ''
showName( function( ) { return 'Interstellar'; } );   // ''

Es ist auch zu berücksichtigen, dass der Bezeichner der Variable nur dann in die Eigenschaft name übernommen wird, wenn der Funktionsausdruck Teil der Zuweisung ist, nicht aber wenn die anonyme Funktion bereits zu einem früheren Zeitpunkt erstellt wurde, wie das folgende Beispiel zeigt.

Anonyme Funktion wird nicht sofort zugewiesen

function createAdder( x ) {
   return function(y) { return x+y; };    // Hier wird die Funktion erzeugt
}

const add7 = createAdder(7);              // Hier wird sie zugewiesen
console.log(add7.name);                   // '' - name ist leergeblieben

Die Zuweisung an eine Objekteigenschaft, also ohne Verwendung eines Objektliterals, weist ebenfalls keinen Namen zu:

Zuweisung an Eigenschaft

const obj = { };

obj.MarioGirotti = function( ) { return 'Terence Hill'; };

console.log(obj.TerenceHill.name);        // '' - sein Name ist Nobody...

Gebundene Funktionen

Die Methode bind(), mit der man eine Funktion an ein bestimmtes this-Objekt binden kann, erzeugt für die name-Eigenschaft der erzeugten Funktion einen Namen, der sich aus der Zeichenkette 'bound ' und dem name-Wert der damit gebundenen Funktion zusammensetzt. Die Leerstelle hinter 'bound' wird dabei immer gesetzt!

Beispiel

function TheGetaway ( ) {
  return 1972;
}

const film1 = TheGetaway.bind({ });
const film2 = (function() { return this; }).bind("James Cameron");

console.log(film1.name); // 'bound TheGetaway'
console.log(film2.name); // 'bound '

Beachten Sie: Die name-Eigenschaft ist zwar schreibgeschützt, aber konfigurierbar. Sie lässt sich deshalb mittels defineProperty ersetzen. Auf diesem Weg können Sie eine Funktion mit einer name-Eigenschaft erzeugen, deren Inhalt keine Zeichenkette ist. Rufen Sie bind() auf einer solchen Funktion auf, erhalten Sie ebenfalls 'bound ' als Name.

Dynamisch erzeugte Funktionen

Wird eine Funktion dynamisch zur Laufzeit durch den Aufruf des Konstruktors Function erzeugt, dann handelt es sich dabei zwar um eine anonyme Funktion, aber ihre name-Eigenschaft ist nicht leer. Statt dessen hinterlegt der Function-Konstruktor die Zeichenkette 'anonymous'.

Verwendung

Sie können die name-Eigenschaft verwenden, um den Typ eines Objekts zu bestimmen, das durch eine Konstruktorfunktion erzeugt wurde. Solche Objekte besitzen als Prototyp das Objekt, das in der prototype-Eigenschaft der Konstruktorfunktion hinterlegt ist, und dieses Prototypobjekt wiederum besitzt eine Eigenschaft constructor, die auf die Konstruktorfunktion verweist.

Name des Konstruktors ermitteln

function Film() {
}

const interstellar = new Film();
console.log(interstellar.constructor.name);     // Film

Beachten Sie: Wenn Sie den Konstruktor vergleichen möchten und an der Stelle, wo Sie das tun wollen, auf die Konstruktorfunktion zugreifen können, ist es besser, die Abfrage in einer der beiden folgenden Formen zu formulieren:

   if (interstellar instanceof Film) ...
   if (interstellar.constructor === Film) ...

Objekte direkt zu vergleichen ist immer besser, als magische Zeichenketten im Code zu verstreuen.

Weblinks

• ECMAScript Spezifikation: [1]