Reutilización de código y sus principios
代码复用, como su nombre indica, es reutilizar la parte o incluso todo el código que se ha escrito para construir un nuevo programa. Cuando se habla de la reutilización del código, lo primero que podemos pensar es继承性. El principio de reutilización de código es:
优先使用对象组合，而不是类继承En JS, dado que no hay concepto de clase, el concepto de instancias no es muy significativo. Los objetos en JS son pares de valor clave simples que se pueden crear y modificar dinámicamente.
Pero en js , podemos instanciar un objeto utilizando constructores y new operadores, que tiene similitud de sintaxis con otros lenguajes de programación que usan clases.
Por ejemplo:
var trigkit4 = new Person(); js parece ser una clase al llamar a la Person del constructor, pero en realidad sigue siendo una función, lo que nos da algunas ideas de desarrollo y patrones de herencia que se supone que se basan en la clase, que podemos llamar "patrones de herencia clásicos".
El modelo de herencia tradicional requiere la palabra clave class . Suponemos que el modelo de herencia de clase anterior es现代继承模式, que es un modelo que no necesita ser considerado de manera de clase.
Modo de herencia clásica
Consulte los siguientes dos ejemplos del Parent() y Child() :
<script type="text/javascript">función parent (nombre) {
this.name = nombre || 'Allen';
}
Parent.prototype.say = function () {
devolver esto.name;
}
Function Child (nombre) {}
// Crear un objeto con el constructor principal y asignar el objeto al prototipo infantil para lograr la herencia
función heredar (c, p) {
C.prototype = new P (); // El atributo prototipo debe apuntar a un objeto, no una función
}
// llamando a la función hereditaria declarada
heredar (niño, padre);
</script>
Cuando se crea un objeto utilizando la instrucción new Child() , obtiene su funcionalidad de Parent() a través del prototipo, como:
var kid = new Child();kid.say();//AllenCadena prototipo
Discutamos cómo funcionan las cadenas prototipo en el modo de herencia de clase. Pensamos en los objetos como bloques en algún lugar de la memoria que contienen datos y referencias a otros bloques. Cuando se crea un objeto usando la instrucción new Parent() , se creará un bloque como este a la izquierda de la figura a continuación. Este bloque guarda name . Si desea acceder say() , podemos acceder Parent.prototype __proto__ de prototype Parent() .
Entonces, ¿qué sucede al crear un nuevo objeto con var kid = new Child() ? Como se muestra en la figura a continuación:
El objeto creado usando new Child() está casi vacía, excepto el enlace implícito __proto__ . En este caso, __proto__ apunta al objeto creado usando la new Parent() en la función inherit()
Al ejecutar kid.say() , dado que el objeto de bloque en la esquina inferior izquierda no tiene say() , consultará el objeto de bloque medio a través de la cadena prototipo. Sin embargo, el objeto de bloque medio tampoco tiene say() , por lo que sigue la cadena prototipo para consultar el objeto de bloque más derecho, y el objeto tiene say() . ¿Está terminado?
La ejecución no está terminada aquí. this.name se hace referencia en say() , que apunta al objeto creado por el constructor. Aquí, apunta al bloque new Child() . Sin embargo, no hay atributo name en new Child() . Por esta razón, se consultará el bloque intermedio y el bloque intermedio tiene name . En este punto, se ha completado la consulta de la cadena prototipo.
Para una discusión más detallada, consulte mi artículo: JavaScript Learning Notes (v) Explicación detallada de prototipos y cadenas de prototipo
Prototipo compartido
La regla de este patrón es que los miembros reutilizables deben transferirse al prototipo en lugar de colocarse en esto. Por lo tanto, con el propósito de la herencia, cualquier cosa que valga la pena heredar debe implementarse en el prototipo. Por lo tanto, puede establecer el prototipo del objeto infantil y el prototipo del objeto principal al mismo que el siguiente:
function inherit(C,P){C.Prototype = P.Prototype;
}
El objeto infantil y el objeto principal comparten el mismo prototipo y pueden acceder say() por igual. Sin embargo, el objeto infantil no hereda name
Herencia prototipo
La herencia prototipo es un modelo de herencia sin clases "moderno". Vea el siguiente ejemplo:
<script type="text/javascript">// el objeto a ser heredado
var parent = {
Nombre: "Jack" // No hay semicolon aquí
};
//新对象var Child = Object (Parent);
alert(child.name);//Jack</script>
En modo prototipo, no es necesario usar literales de objetos para crear objetos principales. Como se muestra en el siguiente código, puede usar el constructor para crear el objeto principal. Al hacerlo, se heredará tanto sus propias propiedades como las propiedades del prototipo del constructor.
<script type="text/javascript">// Constructor de padres
función persona () {
this.name = "trigkit4";
}
// Agregar al atributo prototipo
Persona.prototype.getName = function () {
devolver esto.name;
};
// Crear un nuevo objeto de clase de persona
var obj = nueva persona ();
//heredar
var kid = objeto (obj);
alerta (kid.getName ()); // trigkit4
</script>
En este modo, puede elegir heredar solo el objeto prototipo que existe en el constructor existente. Los objetos heredan de los objetos, independientemente de cómo se cree el objeto principal, como se muestra en el siguiente ejemplo:
<script type="text/javascript">// Constructor de padres
función persona () {
this.name = "trigkit4";
}
// Agregar al atributo prototipo
Persona.prototype.getName = function () {
devolver esto.name;
};
// Crear un nuevo objeto de clase de persona
var obj = nueva persona ();
//heredar
var kid = objeto (persona.prototype);
console.log (typeof kid.getName); // función, porque está en el prototipo
console.log (typeof kid.name); // indefinido, porque solo este prototipo está heredado
</script>