Heritância do construtor de emprestado
Ao resolver o problema de incluir valores de tipo de referência em um protótipo, os desenvolvedores começaram a usar uma técnica chamada Roubo de Construtor de Muraduras (às vezes chamados de objetos forjados ou herança clássica). A idéia básica dessa técnica é bastante simples, a saber, chamar o construtor de supertipo dentro do construtor de subtipo.
Modo básico
function supertype () {this.colors = ["vermelho", "azul", "verde"];} função subtype () {// herdou supertype supertype.call (this);} var instance1 = new Subtype (); instance1.colors.push ("Black); alert (1.col.col.col.col.colors.push; // "vermelho, azul, verde, preto" var instance2 = novo subtipo (); alert (instance2.Colors); // "vermelho, azul, verde"Idéias básicas
A idéia básica de emprestar construtores é usar a chamada ou aplicar para copiar (emprestar) as propriedades e métodos especificados na classe pai na instância criada pela subclasse. Porque esse objeto está vinculado ao tempo de execução com base no ambiente de execução da função. Ou seja, globalmente, isso é igual à janela e, quando uma função é chamada de método de um objeto, isso é igual a esse objeto. Os métodos de chamada e aplicação podem ser usados para chamar um método em vez de outro objeto. Os métodos de chamada e aplicação podem alterar o contexto do objeto de uma função do contexto inicial para um novo objeto especificado por ThisObJ.
Portanto, este construtor de empréstimos é, quando o novo objeto é chamado (observe que o novo operador é diferente da chamada direta. Quando a função é chamada, isso aponta para a janela. Quando o novo é criado, isso aponta para a instância criada), um novo objeto de instância é criado e o código no subtipo é executado. A chamada no subtipo chama Supertyep, o que significa que esse apontamento é alterado para apontar para uma nova instância; portanto, esses atributos e métodos relacionados no Supertype serão atribuídos à nova instância, em vez de atribuir ao Supptype. Todas as instâncias têm essas propriedades e métodos definidos pela classe pai.
Vantagens
Comparado com as cadeias de protótipo, os construtores de empréstimos têm uma grande vantagem, ou seja, eles podem passar parâmetros para construtores de supertipo em construtores de subtipo. Como o atributo está vinculado a isso, ele é atribuído à instância correspondente quando chamado e os valores de cada instância não se afetarão.
Por exemplo:
função supertype (name) {this.name = name;} função subtype () {// herda o supertype e também passa o parâmetro supertype.call (this, "nicholas"); // atributo da instância. //"Nicholas";alert(instance.age); // 29Desvantagens
Se você apenas emprestar um construtor, os problemas com o padrão do construtor não serão evitados - os métodos são todos definidos no construtor; portanto, não há como falar sobre a reutilização da função. Além disso, os métodos definidos nos protótipos de supertipo também são invisíveis para os subtipos e, como resultado, todos os tipos só podem usar padrões de construtor. Dadas essas questões, a técnica de emprestar construtores também é raramente usada sozinha.
Herança combinada
Herança combinada, às vezes chamada de herança pseudo-clássica. É um modelo de herança que combina a cadeia de protótipos e a tecnologia de construtor emprestado em uma peça, de modo a reproduzir os pontos fortes de ambos.
Idéias básicas
A idéia é usar a cadeia de protótipo para implementar a herança de propriedades e métodos de protótipo e implementar a herança das propriedades de instância por emprestar construtores. Dessa maneira, a multiplexação da função é alcançada pela definição de métodos no protótipo e também pode garantir que cada instância tenha seus próprios atributos.
Modelo básico
função supertype (nome) {this.name = name; this.colors = ["vermelho", "azul", "verde"];} supertype.prototype.sayname = function () {alert (this.name);}; function subtype (nome, idade) {// herança atributo supertype.call (this, nome); this.age = Age;} // Método de herança subtype.prototype = new Supertype (); subtype.prototype.constructor = subtype; subtype.prototype.sayage = function () {alert (this.age);}; var1 = new Subtype "" 29); instance1.colors.push ("preto"); alert (instance1.colors); // "vermelho, azul, verde, preto" instance1.sayName (); // "nicholas"; instance1.sayage (); // 29Var Instância2 = novo subtipo ("Greg", 27); Alert (Instance2.Colors); // "vermelho, azul, verde" instance2.SayName (); // "greg"; instance2.sayage (); // 27Vantagens
A herança combinada evita os defeitos das cadeias de protótipo e construtores emprestados, combina suas vantagens e se torna o padrão de herança mais comumente usado no JavaScript.
Desvantagens
O maior problema com a herança combinada é que, em qualquer caso, o construtor de supertipo será chamado duas vezes: uma vez ao criar um protótipo de subtipo e o outro tempo dentro do construtor de subtipo. Embora os subtipos eventualmente conterão todas as propriedades de instância do objeto Supertype, precisamos substituir essas propriedades ao chamar o construtor de subtipo.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.