Descrição do modo de protótipo
Nota: Use instâncias de protótipo para copiar e criar novos objetos personalizáveis; Para objetos recém -criados, você não precisa conhecer o processo específico de criação do objeto original;
Procedimento: prototype => novo protoexam => clone para novo objeto;
Use o código relevante:
A cópia do código é a seguinte:
function prototype () {
this.name = '';
this.age = '';
this.sex = '';
}
Prototype.prototype.userinfo = function () {
Retorne 'Informações pessoais, nome:'+this.name+', idade:'+this.age+', gênero:'+this.sex+'<r />';
}
Agora é necessário dois ou mais informações de informações pessoais:
A cópia do código é a seguinte:
var proto = new prototype ();
var Person1 = Object.create (proto);
pessoa1.name = 'xiao ming';
pessoa1.sex = 'masculino';
Person1.age = 35;
Person1.Userinfo ();
//
var pessoa2 = object.create (proto);
pessoa2.name = 'xiaohua';
pessoa2.Sex = 'feminino';
pessoa2.age = 33;
pessoa2.Userinfo ();
Retornos de saída:
A cópia do código é a seguinte:
Informações pessoais, nome: Xiao Ming, idade: 35, sexo: masculino
Informações pessoais, nome: xiaohua, idade: 33, sexo: feminino
O modo de protótipo é geralmente usado para estruturas abstratas complexas, mas a composição do conteúdo é semelhante, o conteúdo abstrato pode ser personalizado e a nova criação requer apenas um pouco modificada no objeto de criação original para atender aos requisitos;
Object.crete Instruções
1>. Definição: Crie um objeto que especifique um objeto de protótipo e possa conter propriedades personalizadas opcionais;
2> object.create (proto [, propriedades]); Opcional, usado para configurar propriedades de novos objetos;
A cópia do código é a seguinte:
1. Proto: Para criar um protótipo de um novo objeto, ele deve ser nulo; Este proto é valioso apenas se tiver sido criado [novo] ou object.prototype;
2. Propriedades: opcional, estrutura:
{
PropField: {
valor: 'val' | {} | function () {},
gravável: verdadeiro | falso,
enumerável: verdadeiro | falso,
Configurável: Verdadeiro | Falso,
get: function () {return 10},
SET: function (valor) {}
}
}
Atributos personalizados têm os quatro atributos a seguir:
Valor: valor do atributo personalizado;
Reduzido: se o valor deste item é editável, o padrão é falso e, quando verdadeiro, obj.prodfield pode ser atribuído; caso contrário, somente leitura;
enumerável: enumerável;
Configurável: configurável;
Também pode incluir métodos definidos, obterem acessadores;
Entre eles, [set, Get] não pode aparecer ao mesmo tempo que o valor e o gravável;
1. Crie uma classe de protótipo de objeto:
A cópia do código é a seguinte:
function protoclass () {
this.a = 'protoclass';
this.c = {};
this.b = function () {
}
}
Criando um método de protótipo:
A cópia do código é a seguinte:
Protoclass.prototype.amethod = function () {
//this.a;
//this.b ();
devolver isso.A;
}
Como usar
1. Crie um objeto com protoclass.prototype;
A cópia do código é a seguinte:
var obj1 = object.create (protoclass.prototype, {
Foo: {value: 'obj1', gravável: true}
})
OBJ1 possui o método do protótipo de protótipo de protoclass.
A cópia do código é a seguinte:
obj1.amethod ();
// O método indefinido será acessado para ser acessado e o membro do protoclasta não pode ser acessado
No entanto, esse método não pode executar as propriedades do membro de A, B, C em Protoclass:
2. Use protoclass instanciadas como protótipo:
A cópia do código é a seguinte:
var proto = new protoclass ();
var obj2 = object.create (proto, {
foo: {value: 'obj2'}
});
O OBJ2 criado dessa maneira possui todos os atributos de membro A, B, C e Amethod Método de Protoclass de Protoclass; e adiciona um atributo de dados somente leitura Foo;
A cópia do código é a seguinte:
obj2.a; // protoclass
obj2.c: // [objeto]
obj2.b (); //
obj2.amethod (); // protoclass
obj2.foo; // obj2
3. Herança da subclasse:
A cópia do código é a seguinte:
função subclass () {
}
Subclass.prototype = object.create (protoclass.prototype, {
foo: {value: 'subclass'}
});
Subclass.prototype.submethod = function () {
Retorne this.a || this.foo;
}
Este método pode ser herdado do método Amethod do Protoclass e executado;
A cópia do código é a seguinte:
var func = new Subclass ();
func.amethod (); // indefinido, as propriedades do membro do protoclass não podem ser lidas, a, b, c
func.submethod (); // subclasse
Para permitir que a subclasse leia as propriedades do membro do protoclass, a subclasse precisa ser alterada:
A cópia do código é a seguinte:
Subclass de função ()
{
Protoclass.call (this);
}
// outro código;
Este método pode obter as propriedades do membro e os métodos de protótipo de protoclass;:
A cópia do código é a seguinte:
var func = new Subclass ();
func.amethod (); // protoclass
func.submethod (); // protoclass
Outro método é usar o objeto protoclasse instanciado como o protótipo da subclasse;
A cópia do código é a seguinte:
var proto = new protoclass ();
função subclass () {
}
Subclass.prototype = object.create (proto, {
foo: {value: 'subclass'}
});
Dessa forma, após a subclasse ser instanciada, você pode obter todas as propriedades de protoclass e métodos de protótipo e criar um atributo de dados somente leitura Foo;
A cópia do código é a seguinte:
var func = new Subclass ();
func.foo; // Subclasse
func.a; // protoclass
func.b (); //
func.c; //[Objeto]
func.amethod (); // protoclass
4. O outro método de criação de herança é o mesmo que o protoclass instanciado do objeto.Create para protótipos:
A cópia do código é a seguinte:
função subclass () {
this.foo = 'subclasse'; // mas pode ser lido e escrito aqui
}
Subclass.prototype = new protoclass ();
Object.Crie Instruções relacionadas
Object.Create é usado para criar um novo objeto. Quando é objeto, o protótipo é nulo e seu efeito é consistente com o novo objeto (); ou {};
Quando a função, a função é a mesma que o novo nome da função;
A cópia do código é a seguinte:
// 1 objeto
var o = {}
// equivalente a
var o2 = object.create ({});
// Os construtores são os mesmos;
// -------------------------------------------
função func () {
this.a = 'func';
}
func.prototype.method = function () {
devolver isso.A;
}
var newfunc = novo func ();
// equivalente a [o efeito é o mesmo]
var newfunc2 = object.create (object.prototype/*function.prototype || function () {}*/, {
a: {value: 'func', gravidade: true},
Método: {value: function () {return this.a;}}
});
Mas o Newfunc e o NewFunc2 são diferentes nas referências de função para criar seus objetos.
newfunc é function func () {...}, newfunc2 é função função {native}
A cópia do código é a seguinte:
Object.create (proto [, Propertiesfield]):
Proto indica que o valor é necessário e pode ser nulo. Se não estiver definido, uma exceção será lançada;
Proto não é nulo, ou seja, o valor instanciado, ou seja, o valor que tem sido novo; A maioria dos objetos em JavaScript possui atributos do construtor, que atributos indicam qual função do objeto é instanciada;
O Propertiesfield é opcional, definindo as propriedades ou métodos do membro que podem ser necessários para objetos recém -criados;