Versionen vergleichen

Feinheiten des Objektmodells

Version 440221:

Version 440221 von eminor am

Version 440231:

Version 440231 von eminor am

Titel:
Feinheiten des Objektmodells
Feinheiten des Objektmodells
Adressname:
JavaScript/Guide/Feinheiten_des_Objektmodells
JavaScript/Guide/Feinheiten_des_Objektmodells
Inhalt:

Version 440221
Version 440231
n8      JavaScript ist eine objektbasierte Sprache, die auf Prototyn8      JavaScript ist eine objektbasierte Sprache, die auf Prototy
>pen aufbaut anstatt wie andere Sprachen auf Klassen. Aufgrund die>pen aufbaut anstatt wie andere Sprachen auf Klassen. Aufgrund die
>ser unterschiedlichen Aufbauweise ist vielleicht nicht sofort ers>ser unterschiedlichen Aufbauweise ist vielleicht nicht sofort ers
>ichtlich, wie mit JavaScript Objekthierarchien erstellt werden kö>ichtlich, wie mit JavaScript Objekthierarchien zusammengestellt w
>nnen und die Vererbung von Objekteigenschaften und Werten funktio>erden können und die Vererbung von Objekteigenschaften und Werten
>niert. Bei diesem Kapitel wird versucht darüber Klarheit zu schaf> funktioniert. Bei diesem Kapitel wird versucht darüber Klarheit 
>fen.>zu schaffen.
n32      Bei klassenbasierten Sprachen definiert man eine Klasse in n32      Bei klassenbasierten Sprachen definiert man eine Klasse in 
>einer separaten Klassendefintion. In dieser Definition können spe>einer separaten Klassendefinition. In dieser Definition können sp
>zielle Methoden definiert werden, sogenannte Konstruktoren, um In>ezielle Methoden, sogenannte Konstruktoren, zur Erstellung von Kl
>stanzen der Klasse zu erstellen. Mit einer Konstruktormethode las>asseninstanzen definiert werden. Mit einer Konstruktormethode las
>sen sich Startwerte für die Eigenschaften der Instanzen festlegen>sen sich Anfangswerte für die Eigenschaften der Instanzen festleg
> und andere Operationen zum Zeitpunkt der Erstellung durchführen.>en und andere Operationen zum Zeitpunkt der Erstellung durchführe
> Der Operator <code>new</code> kommt in Verbindung mit der Konstr>n. Der Operator <code>new</code> kommt in Verbindung mit der Kons
>uktormethode für die Erstellung von Klasseninstanzen zum Einsatz.>truktormethode für die Erstellung von Klasseninstanzen zum Einsat
 >z.
33    </p>
34    <p>33    </p>
34    <p>
35      JavaScript folgt einem ähnlichen Modell, jedoch gibt es kei35      JavaScript folgt einem ähnlichen Modell, jedoch gibt es kei
>ne seperate Klassendefintion unabhängig vom Konstruktor eines Obj>ne seperate Klassendefintion unabhängig vom Konstruktor eines Obj
>ekts. Stattdessen definiert man eine Konstruktorfunktion, womit O>ekts. Stattdessen definiert man eine Konstruktorfunktion, womit O
>bjekte mit bestimmten in der Definition festgelegten Eigenschafte>bjekte mit bestimmten in der Definition festgelegten Eigenschafte
>n und Werten erstellt werden. Jede JavaScript-Funktion kann dabei>n und Werten erstellt werden. Jede beliebige JavaScript-Funktion 
> als Konstruktor verwendet werden. Der Operator <code>new</code> >kann dabei als Konstruktor verwendet werden. Der Operator <code>n
>kommt in Verbindung mit der Konstruktorfunktion für die Erstellun>ew</code> kommt in Verbindung mit der Konstruktorfunktion für die
>g von Objekten zum Einsatz.> Erstellung von Objekten zum Einsatz.
n41      Bei einer klassenbasierten Sprache kommt die Hierarchie vonn41      Bei einer klassenbasierten Sprache kommt die Hierarchie von
> Klassen durch die Definition von Klassen zustande. Bei der Defin> Klassen durch die Definition von Klassen zustande. Bei der Defin
>ition einer Klasse kann man festlegen, ob die neue Klasse eine Ki>ition einer Klasse kann man festlegen, ob die neue Klasse eine Ki
>ndklasse von einer bereits bestehenden Klasse sein soll. Die Kind>ndklasse von einer bereits bestehenden Klasse sein soll. Die Kind
>klasse erbt sodann alle Eigenschaften der Elternklasse. Zusätzlic>klasse erbt sodann alle Eigenschaften der Elternklasse. Zusätzlic
>h können der Kindklasse neue Eigenschaften hinzugefügt, oder die >h können der Kindklasse neue Eigenschaften hinzugefügt, oder die 
>von der Elternklasse geerbten Eigenschaften verändert werden. Neh>von der Elternklasse geerbten Eigenschaften verändert werden. Neh
>men wir z. B. an, die Klasse <code>Mitarbeiter</code> würde aussc>men wir z. B. an, die Klasse <code>Employee</code> würde ausschli
>hließlich Eigenschaften für den Namen und die Abteilung der jewei>eßlich Eigenschaften für den Namen und die Abteilung der jeweilig
>ligen Mitarbeiter besitzen. Dann kann man eine Klasse <code>Manag>en Mitarbeiter besitzen. Dann kann man eine Klasse <code>Manager<
>er</code> als Kindklasse der Klasse <code>Mitarbeiter</code> erst>/code> als Kindklasse der Klasse <code>Employee</code> erstellen 
>ellen und dieser eine Eigenschaft für Berichte hinzufügen. Eine I>und dieser eine Eigenschaft für Berichte hinzufügen. Eine Instanz
>nstanz der Managerklasse würde dann alle drei Eigenschaften besit> der Managerklasse würde dann alle drei Eigenschaften besitzen: N
>zen: Name, Abteilung und Berichte.>ame, Abteilung und Berichte.
n53      Die folgende Tabelle gibt einen schnellen Überblick über ein53      Die folgende Tabelle gibt einen schnellen Überblick über ei
>nige der Unterschiede. Der Rest dieses Kapitels informiert detail>nige der Unterschiede. Der Rest dieses Kapitels informiert detail
>liert über JavaScript-Konstruktoren und Prototypen für die Erstel>liert über JavaScript-Konstruktoren und Prototypen für die Erstel
>lung von Objekthierarchien und vergleicht das Prinzip von JavaScr>lung von Objekthierarchien und vergleicht das Konzept von JavaScr
>ipt mit dem von Java.>ipt mit dem von Java.
n121      Das Mitarbeiter-Beispieln121      Das Employee-Beispiel
n124      Die nachfolgenden Erklärungen dieses Kapitels beziehen sichn124      Die nachfolgenden Erklärungen dieses Kapitels beziehen sich
> zum Teil auf das Mitarbeiter-Beispiel, dessen Hierarchie wie in > zum Teil auf das Employee-Beispiel, dessen Hierarchie wie in fol
>folgendem Schaubild aufgebaut ist:>gendem Schaubild aufgebaut ist:
n146        <code>SalesPerson</code> basiert auf dem Objekt <code>Worn146        <code>SalesPerson</code> basiert auf dem Objekt <code>Wor
>kerBee</code> und besitzt die zusätzliche Eigenschaft <code>quota>kerBee</code> und besitzt die zusätzliche Eigenschaft <code>quota
></code> (mit <code>100</code> als Anfangswert). Außerdem wird der></code> (mit <code>100</code> als Anfangswert). Außerdem wird der
> Wert der Eigenschaft <code>dept</code> mit dem Wert "sales" über> Wert der Eigenschaft <code>dept</code> mit dem Wert "sales" über
>schrieben, womit angezeigt wird, dass Verkaufsleute in derselben >schrieben, wodurch ersichtlich werden soll, dass Verkaufsleute in
>Abteilung beschäftigt sind.> derselben Abteilung beschäftigt sind.
n149        <code>Engineer</code> basiert auf dem Objekt <code>Workern149        <code>Engineer</code> basiert auf dem Objekt <code>Worker
>Bee</code> und besitzt die zusätzliche Eigenschaft <code>machine<>Bee</code> und besitzt die zusätzliche Eigenschaft <code>machine<
>/code> (mit einem leeren String als Anfangswert). Der Wert der Ei>/code> (mit einem leeren String als Anfangswert). Der Wert der Ei
>genschaft <code>dept</code> wird mit dem Wert "engineering" übers>genschaft <code>dept</code> wird mit dem Wert <code>"engineering"
>chrieben.></code> überschrieben.
n159      Dieser Abschnitt beschreibt, wie mit sehr einfachen (jedochn159      Dieser Abschnitt beschreibt, wie mit sehr einfachen (jedoch
> relativ unflexiblen) Definitionen eine Vererbungshierarchie erst> relativ unflexiblen) Definitionen eine Vererbungshierarchie erst
>ellt werden kann. Bei diesen Definitionen können den Eigenschafte>ellt werden kann. Bei diesen Definitionen können den Eigenschafte
>n eines Objekts bei der Erstellung keine Werte zugewiesen werden.>n eines Objekts bei der Erstellung keine Werte zugewiesen werden.
> Die neu erstellten Objekte erhalten zunächst Standardwerte, welc> Die neu erstellten Objekte erhalten zunächst Anfangswerte, welch
>he dann später geändert werden können. Das Schaubild 8.2 stellt d>e dann später geändert werden können. Das Schaubild 8.2 stellt di
>ie Hierarchie mit diesen simplen Defintionen dar.>e Hierarchie mit diesen simplen Defintionen dar.
160    </p>
161    <p>160    </p>
161    <p>
162      Bei einer echten Applikation würde man evtl. Konstruktoren 162      Bei einer echten Applikation würde man evtl. Konstruktoren 
>definieren, womit den Objekteigenschaften bei der Erzeugung Anfan>definieren, womit den Objekteigenschaften bei der Erzeugung Anfan
>gswerte zugewiesen werden; (siehe {{ linkToFragment("More Flexibl>gswerte zugewiesen werden; (siehe {{ linkToFragment("More Flexibl
>e Constructors") }} für weitere Informationen). An dieser Stelle >e Constructors") }} für weitere Informationen). An dieser Stelle 
>begnügen wir uns jedoch mit einfachen Definitionen, um die Grunds>begnügen wir uns jedoch mit einfachen Definitionen, um rein die G
>truktur der Vererbungshierarchie zu veranschaulichen.>rundstruktur der Vererbungshierarchie zu veranschaulichen.
n208      Die Definitionen der Objekte <code>Manager</code> und <coden208      Die Definitionen der Objekte <code>Manager</code> und <code
>>WorkerBee</code> (Schaubild 8.2) zeigen die Unterschiede bei der>>WorkerBee</code> (Schaubild 8.2) zeigen die Unterschiede bei der
> Spezifikation des übergeordneten Objekts in der Vererbungskette.> Spezifikation des übergeordneten Objekts in der Vererbungskette.
> Bei JavaScript weist man der Eigenschaft <code>prototype</code> > Bei JavaScript weist man der Eigenschaft <code>prototype</code> 
>der Konstruktorfunktion eine Prototype-Instanz als Wert zu. Dies >der Konstruktorfunktion eine Prototype-Instanz als Wert zu. Dies 
>kann jederzeit nach der Definition der Konstruktorfunktion gesche>kann jederzeit nach der Definition der Konstruktorfunktion gesche
>hen. Bei Java gibt man die Elternklasse in der Defintion an. Eine>hen. Bei Java gibt man die Elternklasse in der Definition an. Ein
> Änderung der Elternklasse ist außerhalb der Klassendefintion nic>e Änderung der Elternklasse ist außerhalb der Klassendefintion ni
>ht möglich.>cht möglich.
n257      Mit den Definitionen <code>Engineer</code> und <code>SalesPn257      Mit den Definitionen <code>Engineer</code> und <code>SalesP
>erson</code> werden Objekte erstellt, die von <code>WorkerBee</co>erson</code> werden Objekte erstellt, die von <code>WorkerBee</co
>de> abstammen und darum auch von <code>Employee</code>. Ein Objek>de> abstammen und deshalb auch von <code>Employee,</code> da <cod
>t dieser Gruppe besitzt Eigenschaften von allen Objekten, die in >e>WorkerBee</code> von <code>Employee</code> erbt. Ein Objekt die
>der Hierarchie übergeorndet sind. Darüber hinaus wird der geerbte>ser Gruppe besitzt die Eigenschaften von allen Objekten, die in d
> Wert der Eigenschaft <code>dept</code> mit einem neuen Wert über>er Hierarchie übergeordnet sind. Der geerbte Wert der Eigenschaft
>schrieben.> <code>dept</code> wird mit einem neuen Wert überschrieben.
n310      Durch den Gebrauch dieser Definitionen können Instanzen dern310      Durch den Gebrauch dieser Definitionen können Instanzen der
> entsprechenden Objekte erzeugt werden, welche dann die festgeleg> entsprechenden Objekte erzeugt werden, welche dann die festgeleg
>ten Anfangswerte für die Eigenschaften erhalten. Das Schaubild 8.>ten Anfangswerte für die Eigenschaften erhalten. Das Schaubild 8.
>stellt die Benutzung der Definitionen für die Erstellung neuer >führt die Benutzung der Definitionen für die Erstellung neuer O
>Objekte dar und zeigt die Werte der Eigenschaften von neuen Objek>bjekte vor und zeigt die Werte der Eigenschaften von neuen Objekt
>ten.>en.
311    </p>
312    <p>311    </p>
312    <p>
313      {{ note('Der Begriff Instanz hat bei klassenbasierten Sprac313      {{ note('Der Begriff Instanz hat bei klassenbasierten Sprac
>hen eine spezielle technische Bedeutung. Bei diesen Sprachen ist >hen eine spezielle technische Bedeutung. Bei diesen Sprachen ist 
>eine Instanz eine eigenständige Instanzierung einer Klasse und un>eine Instanz eine eigenständige Instanzierung einer Klasse und un
>terscheidet sich grundlegend von der Klasse selbst. Bei JavaScrip>terscheidet sich grundlegend von der Klasse selbst. Bei JavaScrip
>t gibt es diese spezielle Bedeutung nicht, da es keinen Unterschi>t gibt es diese spezielle Bedeutung nicht, da es keinen Unterschi
>ed zwischen Instanzen und Klassen gibt. Oft spricht man jedoch vo>ed zwischen Instanzen und Klassen gibt. Oft spricht man jedoch vo
>n Instanzen, wenn Objekte gemeint sind, die mit einer bestimmten >n Instanzen, wenn Objekte gemeint sind, die mit einer bestimmten 
>Konstruktorfunktion erstellt wurden. Somit darf man für das Beisp>Konstruktorfunktion erstellt wurden. Somit darf man für das Beisp
>iel behaupten, dass <code>jane</code> eine Instanz von <code><cod>iel behaupten, dass <code>jane</code> eine Instanz von <code><cod
>e>Engineer</code></code> ist. Auf dieselbe Weise haben auch die B>e>Engineer</code></code> ist. Auf dieselbe Weise haben auch die B
>egriffe <em>Eltern</em>, <em>Kind</em>, <em>Vorfahre</em> und <em>egriffe <em>Eltern</em>, <em>Kind</em>, <em>Vorfahre</em> und <em
>>Nachkomme</em> keine formelle Bedeutung bei JavaScript und könne>>Nachkomme</em> keine formelle Bedeutung bei JavaScript und könne
>n für Objekte benutzt werden, die anderen Objekten in der Prototy>n für Objekte benutzt werden, die anderen Objekten in der Prototy
>pe-Kette über- oder untergeordnet sind.') }}>pekette über- oder untergeordnet sind.') }}
n323      Dieser Abschnitt erklärt, wie Objekte die Eigenschaften vonn323      Dieser Abschnitt erklärt, wie Objekte die Eigenschaften von
> anderen Objekten erben, die in der Prototype-Kette hierarchisch > anderen Objekten erben, die in der Prototypekette hierarchisch ü
>übergeordnet sind und was passiert, wenn während der Laufzeit neu>bergeordnet sind und was passiert, wenn neue Eigenschaften währen
>e Eigenschaften hinzugefügt werden.>d der Laufzeit hinzugefügt werden.
n335      Wenn die Ausführung beim <code>new</code>-Operator angelangn335      Wenn die Ausführung beim <code>new</code>-Operator angelang
>t ist, wird ein neues <code>WorkerBee</code>-Objekt erstellt und >t ist, wird ein neues <code>WorkerBee</code>-Objekt erstellt und 
>dieses Objekt dem <code>this</code>-Schlüsselwort der <code>Worke>dieses Objekt dem <code>this</code>-Schlüsselwort der <code>Worke
>rBee</code>-Konstruktorfunktion als Wert zugewiesen. Die Konstruk>rBee</code>-Konstruktorfunktion zugewiesen. Die Konstruktorfunkti
>torfunktion setzt dann explizit den Wert für die Eigenschaft <cod>on setzt dann explizit den Wert für die Eigenschaft <code>project
>e>projects</code> (wie in der Konstruktorfunktion definiert) und >s</code> (wie in der Konstruktorfunktion definiert) und implizit 
>implizit den Wert der internen Eigenschaft <code>__proto__</code>>den Wert der internen Eigenschaft <code>__proto__</code> auf den 
> auf den Wert von <code>WorkerBee.prototype</code> (<code>__proto>Wert von <code>WorkerBee.prototype</code> (<code>__proto__</code>
>__</code> hat jeweils zwei Unterstriche am Anfang und Ende). Die > hat jeweils zwei Unterstriche am Anfang und Ende). Die Eigenscha
>Eigenschaft <code>__proto__</code> bestimmt die Prototype-Verkett>ft <code>__proto__</code> bestimmt die Prototype-Verkettung für d
>ung für die Rückgabe von Eigenschaftswerten. Sobald diese Eigensc>ie Rückgabe von Eigenschaftswerten. Sobald diese Eigenschaften ge
>haften gesetzt sind, wird das neue Objekt zurückgegeben und der V>setzt sind, wird das neue Objekt zurückgegeben und der Variablen 
>ariablen <code>mark</code> zugewiesen.><code>mark</code> zugewiesen.
336    </p>
337    <p>336    </p>
338      Bei diesem Vorgang werden dem Objekt <code>mark</code> nich337    <p>
>t explizit (<em>lokale</em>) Werte für die Eigenschaften zugewies 
>en, die <code>mark</code> etwa von der Prototype-Kette erbt. Wenn 
> der Wert einer Eigenschaft abgefragt wird, überprüft JavaScript  
>zunächst, ob dieser Wert lokal existiert; trifft dies zu, wird de 
>r Wert zurückgegeben; falls die Eigenschaft lokal nicht existiert 
>, überprüft JavaScript die Prototype-Kette (über die Eigenschaft  
><code>__proto__</code>) und wenn ein Objekt in der Prototype-Kett 
>e einen Wert für die Eigenschaft besitzt, wird dieser zurückgegeb 
>en. Falls gar keine solche Eigenschaft gefunden wird, meldet Java 
>Script, dass das Objekt keine solche Eigenschaft besitzt. Demzufo 
>lge hat das Objekt <code>mark</code> die folgenden Eigenschaften  
>und Werte: 
338      Bei diesem Vorgang werden dem Objekt <code>mark</code> nich
 >t explizit (<em>lokale</em>) Werte für die Eigenschaften zugewies
 >en, die <code>mark</code> von der Prototypekette erbt. Sondern we
 >nn der Wert einer Eigenschaft abgefragt wird, überprüft JavaScrip
 >t zunächst, ob dieser Wert lokal existiert; trifft dies zu, wird 
 >der Wert zurückgegeben; falls die Eigenschaft lokal nicht existie
 >rt, überprüft JavaScript die Prototypekette (über die Eigenschaft
 > <code>__proto__</code>). Besitzt ein Objekt in der Prototypekett
 >e einen Wert für die Eigenschaft, wird dieser zurückgegeben. Fall
 >s gar keine solche Eigenschaft gefunden wird, meldet JavaScript, 
 >dass das Objekt keine solche Eigenschaft besitzt. Demzufolge hat 
 >das Objekt <code>mark</code> die folgenden Eigenschaften und Wert
 >e:
n375      Sobald diese Anweisung ausgeführt wird, besitzt das Objekt n375      Sobald diese Anweisung ausgeführt wird, besitzt das Objekt 
><code>mark</code> ebenfalls die Eigenschaft <code>speciality</cod><code>mark</code> ebenfalls die Eigenschaft <code>speciality</cod
>e> mit dem Wert "none". Im nächsten Schaubild ist dargestellt, wi>e> mit dem Wert <code>"none"</code>. Im nächsten Schaubild ist da
>e dem Prototype des <code>Employee</code>-Objekts die neue Eigens>rgestellt, wie dem Prototype des <code>Employee</code>-Objekts di
>chaft hinzugefügt und anschließend dem <code>Engineer</code>-Prot>e neue Eigenschaft hinzugefügt und anschließend dem <code>Enginee
>otype ein anderer Wert zugewiesen wird.>r</code>-Prototype ein anderer Wert zugewiesen wird.
n392      Die folgende Tabelle zeigt die Java- und JavaScript-Defintin392      Die folgende Tabelle zeigt die Java- und JavaScript-Definit
>onen für diese Objekte:>ionen für diese Objekte:
n488      Diese JavaScript-Definitionen setzen ein spezielles Konstrun488      Diese JavaScript-Definitionen verwenden ein spezielles Kons
>kt für Default-Werte ein:>trukt für Default-Werte:
n494      Der JavaScript-Operator für das logische ODER (<code>||</con494      Der JavaScript-Operator für das logische ODER (<code>||</co
>de>) wertet das ihm vorangestellte Argument aus; wenn dieses zu <>de>) wertet das ihm vorangestellte Argument aus; wenn dieses zu <
>code>true</code> evaluiert, wird der Wert zurückgegeben. Andernfa>code>true</code> evaluiert, wird der Wert zurückgegeben. Andernfa
>lls wird der Wert des zweiten Arguments hinter dem Operator zurüc>lls wird der Wert des zweiten Arguments hinter dem Operator zurüc
>kgegeben. Mit dem Ausdruck wird also überprüft, ob <code>name</co>kgegeben. Mit dem Ausdruck wird also überprüft, ob <code>name</co
>de> einen brauchbaren Wert besitzt, welcher der Eigenschaft <code>de> einen brauchbaren Wert besitzt, welcher der Eigenschaft <code
>>this.name</code> zugewiesen werden kann. Falls ja, bekommt <code>>this.name</code> zugewiesen werden kann. Falls ja, bekommt <code
>>this.name</code> diesen Wert. Andernfalls wird <code>this.name</>>this.name</code> diesen Wert. Andernfalls wird <code>this.name</
>code> ein leerer String zugewiesen. In diesem Kapitel wird auf di>code> ein leerer String zugewiesen. In diesem Kapitel wird auf di
>eses Konstrukt zurückgegriffen, um den Code knapp zu halten.>eses Konstrukt zurückgegriffen, um die Code-Beispiele knapp und ü
 >bersichtlich zu halten.
n506      Die Eigenschaften von <code>Jane</code> sind jetzt:n506      Die Eigenschaften von <code>Jane</code> sind sodann:
n518      Bis hierhin hat die Konstruktorfunktion ein generisches Objn518      Bisher haben wir mit der Konstruktorfunktion ein generische
>ekt erstellt und dann lokale Eigenschaften und Werte zugewiesen. >s Objekt erstellt und dann lokale Eigenschaften und Werte zugewie
>Mit dem Konstruktor können mehr Eigenschaften hinzugefügt werden,>sen. Mit dem Konstruktor können mehr Eigenschaften hinzugefügt we
> indem direkt die Konstruktorfunktion eines in der Prototyp-Kette>rden, indem direkt die Konstruktorfunktion eines in der Prototypk
> höherliegenden Objekts aufgerufen wird. Das folgende Schaubild z>ette höherliegenden Objekts aufgerufen wird. Das folgende Schaubi
>eigt diese Definitionen.>ld zeigt diese Definitionen.
n535      Angenommen man erstellt nun ein <code>Engineer</code>-Objecn535      Angenommen man erstellt nun ein <code>Engineer</code>-Objek
>t wie folgt:>t wie folgt:
n575      Dann erbt das Objekt <code>jane</code> die Eigenschaft <codn575      Dann erbt das Objekt <code>jane</code> die Eigenschaft <cod
>e>specialty</code> nicht. Der Prototype muss explizit zugewiesen >e>specialty</code> nicht. Der Prototype muss explizit zugewiesen 
>werden, um die dynamische Vererbung zu realisieren. Verändert man>werden, um die dynamische Vererbung zu umzusetzen. Verändert man 
> den Code wie folgt:>den Code wie folgt:
n617      Die Verwendung der Methode <code>call()</code> ermöglicht sn617      Die Verwendung der Methode <code>call()</code> ermöglicht s
>aubereren Code, weil das <code>base</code>-Objekt nicht mehr gebr>aubereren Code, weil das <code>base</code>-Objekt dabei nicht meh
>aucht wird.>r gebraucht wird.
n623      Die vorhergehenden Abschnitte beschreiben, wie durch JavaScn623      Die vorhergehenden Abschnitte beschreiben, wie durch JavaSc
>ript-Konstruktoren und Prototypen die Vererbungshierarchie aufgeb>ript-Konstruktoren und Prototypen eine Vererbungshierarchie aufge
>aut ist. Dieses Kapitel geht auf die Feinheiten ein, die für die >baut werden kann. Dieser Abschnitt beschreibt die Feinheiten des 
>vorherigen Beschreibungen noch nicht notwendig waren.>Vererbungskonzepts.
n626      Lokalen und vererbte Werten626      Lokale und vererbte Werte
627    </h3>
628    <p>627    </h3>
628    <p>
629      Wenn man auf die Eigenschaft eines Objekts zugreift, führt 629      Beim Zugriff auf die Eigenschaft eines Objekts führt JavaSc
>JavaScript nacheinander diese Schritte aus, wie bereits weiter ob>ript nacheinander diese Schritte aus, wie bereits weiter oben bes
>en beschreiben:>chreiben:
n634      <li>Wenn kein lokaler Wert existiert, überprüfen der Prototn634      <li>Wenn kein lokaler Wert existiert, Überprüfung der Proto
>ype-Kette (über die Eigenschaft <code>__proto__</code>).>typekette (über die Eigenschaft <code>__proto__</code>).
n636      <li>Wenn ein Objekt in der Prototype-Kette einen Wert für dn636      <li>Wenn ein Objekt in der Prototypekette einen Wert für di
>ie Eigenschaft besitzt, Rückgabe dieses Werts.>e Eigenschaft besitzt, Rückgabe dieses Werts.
n642      Das Ergebnis dieser Schritte hängt davon ab, wie madie Din642      Das Ergebnis dieses Ablaufs hängt von den Definitionen ab
>nge bis dahin definiert. Das Beispiel am Anfang des Kapitels war >Das Beispiel am Anfang des Kapitels war so definiert:
>so definiert: 
n662      Dann besitzt <code>amy</code> nur die lokale Eigenschaft <cn662      Dann besitzt <code>amy</code> nur die lokale Eigenschaft <c
>ode>projects</code>. Die Werte der Eigenschaften <code>name</code>ode>projects</code>. Die Werte der Eigenschaften <code>name</code
>> und <code>dept</code> sind nicht lokal zu <code>amy</code> und >> und <code>dept</code> sind nicht lokal zu <code>amy</code> und 
>werden daher über die Prototype-Kette bzw. die Eigenschaft <code>>werden daher über die Prototypekette bzw. die Eigenschaft <code>_
>__proto__</code> abgefragt. Also besitzt <code>amy</code> diese E>_proto__</code> abgefragt. Also besitzt <code>amy</code> diese Ei
>igenschaften und Werte:>genschaften und Werte:
n670      Ändert man nun die Eigenschaft <code>name</code> des Prototn670      Ändert man nun die Eigenschaft <code>name</code> des Protot
>ype, der mit <code>Employee</code> verbunden ist:>ype, der mit <code>Employee</code> verknüpft ist:
n679      Bei <em>jeder</em> Erzeugung einer Instanz des <code>Employn679      Bei <em>jeder</em> Erzeugung einer Instanz des <code>Employ
>ee</code>-Objekts bekommt diese Instanz einen lokalen Wert (einen>ee</code>-Objekts bekommt diese Instanz einen lokalen Wert (einen
> leeren String) für die Eigenschaft <code>name</code> zugewiesen.> leeren String) für die Eigenschaft <code>name</code> zugewiesen.
> Wenn man also den <code>WorkerBee</code>-Prototype festlegt, ind> Wenn man also den <code>WorkerBee</code>-Prototype festlegt, ind
>em man ein neues Employee Objekt erstellt, besitzt <code>Workerbe>em man ein neues <code>Employee</code>-Objekt erstellt, besitzt <
>e.prototype</code> eine Eigenschaft <code>name</code> mit einem l>code>Workerbee.prototype</code> eine Eigenschaft <code>name</code
>okalen Wert. Beim Zugriff auf die Eigenschaft findet JavaScript d>> mit einem lokalen Wert. Beim Zugriff auf die Eigenschaft findet
>ann den lokalen Wert des Prototype <code>WorkerBee.prototype</cod> JavaScript dann den lokalen Wert des Prototype <code>WorkerBee.p
>e> und sucht die Prototype-Kette nicht weiter bis zu <code>Employ>rototype</code> und sucht die Prototypekette nicht weiter bis zu 
>ee.prototype</code> ab.<br>><code>Employee.prototype</code> ab.<br>
n681      Möchte man den Wert einer Objekt-Eigenschaft während der Lan681      Möchte man den Wert einer Objekt-Eigenschaft während der La
>ufzeit ändern, und der neue Wert soll auch für alle erbenden Obje>ufzeit ändern und der neue Wert soll auch für alle erbenden Objek
>kte gesetzt werden, so darf man diesen nicht in der Konstruktorfu>te gesetzt werden, so darf man diesen nicht in der Konstruktorfun
>nktion zuweisen. Stattdessen weist man dem mit dem Objekt verknüp>ktion zuweisen. Stattdessen weist man dem mit dem Objekt verknüpf
>ften Prototype den Wert zu.<br>>ten Prototype den Wert zu.<br>
n701      Dann besitzt die Eigenschaft amy den Wert "Unknown".<br>n701      Dann besitzt die Eigenschaft <code>amy</code> den Wert <cod
 >e>"Unknown"</code>.<br>
n709      Beim Zugriff auf Eigenschaften wird zuerst überprüft, ob dan709      Beim Zugriff auf Eigenschaften wird zuerst überprüft, ob da
>s Objekt selbst eine entsprechende Eigenschaft besitzt. Wird die >s Objekt selbst eine entsprechende Eigenschaft besitzt. Wird die 
>Eigenschaft lokal nicht gefunden, sucht JavaScript in der speziel>Eigenschaft lokal nicht gefunden, sucht JavaScript in der speziel
>len Objekteigenschaft &nbsp; <code>__proto__</code>. Dieser Ablau>len Objekteigenschaft &nbsp; <code>__proto__</code>. Dieser Ablau
>f wird rekursiv fortgeführt, solange bis eine Eigenschaft gefunde>f wird rekursiv fortgeführt, solange bis eine Eigenschaft gefunde
>n oder festgestellt wurde, dass keines der Objekte der Prototype->n oder festgestellt wurde, dass keines der Objekte der Prototypek
>Kette eine solche Eigenschaft besitzt.>ette eine solche Eigenschaft besitzt.
n725      Noch ein genaueres Beispiel: Angenommen man hat dieselben Dn725      Hier noch ein weiteres Beispiel: Angenommen man hat dieselb
>efinitionen wie unter <a href="https://developer.mozilla.org/de/d>en Definitionen wie unter <a href="https://developer.mozilla.org/
>ocs/" title="/de/docs/">Vererbung von Eigenschaften</a> und erste>de/docs/" title="/de/docs/">Vererbung von Eigenschaften</a> und e
>llt ein <code>Engineer</code>-Objekt wie folgt:>rstellt ein <code>Engineer</code>-Objekt wie folgt:
n731      Dann evaluieren für dieses Objekt die folgenen Anweisungen n731      Dann evaluieren die folgenen Anweisungen alle zu <code>true
>alle zu <code>true</code>:></code>:
n757      <strong>Achtung:</strong> Die Implementierung wie oben übern757      <strong>Achtung:</strong> Die Implementierung der Funktion 
>prüft den Typ des Objekts gegen "xml", um eine Eigenheit von neue>überprüft den Typ des Objekts gegen "xml", um eine Eigenheit von 
>ren JavaScript-Versionen bei der Repräsentation von XML-Objekten >neueren JavaScript-Versionen bei der Repräsentation von XML-Objek
>zu beachten. Siehe {{ bug(634150) }} für weitere Informationen.>ten zu beachten. Siehe {{ bug(634150) }} für weitere Informatione
 >n.
n778      Bei der Erstellung von Konstruktoren sollte man vorsichtig n778      Bei der Erstellung von Konstruktoren ist Vorsicht geboten, 
>sein, wenn man globale Informationen im Konstruktor festlegt. Möc>wenn man globale Werte im Konstruktor verändert. Möchte man z. B.
>hte man z. B. für jedes Empoyee-Objekt eine einzigartige ID gener> für jedes <code>Empoyee</code>-Objekt eine eindeutige ID generie
>ieren und automatisch zuweisen, so könnte man <code>Employee</cod>ren und dem Objekt automatisch zuweisen, so könnte man <code>Empl
>e> wie folgt definieren:>oyee</code> wie folgt definieren:
n790      Mit dieser Definition weist der Konstruktor bei der Erstelln790      Mit dieser Definition weist der Konstruktor bei der Erstell
>ung eines Empoyee-Objekts diesem eine ID zu und inkrementiert ans>ung eines <code>Empoyee</code>-Objekts diesem eine ID zu und inkr
>chließend die globale Zählervariable <code>idCounter</code>. Wenn>ementiert anschließend die globale Zählervariable <code>idCounter
> die nächsten Anweisungen wie folgt gemacht werden, bekommt&nbsp;></code>. Wenn die nächsten Anweisungen wie folgt gemacht werden, 
> <code>victoria.id</code> den Wert 1 und <code>harry.id</code> de>bekommt&nbsp; <code>victoria.id</code> den Wert <code>1</code> un
>n Wert 2:>d <code>harry.id</code> den Wert <code>2</code>:
n797      Auf den ersten Blick erscheint diese Vorgehensweise korrektn797      Auf den ersten Blick mag erscheint diese Vorgensweise unpro
>, ist jedoch nicht optimal, da die <code>idCounter</code> bei jed>blematisch erscheinen, da <code>idCounter</code> jedoch bei jeder
>er Erstellung eines <code>Employee</code>-Objekts inkrementiert w> Erstellung eines <code>Employee</code>-Objekts inkrementiert wir
>ird. Erstellt man unter Verwendung dieser Definition die komplett>d, kann diese Implementierung problematisch sein. Hätte man z. B.
>e in diesem Kaptiel beschriebene Hierarchie, wird der <code>Emplo> unter Verwendung dieser Definitionen die komplette in diesem Kap
>yee</code>-Konstuktor bei jeder Zuweisung eines Prototype aufgeru>titel beschriebene Vererbungshierarchie erstellt, dann würde der 
>fen.><code>Employee</code>-Konstuktor bei jeder Zuweisung eines Protot
 >ype aufgerufen.
n826      Angenommen die Definitionen, die hier nicht gezeigt wurden,n826      Weiter angenommen, die Definitionen, deren Definitionen hie
> würden die&nbsp; <code>base</code>-Eigenschaft besitzen und den >r nicht gezeigt wurden, würden die&nbsp; <code>base</code>-Eigens
>Konstruktor des darüberliegenden Objekts in der Prototype-Kette a>chaft besitzen und den Konstruktor des darüberliegenden Objekts i
>ufrufen. In diesem Fall bekäme <code>mac.id</code> bei der Erstel>n der Prototypekette aufrufen, dann bekäme <code>mac.id</code> be
>lung von <code>mac</code> den Wert <code>5</code>.>i der Erstellung von <code>mac</code> den Wert <code>5</code>.
827    </p>
828    <p>827    </p>
828    <p>
829      Ob die zusätzliche Inkrementierung erforderlich ist oder ni829      Ob die zusätzliche Inkrementierung erforderlich ist oder ni
>cht, hängt von der Applikation ab. Falls man einen exakten Wert f>cht, hängt von der Applikation ab. Damit die Zählervariable einen
>ür die Zählervariable nscht, könnte man die Definition wie folg> exakten Wert bekommt, könnte man die Definition wie folgt ändern
>t ändern:>:
n840      Bei der Erstellung einer Employee-Instanz, die als Prototypn840      Bei der Erstellung einer <code>Employee</code>-Instanz, die
>e eingesetzt werden soll, übergibt man keine Argumente an den Kon> als Prototype dient, übergibt man dann einfach keine Argumente a
>struktor. Beim Aufruf des Konstruktors wird <code>id</code> kein >n den Konstruktor. Beim Aufruf des Konstruktors wird <code>id</co
>Wert zugewiesen und die Zählervariable nicht erhöht, falls keine >de> kein Wert zugewiesen und die Zählervariable nicht erhöht. Dam
>Argumente an den Konstruktor übergeben werden. Damit also eine Em>it eine Employee-Instanz eine ID zugewiesen bekommt, muss ein nam
>plyee-Instanz eine ID zugewiesen bekommt, muss ein name als Argum>e als Argument übergeben werden. Bei diesem Beispiel hätte dann <
>ent angegeben werden. Bei diesem Beispiel hätte dann <code>mac.id>code>mac.id</code> den Wert <code>1</code>.
></code> den Wert <code>1</code>. 
841    </p>
842    <p>
843      <span style="color:#ff0000;">...</span>
n846      No multiple inheritancen843      Keine mehrfache Vererbung
847    </h3>
848    <p>844    </h3>
849      Some object-oriented languages allow multiple inheritance. 
>That is, an object can inherit the properties and values from unr 
>elated parent objects. JavaScript does not support multiple inher 
>itance. 
850    </p>845    <p>
846      Manche objektorientierte Programmiersprachen erlauben mehrf
 >ache Vererbung. Das bedeutet, dass Objekte die Eigenschaften und 
 >Werte von nicht verwandten Elternobjekten erben können. JavaScrip
 >t unterstützt diese mehrfache Vererbung nicht.
851    <p>847    </p>
852      Inheritance of property values occurs at run time by JavaSc
>ript searching the prototype chain of an object to find a value.  
>Because an object has a single associated prototype, JavaScript c 
>annot dynamically inherit from more than one prototype chain. 
853    </p>848    <p>
849      Die Vererbung von Eigenschaftswerten erfolgt zur Laufzeit, 
 >indem JavaScript die Prototypekette nach dem Wert absucht. Da ein
 > Objekt nur mit einem einzelnen Prototypen verknüpft werden kann,
 > ist es nicht möglich, dass ein Objekt dynamisch von mehreren Pro
 >totypeketten erbt.
854    <p>850    </p>
855      In JavaScript, you can have a constructor function call mor851    <p>
>e than one other constructor function within it. This gives the i 
>llusion of multiple inheritance. For example, consider the follow 
>ing statements: 
852      Bei JavaScript kann eine Konstruktorfunktion mehrere andere
 > Konstruktorfunktionen aufrufen. Damit lässt sich etwas ähnliches
 > wie mehrfache Vererbung nachbilden. Dies ließe sich z. B. wie in
 > folgendem Beispiel umsetzen:
n874      Further assume that the definition of <code>WorkerBee</coden871      Zusätzlich nehmen wir an, dass die Definition so benutzt wi
>> is as used earlier in this chapter. In this case, the <code>den>rd, wie im vorherigen Abschnitt gezeigt. In diesem Fall hätte das
>nis</code> object has these properties:> Objekt <code>dennis</code> dann diese Eigenschaften:
n884      So <code>dennis</code> does get the <code>hobby</code> propn881      Hier sieht man, dass <code>dennis</code> die Eigenschaft <c
>erty from the <code>Hobbyist</code> constructor. However, assume >ode>hobby</code> des <code>Hobbyist</code>-Konstruktors nicht zug
>you then add a property to the <code>Hobbyist</code> constructor'>ewiesen bekommt. Man könnte dem Prototype des Hobbyist-Konstrukto
>s prototype:>rs die Eigenschaft hinzufügen:
t890      The <code>dennis</code> object does not inherit this new prt887      Das Objekt <code>dennis</code> erbt diese neue Eigenschaft 
>operty.>nicht.

Zurück zur Versionsgeschichte