Beschreibung der Prototypmodus
Hinweis: Verwenden Sie Prototyp -Instanzen, um neue anpassbare Objekte zu kopieren und zu erstellen. Für neu erstellte Objekte müssen Sie den spezifischen Prozess des Erstellens des ursprünglichen Objekts nicht kennen.
Prozedur: Prototyp => Neue Protoexam => Klon zu einem neuen Objekt;
Verwenden Sie den relevanten Code:
Die Codekopie lautet wie folgt:
Funktion prototype () {
this.name = '';
this.age = '';
this.sex = '';
}
Prototype.prototype.userinfo = function () {
Return 'Persönliche Informationen, Name:'+this.name+', Alter:'+this.age+', Geschlecht:'+this.sex+'<br />';
}
Jetzt sind zwei oder mehr personenbezogene Informationen inhalt erforderlich:
Die Codekopie lautet wie folgt:
var proto = neuer Prototypen ();
var person1 = Object.create (Proto);
Person1.Name = 'xiao ming';
Person1.sex = 'männlich';
Person1.age = 35;
Person1.UserInfo ();
//
var person2 = Object.create (Proto);
Person2.name = 'xiaohua';
Person2.Sex = 'weiblich';
Person2.age = 33;
Person2.userinfo ();
Ausgaberendungen:
Die Codekopie lautet wie folgt:
Persönliche Informationen, Name: Xiao Ming, Alter: 35, Geschlecht: männlich
Persönliche Informationen, Name: Xiaohua, Alter: 33, Geschlecht: weiblich
Der Prototypmodus wird im Allgemeinen für komplexe abstrakte Strukturen verwendet. Die Inhaltszusammensetzung ist jedoch ähnlich, abstrakter Inhalt kann angepasst werden, und eine neue Erstellung erfordert nur geringfügig geändert am ursprünglichen Erstellungsobjekt, um die Anforderungen zu erfüllen.
Object.create Anweisungen
1>. Definition: Erstellen Sie ein Objekt, das ein Prototypobjekt angibt und optionale benutzerdefinierte Eigenschaften enthalten kann.
2> Object.create (Proto [, Eigenschaften]); Optional, verwendet, um Eigenschaften neuer Objekte zu konfigurieren;
Die Codekopie lautet wie folgt:
1. Proto: Um einen Prototyp eines neuen Objekts zu erstellen, muss es null sein; Dieser Proto ist nur dann wertvoll, wenn er erstellt wurde.
2. Eigenschaften: Optional, Struktur:
{
Propfield: {
Wert: 'val' | {} | function () {},
beschreibbar: wahr | falsch,
Aufzählbar: wahr | falsch,
Konfigurierbar: Richtig | Falsch,
get: function () {return 10},
SET: Funktion (Wert) {}
}
}
Benutzerdefinierte Attribute haben die folgenden vier Attribute:
Wert: benutzerdefinierter Attributwert;
Beschreibbar: Ob der Wert dieses Elements bearbeitbar ist, der Standard ist falsch, und wenn wahr, kann Obj.Prodfield zugewiesen werden; ansonsten schreibgeschützte;
Aufzählbar: Aufzählbar;
Konfigurierbar: Konfigurierbar;
Es kann auch SET, Accessor -Methoden erhalten.
Unter ihnen kann [Set, Get] nicht gleichzeitig mit Wert und Beschreibung erscheinen;
1. Erstellen Sie eine Prototyp -Objektklasse:
Die Codekopie lautet wie folgt:
Funktion Protoklass () {
this.a = 'Protoklasse';
this.c = {};
this.b = function () {
}
}
Erstellen einer Prototypmethode:
Die Codekopie lautet wie folgt:
Protoclass.prototype.amethod = function () {
//this.a;
//this.b ();
kehre dies zurück. A;
}
Wie man benutzt
1. Erstellen Sie ein Objekt mit Protoklassen.Prototyp;
Die Codekopie lautet wie folgt:
var obj1 = Object.create (protoklass.prototype, {
foo: {value: 'obj1', beschreibbar: true}
})
OBJ1 hat die Amethod -Methode der Protoklassenprototypmethode;
Die Codekopie lautet wie folgt:
obj1.amethod ();
// Auf die undefinierte Methode wird ausgegeben, um zugänglich zu sein, und auf das Protoklassenelement kann nicht zugegriffen werden
Diese Methode kann jedoch die Mitgliedereigenschaften von A, B, C unter Protoklassen nicht ausführen:
2. Verwenden Sie instanziiertes Protoklas als Prototyp:
Die Codekopie lautet wie folgt:
var Proto = neuer Protoklass ();
var obj2 = Object.create (Proto, {
foo: {value: 'obj2'}
});
Auf diese Weise erstellte OBJ2 hat alle Mitgliedattribute A, B, C und Amethod Prototype der Protoklasse; und fügt ein nur schreibgeschütztes Datenattribut hinzu;
Die Codekopie lautet wie folgt:
obj2.a; // Protoklas
obj2.c: // [Objekt]
obj2.b (); //
obj2.amethod (); // Protoklas
obj2.foo; // obj2
3. Erb der Unterklasse:
Die Codekopie lautet wie folgt:
Funktion subclass () {
}
Subclass.prototype = Object.create (protoklass.prototype, {
foo: {value: 'subclass'}
});
Subclass.prototype.subMethod = function () {
Gibt dies zurück. A || this.foo;
}
Diese Methode kann von der Amethod -Methode von Protoklassen vererbt und ausgeführt;
Die Codekopie lautet wie folgt:
var func = new subclass ();
func.amethod (); // undefined, die Mitgliedseigenschaften von Protoklas können nicht gelesen werden, a, b, c
func.subMethod (); // Unterklasse
Um die Unterklasse zu ermöglichen, die Mitgliedereigenschaften von Protoklasse zu lesen, muss die Unterklasse geändert werden:
Die Codekopie lautet wie folgt:
Funktionsunterklasse ()
{
Protoklass.call (this);
}
// anderer Code;
Diese Methode kann die Member -Eigenschaften und Prototyp -Protoklasmethoden erhalten ;:
Die Codekopie lautet wie folgt:
var func = new subclass ();
func.amethod (); // Protoklas
func.subMethod (); // Protoklas
Eine andere Methode besteht darin, das instanziierte Protoklasobjekt als Prototyp der Unterklasse zu verwenden.
Die Codekopie lautet wie folgt:
var Proto = neuer Protoklass ();
Funktion subclass () {
}
Subclass.prototype = Object.create (Proto, {{
foo: {value: 'subclass'}
});
Auf diese Weise können Sie nach der Instanziierung der Unterklasse alle Protoklaseigenschaften und Prototypmethoden erhalten und ein schreibgeschütztes Datenattribut für Daten erstellen.
Die Codekopie lautet wie folgt:
var func = new subclass ();
func.foo; //Unterklasse
func.a; // Protoklas
func.b (); //
func.c; //[Objekt]
func.amethod (); // Protoklas
4. Die andere Methode zur Erstellung von Vererbung ist die gleiche wie Object.creats instanciated Protoklas für Prototypen:
Die Codekopie lautet wie folgt:
Funktion subclass () {
this.foo = 'Subklasse'; // aber es kann hier gelesen und geschrieben werden
}
Subclass.Prototype = new Protoklass ();
Object.Create Related Anweisungen
Object.create wird verwendet, um ein neues Objekt zu erstellen. Wenn es sich um Objekt handelt, ist der Prototyp null, und sein Effekt stimmt mit dem neuen Objekt () überein. oder {};
Bei der Funktion ist die Funktion mit neuem Funktionsname die gleiche.
Die Codekopie lautet wie folgt:
// 1 Objekt
var o = {}
// Äquivalent zu
var o2 = Object.create ({});
// Die Konstruktoren sind gleich;
// -----------------------------------------
Funktion func () {
this.a = 'func';
}
func.prototype.method = function () {
kehre dies zurück. A;
}
var newfunc = new func ();
// Äquivalent zu [der Effekt ist der gleiche]
var newfunc2 = Object.create (Object.Prototype/*function.Prototype || function () {}*/, {{
A: {value: 'func', beschreibbar: true},
Methode: {value: function () {return this.a;}}
});
Newfunc und Newfunc2 unterscheiden sich jedoch in den Funktionsreferenzen, um ihre Objekte zu erstellen.
Newfunc ist Funktion func () {...}, newfunc2 ist Funktionsfunktion {nativ}
Die Codekopie lautet wie folgt:
Object.create (Proto [, Propertiesfield]):
Proto gibt an, dass der Wert erforderlich ist und null sein kann. Wenn es nicht festgelegt ist, wird eine Ausnahme geworfen.
Proto ist nicht null, dh der instanziierte Wert, dh der Wert, der neu war; Die meisten Objekte in JavaScript haben Konstruktorattribute, welche Attribute angeben, in welcher Funktion das Objekt instanziiert wird.
Propertiesfield ist optional und setzen die Mitgliedereigenschaften oder -methoden ein, die für neu erstellte Objekte erforderlich sein können.