> Würden wir hingegen das Schlüsselwort `new`{: .language-javascript} bei unserem Funktionsaufruf vergessen, dann hätten wir unter Anderem ein paar neue _globale Variablen_ produziert… Dagegen beschützt dich der strict-Mode. > Aber als **Funktionsobjekt** besitzt unser Konstruktor ja auch noch eine Eigenschaft namens `prototype`, bei der es sich ebenso um ein (_beinahe_) leeres `Object` handelt, welchem wir ebenfalls Eigenschaften und Methoden zuweisen können: > > ~~~ javascript > var Kaefer = function (name) { > this.name = name; > this.typ = 'Ungeziefer'; > this.farbe = 'braun'; > }; > > Kaefer.prototype.beruf = false; > > Kaefer.prototype.gesundheit = 0; > > Kaefer.prototype.bewerfen = function ( ) { > this.gesundheit -= Math.ceil(Math.random( ) * 10); > }; > ~~~ > > Wenn wir nun also `Kaefer` als Konstruktor aufrufen, dann verfügt `gregor` nicht nur über die direkt **in** der Funktion deklarierten Eigenschaften, sondern **ebenso** über die Eigenschaften und Methoden, welche von uns in `Kaefer.prototype` hinterlegt wurden: > > ~~~ javascript > var gregor = new Kaefer('Gregor'); > > gregor.bewerfen( ); > gregor.bewerfen( ); > > var status = gregor.gesundheit; // z.B. -7 :-( > ~~~ > > Zwischen den direkt im Konstruktor angelegten Objekteigenschaften und denjenigen, welche wir im Prototypobjekt des Konstruktors spezifiziert haben, besteht allerdings ein Unterschied: > > ~~~ javascript > var farbe = gregor.hasOwnProperty('farbe'); // true > > var beruf = gregor.hasOwnProperty('beruf'); // false > ~~~ > > Bei den Eigenschaften, welche wir für das Prototypobjekt der Konstruktorfunktion angelegt hatten, handelt es sich also **nicht** um _eigene_ Eigenschaften unseres Instanzobjektes, sondern um _geerbte_. Interessant in dem Zusammenhang ist, dass die Methode `bewerfen`{: javascript-language} bei ihrem ersten Aufruf eine neue Eigenschaft direkt auf der Instanz erzeugt, und nicht die Eigenschaft des Prototyps verändert: ~~~js var gregor = new Kaefer('gregor'); console.assert(gregor.hasOwnProperty('gesundheit') === false, 'Gesundheit ist eine direkte Eigenschaft von gregor'); gregor.bewerfen(); console.assert(gregor.hasOwnProperty('gesundheit') === true, 'Gesundheit ist keine direkte Eigenschaft von gregor'); ~~~ *Die Meldungen sind etwas konfus, weil sie an der Stelle Fehlermeldungen darstellen und keine Erläuterungen. Sie beschreiben also den negativen Fall, dass die Assertions fehlschlagen, nicht den positiven Fall (hier fallen beide Assertions positiv aus)* Eine unmittelbare Auswirkung ist, dass die bewerfen-Methode die Zustände anderer Kaefer-Instanzen unverändert lässt. > Nachdem wir dies also vollbracht haben, verfügt `gregor` nun über eine ganze Reihe an Eigenschaften, von denen lediglich `name`, `typ` und `farbe` _eigene_ Eigenschaften sind, welche in der **Konstruktorfunktion** spezifiziert wurden, während der gesamte Rest über die **Prototypenkette** geerbt wurde. Bis auf solche Eigenschaften, die durch *Duck typing* eben noch zur Laufzeit hinzukommen können, wie im oberen Fall geschildert. `gesundheit`{: javascript-language} ist zunächst keine eigene Eigeschaft von Kaefer-Instanzen, wird aber dazu, sobald die bewerfen-Methode aufgerufen wird.

> Würden wir hingegen das Schlüsselwort `new`{: .language-javascript} bei unserem Funktionsaufruf vergessen, dann hätten wir unter Anderem ein paar neue _globale Variablen_ produziert… Dagegen beschützt dich der strict-Mode. > Aber als **Funktionsobjekt** besitzt unser Konstruktor ja auch noch eine Eigenschaft namens `prototype`, bei der es sich ebenso um ein (_beinahe_) leeres `Object` handelt, welchem wir ebenfalls Eigenschaften und Methoden zuweisen können: > > ~~~ javascript > var Kaefer = function (name) { > this.name = name; > this.typ = 'Ungeziefer'; > this.farbe = 'braun'; > }; > > Kaefer.prototype.beruf = false; > > Kaefer.prototype.gesundheit = 0; > > Kaefer.prototype.bewerfen = function ( ) { > this.gesundheit -= Math.ceil(Math.random( ) * 10); > }; > ~~~ > > Wenn wir nun also `Kaefer` als Konstruktor aufrufen, dann verfügt `gregor` nicht nur über die direkt **in** der Funktion deklarierten Eigenschaften, sondern **ebenso** über die Eigenschaften und Methoden, welche von uns in `Kaefer.prototype` hinterlegt wurden: > > ~~~ javascript > var gregor = new Kaefer('Gregor'); > > gregor.bewerfen( ); > gregor.bewerfen( ); > > var status = gregor.gesundheit; // z.B. -7 :-( > ~~~ > > Zwischen den direkt im Konstruktor angelegten Objekteigenschaften und denjenigen, welche wir im Prototypobjekt des Konstruktors spezifiziert haben, besteht allerdings ein Unterschied: > > ~~~ javascript > var farbe = gregor.hasOwnProperty('farbe'); // true > > var beruf = gregor.hasOwnProperty('beruf'); // false > ~~~ > > Bei den Eigenschaften, welche wir für das Prototypobjekt der Konstruktorfunktion angelegt hatten, handelt es sich also **nicht** um _eigene_ Eigenschaften unseres Instanzobjektes, sondern um _geerbte_. Interessant in dem Zusammenhang ist, dass die Methode `bewerfen`{: javascript-language} bei ihrem ersten Aufruf eine neue Eigenschaft direkt auf der Instanz erzeugt, und nicht die Eigenschaft des Prototyps verändert: ~~~js var gregor = new Kaefer('gregor'); console.assert(gregor.hasOwnProperty('gesundheit') === false, 'Gesundheit ist eine direkte Eigenschaft von gregor'); gregor.bewerfen(); console.assert(gregor.hasOwnProperty('gesundheit') === true, 'Gesundheit ist keine direkte Eigenschaft von gregor'); ~~~ *Die Meldungen sind etwas konfus, weil sie an der Stelle Fehlermeldungen darstellen und keine Erläuterungen. Sie beschreiben also den negativen Fall, dass die Assertions fehlschlagen, nicht den positiven Fall (heir fallen beide Assertions positiv aus)* Eine unmittelbare Auswirkung ist, dass die bewerfen-Methode die Zustände anderer Kaefer-Instanzen unverändert lässt. > Nachdem wir dies also vollbracht haben, verfügt `gregor` nun über eine ganze Reihe an Eigenschaften, von denen lediglich `name`, `typ` und `farbe` _eigene_ Eigenschaften sind, welche in der **Konstruktorfunktion** spezifiziert wurden, während der gesamte Rest über die **Prototypenkette** geerbt wurde. Bis auf solche Eigenschaften, die durch *Duck typing* eben noch zur Laufzeit hinzukommen können, wie im oberen Fall geschildert. `gesundheit`{: javascript-language} ist zunächst keine eigene Eigeschaft von Kaefer-Instanzen, wird aber dazu, sobald die bewerfen-Methode aufgerufen wird.

> Würden wir hingegen das Schlüsselwort `new`{: .language-javascript} bei unserem Funktionsaufruf vergessen, dann hätten wir unter Anderem ein paar neue _globale Variablen_ produziert… Dagegen beschützt dich der strict-Mode. > Aber als **Funktionsobjekt** besitzt unser Konstruktor ja auch noch eine Eigenschaft namens `prototype`, bei der es sich ebenso um ein (_beinahe_) leeres `Object` handelt, welchem wir ebenfalls Eigenschaften und Methoden zuweisen können: > > ~~~ javascript > var Kaefer = function (name) { > this.name = name; > this.typ = 'Ungeziefer'; > this.farbe = 'braun'; > }; > > Kaefer.prototype.beruf = false; > > Kaefer.prototype.gesundheit = 0; > > Kaefer.prototype.bewerfen = function ( ) { > this.gesundheit -= Math.ceil(Math.random( ) * 10); > }; > ~~~ > > Wenn wir nun also `Kaefer` als Konstruktor aufrufen, dann verfügt `gregor` nicht nur über die direkt **in** der Funktion deklarierten Eigenschaften, sondern **ebenso** über die Eigenschaften und Methoden, welche von uns in `Kaefer.prototype` hinterlegt wurden: > > ~~~ javascript > var gregor = new Kaefer('Gregor'); > > gregor.bewerfen( ); > gregor.bewerfen( ); > > var status = gregor.gesundheit; // z.B. -7 :-( > ~~~ > > Zwischen den direkt im Konstruktor angelegten Objekteigenschaften und denjenigen, welche wir im Prototypobjekt des Konstruktors spezifiziert haben, besteht allerdings ein Unterschied: > > ~~~ javascript > var farbe = gregor.hasOwnProperty('farbe'); // true > > var beruf = gregor.hasOwnProperty('beruf'); // false > ~~~ > > Bei den Eigenschaften, welche wir für das Prototypobjekt der Konstruktorfunktion angelegt hatten, handelt es sich also **nicht** um _eigene_ Eigenschaften unseres Instanzobjektes, sondern um _geerbte_. Interessant in dem Zusammenhang ist, dass die Methode `bewerfen`{: javascript-language} bei ihrem ersten Aufruf eine neue Eigenschaft direkt auf der Instanz erzeugt, und nicht die Eigenschaft des Prototyps verändert: ~~~js var gregor = new Kaefer('gregor'); console.assert(gregor.hasOwnProperty('gesundheit') === false, 'Gesundheit ist eine direkte Eigenschaft von gregor'); gregor.bewerfen(); console.assert(gregor.hasOwnProperty('gesundheit') === true, 'Gesundheit ist keine direkte Eigenschaft von gregor'); ~~~ *Die Meldungen sind etwas konfus, weil sie an der Stelle Fehlermeldungen dastellen und keine Erläuterungen. Sie beschreiben also den negativen Fall, dass die Assertions fehlschlagen, nicht den positiven Fall (heir fallen beide Assertions positiv aus)* Eine unmittelbare Auswirkung ist, dass die bewerfen-Methode die Zustände anderer Kaefer-Instanzen unverändert lässt. > Nachdem wir dies also vollbracht haben, verfügt `gregor` nun über eine ganze Reihe an Eigenschaften, von denen lediglich `name`, `typ` und `farbe` _eigene_ Eigenschaften sind, welche in der **Konstruktorfunktion** spezifiziert wurden, während der gesamte Rest über die **Prototypenkette** geerbt wurde. Bis auf solche Eigenschaften, die durch *Duck typing* eben noch zur Laufzeit hinzukommen können, wie im oberen Fall geschildert. `gesundheit`{: javascript-language} ist zunächst keine eigene Eigeschaft von Kaefer-Instanzen, wird aber dazu, sobald die bewerfen-Methode aufgerufen wird.

> Würden wir hingegen das Schlüsselwort `new`{: .language-javascript} bei unserem Funktionsaufruf vergessen, dann hätten wir unter Anderem ein paar neue _globale Variablen_ produziert… Dagegen beschützt dich der strict-Mode. > Aber als **Funktionsobjekt** besitzt unser Konstruktor ja auch noch eine Eigenschaft namens `prototype`, bei der es sich ebenso um ein (_beinahe_) leeres `Object` handelt, welchem wir ebenfalls Eigenschaften und Methoden zuweisen können: > > ~~~ javascript > var Kaefer = function (name) { > this.name = name; > this.typ = 'Ungeziefer'; > this.farbe = 'braun'; > }; > > Kaefer.prototype.beruf = false; > > Kaefer.prototype.gesundheit = 0; > > Kaefer.prototype.bewerfen = function ( ) { > this.gesundheit -= Math.ceil(Math.random( ) * 10); > }; > ~~~ > > Wenn wir nun also `Kaefer` als Konstruktor aufrufen, dann verfügt `gregor` nicht nur über die direkt **in** der Funktion deklarierten Eigenschaften, sondern **ebenso** über die Eigenschaften und Methoden, welche von uns in `Kaefer.prototype` hinterlegt wurden: > > ~~~ javascript > var gregor = new Kaefer('Gregor'); > > gregor.bewerfen( ); > gregor.bewerfen( ); > > var status = gregor.gesundheit; // z.B. -7 :-( > ~~~ > > Zwischen den direkt im Konstruktor angelegten Objekteigenschaften und denjenigen, welche wir im Prototypobjekt des Konstruktors spezifiziert haben, besteht allerdings ein Unterschied: > > ~~~ javascript > var farbe = gregor.hasOwnProperty('farbe'); // true > > var beruf = gregor.hasOwnProperty('beruf'); // false > ~~~ > > Bei den Eigenschaften, welche wir für das Prototypobjekt der Konstruktorfunktion angelegt hatten, handelt es sich also **nicht** um _eigene_ Eigenschaften unseres Instanzobjektes, sondern um _geerbte_. Interessant in dem Zusammenhang ist, dass die Methode `bewerfen`{: javascript-language} bei ihrem ersten Aufruf eine neue Eigenschaft direkt auf der Instanz erzeugt, und nicht die Eigenschaft des Prototyps verändert: ~~~js var gregor = new Kaefer('gregor'); console.assert(gregor.hasOwnProperty('gesundheit') === false, 'Gesundheit ist eine direkte Eigenschaft von gregor'); gregor.bewerfen(); console.assert(gregor.hasOwnProperty('gesundheit') === true, 'Gesundheit ist keine direkte Eigenschaft von gregor'); ~~~ *Die Meldungen sind etwas konfus, weil sie an der Stelle Fehlermeldungen dastellen und keine Erläuterungen. Sie beschreiben also den negativen Fall, dass die Assertions fehlschlagen, nicht den positiven Fall (in diesem Fall fallen beide Assertions positiv aus)* Eine unmittelbare Auswirkung ist, dass die bewerfen-Methode die Zustände anderer Kaefer-Instanzen unverändert lässt. > Nachdem wir dies also vollbracht haben, verfügt `gregor` nun über eine ganze Reihe an Eigenschaften, von denen lediglich `name`, `typ` und `farbe` _eigene_ Eigenschaften sind, welche in der **Konstruktorfunktion** spezifiziert wurden, während der gesamte Rest über die **Prototypenkette** geerbt wurde. Bis auf solche Eigenschaften, die durch *Duck typing* eben noch zur Laufzeit hinzukommen können, wie im oberen Fall geschildert. `gesundheit`{: javascript-language} ist zunächst keine eigene Eigeschaft von Kaefer-Instanzen, wird aber dazu, sobald die bewerfen-Methode aufgerufen wird.

> Würden wir hingegen das Schlüsselwort `new`{: .language-javascript} bei unserem Funktionsaufruf vergessen, dann hätten wir unter Anderem ein paar neue _globale Variablen_ produziert… Dagegen beschützt dich der strict-Mode. > Aber als **Funktionsobjekt** besitzt unser Konstruktor ja auch noch eine Eigenschaft namens `prototype`, bei der es sich ebenso um ein (_beinahe_) leeres `Object` handelt, welchem wir ebenfalls Eigenschaften und Methoden zuweisen können: > > ~~~ javascript > var Kaefer = function (name) { > this.name = name; > this.typ = 'Ungeziefer'; > this.farbe = 'braun'; > }; > > Kaefer.prototype.beruf = false; > > Kaefer.prototype.gesundheit = 0; > > Kaefer.prototype.bewerfen = function ( ) { > this.gesundheit -= Math.ceil(Math.random( ) * 10); > }; > ~~~ > > Wenn wir nun also `Kaefer` als Konstruktor aufrufen, dann verfügt `gregor` nicht nur über die direkt **in** der Funktion deklarierten Eigenschaften, sondern **ebenso** über die Eigenschaften und Methoden, welche von uns in `Kaefer.prototype` hinterlegt wurden: > > ~~~ javascript > var gregor = new Kaefer('Gregor'); > > gregor.bewerfen( ); > gregor.bewerfen( ); > > var status = gregor.gesundheit; // z.B. -7 :-( > ~~~ > > Zwischen den direkt im Konstruktor angelegten Objekteigenschaften und denjenigen, welche wir im Prototypobjekt des Konstruktors spezifiziert haben, besteht allerdings ein Unterschied: > > ~~~ javascript > var farbe = gregor.hasOwnProperty('farbe'); // true > > var beruf = gregor.hasOwnProperty('beruf'); // false > ~~~ > > Bei den Eigenschaften, welche wir für das Prototypobjekt der Konstruktorfunktion angelegt hatten, handelt es sich also **nicht** um _eigene_ Eigenschaften unseres Instanzobjektes, sondern um _geerbte_. Interessant in dem Zusammenhang ist, dass die Methode `bewerfen`{: javascript-language} bei ihrem ersten Aufruf eine neue Eigenschaft direkt auf der Instanz erzeugt, und nicht die Eigenschaft des Prototyps verändert: ~~~js var gregor = new Kaefer('gregor'); console.assert(gregor.hasOwnProperty('gesundheit') === false, 'Gesundheit ist keine direkte Eigenschaft von gregor'); gregor.bewerfen(); console.assert(gregor.hasOwnProperty('gesundheit') === true, 'Gesundheit ist eine direkte Eigenschaft von gregor'); ~~~ *Die Meldungen sind etwas konfus, weil sie an der Stelle Fehlermeldungen dastellen und keine Erläuterungen. Sie beschreiben also den negativen Fall, dass die Assertions fehlschlagen, nicht den positiven Fall (in diesem Fall fallen beide Assertions positiv aus)* Eine unmittelbare Auswirkung ist, dass die bewerfen-Methode die Zustände anderer Kaefer-Instanzen unverändert lässt. > Nachdem wir dies also vollbracht haben, verfügt `gregor` nun über eine ganze Reihe an Eigenschaften, von denen lediglich `name`, `typ` und `farbe` _eigene_ Eigenschaften sind, welche in der **Konstruktorfunktion** spezifiziert wurden, während der gesamte Rest über die **Prototypenkette** geerbt wurde. Bis auf solche Eigenschaften, die durch *Duck typing* eben noch zur Laufzeit hinzukommen können, wie im oberen Fall geschildert. `gesundheit`{: javascript-language} ist zunächst keine eigene Eigeschaft von Kaefer-Instanzen, wird aber dazu, sobald die bewerfen-Methode aufgerufen wird.