O JavaScript não é uma linguagem orientada a objetos e não fornece métodos tradicionais de herança, mas fornece uma maneira de herança de protótipo, usando as propriedades do protótipo que fornece para obter herança.
A cadeia de protótipo é o principal método de herança em JavaScript.
A idéia básica da cadeia de protótipos é: use protótipos para permitir um tipo de referência para herdar as propriedades e métodos de outro tipo de referência.
Relacionamento entre construtores, protótipos e instâncias: cada construtor possui um objeto de protótipo, o objeto de protótipo contém um ponteiro para o construtor e a instância contém um ponteiro interno para o objeto protótipo.
Se o objeto de protótipo for igual a uma instância de outro objeto, o objeto de protótipo conterá um ponteiro para outro protótipo e, portanto, o outro protótipo também contém um ponteiro para outro construtor.
Modo básico de implementar a cadeia de protótipos:
function supertype () {this.property = true;} supertype.prototype.getSuperValue = function () {return this.Property;}; function subtype () {this.subProperty = false;} // iHeritTypeStyTyPe.Protype = NewTyPeMeTtyPe (} // iHeritTypeStyType.Protype = {return this.subProperty;}; var instance = new Subtype (); alert (instance.getSuperValue ()); // verdadeiroO Subtype herda o Supertype, que é alcançado pela criação de uma instância de supertipo e atribuindo a instância ao subtype.prototype. A essência da implementação é reescrever o objeto de protótipo e substituí -lo por uma instância de um novo tipo. Dessa forma, as propriedades e métodos que existem originalmente na instância do supertipo também existem no subtipo.prototipo. Em seguida, adicione um método ao subtipo.prototipo, que adiciona outro método baseado na herdeira das propriedades e métodos de supertipo.
O relacionamento de instância no exemplo acima é expresso da seguinte forma:
O acima não usa o protótipo fornecido pelo subtipo por padrão, mas o substitui por um novo protótipo; Este novo protótipo é uma instância de supertipo. Há também um ponteiro para o protótipo que executa o supertipo dentro do novo protótipo. Como resultado, a instância aponta para o protótipo do subtipo, que aponta para o protótipo de supertipo. O método getValue () ainda está no supertype.prototype, mas o protótipo está no subtipo.prototipo. Isso ocorre porque a propriedade é uma propriedade de instância e getSuperValue () é um método de protótipo. Como o subtype.prototype agora é uma instância de supertipo, a propriedade está naturalmente localizada nessa instância.
Nota: Instância.Constructor agora aponta para o Supertype, porque o protótipo do subtipo aponta para outro objeto - o protótipo do Supertype e o atributo construtor desse protótipo aponta para o supertype.
Ao acessar um atributo no modo de leitura, a instância é pesquisada pela primeira vez para esse atributo. Se a propriedade não for encontrada. Em seguida, a pesquisa pelo protótipo da instância continuará. Quando a herança é alcançada através da cadeia de protótipo, o processo de pesquisa pode continuar a subir para cima ao longo da cadeia de protótipo.
Protótipo padrão
Todos os tipos de referência herdam objeto por padrão, e essa herança também é implementada através da cadeia de protótipo. O protótipo padrão de todas as funções é uma instância do objeto. Portanto, o protótipo padrão conterá um ponteiro interno para objeto.prototipo. É por isso que os tipos personalizados herdarão métodos como ToString (), ValueOf (), etc.
Cadeia completa de protótipo:
No sistema de herança acima, o subtipo herda o supertipo e o objeto de herda do supertipo. Quando a instância.toString () é chamada, o método salvo no object.prototype é realmente chamado.
Determine a relação entre instância e protótipo
Existem duas maneiras de determinar a relação entre um protótipo e uma instância:
Use a instância do operador
alerta (instância da instância do objeto); alerta (instância da instância do supertipo); alerta (instância da instância do subtipo);
Devido à relação entre a cadeia de protótipo, todos os acima retornam verdadeiros.
Use o método isprototypeOf ()
alert (object.prototype.isprototypeof (instância)); alert (supertype.prototype.isprototypeof (instância)); alerta (subtype.prototype.isprototypeof (instância)); alerta (subtype.prototype.isprototypeof (instância));
Defina o método cuidadosamente
O código para adicionar métodos ao protótipo deve ser colocado após a declaração que substitui o protótipo.
função supertype () {this.property = true;} supertype.prototype.getSuperValue = function () {return this.property;}; function subtype () {this.subProperty = false;} supertype.PrototyPT = newetype (); this.subProperty;}; // substitui o método subtype.prototype.getSuperValue = function () {return this.subProperty;}; // substitua o método subtype.prototype.getSuperValue = function () {retorn; // falseNo exemplo acima, deve -se notar que, depois de substituir o protótipo pela instância do Supertype e depois definir esses dois métodos.
Além disso, ao herdar através da cadeia de protótipo, você não pode usar o objeto literal para criar um método de protótipo. Porque isso reescreverá a cadeia de protótipos:
function supertype () {this.property = true;} supertype.prototype.getSuperValue = function () {return this.property;}; function subtype () {this.subProperty = FalseppeRty;} // heritsubtypepe.Protype = supertyPeSPE (supertyPeSPE (} //) em hitertypesubtype.protype = supertypests (supertyppesty; Subtype.prototype inválido = {getSubValue: function () {return this.subProperty;}, algumteMethod: function () {return false;}}; var instance = new Subtype (); alert (instance.getSuperValue ()); // erroO exemplo acima atribui a instância do supertipo ao protótipo e substitui o protótipo por um objeto literal. O protótipo atual contém uma instância de objeto, não uma instância de supertipo, e não há relação entre subtipo e supertipo.
Problema da cadeia de protótipo
Como mencionado anteriormente, os atributos do protótipo contendo tipos de referência são compartilhados por todas as instâncias; É por isso que os atributos devem ser definidos no construtor e não no objeto de protótipo.
função supertype () {this.colors = ["vermelho", "azul", "verde"];} função subtype () {} subtype.prototype = new supertype (); var instance1 = new Subtype (); instance1.colors.push ("Black"); alert (1.Colors); instance1.colors.push ("Black"); alert (1.Colors; // "vermelho", "azul", "verde", "preto" var instance2 = new subtype (); alert (instance2.colors); // "vermelho", "azul", "verde", "preto"No exemplo acima, uma propriedade de cores é definida no construtor de supertipo, que contém uma matriz, e cada instância de supertipo terá uma propriedade de cores que contém sua própria matriz. Depois que o subtipo herda o supertipo através da cadeia de protótipos, o subtipo.prototipo se torna uma instância de supertipo, por isso também possui seu próprio atributo de cores. No entanto, todas as instâncias de subtipo compartilham esta propriedade One Colors.
Outro problema é que não há como passar os parâmetros para o construtor de superclasse sem afetar todas as instâncias de objetos.
O exposto acima é o conhecimento relevante do JavaScript baseado na herança da cadeia de protótipo que o editor apresentou a você. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!