introducir
Cualquier programación propone la reutilización del código. De lo contrario, si necesita escribir un nuevo programa cada vez que desarrolle un nuevo programa o escriba una nueva función, entonces será una parada. Sin embargo, la reutilización del código también es buena o mala. En los próximos dos artículos, discutiremos la reutilización del código. El primer artículo evita el uso de estos patrones tanto como sea posible, porque trae algunos problemas en mayor o menor medida; La segunda fila es la recomendación, que se refiere al patrón recomendado que todos usan, y generalmente no habrá problemas.
Modo 1: Modo predeterminado
A menudo hay un problema con la reutilización del código del modo predeterminado comúnmente utilizado por todos. Este modo usa el constructor de Parent () para crear un objeto y asignar el objeto al prototipo Child (). Veamos el código:
La copia del código es la siguiente:
función heredar (c, p) {
C.prototype = new P ();
}
// Constructor de padres
función parent (nombre) {
this.name = nombre || 'Adán';
}
// Agregar función Say al prototipo
Parent.prototype.say = function () {
devolver esto.name;
};
// El constructor infantil está vacío
function child (nombre) {
}
// ejecutar herencia
heredar (niño, padre);
var kid = new Child ();
console.log (kid.say ()); // "Adán"
var kiddo = new Child ();
kiddo.name = "Patrick";
console.log (kiddo.say ()); // "Patrick"
// Desventajas: no puede pasar parámetros al constructor infantil
var s = nuevo niño ('seth');
console.log (S.Say ()); // "Adán"
La desventaja de este modo es que el niño no puede pasar los parámetros, lo cual es básicamente inútil.
Patrón 2: Constructor de préstamo
Este patrón es que el constructor de los padres de niños presta a los niños, y luego pasa esto y los parámetros del niño al método de aplicación:
La copia del código es la siguiente:
// Constructor de padres
función parent (nombre) {
this.name = nombre || 'Adán';
}
// Agregar función Say al prototipo
Parent.prototype.say = function () {
devolver esto.name;
};
// Constructor infantil
function child (nombre) {
Parent.apply (esto, argumentos);
}
var niño = nuevo niño ("Patrick");
console.log (kid.name); // "Patrick"
// Desventajas: el método Say no se hereda del constructor
console.log (typeof kid.say); // "indefinido"
La desventaja también es obvia, y el método Say no está disponible porque no ha sido heredado.
Patrón 3: Tome prestado el constructor y establezca el prototipo
Los dos modos anteriores tienen sus propias deficiencias, entonces, ¿cómo eliminar las deficiencias de ambos? Probemos:
La copia del código es la siguiente:
// Constructor de padres
función parent (nombre) {
this.name = nombre || 'Adán';
}
// Agregar función Say al prototipo
Parent.prototype.say = function () {
devolver esto.name;
};
// Constructor infantil
function child (nombre) {
Parent.apply (esto, argumentos);
}
Child.prototype = new Parent ();
var niño = nuevo niño ("Patrick");
console.log (kid.name); // "Patrick"
console.log (typeof kid.say); // función
console.log (kid.say ()); // Patrick
console.dir (niño);
Eliminar el nombre del niño;
console.log (kid.say ()); // "Adán"
Cuando se ejecuta, todo es normal, pero ¿has notado que el constructor matriz fue ejecutado dos veces, por lo que aunque el programa está disponible, es muy ineficiente?
Modo 4: Prototipo compartido
El prototipo compartido significa que los niños y los padres usan el mismo prototipo, el código es el siguiente:
La copia del código es la siguiente:
función heredar (c, p) {
C.Prototype = P.Prototype;
}
// Constructor de padres
función parent (nombre) {
this.name = nombre || 'Adán';
}
// Agregar función Say al prototipo
Parent.prototype.say = function () {
devolver esto.name;
};
// Constructor infantil
function child (nombre) {
}
heredar (niño, padre);
var kid = nuevo niño ('Patrick');
console.log (kid.name); // indefinido
console.log (typeof kid.say); // función
kid.name = 'Patrick';
console.log (kid.say ()); // Patrick
console.dir (niño);
Es cierto que lo mismo es verdadero, los parámetros del niño no se reciben correctamente.
Patrón 5: Constructor temporal
Primero, tome prestado el constructor, luego establezca el prototipo infantil en una instancia del constructor prestado y finalmente restaure el constructor del prototipo infantil. El código es el siguiente:
La copia del código es la siguiente:
/* Cierre*/
var herherit = (function () {
var f = function () {
};
función de retorno (c, p) {
F.Prototype = P.Prototype;
C.prototype = new f ();
C.UBER = P.Prototype;
C.Prototype.Constructor = C;
}
} ());
función parent (nombre) {
this.name = nombre || 'Adán';
}
// Agregar función Say al prototipo
Parent.prototype.say = function () {
devolver esto.name;
};
// Constructor infantil
function child (nombre) {
}
heredar (niño, padre);
var kid = new Child ();
console.log (kid.name); // indefinido
console.log (typeof kid.say); // función
kid.name = 'Patrick';
console.log (kid.say ()); // Patrick
var kid2 = nuevo niño ("tom");
console.log (kid.say ());
console.log (kid.constructor.name); // Niño
console.log (Kid.Constructor === Parent); // FALSO
El problema sigue siendo el mismo, el niño no puede recibir parámetros normalmente.
Modo 6: Klass
Comencemos con el código para este patrón:
La copia del código es la siguiente:
var klass = function (parent, accesorios) {
var niño, f, i;
// 1.
// nuevo constructor
Niño = function () {
if (child.uber && child.uber.hasownproperty ("__ construct")) {
Child.uber .__ construct.apply (this, argumentos);
}
if (child.prototype.hasownproperty ("__ construct")) {
Child.prototype .__ construct.apply (this, argumentos);
}
};
// 2.
// Herencia
Padre = Padre || Objeto;
F = function () {
};
F.Prototype = parent.prototype;
Child.prototype = new f ();
Child.uber = parent.prototype;
Child.prototype.Constructor = Child;
// 3.
// Agregar método de implementación
para (i en accesorios) {
if (props.hasownproperty (i)) {
Child.prototype [i] = props [i];
}
}
// Devuelve la "clase"
niño de regreso;
};
var hombre = klass (nulo, {
__construct: function (what) {
console.log ("Constructor del hombre");
this.name = What;
},
getName: function () {
devolver esto.name;
}
});
var primero = nuevo hombre ('Adam'); // registra el "constructor del hombre"
first.getName (); // "Adán"
var superman = klass (hombre, {
__construct: function (what) {
console.log ("Constructor de Superman");
},
getName: function () {
var name = Superman.uber.getName.call (this);
regresar "I Am" + Nombre;
}
});
var Clark = new Superman ('Clark Kent');
Clark.getName (); // "Soy Clark Kent"
console.log (instancia de Clark de hombre); // verdadero
console.log (Clark instancia de Superman); // verdadero
¿Qué tal? ¿Es un poco mareado de ver? Para ser amable, la gramática y la especificación de este patrón son los mismos que otros idiomas. ¿Estás dispuesto a usarlo? tos. . .
Resumir
Aunque los seis modos anteriores implementan ciertas funciones en ciertas circunstancias especiales, todos tienen sus propias deficiencias, por lo que, en general, todos deben evitar usarlas.