Was sind die Vorteile einer klassischen Struktur gegenüber einer prototypischen Struktur?

Question

Ich habe erst vor kurzem mit dem Programmieren begonnen, und da ich mir alles selbst beigebracht habe, habe ich leider nicht die Vorteile eines ausführlichen Informatikkurses. Ich habe in letzter Zeit viel über JavaScript gelesen, und ich versuche, den Nutzen von Kursen über die Prototyp-Natur von JavaScript zu finden. Die Frage scheint in der Mitte zu liegen, was besser ist, und ich möchte die klassische Seite davon sehen.

Wenn ich mir das Beispiel des Prototyps ansehe:

var inst_a = {
  "X": 123,
  "Y": 321,
  add: function () {
    return this.X+this.Y;
  }
};
document.write(inst_a.add());

Und dann die klassische Version

function A(x,y){
  this.X = x;
  this.Y = y;
  this.add = function(){
    return this.X+this.Y;
  };
};
var inst_a = new A(123,321);
document.write(inst_a.add());

Ich habe darüber nachgedacht, weil ich mir gerade die neue ecmascript-Revision 5 ansehe und viele Leute sich darüber aufregen, dass sie kein Klassensystem hinzugefügt haben.

Answer 1

Wenn Sie ein Objekt über new wird es seine Prototypenkette verwenden, um nach Eigenschaften zu suchen, die in der Instanz nicht gefunden werden.

So könnten Sie zum Beispiel die add Methode zu A.prototype nur einmal, anstatt jedes Mal eine neue Kopie derselben Funktion zu definieren, wenn Sie eine neue Instanz von A .

function A(x,y){
  this.X = x;
  this.Y = y;

};
//define add once, instead of every time we create a new 'A'
A.prototype.add = function(){
    return this.X+this.Y;
  };

Answer 2

Die Vererbung ist ohne die Verwendung des pseudoklassischen Stils nicht wirklich möglich. Sehen Sie, was Douglas Crockford zu sagen hat sagen darüber. Selbst wenn Sie eine rein prototypische Objektstruktur verwenden würden, müssten Sie eine Konstruktorfunktion für die Vererbung erstellen (was Crockford tut, und diese dann hinter einem create Methode ruft sie dann rein prototypisch auf)

Answer 3

Mit der zweiten Methode können Sie Instanzen von A So können Sie mehrere gleichzeitig nutzen. Zum Beispiel:

var inst_one = new A(123,321);
var inst_two = new A(456,654);

// some meaningful code here...
document.write(inst_one.add());

// some more meaningful code here...
document.write(inst_two.add());

Das von Ihnen angeführte Beispiel ist trivial, also lassen Sie uns ein intuitiveres Beispiel erfinden:

function Comment(user,text){
  this.user = user;
  this.text = text;
  this.toString = function(){
    return '<span class="comment">'+this.text+' - <a class="user">'+this.user+'</a></span>';
  };
};

var comments = someFunctionThatReturnsALotOfCommentObjects();
for(c=0;c<comments.length;c++)
  document.getElementById('comments_container').innerHTML += comments[c].toString();

Dies zeigt (hoffentlich) den Vorteil der Möglichkeit, mehrere Instanzen einer Klasse zu erstellen. Dies ist kein grundlegendes JavaScript-Konzept, es ist ein grundlegendes Objektorientierte Programmierung Konzept, weshalb Sie vielleicht nicht damit vertraut sind, wenn Sie keine formalen Programmierkurse besucht haben.

Answer 4

Um fair zu sein: JavaScript tut haben Unterricht. Nun, vielleicht würden einige das bestreiten, aber ich halte das nur für semantische Haarspalterei. Wenn eine Klasse als Blaupause für die Erstellung von Objekten betrachtet wird, kann eine JavaScript-Funktion diese Funktion übernehmen. Es gibt keine viel Unterschied in der Funktion, nur in der Form:

class someObj
{
    private int x;
    public int returnX()
    {
        return x;
    }
}
someObj temp = new someObj();

-

function someObj {
    var x;
    this.returnX = function() {
        return x;
    };
}
var temp = new someObj();

Unter der Haube sind sie unterschiedlich, aber Sie können beide Formen verwenden, um den gleichen Zweck zu erfüllen.

Prototypisch unterscheidet sich wirklich in der Vererbung. Wenn Sie bei der prototypischen Vererbung ein neues Objekt erstellen, kopieren Sie eigentlich eine Instanz des Prototyp-Objekts und fügen ihm dann neue Felder oder Mitglieder hinzu. Bei der klassischen Vererbung hingegen handelt es sich nicht um eine Instanz, sondern nur um einen "Bauplan". In JavaScript würde man zum Beispiel sagen:

temp.prototype = new someOtherObj(); //Creating a new instance to serve as the prototype.

In einer klassischen Sprache könnte man sagen:

class someObj : someOtherObj //Copying the "blue print" over.

Dies hat zur Folge, dass Daten von abgeleiteten Objekten in der Prototypensprache gemeinsam genutzt werden. Ich habe einmal eine Funktion geschrieben und eine andere Funktion davon durch Prototyping in JavaScript ableiten lassen. Dieses Basisobjekt enthielt einen Verweis auf ein DOM-Objekt, und wenn ich es in einem Unterobjekt änderte, wurde es für alle Instanzen dieses Unterobjekts geändert. Das liegt daran, dass man in der Prototypensprache von einer Instanz und nicht von einer "Blaupause" ableitet.

Answer 5

In der klassischen Version können private Variablen "innerhalb" des Objekts deklariert werden, während dies in der Prototyp-Version nicht möglich ist.