Descripción del modo prototipo
Nota: Use instancias prototipo para copiar y crear nuevos objetos personalizables; Para los objetos recién creados, no necesita conocer el proceso específico de crear el objeto original;
Procedimiento: prototipo => nuevo protoexam => clon a nuevo objeto;
Use el código relevante:
La copia del código es la siguiente:
function prototype () {
this.name = '';
this.age = '';
this.sex = '';
}
Prototype.prototype.userinfo = function () {
Devuelve 'Información personal, nombre:'+this.name+', edad:'+this.age+', género:'+this.sex+'<r />';
}
Ahora se requiere dos o más contenido de información personal:
La copia del código es la siguiente:
var proto = new Prototype ();
var persona1 = objeto.create (proto);
persona1.name = 'Xiao Ming';
persona1.sex = 'masculino';
persona1.age = 35;
persona1.userinfo ();
//
var persona2 = objeto.create (proto);
persona2.name = 'xiaohua';
persona2.sex = 'femenino';
persona2.age = 33;
persona2.userinfo ();
El resultado devuelve:
La copia del código es la siguiente:
Información personal, nombre: Xiao Ming, Edad: 35, Género: Hombre
Información personal, Nombre: Xiaohua, Edad: 33, Género: Hembra
El modo prototipo generalmente se usa para estructuras abstractas complejas, pero la composición del contenido es similar, el contenido abstracto se puede personalizar y la nueva creación solo requiere ligeramente modificada en el objeto de creación original para cumplir con los requisitos;
Object.Create las instrucciones
1>. Definición: cree un objeto que especifique un objeto prototipo y pueda contener propiedades personalizadas opcionales;
2> Object.Create (Proto [, propiedades]); Opcional, utilizado para configurar propiedades de nuevos objetos;
La copia del código es la siguiente:
1. Proto: para crear un prototipo de un nuevo objeto, debe ser nulo; Este proto es valioso solo si se ha creado [nuevo] u objeto.prototype;
2. Propiedades: Opcional, Estructura:
{
propField: {
valor: 'val' | {} | function () {},
Writable: Verdadero | Falso,
enumerable: verdadero | falso,
configurable: verdadero | falso,
get: function () {return 10},
set: function (valor) {}
}
}
Los atributos personalizados tienen los siguientes cuatro atributos:
Valor: Valor de atributo personalizado;
Writable: si el valor de este elemento es editable, el valor predeterminado es falso y cuando es verdadero, se puede asignar obj.prodfield; de lo contrario de solo lectura;
enumerable: enumerable;
configurable: configurable;
También puede incluir métodos Set, Get Accessor;
Entre ellos, [set, get] no puede aparecer al mismo tiempo que el valor y la escritura;
1. Cree una clase de objeto prototipo:
La copia del código es la siguiente:
function Protoclass () {
this.a = 'Protoclass';
this.c = {};
this.b = function () {
}
}
Creación de un método prototipo:
La copia del código es la siguiente:
Protoclass.prototype.amethod = function () {
//this.a;
//this.b ();
devolver esto.a;
}
Cómo usar
1. Cree un objeto con Protoclass.prototype;
La copia del código es la siguiente:
var obj1 = object.create (protoclass.prototype, {
foo: {valor: 'obj1', Writable: True}
})
OBJ1 tiene el método prototipo de prototipo Protoclass Método;
La copia del código es la siguiente:
obj1.amethod ();
// El método indefinido se emitirá para ser accesible y no se puede acceder al miembro de Protoclass
Sin embargo, este método no puede ejecutar las propiedades del miembro de A, B, C en Protoclass:
2. Use la protoclase instanciado como prototipo:
La copia del código es la siguiente:
var proto = new Protoclass ();
var obj2 = object.create (proto, {
foo: {valor: 'obj2'}
});
OBJ2 creado de esta manera tiene todos los atributos del miembro A, B, C y Método Prototipo de Ametodos de Protoclass; y agrega un atributo de datos de solo lectura FOO;
La copia del código es la siguiente:
obj2.a; // Protoclase
obj2.c: // [objeto]
obj2.b (); //
obj2.amethod (); // Protoclase
obj2.foo; // obj2
3. Herencia de subclase:
La copia del código es la siguiente:
función subclass () {
}
Subclass.prototype = object.create (protoclass.prototype, {
foo: {valor: 'subclase'}
});
Subclass.prototype.submethod = function () {
devuelve esto.a || this.foo;
}
Este método puede ser heredado del método de ametodos de Protoclass y ejecutado;
La copia del código es la siguiente:
var func = new Subclase ();
func.amethod (); // Undefined, las propiedades miembros de la protoclase no se pueden leer, a, b, c
func.submethod (); // subclase
Para habilitar la subclase para leer las propiedades del miembro de la protoclase, la subclase debe cambiarse:
La copia del código es la siguiente:
Función Subclase ()
{
Protoclass.call (esto);
}
// otro código;
Este método puede obtener las propiedades del miembro y los métodos prototipo de protoclase;:
La copia del código es la siguiente:
var func = new Subclase ();
func.amethod (); // Protoclass
func.submethod (); // Protoclass
Otro método es usar el objeto de protoclase instanciado como el prototipo de subclase;
La copia del código es la siguiente:
var proto = new Protoclass ();
función subclass () {
}
Subclass.prototype = object.create (proto, {
foo: {valor: 'subclase'}
});
De esta manera, después de la instancia de la subclase, puede obtener todas las propiedades de protoclase y métodos prototipo, y crear un atributo de datos de solo lectura FOO;
La copia del código es la siguiente:
var func = new Subclase ();
FURC.FOO; // subclase
FURC.A; // Protoclase
func.b (); //
func.c; //[Objeto]
func.amethod (); // Protoclase
4. El otro método para crear herencia es el mismo que el objeto.
La copia del código es la siguiente:
función subclass () {
this.foo = 'subclase'; // pero se puede leer y escribir aquí
}
Subclass.prototype = new Protoclass ();
Object.Cree las instrucciones relacionadas
Object.Create se usa para crear un nuevo objeto. Cuando es objeto, el prototipo es nulo, y su efecto es consistente con el nuevo objeto (); o {};
Cuando la función, la función es la misma que el nuevo nombre de función;
La copia del código es la siguiente:
// 1 objeto
var o = {}
// equivalente a
var o2 = object.create ({});
// Los constructores son los mismos;
// -----------------------------------------
función func () {
this.a = 'func';
}
func.prototype.method = function () {
devolver esto.a;
}
var newfunc = new Func ();
// equivalente a [el efecto es el mismo]
var newfunc2 = Object.Create (object.prototype/*function.prototype || function () {}*/, {
a: {valor: 'func', writable: true},
Método: {valor: function () {return this.a;}}
});
Pero NewFunc y NewFunc2 son diferentes en las referencias de la función para crear sus objetos.
NewFunc es function func () {...}, newfunc2 es función de función {nativo}
La copia del código es la siguiente:
Object.Create (Proto [, PropertiesField]):
Proto indica que el valor es necesario y puede ser nulo. Si no está configurado, se lanzará una excepción;
Proto no es nulo, es decir, el valor instanciado, es decir, el valor que ha sido nuevo; La mayoría de los objetos en JavaScript tienen atributos de constructor, qué atributos indican qué función se instancia el objeto;
Propertiesfield es opcional, estableciendo las propiedades o métodos del miembro que pueden ser necesarios para los objetos recién creados;