OOP ... wie war das noch ?

[heinetz]

Hallo Forum,

ich verwende ein objektorientiert programmiertes Javascript.
Das ist folgendermassen aufgebaut:

/* Constructor */
function Klasse ()
                  {
                   var idOfTree;
                   this.eigenschaft = wert;
                   //usw.
                  }

/* my_object class */
Klasse.prototype = {
methode_a : function (paramter)
                    {
                     return wert;
                    },
methode_b : function (paramter)
                    {
                     return wert;
                    }
//usw.
}

Es macht zu 90% was ich will, aber ich benötige weitere
Methoden. Die könnte ich natürlich genauso definieren,
wie die vorhanden und direkt in dem Script programmieren.
Ich möchte das vorhandene aber ungern verändern und die
Methoden gerne in einem anderen Script definieren

(
<script src="js/Klasse.js"></script>
<script src="js/my_Klasse.js"></script>
)

Wie macht man das?

Danke für Tipps und

beste grüsse,
heinetz

[molily]

Klasse.prototype = { ... }

Ich möchte das vorhandene aber ungern verändern und die
Methoden gerne in einem anderen Script definieren

Klasse.prototype.weitererMember = ...;

Oder du verwendest eine extend-Methode wie die aus der Prototype-Bibliothek:

Object.extend = function(destination, source) {  
  for (var property in source)  
    destination[property] = source[property];  
  return destination;  
};

Dann kannst du beliebig oft notieren:

function Konstruktor () {}  
  
Object.extend(Konstruktor.prototype, {  
   memberA : ...,  
   memberB : ...  
});  
Object.extend(Konstruktor.prototype, {  
   memberC : ...,  
   memberD : ...  
});  
...

Mathias

[heinetz]

Jo, immer das selbe:

ich schreibe Postings, wärend dessen wird mir klar, dass
ich die Zeit, die ich in so ein Posting investiere,
genauso für's Suchen und Doku lesen hätte. Dann schreibe
ich es für den Fall, dass ich selbst nicht weiter komme
zuende und mache mich danach an's Suchen und Doku lesen.

Und so:

entspr. Deinem Vorschlag (Klasse.prototype.weitererMember)
habe ich's dann auch einfach mal ausprobiert und es funktioniert
auch. Was ausserdem auf diese Weise funktioniert, ist das Überscheiben von zuvor definierten Methoden. Ich habe also
sämtliche zuvor an der Original-Klasse rückgängig gemacht
und auf dem Weg meine Anpassungen ausgelagert. Was gerade
noch hakt ist folgendes:

<script src="js/Klasse.js"></script>
/* Constructor */
function Klasse ()
                  {
                   var idOfTree;
                   this.eigenschaft = 1;
                   //usw.
                  }

/* my_object class */
Klasse.prototype = {
methode_a : function (wert)
                    {
                     return wert;
                    },
methode_b : function (wert)
                    {
                     return this.name;
                    }
//usw.
}

<script src="js/my_Klasse.js"></script>
JSDragDropTree.prototype.eigenschaft = 2;
//bzw.
JSDragDropTree.eigenschaft = 2;

[heinetz]

ich meine natürlich:

<script src="js/my_Klasse.js"></script>
Klasse.prototype.eigenschaft = 2;
//bzw.
Klasse.eigenschaft = 2;

beste gruesse,
heinetz

[Struppi]

ich meine natürlich:

<script src="js/my_Klasse.js"></script>
Klasse.prototype.eigenschaft = 2;
//bzw.
Klasse.eigenschaft = 2;

was hakt da konkret?
Das erste ist eine prototypische Eigenschaft, die jedes Objekt erhält und das zweite der Zugriff darauf.

Struppi.

[heinetz]

ich habe beides ausprobiert, um die im Konstruktor ursprünglich definierte Eigenschaft auf diese Weise zu überschreiben. Das
ging so nicht. Was funktioniert hat war dann folgender Umweg:

Klasse.prototype.eigenschaft_ueberschreiben = function(wert)
{
this.eigenschaft = wert;
}

instanz.eigenschaft_ueberschreiben ('2');

... was aber etwas anderes ist.

beste gruesse,
heinetz

[Timo "God's Boss" Reitz]

ich habe beides ausprobiert, um die im Konstruktor ursprünglich definierte Eigenschaft auf diese Weise zu überschreiben. Das
ging so nicht.

Achso! Das geht auch nicht. Wenn ein Objekt selbst über ein Attribut verfügt, dann wird ein gleichnamiges Attribut in der Reihe der Prototypen nicht berücksichtigt. Beispiel:

function Class(){this.x='instance';}  
Class.prototype.x='prototype';  
var c=new Class();  
alert(c.x);

Diese Code gibt die Meldung "instance" aus.

Was funktioniert hat war dann folgender Umweg:
Klasse.prototype.eigenschaft_ueberschreiben = function(wert){
this.eigenschaft = wert;}
instanz.eigenschaft_ueberschreiben ('2');
... was aber etwas anderes ist.

Ist aber offenbar, was du brauchst, denn du möchtest ein Attribut eines instanzierten Objekts überschreiben.

[Struppi]

ich habe beides ausprobiert, um die im Konstruktor ursprünglich definierte Eigenschaft auf diese Weise zu überschreiben.

Als Ergänzung:

  
Klasse.prototype.eigenschaft = 2;  
Klasse.eigenschaft = 2;

Das erste ist eine prototypische Eigenschaft, die jede neue Instanz als Eigenschaft erhält. Das zweite ist eine statisches Attribut, auf dass jede Instanz zugreifen kann. Wenn eine Instanz den Wert verändert, können alle auf den neuen Wert zugreifen.

Wie gesagt, JS ist extrem flexibel und bietet viel mehr Möglichkeiten als die meisten anderen Objektorientierten Sprachen, um in die Objekte einzugreifen und zu ändern.

Struppi.

[Struppi]

Es macht zu 90% was ich will, aber ich benötige weitere
Methoden. Die könnte ich natürlich genauso definieren,
wie die vorhanden und direkt in dem Script programmieren.
Ich möchte das vorhandene aber ungern verändern und die
Methoden gerne in einem anderen Script definieren

Du meinst vererben? Oder dekorieren? Mit JS hast du mehrere Möglichkeiten.

Wenn du vererben willst und des englischen mächtig, würde ich dir Douglas Crockford empfehlen:
http://javascript.crockford.com/inheritance.html
http://javascript.crockford.com/prototypal.html

Vor allem das zweite beschreibt eine gute Methode um von einer Klasse zu erben. Du kannst aber auch jederzeit zur Laufzeit eine Klasse erweitern.

/* Constructor */  
function Klasse ()  
                  {  
                   var idOfTree;  
                   this.eigenschaft = 1;  
                   //usw.  
                  }  
  
/* my_object class */  
Klasse.prototype = {  
methode_a : function (wert)  
                    {  
                     return wert;  
                    },  
methode_b : function (wert)  
                    {  
                     return this.name;  
                    }  
//usw.  
}  
function extendObj(destination, source) {  
    for (var property in source) destination[property] = source[property];  
    return destination;  
}  
function Klasse_B() {  
 this.name = 'Klasse_B';  
 extendObj(this, new Klasse);  
}  
  
var x = new Klasse_B();  
alert(x.methode_b());  

Je nachdem wie man's mag.

Struppi.