JavaScript/Objekte/Function/name

Aus SELFHTML-Wiki
Wechseln zu: Navigation, Suche

Die Eigenschaft name des Konstruktors Function gibt einen String mit dessen Bezeichner zurück, also die Zeichenkette Function.


Syntax

Function.name


Attribute
Writable false
Enumerable false
Configurable true


Allgemeines[Bearbeiten]

Die meisten Funktionen verfügen über eine eigene, schreibgeschützte Eigenschaft mit dem Bezeichner name. Die Eigenschaft besitzt keine semantische Relevanz, sondern dient lediglich der Beschreibung der Funktion. Wird eine solche Eigenschaft implizit auf einem Funktionsobjekt definiert, dann hängt der Wert der Eigenschaft einerseits davon ab wie die Funktion erzeugt wurde und andererseits davon, ob es sich um eine benannte oder um eine anonyme Funktion handelt. Ist eine Funktion benannt, dann ist grundsätzlich eine Stringrepräsentation ihres Bezeichners als Wert der Eigenschaft name hinterlegt.


Beispiel
const name = Function.name;

console.info(name); // Function


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. Die Eigenschaft wird jedoch nicht nur für solche Funktionen definiert, die als Teil der Sprache oder der Ausführungsumgebung bereitgestellt werden, weshalb in den folgenden Abschnitten gezeigt wird, unter welchen Voraussetzungen und in welcher Weise die Eigenschaft name auf Funktionsobjekten angelegt wird.

Funktionsdeklarationen[Bearbeiten]

Funktionen die deklariert werden (Function Declarations) besitzen immer eine eigene Eigenschaft name, deren Wert üblicherweise der in einen String konvertierte Bezeichner der Funktion ist. Denn Funktionsdeklarationen ohne Angabe eines Bezeichners erzeugen in aller Regel einen Syntaxfehler und bei benannten Funktionen wird wie gesehen immer der Bezeichner der Funktion als Wert der Eigenschaft name hinterlegt.


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[Bearbeiten]

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 auch in diesem Fall auf dem Funktionsobjekt eine eigene Eigenschaft name definiert, deren Wert der in einen String konvertierte Bezeichner der Funktion ist.


Beispiel
const actress = function VeronicaLake ( ) {
  return 'The Blue Dahlia';
};

console.info(actress.name); // VeronicaLake


Wird für die Funktion hingegen kein Bezeichner angegeben, handelt es sich also um einen anonymen Funktionsausdruck, dann hängt es davon ab in welchem Kontext der Ausdruck notiert wurde, ob für die Funktion eine eigene Eigenschaft mit dem Bezeichner name angelegt wird und falls dies geschieht, mit welchem Wert die Eigenschaft initialisiert wird.


Beispiel
const LeeMarvin = (function ( ) {
  return 'Point Blank';
}).name;

console.info(LeeMarvin); //


Die Grundregel hinsichtlich anonymer Funktionsausdrücke ist, dass für die Funktion keine eigene Eigenschaft mit dem Bezeichner name definiert wird. Das heißt, sofern nicht eine der im Folgenden beschriebenen Ausnahmeregeln greift, erben anonyme Funktionen die Eigenschaft name von Function.prototype, deren Wert standardmäßig ein leerer String ist.


Beispiel
var TheBigHeat = function ( ) {
  return 1953;
};

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


const TheThirdMan = function ( ) {
  return 'Carol Reed';
};

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


Wenn einer Variable ein anonymer Funktionsausdruck zugewiesen wird (Assignment Expression), dann wird für die Funktion eine eigene Eigenschaft name definiert, deren Wert der in einen String konvertierte Bezeichner der Variable ist. Dabei spielt weder der Typ der Variable eine Rolle, noch ob die Variable bereits zuvor deklariert wurde und sie erst zu einem späteren Zeitpunkt mit dem Ergebnis des Ausdrucks initialisiert wird. Wobei letzteres natürlich nur dann möglich ist, wenn es sich bei der Variable nicht um eine Konstante handelt, denn eine solche muss grundsätzlich bei ihrer Deklaration initialisiert werden.


Beispiel
let TheAsphaltJungle = function ( ) {
  return 1950;
};

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


let AllThroughTheNight;

if (true) {
  AllThroughTheNight = function ( ) {
    return 'Vincent Sherman';
  };
}

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


Dabei ist jedoch 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.


Beispiel
const RichardBrooks = TennesseeWilliams( );

function TennesseeWilliams ( ) {
  return function ( ) {
    const title = 'Cat on a Hot Tin Roof';
  };
}

console.info(RichardBrooks.hasOwnProperty('name')); // false

console.info(RichardBrooks.name); //


Da der Funktionsausdruck hier Teil einer Rückgabeanweisung (Return Statement) ist, wird die Eigenschaft name auf dem anonymen Funktionsobjekt nicht definiert. Die spätere Zuweisung des Rückgabewertes der aufgerufenen Funktion an die Variable ist in diesem Zusammenhang nicht mehr relevant. Entsprechend erbt die unbenannte Funktion die Eigenschaft name von Function.prototype, sodass beim Zugriff auf die Eigenschaft ein leerer String zurückgegeben wird.


Beispiel
const film = {
  LanaTurner : function ( ) {
    return 'The Postman Always Rings Twice';
  }
};
 
console.info(film.LanaTurner.name); // LanaTurner


Ähnlich wie bei der Initialisierung einer Variable, wird auch bei anonymen Funktionsausdrücken die als Teil einer Eigenschaftsdefinition in einem Objektliteral notiert werden (Property Definition) implizit eine eigene Eigenschaft name definiert, deren Wert der Name der Objekteigenschaft ist.


Beispiel
const Chinatown = function ( ) {
  return ['Jack Nicholson', 'Faye Dunaway'];
};
 
const film = {
  RomanPolański : Chinatown
};
 
console.log(film.RomanPolański.name); // Chinatown


Dabei ist aber zu beachten, dass auch hier der Name der Objekteigenschaft nur dann übernommen wird, wenn der Funktionsausdruck ein Teil der Zuweisung ist. Wird wie in dem Beispiel oben nur eine Referenz auf eine bereits erstellte Funktion zugewiesen, dann wird der Wert der Eigenschaft name durch diese Zuweisung nicht verändert.


Beispiel
const actress = {
  MaryAstor : function (Midnight) {
    return Midnight;
  }(function ( ) {
    return 1939;
  })
};

console.log(actress.MaryAstor.hasOwnProperty('name')); // false

console.log(actress.MaryAstor.name); //


Dies gilt wie das Beispiel oben zeigt auch in dem Fall, dass eine Referenz auf eine anonyme Funktion zugewiesen wird, die noch über keine eigene Eigenschaft name verfügt.


Beispiel
const film = {
  WalterHill : function TheDriver ( ) {
    return ['Ryan O’Neal', 'Isabelle Adjani'];
  }
};
 
console.log(film.WalterHill.name); // TheDriver


Auch bei der Eigenschaftsdefinition in einem Objektliteral gilt aber natürlich, dass bei einem benannten Funktionsausdruck der Bezeichner der Funktion in der Eigenschaft name hinterlegt wird, denn die explizite Angabe eines Funktionsbezeichners hat immer Vorrang vor einer impliziten Eigenschaftsdefinition.


Beispiel
const basket = {
  case : function ( ) {
    return ['Frank Henenlotter', 1982];
  }
};
 
console.log(basket.case.name); // case


Als Name für Objekteigenschaften kommen übrigens nicht nur reguläre Bezeichner in Frage. So können hier unter anderem auch geschützte Worte (Reserved Words) verwendet werden, was an anderer Stelle einen Syntaxfehler produzieren würde. Entsprechend wird in dem Beispiel oben der Bezeichner case in einen String konvertiert und als Wert der Eigenschaft name hinterlegt, obwohl es sich bei diesem Bezeichner um ein geschütztes Wort handelt. Es ist hierbei allerdings zu beachten, dass die anderen Voraussetzungen für die Gültigkeit von Bezeichnern durch diese Sonderregel nicht außer Kraft gesetzt sind.


Beispiel
const films = {
  'FritzLang' : function ( ) {
    return ['Metropolis', 'Das Testament des Dr. Mabuse'];
  }
};
 
console.log(films.FritzLang.name); // FritzLang


Auch ist es nicht erforderlich, dass überhaupt ein Bezeichner als Eigenschaftsname in einem Objektliteral verwendet wird. Wie in dem Beispiel oben gezeigt, kann auch ein Wert vom Datentyp String als Name der Eigenschaft angegeben werden (String Literal). Wird ein String als Eigenschaftsname angegeben und handelt es sich bei dem Wert der Eigenschaft um einen anonymen Funktionsausdruck, dann wird auch hier eine eigene Eigenschaft name auf dem Funktionsobjekt definiert, deren Wert der Name der Objekteigenschaft ist.


Beispiel
const JohnSteinbeck = {
  'East of Eden' : function ( ) {
    return ['Elia Kazan', 1955];
  }
};

console.info(JohnSteinbeck['East of Eden'].name); // East of Eden


Bei der Verwendung eines Stringliterals als Eigenschaftsname ist aber zu beachten, dass ein späterer Zugriff auf die Objekteigenschaft nur dann über die Punktnotation erfolgen kann, wenn es möglich ist den String als gültigen Bezeichner zu notieren, von dem hier nicht einschlägigen Verbot der Verwendung geschützter Namen einmal abgesehen. Sonst muss der Zugriff wie in dem Beispiel oben über die Klammernotation erfolgen.


Beispiel
const GérardDepardieu = {
  1492 : function ( ) {
    return 'Conquest of Paradise';
  }
};

console.info(GérardDepardieu[1492].name); // 1492


Auch kann statt eines Bezeichners oder eines Strings ein Wert vom Datentyp Number als Eigenschaftsname verwendet werden (Numeric Literal). In diesem Fall wird eine Stringkonversion des numerischen Wertes in der Eigenschaft name gespeichert, wenn ein anonymer Funktionsausdruck zugewiesen wird. Der Zugriff auf eine solche Objekteigenschaft muss allerdings auch hier wieder über die Klammernotation erfolgen, da ein gültiger Bezeichner nicht mit einer Zahl beginnen darf.


Hinweis

Dass ein als numerischer Wert angegebener Eigenschaftsname automatisch in einen String umgewandelt wird liegt übrigens daran, dass als Schlüssel für Objekteigenschaften intern nur primitive Werte vom Typ String oder vom Typ Symbol erlaubt sind. Das bedeutet, alle in zulässiger Weise für den Namen angegebenen Werte, bei denen es sich nicht bereits um einen von diesen beiden Typen handelt, werden zu Strings konvertiert. Diesen Umstand kann man sich zu Nutze machen, aber er birgt auch das Risiko, dass bei dessen Nichtberücksichtigung Eigenschaften überschrieben werden, denn alle Eigenschaften müssen aus Gründen der Identifizierbarkeit über einen individuellen Schlüssel verfügen.


Neben der Notierung des Namens der Eigenschaft als Bezeichner, als Stringliteral oder als numerischer Wert, gibt es außerdem noch die Möglichkeit, berechnete Eigenschaftsnamen zu verwenden (Computed Property Names). Das heißt, ebenso wie bei der Klammernotation zum Zugriff auf Objekteigenschaften kann innerhalb eines Objektliterals als Eigenschaftsname in eckige Klammern gefasst ein beliebiger Ausdruck notiert werden, dessen Wert dann als Schlüssel für die Eigenschaft gesetzt wird, gegebenenfalls nach einer impliziten Typumwandlung.


Beispiel
const key = Symbol('James Dean');
 
const actor = {
  [key] : function ( ) {
    return 'Rebel Without a Cause';
  }
};
 
console.info(actor[key].name); // [James Dean]


So kann als Schlüssel für eine Eigenschaft auch ein Wert vom Datentyp Symbol verwendet werden, entweder indem dieser direkt innerhalb der eckigen Klammern erzeugt wird, oder indem wie im Beispiel oben eine Referenz auf die Variable mit dem Symbol hinterlegt wird. Die Eigenschaft name enthält in diesem Fall, in eckige Klammern gefasst, den bei der Erzeugung des Symbols optionalerweise als Argument an die Funktion Symbol übergebenen String, der in der internen Eigenschaft [[Description]] des Symbols hinterlegt wird. Zwar ist das Symbol hier der Schlüssel und nicht dessen Beschreibung, aber wenn eine Beschreibung vorhanden ist, dann wird diese in der gezeigten Weise als Name der anonymen Funktion gespeichert.


Beispiel
const key = Symbol( );

const MilošForman = {
  [key] : function ( ) {
    return 'One Flew Over The Cuckoo’s Nest';
  }
};

console.log(MilošForman[key].hasOwnProperty('name')); // true

console.log(MilošForman[key].name); //


Wird allerdings ein Symbol als Schlüssel der Objekteigenschaft verwendet und für dieses Symbol keine Beschreibung angegeben, dann enthält die Eigenschaft name der Funktion einen leeren String. Dabei ist allerdings zu beachten, dass in diesem Fall dennoch eine eine eigene, schreibgeschützte Eigenschaft auf dem Funktionsobjekt definiert wird.


Beispiel
function GeorgesFranju (name) {
  return {
    [typeof name == 'string' ? name : 'film'] : function ( ) {
      return 'Les yeux sans visage';
    }
  };
}

console.log(GeorgesFranju( ).film.name); // film


Die Syntax für berechnete Eigenschaftsnamen ermöglicht es aber auch, komplexere Ausdrücke zu notieren, wie etwa die Prüfung mittels des ternären Operators in dem Beispiel oben. Das Ergebnis der Auswertung des gesamten Ausdrucks wird dann nach etwaiger Stringkonversion als Eigenschaftsname verwendet. Handelt es sich bei dem Wert des Ausdrucks um einen String wie in dem Beispiel oben, dann wird dieser in der Eigenschaft name gespeichert, handelt es sich hingegen um ein Symbol, dann wird wie gesehen entweder dessen Beschreibung oder ein leerer String hinterlegt. Ist das Ergebnis der Auswertung des Ausdrucks schließlich ein Wert, der nicht vom Datentyp String oder Symbol ist, dann wird dieser Wert in einen String umgewandelt und dieser wird als Wert für die Eigenschaft name definiert.


Beispiel
const Alphaville = {
  director : 'Jean-Luc Godard',
  toString ( ) {
    return 'Alphaville';
  }
};

const actors = {
  [Alphaville] : function ( ) {
    return ['Anna Karina', 'Eddie Constantine'];
  }
}

console.info(actors.Alphaville.name); // Alphaville


Wie dieses Beispiel zeigt, ist es unter Verwendung der Syntax für berechnete Eigenschaftsnamen ebenfalls möglich, ein Objekt als Name für eine Eigenschaft zu verwenden. Da aber wie gesehen alle Werte, bei denen es sich nicht um Strings oder Symbole handelt, in Strings konvertiert werden, wird hier entsprechend nicht das Objekt selbst oder eine Referenz darauf als Schlüssel hinterlegt, sondern das Ergebnis des automatischen Aufrufs der Methode toString. Da das Ergebnis des Aufrufs dieser Methode bei planen Objekten standardmäßig der String [object Object] ist, muss hier also entweder das als Schlüssel verwendete Objekt selbst, oder aber einer seiner Prototypen über eine Methode mit dem Bezeichner toString verfügen, welche die Originalmethode innerhalb der Prototypenkette verschattet, damit die Eigenschaft dem Objekt korrekt zugeordnet werden kann. Jedenfalls wird auch hierbei eine eigene Eigenschaft mit dem Bezeichner name für die anonyme Funktion definiert, deren Wert der Name der Objekteigenschaft ist.


Beispiel
const film = { };

film.HerkHarvey = function ( ) {
  return 'Carnival of Souls';
};

console.info(film.HerkHarvey.hasOwnProperty('name')); // false

console.info(film.HerkHarvey.name); //


Die implizite Definition der Eigenschaft name bei anonymen Funktionsausdrücken, wie sie bei der Zuweisung an eine Variable oder bei der Eigenschaftsdefinition innerhalb eines Objektliterals erfolgt, wird bei der Zuweisung an eine Objekteigenschaft außerhalb eines Objektliterals allerdings nicht durchgeführt. Handelt es sich also bei dem Ausdruck auf der linken Seite um einen Elementausdruck (Member Expression), dann wird, obwohl dieses Verhalten wenig konsistent erscheint, die Eigenschaft name auf dem Funktionsobjekt nicht definiert und es wird infolgedessen nur der von Function.prototype geerbte Leerstring zurückgegeben.


Beispiel
const ArthurMiller = { };

ArthurMiller['Death of a Salesman'] = function ( ) {
  return {
    director : 'Volker Schlöndorff',
    year : 1985
  };
};

console.info(ArthurMiller['Death of a Salesman'].name); //


Wie das Beispiel oben veranschaulicht, spielt es hierbei wie erwartet auch keine Rolle, ob für den Elementausdruck ein Bezeichner angegeben wird oder ob der Eigenschaftsname als Ausdruck in eckigen Klammern notiert wird. Es wird bei dieser Form der Zuweisung eines anonymen Funktionsausdruckes grundsätzlich keine Eigenschaft name auf dem Funktionsobjekt definiert.

Gebundene Funktionen[Bearbeiten]

Wird durch den Aufruf der von Function.prototype vererbten Methode bind ein exotisches Funktionsobjekt erzeugt (Bound Function), dann wird dieses immer mit einer eigenen Eigenschaft name initialisiert. Der Eigenschaftswert hängt dabei von der Funktion ab, in deren Kontext die Methode aufgerufen wurde.


Beispiel
function TheGetaway ( ) {
  return 1972;
}

const film = TheGetaway.bind({ });

console.log(film.name); // bound TheGetaway


In diesem Beispiel ist der Wert der Kontextvariable this eine deklarierte Funktion, die mithin über eine eigene Eigenschaft name verfügt, deren Wert der in einen String konvertierte Bezeichner der Funktion ist. Für die durch den Methodenaufruf erzeugte gebundene Funktion wird nun implizit eine eigene Eigenschaft name definiert, deren Wert ein String beginnend mit dem Prefix bound ist, gefolgt von einem Leerzeichen und dann dem Wert der Eigenschaft name des Kontextobjektes.


Beispiel
const log = console.log.bind(console);

const TaxiDriver = (function ( ) { 
  return ['Martin Scorsese', 1976];
}).bind({ });

log(TaxiDriver.name); // bound

log(TaxiDriver.name == 'bound'); // false

log(TaxiDriver.name.includes(' ')); // true


Besitzt die Funktion in deren Kontext die Methode bind aufgerufen wird hingegen keine eigene Eigenschaft name, sodass wie in dem Beispiel oben von Function.prototype der leere String geerbt wird, dann besteht der als Eigenschaftswert von name bei der gebundenen Funktion hinterlegte String auf den ersten Blick nur aus dem Prefix bound. Tatsächlich wird in diesem Fall jedoch nach dem Prefix noch ein Leerzeichen eingefügt, weshalb die Prüfung auf die Zeichenkette bound false ergibt.


Beispiel
function RagingBull ( ) {
  return ['Martin Scorsese', 1980];
}

const name = Object.defineProperty(RagingBull, 'name', {
  value : {
     alias : 'Jake LaMotta'
  }
}).bind({ }).name;

console.log(name); // bound

console.log(name.includes(' ')); // true


Das gleiche Verhalten zeigt sich, wenn der Wert der Eigenschaft name der Funktion, in deren Kontext die Methode bind aufgerufen wurde, nicht vom Datentyp String ist, so wie in dem Beispiel oben, in dem für die Eigenschaft name als Wert ein planes Objekt bestimmt wird. Das heißt, es wird hier keine Stringkonvertierung des Eigenschaftswertes durchgeführt, sondern dieser wird bei der Definition der Eigenschaft name für die gebundene Funktion durch einen Leerstring ersetzt.


Beispiel
function MartinScorsese ( ) {
  return 'Bringing Out the Dead';
}

Object.defineProperty(MartinScorsese, 'name', {
  get : function ( ) {
    return 'Martin Charles Scorsese';
  }
});

const name = MartinScorsese.bind({ }).name;

console.log(name); // bound Martin Charles Scorsese


Bezogen auf die Verwendung des Wertes der Eigenschaft name des Kontextobjektes ist es darüber hinaus auch unerheblich, ob für die Eigenschaft ein Getter implementiert wurde. Ist dies wie in dem Beispiel oben der Fall, dann wird der Getter bei der internen Prüfung aufgerufen und für seinen Rückgabewert gelten die beschriebenen Regeln, das heißt wenn dabei ein String zurückgegeben wird, dann wird dieser bei der Konkatenation des Strings für die Eigenschaft name der gebundenen Funktion berücksichtigt, sonst wird wie gesehen ein Leerstring eingesetzt.

Dynamisch erzeugte Funktionen[Bearbeiten]

Wird eine Funktion dynamisch zur Laufzeit durch den Aufruf des Konstruktors Function erzeugt, dann handelt es sich dabei immer um eine anonyme Funktion. Im Gegensatz zu anderen unbenannten Funktionen wird hierbei jedoch standardmäßig eine eigene Eigenschaft mit dem Bezeichner name definiert und als Eigenschaftswert die Zeichenkette anonymous hinterlegt.


Beispiel
const body = 'return ["Blue Velvet", "Lost Highway"]';

const DavidLynch = new Function(body);

DavidLynch( ).forEach(function (title) {
  console.log(title); // Blue Velvet, Lost Highway
});

console.log(DavidLynch.name); // anonymous


Dabei macht es auch keinen Unterschied, ob Function unter Verwendung des Operators new als Konstruktor aufgerufen wird, oder ob es sich um einen normalen Funktionsaufruf handelt. Im Ergebnis wird von der Eigenschaft name prinzipiell der String anonymous zurückgegeben.


Beispiel
const OlivierSmolders = Function ('title', 'console.log(title)');

OlivierSmolders('Nuit Noire'); // Nuit Noire

console.log(OlivierSmolders.name); // anonymous


Es ist allerdings davon abzuraten Funktionen auf diese Weise zu erstellen, denn es ist im Zweifel sehr unperformant, da hierbei ebenso wie bei der Funktion eval zur Laufzeit des Programms der Interpreter angeworfen wird, und es geht auch darüber hinaus mit Nachteilen einher. So verfügt eine durch Function erzeugte Funktion beispielsweise über keine Bindung zu dem umgebenden lexikalischen Kontext, sodass in ihr nur die Variablen des eigenen und diejenigen des globalen Kontextes referenziert werden können. Funktionen auf diese Weise zu erzeugen ist also meist eine schlechte Wahl.

Verwendung[Bearbeiten]

Ein sinnvolles Beispiel für die Verwendung der Eigenschaft name ist die Typbestimmung auf Instanzobjekten. Wird unter Verwendung des Operators new eine Funktion als Konstruktor aufgerufen und auf diese Weise ein Objekt erzeugt, dann ist der Wert der internen Eigenschaft [[Prototype]] dieser Instanz immer eine Referenz auf das Objekt, welches standardmäßig in der Eigenschaft prototype des Konstruktors hinterlegt ist. Dieses Prototypenobjekt enthält wiederum eine Eigenschaft constructor, deren Wert eine Referenz auf das dazugehörige Funktionsobjekt ist. Da die Instanz diese Eigenschaft von ihrem Prototypen erbt, kann über diese Referenz auf den Konstruktor dessen Name in Erfahrung gebracht werden.


Beispiel
function PeterYates (actor) {
  if (!new.target) {
    throw new TypeError('constructor called without new');
  }
  this.actor = actor;
}

const Bullitt = new PeterYates('Steve McQueen');

console.log(Bullitt.constructor.name); // PeterYates


In diesem Beispiel wird zunächst eine Konstruktorfunktion deklariert, von der in einem zweiten Schritt unter Verwendung des Operators new eine Instanz erzeugt wird. Wie gesehen, erbt diese Instanz von ihrem Prototypen, in diesem Fall also PeterYates.prototype, die Eigenschaft constructor, welche eine Referenz auf den Konstruktor enthält. Über die Eigenschaft name lässt sich also in Erfahrung bringen, dass es sich bei dem Instanzobjekt mit dem Bezeichner Bullitt um ein Objekt vom Typ PeterYates handelt.

Weblinks[Bearbeiten]

  • ECMAScript 2017 (7th Edition, ECMA-262 Draft): name