Reutilização de código e seus princípios
代码复用, como o nome sugere, é reutilizar parte ou mesmo todo o código que foi gravado para criar um novo programa. Ao falar sobre a reutilização do código, a primeira coisa em que podemos pensar é继承性. O princípio da reutilização do código é:
优先使用对象组合，而不是类继承No JS, como não há conceito de classe, o conceito de instâncias não é muito significativo. Objetos em JS são pares simples de valor-chave que podem ser criados e modificados dinamicamente.
Mas no js , podemos instanciar um objeto usando construtores e new operadores, que possui similaridade de sintaxe com outras linguagens de programação que usam classes.
Por exemplo:
var trigkit4 = new Person(); js parece ser uma classe ao chamar a Person construtora, mas na verdade ainda é uma função, o que nos dá algumas idéias de desenvolvimento e padrões de herança que se supõem ser baseados na classe, que podemos chamar de "padrões de herança clássica".
O modelo tradicional de herança requer a palavra -chave class . Assumimos que o modelo de herança de classe acima é现代继承模式, que é um modelo que não precisa ser considerado de uma maneira de classe.
Modo de herança clássica
Veja os dois exemplos a seguir do construtor Parent() e Child() :
<script type="text/javascript">função pai (nome) {
this.name = nome || 'Allen';
}
Parent.prototype.say = function () {
retornar este.name;
}
função filho (nome) {}
// Crie um objeto com o construtor pai e atribua o objeto ao protótipo infantil para obter herança
função herdeira (c, p) {
C.prototype = novo p (); // o atributo de protótipo deve apontar para um objeto, não uma função
}
// chamando a função herdada declarada
herdar (criança, pai);
</script>
Quando um objeto é criado usando a instrução new Child() , ele obtém sua funcionalidade da instância Parent() através do protótipo, como:
var kid = new Child();kid.say();//AllenCadeia de protótipo
Vamos discutir como as cadeias de protótipo funcionam no modo de herança de classe. Pensamos nos objetos como blocos em algum lugar da memória que contêm dados e referências a outros blocos. Quando um objeto é criado usando a new Parent() , um bloco como este à esquerda da figura abaixo será criado. Este bloco salva name . Se você deseja acessar say() , podemos acessar o __proto__ Parent.prototype à direita, apontando para prototype do construtor Parent() .
Então, o que acontece ao criar um novo objeto com var kid = new Child() ? Como mostrado na figura abaixo:
O objeto criado usando new Child() está quase vazio, exceto pelo link implícito __proto__ . Nesse caso, __proto__ aponta para o objeto criado usando a new Parent() na função inherit()
Ao executar kid.say() , como o objeto de bloco no canto inferior esquerdo não possui say() , ele consultará o objeto do bloco do meio através da cadeia de protótipo. No entanto, o objeto de bloco do meio também não possui say() , por isso segue a cadeia de protótipo para consultar o objeto de bloco mais à direita, e o objeto possui say() . Está terminado?
A execução não foi concluída aqui. this.name é referenciado no método say() , que aponta para o objeto criado pelo construtor. Aqui, aponta para o bloco new Child() . No entanto, não há atributo name em new Child() . Por esse motivo, o bloco intermediário será consultado e o bloco intermediário possui name . Neste ponto, a consulta da cadeia de protótipos foi concluída.
Para uma discussão mais detalhada, consulte meu artigo: Javascript Learning Notes (v) Explicação detalhada de protótipos e cadeias de protótipo
Protótipo compartilhado
A regra desse padrão é que os membros reutilizáveis devem ser transferidos para o protótipo, em vez de colocados nisso. Portanto, para fins de herança, qualquer coisa que valha a pena herdar deve ser implementada no protótipo. Portanto, você pode definir o protótipo do objeto filho e o protótipo do objeto pai para o mesmo que o exemplo abaixo:
function inherit(C,P){C.Prototype = P.Prototype;
}
O objeto filho e o objeto pai compartilham o mesmo protótipo e podem acessar say() igualmente. No entanto, o objeto infantil não herda name
Herança de protótipo
A herança do protótipo é um modelo de herança "moderno" sem classe. Veja o seguinte exemplo:
<script type="text/javascript">// o objeto a ser herdado
var pai = {
Nome: "Jack" // não há semicolon aqui
};
//新对象var criança = objeto (pai);
alert(child.name);//Jack</script>
No modo de protótipo, não é necessário usar literais de objeto para criar objetos pai. Conforme mostrado no código a seguir, você pode usar o construtor para criar o objeto pai. Ao fazer isso, tanto suas próprias propriedades quanto as propriedades do protótipo do construtor serão herdadas.
<script type="text/javascript">// Construtor pai
função pessoa () {
this.name = "trigkit4";
}
// Adicione ao atributo de protótipo
Person.prototype.getName = function () {
retornar este.name;
};
// Crie um novo objeto de classe pessoa
var obj = new Person ();
//herdar
var infantil = objeto (obj);
alerta (Kid.getName ()); // trigkit4
</script>
Nesse modo, você pode optar por herdar apenas o objeto de protótipo que existe no construtor existente. Os objetos herdam de objetos, independentemente de como o objeto pai é criado, como mostrado no exemplo a seguir:
<script type="text/javascript">// Construtor pai
função pessoa () {
this.name = "trigkit4";
}
// Adicione ao atributo de protótipo
Person.prototype.getName = function () {
retornar este.name;
};
// Crie um novo objeto de classe pessoa
var obj = new Person ();
//herdar
var infantil = objeto (pessoa.prototipo);
console.log (typeof Kid.getName); // Função, porque está no protótipo
console.log (typeof Kid.name); // indefinido, porque apenas este protótipo é herdado
</script>