Objektorientierte Programmierung

Was ist der Unterschied zwischen folgenden Varianten:

------------------------ (Variante 1) ---------------
function ClassA(name){
this.name = name;

this.getName = _getLayer;
this.setName = _setName;

function _getName(){
return name;
}
function _setName(name){
this.name = name;
}
}

--------- oder: ------ (Variante 2) --------------
function ClassA(name){
this.name = name;
}

ClassA.prototype.getName = function () {
return name;
}

ClassA.prototype.setName = function (name) {
this.name = name;
}

--------- oder: -------- (Variante 3) --------------
function ClassA(name){
this.name = name;

ClassA.prototype.getName = function () {
return name;
}

ClassA.prototype.setName = function (name) {
this.name = name;
}
}


Oder muss ich das irgendwie anders definieren?
Was ist der Vorteil der einzelnen Varianten?
Sollte man eine bestimmte Varianten bevorzugen/vermeiden? Wenn ja, warum?
Variante 2 funktionier bei mir nicht, obwohl sie in vielen Büchern
angegeben wird.

Vielen Dank

Manfred Zerndl

Manfred Zerndl wrote:

Was ist der Unterschied zwischen folgenden Varianten:

------------------------ (Variante 1) ---------------
[...]

Hier werden innerhalb der Funktion/globalen Methode `ClassA' weitere
Funktionen definiert. Nach ECMAScript 3, d.h. hier z.B. mit Microsoft
JScript, kann auf diese Funktionen nur innerhalb von `ClassA'
zugegriffen werden. (Netscape) JavaScript erweitert ECMAScript
dahingehend, dass auf innere Funktionen mittels `ClassA.bezeichner'
zugegriffen werden kann, diese also Eigenschaften des Variablenobjekts
werden.

Wird ClassA mit Schlüsselwort `new' als Konstruktor benutzt, so
erhalten damit erzeugte (ClassA-)Objekte die Function-Eigenschaften,
d.h. Methoden, `getName' und `setName', sowie die Eigenschaft `name'
mit dem Konstruktorargument als Wert.

--------- oder: ------ (Variante 2) --------------
[...]

Hier erhalten neue ClassA-Objekte die Eigenschaft `name' mit dem
Knnstruktorargument als Wert. Ausserdem haben nicht nur ClassA-Objekte
die Methoden `getName' und `setName', sondern auch Objekte, die mit
Konstruktoren erzeugt wurden, deren Prototyp von ClassA abgeleitet ist:

function Foo(x)
{
this.blubb = x;
}

Foo.prototype.foo = function()
{
}

function Bar(y)
{
Foo.call(this, y);
// ...
}

Bar.prototype = new Foo();

var
f = new Foo(23),
b = new Bar(42);

alert([f.foo, f.blubb, b.foo, b.blubb]);

--------- oder: -------- (Variante 3) --------------
[...]

Wie oben, allerdings werden die Prototyp-Methoden bei jedem
Konstruktoraufruf wiederhergestellt/überschrieben.

Oder muss ich das irgendwie anders definieren?

Du *musst* gar nichts. Es gibt verschiedene Möglichkeiten.

Allerdings gibt es in ECMAScript-Implementationen vor Edition 4
keine Klassen, diese Sprachen verwenden prototypbasierte Vererbung.
Insofern ist der Bezeichner `ClassA' irreführend.

Übrigens existiert <http://dcljs.de/links.php>, siehe FAQ-Pointer.

Was ist der Vorteil der einzelnen Varianten?

Siehe oben.

Sollte man eine bestimmte Varianten bevorzugen/vermeiden? Wenn ja,
warum?

Das kannst nur Du wissen, siehe oben.

Variante 2 funktionier bei mir nicht, obwohl sie in vielen
Büchern angegeben wird.

<http://glasgoogle.de/>


HTH

PointedEars

Manfred Zerndl wrote:

--------- oder: ------ (Variante 2) --------------
function ClassA(name){
this.name = name;
}

ClassA.prototype.getName = function () {
return name;

Nimm
return this.name;
dann funktioniert diese Variante.



--

Martin Honnen
http://JavaScript.FAQTs.com/