Description du mode prototype
Remarque: utilisez des instances de prototypes pour copier et créer de nouveaux objets personnalisables; Pour les objets nouvellement créés, vous n'avez pas besoin de connaître le processus spécifique de création de l'objet d'origine;
Procédure: prototype => nouveau protoexam => clone vers un nouvel objet;
Utilisez le code pertinent:
La copie de code est la suivante:
Function Prototype () {
this.name = '';
this.age = '';
this.sex = '';
}
Prototype.prototype.UserInfo = fonction () {
return 'Informations personnelles, nom:' + this.name + ', âge:' + this.age + ', genre:' + this.sex + '<br />';
}
Maintenant, deux ou plusieurs informations sur des informations personnelles sont requises:
La copie de code est la suivante:
var proto = new prototype ();
var person1 = object.create (proto);
personne1.name = 'xiao ming';
personne1.sex = 'mâle';
Person1.age = 35;
Person1.UserInfo ();
//
var person2 = object.create (proto);
Person2.name = 'xiaohua';
person2.sex = 'femme';
Person2.age = 33;
Person2.UserInfo ();
Renvoie la sortie:
La copie de code est la suivante:
Informations personnelles, Nom: Xiao Ming, Âge: 35 ans, Sexe: Homme
Informations personnelles, Nom: Xiaohua, âge: 33 ans, Sexe: Femme
Le mode prototype est généralement utilisé pour des structures abstraites complexes, mais la composition du contenu est similaire, le contenu abstrait peut être personnalisé et une nouvelle création ne nécessite que légèrement modifiée sur l'objet de création d'origine pour répondre aux exigences;
Objet.Create Instructions
1>. Définition: créer un objet qui spécifie un objet prototype et peut contenir des propriétés personnalisées facultatives;
2> object.create (proto [, propriétés]); Facultatif, utilisé pour configurer les propriétés de nouveaux objets;
La copie de code est la suivante:
1. Proto: pour créer un prototype d'un nouvel objet, il doit être nul; Ce proto n'est précieux que s'il a été créé [nouveau] ou objet.prototype;
2. Propriétés: Facultatif, structure:
{
Propfield: {
valeur: 'val' | {} | function () {},
Écrivable: vrai | Faux,
Énumérable: vrai | faux,
configurable: vrai | false,
get: function () {return 10},
set: fonction (valeur) {}
}
}
Les attributs personnalisés ont les quatre attributs suivants:
Valeur: valeur d'attribut personnalisée;
Writable: si la valeur de cet élément est modifiable, la valeur par défaut est fausse, et lorsque vous êtes vrai, obj.prodfield peut être attribué; Sinon en lecture seule;
Énumérable: Énumérable;
configurable: configurable;
Il peut également inclure un ensemble, obtenir des méthodes d'accessoires;
Parmi eux, [set, get] ne peut pas apparaître en même temps que la valeur et le scrutin;
1. Créez une classe d'objets prototype:
La copie de code est la suivante:
fonction protoClass () {
this.a = 'protoclass';
this.c = {};
this.b = function () {
}
}
Création d'une méthode de prototype:
La copie de code est la suivante:
Protoclass.prototype.amethod = function () {
//this.a;
//this.b ();
Renvoyez ceci.a;
}
Comment utiliser
1. Créez un objet avec protoclass.prototype;
La copie de code est la suivante:
var obj1 = object.create (protoclass.prototype, {
foo: {value: 'obj1', écrivable: true}
})
OBJ1 a la méthode prototype de protoclasse Méthode Amethod;
La copie de code est la suivante:
obj1.amethod ();
// La méthode non définie sera la sortie pour être accessible, et le membre du protoclasse ne peut pas être accessible
Cependant, cette méthode ne peut pas exécuter les propriétés des membres de A, B, C sous ProtoClass:
2. Utilisez le protoclasse instanciée comme prototype:
La copie de code est la suivante:
var proto = new protoClass ();
var obj2 = object.create (proto, {
foo: {valeur: 'obj2'}
});
OBJ2 créé de cette manière a tous les attributs de membres A, B, C et Amethod Prototype Method of Protoclass; et ajoute un attribut de données en lecture seule FOO;
La copie de code est la suivante:
obj2.a; // Protoclasse
obj2.c: // [objet]
obj2.b (); //
obj2.amethod (); // Protoclasse
obj2.foo; // obj2
3. Héritage de sous-classe:
La copie de code est la suivante:
fonction subclass () {
}
Sous-class.prototype = object.create (protoclass.prototype, {
foo: {value: 'subclass'}
});
Sous-class.prototype.subMethod = function () {
Renvoie ce.a || this.foo;
}
Cette méthode peut être héritée de la méthode Amethod de Protoclass et exécutée;
La copie de code est la suivante:
var func = new SubSlass ();
func.Amethod (); // Undefined, les propriétés membre du protoclasse ne peuvent pas être lues, a, b, c
func.SubMethod (); // sous-classe
Pour permettre à la sous-classe de lire les propriétés des membres du protoclasse, la sous-classe doit être modifiée:
La copie de code est la suivante:
Sous-classe de fonction ()
{
ProtoClass.Call (this);
}
// autre code;
Cette méthode peut obtenir les propriétés des membres et les méthodes de prototype de protoclasse;:
La copie de code est la suivante:
var func = new SubSlass ();
func.amethod (); // protoclasse
func.SubMethod (); // ProtoClass
Une autre méthode consiste à utiliser l'objet protoclasse instancié comme prototype de la sous-classe;
La copie de code est la suivante:
var proto = new protoClass ();
fonction subclass () {
}
Sous-class.prototype = object.create (proto, {
foo: {value: 'subclass'}
});
De cette façon, après l'instanciation de la sous-classe, vous pouvez obtenir toutes les propriétés et méthodes prototypes de protocoles et créer un attribut de données en lecture seule;
La copie de code est la suivante:
var func = new SubSlass ();
func.foo; // sous-classe
func.a; // Protoclasse
func.b (); //
func.c; //[Objet]
func.Amethod (); // Protoclasse
4. L'autre méthode de création de l'héritage est la même que l'objet.
La copie de code est la suivante:
fonction subclass () {
this.foo = 'Subclass'; // mais il peut être lu et écrit ici
}
Sous-class.prototype = new protoClass ();
Objet.Create des instructions connexes
Object.Create est utilisé pour créer un nouvel objet. Lorsqu'il est objet, le prototype est nul et son effet est cohérent avec le nouvel objet (); ou {};
Lorsque la fonction, la fonction est la même que la nouvelle fonctionname;
La copie de code est la suivante:
// 1 objet
var o = {}
// équivalent à
var o2 = object.create ({});
// Les constructeurs sont les mêmes;
// -----------------------------------------
fonction func () {
this.a = 'func';
}
func.prototype.method = function () {
Renvoyez ceci.a;
}
var newfunc = new func ();
// équivalent à [l'effet est le même]
var newfunc2 = object.create (object.prototype / * function.prototype || function () {} * /, {{
a: {valeur: 'func', écrivable: true},
Méthode: {valeur: function () {return this.a;}}
});
Mais NewFunc et NewFunc2 sont différents dans les références de fonction pour créer leurs objets.
newFunc est la fonction func () {...}, newFunc2 est la fonction de fonction {native}
La copie de code est la suivante:
Object.create (proto [, PropertiesField]):
Proto indique que la valeur est requise et peut être nulle. S'il n'est pas défini, une exception sera lancée;
Proto est non nul, c'est-à-dire la valeur instanciée, c'est-à-dire la valeur qui a été nouvelle; La plupart des objets de JavaScript ont des attributs de constructeur, qui les attributs indiquent la fonction de l'objet qui est instancié;
PropertiesField est facultative, définissant les propriétés ou méthodes des membres qui peuvent être nécessaires pour les objets nouvellement créés;