nicht angemeldet
Hallo,
Also die Funktion, die für das Erzeugen des Objekts zuständig ist, sieht in etwa so aus:
function NewObject(id){ // properties: this.name = id; this.left = 0; this.top = 0; [etc.]
// methods: this.function1 = ObjFunction1; this.function2 = ObjFunction2; [etc.] }
nach dem Laden der Seite wird jetzt eine bestimmte Anzahl solcher Objekte erzeugt.
D = new Array();
function Startup(){ for(var i=0; i<10; i++){ D[i] = new NewObject(i+'id'); D[i].left = 50; [etc.] } }
Mit diesem Vorgehen hat doch zunächst einmal das abstrakte Objekt die Methoden und beim Erzeugen der einzelnen Instanzen bekommen diese die dann ebenfalls mit überreicht ? Oder denk ich da falsch ?
Nö, du denkst da schon ganz richtig. Sie (Instanzen) bekommen es (Eigenschaften, Methoden) aber nicht über einen prototypischen Verweis überreicht, sondern werden hier pro Instanz neu zugewiesen, sprich es wird Speicherplatz reserviert etc.
Beispiel:
function A() { this.name = "walter"; }
var v1 = new A(); var v2 = new A();
*************** *************** +++++++++++++++
- A (Instanz) * * A (Instanz) * <-- Kopie pro Instanz --- + A (Vorlage) + *************** *************** +++++++++++++++ name="walter" name="walter" *************** *************** ^ ^ | | | | v1 v2
Bei dem Einsatz von Prototypen ist es anders. Dort gibt es einen Verweis auf ein prototypisches Objekt mit den genannten Eigenschaften und Methoden für alle Instanzen. Der Grund dafür liegt darin, dass der Prototyp bzw. dessen Instanz nicht mitkopiert wird, der Verweis hingegen schon.
Beispiel:
function A() { this.name = "walter"; }
function B() { } B.prototype = new A();
var v1 = new B(); var v2 = new B();
*************** +++++++++++++++ * A (Instanz) * <-- Kopie pro Instanz --- + A (Vorlage) + *************** +++++++++++++++ name="walter" *************** | #---------- Prototyp (B.prototype = new A();) ---# . | . | ....übernommener Verweis.... | Verweis . . | . . | *************** *************** +++++++++++++++
- B (Instanz) * * B (Instanz) * <-- Kopie pro Instanz --- + B (Vorlage) + *************** *************** +++++++++++++++ ^ ^ | | | | v1 v2
Wie du siehst hat weder v1 noch v2, als Instanz gesehen, die Eigenschaft name, sondern teilen sich ein prototypisches Objekt mit der Eigenschaft name ("walter"). Würdest du nun über B.prototype.name den Namen ändern (z.B. "dieter"), dann würde auch v2, da auf die Eigenschaft name über den prototypischen Verweis zugegriffen wird, davon betroffen sein.
Anders verhält es sich bei einer Zuweisung einer Eigenschaft oder Methode an eine Instanz. Diese wird, weil es sich letztendlich um ein generisches Objekt handelt, dynamisch um die Eigenschaft bzw. Methode erweitert.
Beispiel:
function A() { this.name = "walter"; }
function B() { } B.prototype = new A();
var v1 = new B(); var v2 = new B();
v1.name = "dieter";
*************** +++++++++++++++ * A (Instanz) * <-- Kopie pro Instanz --- + A (Vorlage) + *************** +++++++++++++++ name="walter" *************** | #---------- Prototyp (B.prototype = new A();) ---# . | . | ....übernommener Verweis.... | Verweis . . | . . | *************** *************** +++++++++++++++
- B (Instanz) * * B (Instanz) * <-- Kopie pro Instanz --- + B (Vorlage) + *************** *************** +++++++++++++++ name="dieter" ^ *************** | ^ | | | | | v1 v2
Ein alert(v1.name) gibt "dieter" aus, wohingegen ein alert(v2.name) "walter" ausgibt. In Wirklichkeit ist es aber noch wesentlich komplexer, kann aber nicht in einem Post erklärt werden.
Bei dem Prototype dachte ich eigentlich bisher, dass er sich besonders gut eignet, wenn ich für bereits vorhandene Instanzen neue Methoden anfügen will, d.h. mittels prototype bekommt das abstrakte Objekt die neue Methode und damit wird sie dann aucht automatisch an alle bereits erzeugten Instanzen weitergereicht ???
Genau, wie die "Grafik" es anschaulich zeigt, teilen sich dann die entspr. Instanzen das prototypische Objekt. Sie verlangen dadurch wesentlich weniger Resourcen und sind in ihrer Erzeugung schneller (Speicherreservierung, Codeauswertung) weil es nur einmal geschieht (für das prototypische Objekt). Sinn mach dies aber wirklich nur bei Methoden, weil diese sich meisten nicht ändern und somit unbedenklich geteilt werden könne, wohingegen Eigenschaften sicherlich für jede Instanz neu gesetzt werden (die Werte).
Ich hoffe dass ich mich etwas klarer ausgedrückt habe. Falls jemand Fehler sieht möge er mich korrigieren.
bernd.