No JavaScript, podemos usar protótipos para obter herança.
Por exemplo
function baz () {this.oo = "";} function foo () {} foo.prototype = new Baz (); var myfoo = new Foo (); myfoo.oo;Dessa maneira, podemos acessar o atributo OO no Baz. Isso não é possível no uso real, devido às características de compartilhamento do protótipo (os dados são salvos na pilha),
Todas as instâncias usam um protótipo, mas uma vez que o atributo BAZ tenha um tipo de referência, ele será trágico. Se uma instância for modificada, a outra instância também mudará ... Wuwuwu
Naturalmente haverá herança combinada
function baz () {this.oo = "";} baz.prototype.xx = function () {} function foo () {baz.call (this); // a segunda chamada} foo.prototype = new baz (); // a primeira chamada var myfoo = new foo (); myfoo.oo;Isso terá um problema, e o código também mostra que o BAZ será chamado duas vezes. Como Virgem pode permitir?
Se você adicionar uma frase, o segundo método não precisará ter o problema com o primeiro método? A resposta é não.
O motivo é que a busca por atributos começa com o próprio objeto. Somente quando não for encontrado, será encontrado, será encontrado no protótipo. Ao ligar, os atributos são herdados.
Deixe -me adicionar outra frase, então não será suficiente para usar a herança de chamadas como essa? Isso é viável se você não usar um protótipo, mas como você não pode usar um protótipo como virgem?
O método é compartilhado no protótipo, portanto o desempenho será muito melhor.
Herança de combinação parasita
__extends = function (p, c) {function ctor () {this.Constructor = c; // construtor de atribuição} ctor.prototype = p.prototype; c.prototype = new cTor ();} função baz () {this.oo = [1];}} baz.proType.xxxxxxx = function = () {this.oo = [1];}}} {) functynx = function = functy (); foo () {baz.call (this);} var myfoo = new foo (); myfoo.oo; myfoo.xx;Isso não apenas resolve o problema de duas chamadas, mas também resolve o problema de que, quando o objeto chama o construtor, a função real que cria o objeto é chamada em vez de outros construtores na cadeia de protótipo.
Há uma declaração no código.
O construtor é um atributo no objeto de protótipo e é o criador do objeto. Como nossos atributos de protótipo são transferidos, o construtor é herdado.
Aqui, quero falar sobre como os objetos são criados, isto é, o que novo fez.
Por exemplo:
var a = novo b ();
Na verdade, é assim, a = {}; cria um para a e depois b.call (a); Chamada inicializa a. Há mais uma etapa antes da chamada, que é o protótipo interno objeto de a.
O objeto de protótipo ao qual a propriedade do protótipo está definida como B Pontos. Existe um atributo construtor no protótipo, usado para criar controles de memória de alocação de objetos.
Provavelmente é tudo ... ainda é tarde, vamos quebrá -lo. Mantenha a mente calma e não fique impaciente. Trabalhe duro para mudar amanhã e espero que tudo gradualmente melhore.
O exposto acima é todo o conteúdo que o editor lhe traz sobre o entendimento abrangente da herança (leitura obrigatória) no JavaScript. Espero que todos apoiem mais os passos da casa.