JavaScript objektorientiert programmieren

[paula123]

Hallo,

ich habe bisher zwei Arten JavaScript objektorientiert zu programmieren gesehen:

1. Variante:

function Medium(id, preis)
{
   this.mId = id; 
   this.mPreis = preis;
}

Medium.prototype.getPreis = function()
{
    return this.mPreis;
};

Medium.prototype.setPreis = function(preis)
{
    this.mPreis = preis;
};

function Buch(id, preis, titel)
{
    this.constructor(id, preis);
    this.mTitel = titel;
}

Buch.prototype = new Medium(0.0);

Buch.prototype.getTitel = function()
{
    return this.mTitel;
};

Variante 2:

function Medium(id, preis)
{
   var self = this;
   
   var mId = id; 
   var mPreis = preis;

   self.getPreis = function()
   {
       return mPreis;
   };

   self.setPreis = function(preis)
   {
       mPreis = preis;
   };
}

function Buch(id, preis, titel)
{
   var self = this;

   self.basis = Medium;
   self.basis(id, preis);

   var mTitel = titel;

   self.getTitel = function()
   {
       return mTitel;
   };

   self.setTitel = function(titel)
   {
       mTitel = titel;
   };
}

Jetzt stellt sich mir die Frage, welche Variante ich zukünftig nutzen soll, wenn ich objektorientiert Javascript programmiere. Kennt jemand Vor- bzw. Nachteile einer dieser Varianten?

Danke

Paula

 

[OnlyFoo]

Ich bevorzuge die erste Art und Weise... schon allein weil das prototype-Model ja nicht umsonnst erfunden wurde =)
Das ermöglicht ja zum Beispiel auch Vererbung (naja ok, das geht über die andere Art und Weise auch... =) )
Ich denke mal, das wird Geschmacksache sein.

 

[Operator_Jon]

Naja, ich mag hingegen die 2te Variante lieber, finde ich einfach übersichtlicher !

 

[OnlyFoo]

Kommt drauf an... Bei kleineren Klassen/Objekten ist sie auf jeden fall übersichtlicher, eindeutig, aber wenn die Klasse Recht groß wird, kann man über die prototype Methode auch einzelne Methoden in andere Dateien auslagern und so wieder für Übersicht sorgen =)
Aber am Ende bleibt das wahrscheinlich Geschmackssache.

 

[Operator_Jon]

Aber am Ende bleibt das wahrscheinlich Geschmackssache.

Das denke ich nämlich auch

 

[con-f-use]

Das prototype-Modell wurde ursprünglich nur hinzugefügt, um bestehenden, build-in-Objekten wie z.B. dem String-Objekt oder dem Frame-Objekt neue Methoden hinzuzufügen. Die 2.-Variante ist also eher, die Variante der Wahl - so rein von der Absicht, der Urherber her.

 

[FipsTheThief]

Ich nehm auch die 2. Variante wenn ich JavaScript Objekte schreibe. Der vorteil ist man kann es privat oder global verfügbar machen, beim Prototype ist alles global.Wobei ich dann nicht das self.xyz = function () wählen würde sondern nur dann wenn ich öffentlich machen will.

bei mir sieht das meist so aus dann.

var foo = new Object;
foo.construct = function () {

   var thisObj = this;
   thisObj.number1  = 10
   thisObj.number2  = 20;
   thisObj.number3  = 30;

   thisObj.getNumber1 =  function (number1) {
     return thisObj.number1;
   }

   function getNumber2() {
      return thisObj.number2;
   }
}

// eigentliche Klasse erweitern 
foo.construct.prototype = {
   getNumber3:function () {
       return this.number3;
   }
}

var test = new foo.construct();
alert(test.getNumber1());
alert(test.getNumber2()); // das hier wird für einen fehler sorgen nun
alert(test.getNumber3());

Mit Prototype kann man natürlich dann bestendende eigene Objekte / Klassen erweitern oder gar vererben. Ist also eher ein Mix von beiden der einen gut helfen kann

Zum einen kann man das was der User nicht sehen soll in der Hauptklasse unterbringen und mit Prototye darf dann jeder der will noch mitspielen , beispielsweise CallBack Handler definieren die wärend der Laufzeit dann aufgerufen werden.