Prototyping oder Vererbung... unter der Lupe

Hallo,

ich habe in der letzen Zeit schon einiges über Vererbung bzw.
Prototyping in JavaScript gelesen und auch probiert. Jedoch fehlt mir
an der ein oder anderen Stelle noch eine Bestätigung bzw. ganz und gar
Wissen.

Bisher konnte ich mehrere Implementierungsbeispiele finden die ich
jetzt auch gern bis ins Detail verstehen möchte. Hier einige Beispiele
mit dem was ich dabei verstehe und eventuell Fragen.

Allgemein gilt:
..-.-.-.-.-.-.-.-.
function Super(){
this.foo = function(){...}
}

---------------------------------------------------
---------------------------------------------------

Variante 1:
-----------
function Sub(){
this.constructor();
}
Sub.prototype = Super;

Diese Variante verwende ich zur Zeit am liebsten. Jedoch hat sie einen
Nachteil. Ich kann eine Vererbung mit mehr als einem Sub-Objekt
herstellen.

Denn: Zu einer Vererbungskette (wie ich sie im Falle von JS mal
bezeiche) gibt es nur ein Konstruktor-Objekt, welches die "prototype"
und "constructor" Eigenschaft hält. Bitte hier korrigieren oder
kommentieren!

Füge ich den folgenden Programmcode hinzu, bekomme ich eine
Endlose-Schleife im Aufruf "Sub.constructor()", da ich die "prototype"
Eigenschaft meines Konstruktor-Objektes auf "Sub" gesetzt habe. Kann
man das so sagen? (setze voraus dass Definitionen in gleicher
Reihenfolge erfolgen)

function SubSub(){
this.constructor();
}
SubSub.prototype = Sub;

---------------------------------------------------
---------------------------------------------------

Variante 2.
-----------
function Sub(){

}
Sub.prototype = new Super();

Nun zur zweiten Variante. Hierbei wird für jede Hierarchiestufe der
Vererbungsstruktur ein Oberklassen-Objekt erstellt. Somit hat jede
Vererbungsstufe ihr eigene "prototype" und "constructor" Eigenschaft.
(Kommentieren Bitte) Das Instanziieren wird beim einlesen des Scripts
durchgeführt (RT).

Damit teilen sich alle Instanzen der Subklasse, die irgendwann erstellt
werden, ein Oberobjekt. D.h. verändert eine Subinstanze den Zustand
des Oberobjekts, dann betrifft dies alle Instanzen.
(Kommentieren Bitte)

---------------------------------------------------
---------------------------------------------------

und zu guter letzt Variante 3.
------------------------------
function Sub(){
this.super = new Super();
this.foo = this.super.foo;
}

Nun noch eine letzte Variante, welche ich oft in diesem Zusammenhang
gesehen habe. Diese Variante halte ich eher für eine Aggregation. Ich
kenne bisher keinen Grund warum ich sowas als Vererbung bezeichnet.
Diese Variante halte ich eher für ein Missverständniss des Autors was
OO angeht. (Sofern ich hier richtig liege bitte keinen Kommentar)

Gruss

Alexander

alsc0001 wrote:

ich habe in der letzen Zeit schon einiges über Vererbung bzw.
Prototyping in JavaScript gelesen und auch probiert. Jedoch fehlt mir
an der ein oder anderen Stelle noch eine Bestätigung bzw. ganz und gar
Wissen.

Hast du dir prototype.js dabei auch angeschaut? Unbedingt
empfehlenswert:

http://prototype.conio.net/

Michael

--
Michael Schuerig The Fifth Rider of the Apocalypse
mailto:michael (AT) schuerig (DOT) de is a programmer.
http://www.schuerig.de/michael/

Michael Schuerig schrieb:

alsc0001 wrote:

ich habe in der letzen Zeit schon einiges über Vererbung bzw.
Prototyping in JavaScript gelesen und auch probiert. Jedoch fehlt mir
an der ein oder anderen Stelle noch eine Bestätigung bzw. ganz und gar
Wissen.

Hast du dir prototype.js dabei auch angeschaut? Unbedingt
empfehlenswert:

http://prototype.conio.net/

Michael

--
Michael Schuerig The Fifth Rider of the Apocalypse
mailto:michael (AT) schuerig (DOT) de is a programmer.
http://www.schuerig.de/michael/

Wirklich interessante Geschichte. Wenn ich das richtig verstehe pflegen
die Leute eine Liste von prototype Eigenschaften. Damit erweitern sie
den Funktionsumfang eines Objekts. Weiss nicht... würde sagen das
schießt an meiner Intension, dem Aufbau von Vererbungsstrukturen,
vorbei.


gruss und vielen dank

Alexander

alsc0001 wrote:

Michael Schuerig schrieb:

Hast du dir prototype.js dabei auch angeschaut? Unbedingt
empfehlenswert:

http://prototype.conio.net/

Wirklich interessante Geschichte. Wenn ich das richtig verstehe
pflegen die Leute eine Liste von prototype Eigenschaften. Damit
erweitern sie den Funktionsumfang eines Objekts. Weiss nicht... würde
sagen das schießt an meiner Intension, dem Aufbau von
Vererbungsstrukturen, vorbei.

Ich glaube, du verstehst da etwas miss. Nicht "die Leute" pflegen eine
Liste von prototype Eigenschaften, sondern das ist Standard-JavaScript.
Es ist Bestandteil der Sprache, dass Objekte Prototypen haben und das
Methodenaufrufe dorthin delegiert werden. Wird also ein solcher
Prototyp um neue Methoden erweitert, so sind diese Methoden für alle
Objekte mit diesem Prototypen verfügbar.

Michael

--
Michael Schuerig You can twist perceptions
mailto:michael (AT) schuerig (DOT) de Reality won't budge
http://www.schuerig.de/michael/ --Rush, Show Don't Tell

Michael Schuerig wrote:

alsc0001 wrote:
ich habe in der letzen Zeit schon einiges über Vererbung bzw.
Prototyping in JavaScript gelesen und auch probiert. Jedoch fehlt mir
an der ein oder anderen Stelle noch eine Bestätigung bzw. ganz und gar
Wissen.

Hast du dir prototype.js dabei auch angeschaut? Unbedingt
empfehlenswert:

http://prototype.conio.net/

Nein.


PointedEars
--
Denn machen wir uns nichts vor, liebe Freunde: Es ist nicht nur der
Rinderwahnsinn, der unser Hirn bedroht ... oder RTL2 vielleicht ... :-)
-- Reinhard Mey in der Einleitung zu
"Irgendein Depp bohrt irgendwo immer"

Thomas 'PointedEars' Lahn wrote:

Michael Schuerig wrote:

alsc0001 wrote:
ich habe in der letzen Zeit schon einiges über Vererbung bzw.
Prototyping in JavaScript gelesen und auch probiert. Jedoch fehlt
mir an der ein oder anderen Stelle noch eine Bestätigung bzw. ganz
und gar Wissen.

Hast du dir prototype.js dabei auch angeschaut? Unbedingt
empfehlenswert:

http://prototype.conio.net/

Nein.

Ach, Thomas, schön das du wieder da bist. Mit bekannt kernigen
Beiträgen.

Prototype.js demonstriert ein Stil, mit dem vergleichsweise einfach auf
der Basis von Prototypen objektorientiert programmiert werden kann. Der
Namespace wird nicht unnötig verschmutzt. Die Implementierung macht
guten Gebrauch von Abstraktion. Die Funktionalität ist vielfältig
nutzbar.

Jetzt bist du dran: Was ist schlecht?

Michael

--
Michael Schuerig Those people who smile a lot
mailto:michael (AT) schuerig (DOT) de Watch the eyes
http://www.schuerig.de/michael/ --Ani DiFranco, Outta Me, Onto You

Michael Schuerig wrote:

Thomas 'PointedEars' Lahn wrote:
Michael Schuerig wrote:
alsc0001 wrote:
ich habe in der letzen Zeit schon einiges über Vererbung bzw.
Prototyping in JavaScript gelesen und auch probiert. Jedoch fehlt
mir an der ein oder anderen Stelle noch eine Bestätigung bzw. ganz
und gar Wissen.

Hast du dir prototype.js dabei auch angeschaut? Unbedingt
empfehlenswert:

http://prototype.conio.net/

Nein.

Ach, Thomas, schön das du wieder da bist. Mit bekannt kernigen
Beiträgen.

Prototype.js demonstriert ein Stil, mit dem vergleichsweise einfach auf
der Basis von Prototypen objektorientiert programmiert werden kann. Der
Namespace wird nicht unnötig verschmutzt. Die Implementierung macht
guten Gebrauch von Abstraktion. Die Funktionalität ist vielfältig
nutzbar.

Wenigstens hast Du eine blühende Phantasie.

Jetzt bist du dran: Was ist schlecht?

Das habe ich schonmal geschrieben. Neue Argumente Deinerseits wären
daher hilfreich.


PointedEars
--
http://members.ud.com/download/gold/
http://folding.stanford.edu/
http://alien.de/seti/
http://setiathome.ssl.berkeley.edu/

Thomas 'PointedEars' Lahn wrote:

Michael Schuerig wrote:

Thomas 'PointedEars' Lahn wrote:
Michael Schuerig wrote:
alsc0001 wrote:
ich habe in der letzen Zeit schon einiges über Vererbung bzw.
Prototyping in JavaScript gelesen und auch probiert. Jedoch fehlt
mir an der ein oder anderen Stelle noch eine Bestätigung bzw. ganz
und gar Wissen.

Hast du dir prototype.js dabei auch angeschaut? Unbedingt
empfehlenswert:

http://prototype.conio.net/

Nein.

Ach, Thomas, schön das du wieder da bist. Mit bekannt kernigen
Beiträgen.

Prototype.js demonstriert ein Stil, mit dem vergleichsweise einfach
auf der Basis von Prototypen objektorientiert programmiert werden
kann. Der Namespace wird nicht unnötig verschmutzt. Die
Implementierung macht guten Gebrauch von Abstraktion. Die
Funktionalität ist vielfältig nutzbar.

Wenigstens hast Du eine blühende Phantasie.

Jetzt bist du dran: Was ist schlecht?

Das habe ich schonmal geschrieben. Neue Argumente Deinerseits wären
daher hilfreich.

Wenn du so sicher bist, dass du in dieser Newsgroup schon etwas dazu
geschrieben hast, dann wäre ein Verweis auf den Beitrag angebracht.

Ich habe gesehen, dass du in comp.lang.javascript ein wenig über
theoretische Mängel von prototype.js geschimpft hast. Das sagt
allerdings nichts über den Nutzen dieser Bibliothek aus. Vor allem aber
ist es in einer Gruppe gewesen. Ich verspüre üblicherweise keinen
Drang, den potenziellen Begründungen für deine Behauptungen über Usenet
und Web nach zu jagen. An keiner Stelle habe ich von dir etwas dazu
gefunden, was die von mir genannten Argumente konterkariert.

Michael

--
Michael Schuerig Failures to use one's frontal lobes
mailto:michael (AT) schuerig (DOT) de can result in the loss of them.
http://www.schuerig.de/michael/ --William H. Calvin

Michael Schuerig wrote:

Thomas 'PointedEars' Lahn wrote:
[prototype.js ist nicht empfehlenswert]
Wenn du so sicher bist, dass du in dieser Newsgroup schon etwas dazu
geschrieben hast, dann wäre ein Verweis auf den Beitrag angebracht.

Ja, es war doch nicht hier, sondern

Ich habe gesehen, dass du in comp.lang.javascript

eben da.

ein wenig über theoretische Mängel von prototype.js geschimpft hast.
Das sagt allerdings nichts über den Nutzen dieser Bibliothek aus.

Ach, Du möchtest mangelhafte Scripts benutzen und weiterempfehlen?

[...] An keiner Stelle habe ich von dir etwas dazu
gefunden, was die von mir genannten Argumente konterkariert.

Sinnentnehmendes Lesen/Englisch ist anscheinend nicht Deine Stärke.
Ich schrieb in

<2377616.bzk5MvnWfF (AT) PointedEars (DOT) de>
http://groups.google.de/group/comp.l...b18 6e29dbe1c

zu gut Deutsch:

Elf M. Sternberg schrieb:
Einer der Mängel von prototype.js (google danach, wenn Du
es nicht kennst) ist, dass es schlecht dokumentiert ist.

Es ist nicht nur schlecht dokumentiert, sondern beruht mit ziemlicher
Sicherheit auf einem (verbreiteten?) Missverständnis. Was soll eine
"objektorientierte Javascript-Bibliothek" sein?
J(ava)Script/ECMAScript *sind* objektorientierte Programmiersprachen;
dass JavaScript < 2.0 (v2.0 ist nur in der Epimetheus-Testimplementation
verfügbar), JScript < 7.0 (v7.0 nur im .NET-Framework) und ECMAScript < 4
(Ed. 4 ist noch immer nur ein Vorschlag von Netscape) lediglich für
prototypbasierte Vererbung bereitstellen, mindert weder ihren Status
noch den von anderen OOP-Sprachen, die dasselbe Objektmodell verwenden.

Obwohl das Emulieren von klassenbasierter Vererbung in einer
prototypbasierten Sprache interessant sein kann, ist der Ansatz,
der hier benutzt wird, (jedenfalls für mich) eher zweifelhaft.
Statt ordentliche Funktionsdeklarationen für Konstruktoren zu
benutzen, wird dort ein Objekt über einen zuvor erstellten und
später veränderten Prototyp mittels Class.create() erzeugt, der
wiederum eine `initialize'-Eigenschaft erfordert, welche den
Aufruf von Function.prototype.apply() erfordert. Ich kann dabei
keinen Sinn und Zweck ausser Verschleierung von Code oder sonst
einen Vorteil darin sehen (wenn man Verschleierung überhaupt
einen Vorteil nennen kann); im Vergleich zum Aufruf einer
Konstruktorfunktion mit dem Schlüsselwort `new' (welche die
Initialisierung durchführen kann) reduziert es die Effizienz
des Codes und erhöht seinen Speicherbedarf [des Programms;
Anm. d. Übers.].

Du solltest lernen, zwischen "Schimpfen" und fachlicher Kritik zu
unterscheiden. In dem Zusammenhang wäre es vielleicht ratsam, wenn
Du meine Artikel wenigstens gelegentlich zuende lesen würdest.

Einen deutlich besseren Ansatz für die Emulation klassenbasierter
Vererbung in JS findet man übrigens hier:

<http://crockford.com/javascript/inheritance.html>


PointedEars
--
Gleich Warnung an diejenigen, die auf Mallorca 'ne Finca besitzen:
Verkaufen! Denn: In 50 Millionen Jahren kommt der Afrikaner hierher,
ob wir nun Einwanderungsgesetze haben oder nicht.
-- Prof. Dr. H. Lesch über die Kontinentaldrift in "alpha centauri"

Thomas 'PointedEars' Lahn wrote:

Michael Schuerig wrote:

Ich habe gesehen, dass du in comp.lang.javascript

eben da.

ein wenig über theoretische Mängel von prototype.js geschimpft hast.
Das sagt allerdings nichts über den Nutzen dieser Bibliothek aus.

Ach, Du möchtest mangelhafte Scripts benutzen und weiterempfehlen?

Wobei das "mangelhaft" noch zu zeigen wäre.

[Thomas über prototype.js:]

| Es ist nicht nur schlecht dokumentiert, sondern beruht mit
| ziemlicher
| Sicherheit auf einem (verbreiteten?) Missverständnis. Was soll eine
| "objektorientierte Javascript-Bibliothek" sein?
| J(ava)Script/ECMAScript *sind* objektorientierte
| Programmiersprachen; dass JavaScript < 2.0 (v2.0 ist nur in der
| Epimetheus-Testimplementation verfügbar), JScript < 7.0 (v7.0 nur im
| .NET-Framework) und ECMAScript < 4 (Ed. 4 ist noch immer nur ein
| Vorschlag von Netscape) lediglich für prototypbasierte Vererbung
| bereitstellen, mindert weder ihren Status noch den von anderen
| OOP-Sprachen, die dasselbe Objektmodell verwenden.
|
| Obwohl das Emulieren von klassenbasierter Vererbung in einer
| prototypbasierten Sprache interessant sein kann, ist der Ansatz,
| der hier benutzt wird, (jedenfalls für mich) eher zweifelhaft.

Bis hierher bekundest du nichts weiter als dein theoretisches
Missfallen.

| Statt ordentliche Funktionsdeklarationen für Konstruktoren zu
| benutzen, wird dort ein Objekt über einen zuvor erstellten und
| später veränderten Prototyp mittels Class.create() erzeugt, der
| wiederum eine `initialize'-Eigenschaft erfordert, welche den
| Aufruf von Function.prototype.apply() erfordert. Ich kann dabei
| keinen Sinn und Zweck ausser Verschleierung von Code oder sonst
| einen Vorteil darin sehen (wenn man Verschleierung überhaupt
| einen Vorteil nennen kann);

"Ordentlich", "ich kann nicht sehen", "verschleiern". Ich vermisse das
Argument. Statt dessen wieder nur Meinung. Dagegen kann ich auch meine
Meinung halten. Ich finde

MeineKlasse = Class.create();
MeineKlasse.prototype = {
initialize: function(arg1, arg2) {
...
},
methode: function(arg1) {
...
}
};

gut lesbar und nachvollziehbar auch für jemand, der die genaue
Funktionsweise von Class.create usw. nicht kennt.

| im Vergleich zum Aufruf einer
| Konstruktorfunktion mit dem Schlüsselwort `new' (welche die
| Initialisierung durchführen kann) reduziert es die Effizienz
| des Codes und erhöht seinen Speicherbedarf [des Programms;
| Anm. d. Übers.].

Erhöht es den Speicherbedarf tatsächlich? Dabei solltest du vergleichen,
wie der Speicherbedarf einer Closure-basierten Lösung aussähe. Ohne
nähere Untersuchung überzeugt mich deine Behauptung nicht. Sie ist
jedenfalls nicht offensichtlich zutreffend. Wenn sich heraus stellt,
dass der Speicherbedarf höher ist, ist es temporär oder dauerhaft? Gibt
es messbare Auswirkungen?

Du solltest lernen, zwischen "Schimpfen" und fachlicher Kritik zu
unterscheiden. In dem Zusammenhang wäre es vielleicht ratsam, wenn
Du meine Artikel wenigstens gelegentlich zuende lesen würdest.

Ich lese deine Artikel vollständig, sofern ich nicht von den Invektiven
abgelenkt oder vertrieben werde.

Einen deutlich besseren Ansatz für die Emulation klassenbasierter
Vererbung in JS findet man übrigens hier:

Was ist daran besser? Du hast wieder das Argument vergessen.

Michael

--
Michael Schuerig Airtight arguments have
mailto:michael (AT) schuerig (DOT) de vacuous conclusions.
http://www.schuerig.de/michael/ --A.O. Rorty, Explaining Emotions