einführen
Jede Programmierung schlägt eine Wiederverwendung von Code vor. Andernfalls wird es ein Stopp sein, wenn Sie jedes Mal ein neues Programm schreiben müssen, wenn Sie ein neues Programm entwickeln oder eine neue Funktion schreiben. Die Wiederverwendung von Code ist jedoch auch gut oder schlecht. In den nächsten beiden Artikeln werden wir die Wiederverwendung von Code diskutieren. Der erste Artikel vermeidet die Verwendung dieser Muster so weit wie möglich, da er einige Probleme in größerem oder geringem Maße mit sich bringt. Die zweite Reihe ist die Empfehlung, die sich auf das empfohlene Muster bezieht, das jeder verwendet, und es wird im Allgemeinen keine Probleme geben.
Modus 1: Standardmodus
Es gibt oft ein Problem bei der Wiederverwendung des Standardmodus, der üblicherweise von allen verwendet wird. In diesem Modus wird der Konstruktor von Parent () verwendet, um ein Objekt zu erstellen und dem Objekt dem Child () -Prototyp zuzuweisen. Schauen wir uns den Code an:
Die Codekopie lautet wie folgt:
Funktion inherit (c, p) {
C.Prototype = neu p ();
}
// Elternkonstruktor
Funktion Eltern (Name) {
this.name = name || 'Adam';
}
// Fügen Sie dem Prototyp eine Funktion hinzu.
Parent.prototype.say = function () {
kehre diesen namennamen zurück;
};
// Kinderkonstruktor ist leer
Funktion child (name) {
}
// Erbschaft ausführen
Erbe (Kind, Eltern);
var kid = new Child ();
console.log (kid.say ()); // "Adam"
var kiddo = new Child ();
kiddo.name = "patrick";
console.log (kiddo.say ()); // "Patrick"
// Nachteile: Sie können keine Parameter in den Kinderkonstruktor übergeben
var S = neues Kind ('Seth');
console.log (S. say ()); // "Adam"
Der Nachteil dieses Modus ist, dass das Kind keine Parameter übergeben kann, was im Grunde genommen nutzlos ist.
Muster 2: Ausleihenkonstruktor
Dieses Muster ist, dass sich die Kinderkonstruktorin für Kinder anwenden und dann die des Kindes und Parameter an die Anwendenmethode übergeben:
Die Codekopie lautet wie folgt:
// Elternkonstruktor
Funktion Eltern (Name) {
this.name = name || 'Adam';
}
// Fügen Sie dem Prototyp eine Funktion hinzu.
Parent.prototype.say = function () {
kehre diesen namennamen zurück;
};
// Kinderkonstruktor
Funktion child (name) {
Elternteil.Apply (this, Argumente);
}
var kid = neues Kind ("Patrick");
console.log (kid.name); // "Patrick"
// Nachteile: Die Say -Methode wird nicht vom Konstruktor geerbt
console.log (typeof kid.say); // "undefiniert"
Der Nachteil ist ebenfalls offensichtlich, und die Say -Methode ist nicht verfügbar, da sie nicht geerbt wurde.
Muster 3: Leihen Sie den Konstruktor aus und setzen Sie den Prototyp
Die beiden oben genannten Modi haben ihre eigenen Mängel. Wie entfernen Sie also die Mängel beider? Versuchen wir:
Die Codekopie lautet wie folgt:
// Elternkonstruktor
Funktion Eltern (Name) {
this.name = name || 'Adam';
}
// Fügen Sie dem Prototyp eine Funktion hinzu.
Parent.prototype.say = function () {
kehre diesen namennamen zurück;
};
// Kinderkonstruktor
Funktion child (name) {
Elternteil.Apply (this, Argumente);
}
Child.Prototype = new Parent ();
var kid = neues Kind ("Patrick");
console.log (kid.name); // "Patrick"
console.log (typeof kid.say); // Funktion
console.log (kid.say ()); // Patrick
console.dir (kid);
kid.name löschen;
console.log (kid.say ()); // "Adam"
Wenn es läuft, ist alles normal, aber haben Sie bemerkt, dass der übergeordnete Konstruktor zweimal ausgeführt wurde. Obwohl das Programm verfügbar ist, ist es sehr ineffizient.
Modus 4: gemeinsamer Prototyp
Shared Prototype bedeutet, dass untergeordnetes und übergeordnetes das gleiche Prototyp wie folgt ist:
Die Codekopie lautet wie folgt:
Funktion inherit (c, p) {
C.Prototype = p.Prototype;
}
// Elternkonstruktor
Funktion Eltern (Name) {
this.name = name || 'Adam';
}
// Fügen Sie dem Prototyp eine Funktion hinzu.
Parent.prototype.say = function () {
kehre diesen namennamen zurück;
};
// Kinderkonstruktor
Funktion child (name) {
}
Erbe (Kind, Eltern);
var kid = neues Kind ('Patrick');
console.log (kid.name); // undefiniert
console.log (typeof kid.say); // Funktion
kid.name = 'patrick';
console.log (kid.say ()); // Patrick
console.dir (kid);
Es ist sicher, dass dasselbe wahr ist, dass die Parameter des Kindes nicht richtig empfangen werden.
Muster 5: Temporärer Konstruktor
Leihen Sie den Konstruktor aus, setzen Sie dann den Kinderprototyp auf eine Instanz des geliehenen Konstruktors und stellen Sie schließlich den Konstruktor des untergeordneten Prototyps wieder her. Der Code ist wie folgt:
Die Codekopie lautet wie folgt:
/* Schließung*/
var inherit = (function () {
var f = function () {
};
Rückgabefunktion (c, p) {
F.Prototype = p.Prototype;
C.Prototype = new f ();
C.uber = p.Prototype;
C.Prototype.Constructor = C;
}
} ());
Funktion Eltern (Name) {
this.name = name || 'Adam';
}
// Fügen Sie dem Prototyp eine Funktion hinzu.
Parent.prototype.say = function () {
kehre diesen namennamen zurück;
};
// Kinderkonstruktor
Funktion child (name) {
}
Erbe (Kind, Eltern);
var kid = new Child ();
console.log (kid.name); // undefiniert
console.log (typeof kid.say); // Funktion
kid.name = 'patrick';
console.log (kid.say ()); // Patrick
var kid2 = neues Kind ("Tom");
console.log (kid.say ());
console.log (kid.constructor.name); // Kind
console.log (kid.constructor === Elternteil); // FALSCH
Das Problem ist immer noch das gleiche, das Kind kann normalerweise keine Parameter erhalten.
Modus 6: Klass
Beginnen wir mit dem Code für dieses Muster:
Die Codekopie lautet wie folgt:
var klass = function (übergeordnet, props) {
var Child, f, ich;
// 1.
// neuer Konstruktor
Child = function () {
if (Child.uber && child.uber.hasownProperty ("__ construct")) {
Child.uber .__ Construct.Apply (this, Argumente);
}
if (child.prototype.hasownProperty ("__ construct")) {
Child.Prototype .__ Construct.Apply (this, Argumente);
}
};
// 2.
// Nachlass
Eltern = Eltern || Objekt;
F = function () {
};
F.Prototype = parent.prototype;
Child.Prototype = new f ();
Child.uber = parent.prototype;
Child.Prototype.Constructor = Child;
// 3.
// Implementierungsmethode hinzufügen
für (i in Requisiten) {
if (props.hasownProperty (i)) {
Child.Prototyp [i] = Props [i];
}
}
// Die "Klasse" zurückgibt
Kind zurückkehren;
};
var man = klass (null, {
__construct: function (was) {
console.log ("Mann des Konstruktors");
this.name = was;
},
GetName: function () {
kehre diesen namennamen zurück;
}
});
var First = New Man ('Adam'); // protokolliert "Man des Konstruktors des Menschen"
first.getName (); // "Adam"
var Superman = klass (Mann, {
__construct: function (was) {
console.log ("Supermans Konstruktor");
},
GetName: function () {
var name = superman.uber.getName.call (this);
Rückgabe "Ich bin" + Name;
}
});
var clark = neuer Superman ('Clark Kent');
Clark.getName (); // "Ich bin Clark Kent"
console.log (Clarkinstanz des Menschen); // WAHR
console.log (Clarkinstanz von Superman); // WAHR
Wie wäre es damit? Ist es ein bisschen schwindelig zu sehen? Um nett zu sein, sind die Grammatik und die Spezifikation dieses Musters die gleichen wie andere Sprachen. Sind Sie bereit, es zu benutzen? Husten. . .
Zusammenfassen
Obwohl die oben genannten sechs Modi unter bestimmten besonderen Umständen bestimmte Funktionen implementieren, haben sie alle ihre eigenen Mängel, sodass im Allgemeinen jeder vermeiden sollte, sie zu verwenden.