Este artigo resume o uso de JavaScript sobre herança. Compartilhe para sua referência. Os detalhes são os seguintes:
exemplo:
Copie o código da seguinte forma:/**
* As subclasses de implementação herdam a classe pai, mas não geram propriedades e métodos desnecessários
* @returns {function}
*/
define (function () {
Função de retorno (Subtipo, Supertype) {
var proto = novo objeto (supertype.prototype);
proto.constructor = subtipo;
subtype.prototype = proto;
};
});
// - - - - - - - - - - - - - - - - - - - - -
define (function () {
função ostring (s)
{
this.str = s;
this.length = this.str.length;
}
ostring.prototype.show = function () {
alerta (this.str);
};
retornar ostring;
});
// - - - - - - - - - - - - - - - - - - - - -
Definir (['Herito', 'Ostring'], função (herança, ostring) {
função wString (s) {
// Use a chamada para o construtor da classe pai
ostring.call (this, s);
this.chlength = 2 * s.Length;
}
// herdar outros atributos
herdar (wstring, ostring);
wstring.prototype.add = function (w)
{
alerta (this.str + w);
};
retornar WString;
});
Veja o exemplo novamente
1. Use a função para implementar:
Copie o código da seguinte forma: Função Pessoa (nome) {
this.name = nome;
}
Person.prototype.getName = function () {
retornar este.name;
}
Autor da função (nome, livros) {
this.Irérit = pessoa;
this.Irérit (nome);
this.books = livros;
}
var au = novo autor ("dororo", "aprenda muito");
Au.name
Ou equivalente:
Copie o código da seguinte forma: Função Pessoa (nome) {
this.name = nome;
}
Person.prototype.getName = function () {
retornar este.name;
}
Autor da função (nome, livros) {
Pessoa.call (este, nome);
this.books = livros;
}
var au = novo autor ("dororo", "aprenda muito");
Au.getName
Como isso está apenas tomando isso como um parâmetro, chamando o construtor da pessoa da classe pai e atribuindo todos os domínios atribuídos à classe pai para a subclasse do autor, quaisquer domínios definidos fora do construtor da pessoa da classe pai não serão herdados. Portanto, no exemplo acima, o Au.getName não será definido (indefinido) porque o GetName é definido pessoalmente o objeto de protótipo da pessoa.
Além disso, o construtor de uma subclasse deve chamar o construtor da classe pai antes de definir seu próprio domínio, para não substituir a definição da subclasse pela classe pai. Em outras palavras, o autor define o livro da propriedade após a pessoa. Ao mesmo tempo, é melhor não usar o protótipo para definir o domínio da função da subclasse nas subclasses, porque após uma subclasse ser nova e instanciada, o protótipo deve ser executado e, em seguida, o construtor da classe pai é chamado, que também é fácil de ser superando os atributos da classe pai.
2. Use o protótipo para implementar:
Copie o código da seguinte forma: Função Pessoa (nome) {
this.name = nome;
}
Person.prototype.getName = function () {
retornar este.name;
}
Autor da função (nome, livros) {
this.books = livros;
}
Autor.prototype = nova pessoa (nome);
Autor.prototype.Constructor = Author;
Author.prototype.getbooks = function () {
devolver este.books;
}
var au1 = novo autor ("dororo1", "aprenda muito");
var au2 = novo autor ("dororo2", "aprenda menos");
alerta (au1.getName ());
alerta (AU2.getName ());
Este método evita o problema que o protótipo não pode ser herdado na implementação da função. Porque Author.Prototype = New Pessoa (nome); New Perso () Instância chamará todas as propriedades da construção e protótipo de pessoa. Mas a desvantagem é que o autor.prototipo foi instanciado. Portanto, quando as subclasses são instanciadas, todos os tipos de dados não-base são cópias de referência. Portanto, no exemplo acima, o valor retornado pelo exemplo AU1 ou AU2 é Dororo1.
3. Use "híbrido" para alcançar
Copie o código da seguinte forma: Função Pessoa (nome) {
this.name = nome;
}
Person.prototype.getName = function () {
retornar este.name;
}
Autor da função (nome, livros) {
this.base = nova pessoa (nome);
para (tecla var neste.base) {
if (! isto [key]) {
este [key] = this.base [key];
}
}
this.book = livros;
}
var au1 = novo autor ("dororo1", "trabalho");
var au2 = novo autor ("dororo2", "play");
alerta (au1.getName ());
alerta (AU2.getName ());
Au1.book;
Au2.book;
Pertence a uma extensão, copie todos os domínios da classe pai para uma subclasse. Não há problemas nos dois aspectos acima.
Modo de combinação parasita)
A herança do JS inclui herança de atributos e herança de métodos, que são implementados através de diferentes métodos.
1. Herança de atributos
A herança de atributos é alcançada alterando o ambiente de execução da função. O ambiente de execução da alteração da função pode ser implementado usando dois métodos: Call () e Aplicar ().
Primeiro, criamos uma "classe" animal (porque não existe um conceito de classe em JS, aqui está apenas uma simulação, na verdade é apenas um objeto de função de função).
Copie o código da seguinte forma: Função Animal (Typename) {
// Adicione um tipo de nome de propriedade para o ambiente de execução do método atual (this)
// mas o ambiente de execução (isso) deve ser executado antes que possa ser determinado
this.typeName = typename;
this.colors = ["vermelho", "while"];
}
// eu quero adicionar dois métodos (de objeto) ao protótipo da função
Animal.prototype.shout = function () {alert ("eu sou: -" + this.typeName);};
Animal.prototype.eat = function () {alert ("Eu sou: -" + this.typeName)};
//-defina um leão-"classe" (na verdade uma função)
função leão (tn) {
//-Execute o método animal e modifique o ambiente de execução de animais para este leão através do primeiro parâmetro de aplicação
// Da mesma forma, isso deve ser executado para determinar quem é
Animal.Apply (isto, ["leão"]); //-herda os atributos variáveis da classe pai, isso é porque é novo leão, este é o leão
}
Lion.Prototype = Animal.prototype; // herde o método da classe pai e faça-o, mas isso não está bem escrito. Quando a classe infantil adiciona um método, a classe pai também possui esse método. Esta é uma referência de ponteiro
Lion.prototype.hunt = function () {
alerta ("Eu sou: leão, eu quero caçar ~~ ・ ~");
}
var aminm = novo animal ();
aminm.hunt (); // --- você pode acessar o método da subclasse, que não é bom
// ---- Então, como resolver esse problema? ? ? ? ? ?
// --- Solução: você pode escrever isso ao herdar o método:
Lion.Prototype = new Animal (); // herdar o método da classe pai e atribuir o objeto animal ao protótipo do protótipo. De fato, ele também tem atributos.
var Lion = new Lion (); // Além de criar a nova palavra -chave, ela também modificará o ambiente de execução do objeto de leão para o próprio objeto de leão
// --- Em outras palavras, depois que o novo é concluído, esta na função do leão é a própria função do leão, e então a função do leão é chamada
Analise as novas palavras -chave:
A nova palavra -chave é muito boa. No código anterior, a nova palavra -chave conclui as seguintes tarefas:
1) Abra o espaço da pilha para se preparar para armazenar objetos de leão
2) Modifique o ambiente de execução do próprio objeto de leão, para que essa da função do leão aponte para o próprio objeto de função do leão.
3) Chame o "Construtor" da classe Lion "e crie um objeto de leão
4) Atribuir o endereço da pilha do objeto de função do leão à variável L e, neste momento, L aponta para o objeto de função do leão
leão.shout ();
leão.eat ();
No entanto, essa herança tem uma desvantagem: o construtor da classe pai é chamado duas vezes, ligue uma vez e depois novamente.
Espero que este artigo seja útil para a programação JavaScript de todos.