Este método no es original por el autor. Lo resumí en base a los predecesores y se me ocurrió un método de herencia conciso y práctico de JavaScript.
JavaScript tradicional hereda las cadenas prototipo basadas en prototipos y requiere muchas operaciones nuevas. El código no es lo suficientemente conciso, la legibilidad no es muy fuerte y parece estar fácilmente contaminada por cadenas prototipo.
El método de herencia resumido por el autor es conciso y claro. Aunque no es la mejor manera, espero que pueda inspirar a los lectores.
De acuerdo, no digas muchas tonterías, solo mira el código, los comentarios son detallados, puedes entenderlo a primera vista ~~~
La copia del código es la siguiente:
/**
* Creado por Yang Yuanon 14-11-11.
* No use prototipo para implementar la herencia
*
*/
/**
* Copia de objeto JavaScript, solo copia de una capa y solo de copia de los atributos de la función, ¡no universal!
* @param obj objeto para copiar
* @returns objeto
*/
Objeto.prototype.clone = function () {
var _s = esto,
newobj = {};
_s.each (función (clave, valor) {
if (object.prototype.tostring.call (valor) === "[función de objeto]") {
newobj [clave] = valor;
}
});
devolver newobj;
};
/**
* Iterar a través de todas sus propias propiedades
*
* @Param Función de devolución de llamada. La devolución de llamada contendrá dos parámetros: nombre del atributo de clave y valor del atributo de valor
*/
Object.prototype.each = function (devolución de llamada) {
var key = "",
_THIS = esto;
para (clave en _THIS) {
if (object.prototype.hasownproperty.call (_this, key)) {
devolución de llamada (clave, _Tis [clave]);
}
}
};
/**
* Crear subclases
* @param ext obj, contiene métodos que deben reescribir o extender.
* @returns objeto
*/
Objeto.prototype.extend = function (ext) {
var child = this.clone ();
ext.each (function (clave, valor) {
niño [clave] = valor;
});
niño de regreso;
};
/**
* Crear un objeto (instancia)
* @param Los argumentos pueden aceptar cualquier número de parámetros como una lista de parámetros de constructor
* @returns objeto
*/
Objeto.prototype.create = function () {
var obj = this.clone ();
if (obj.construct) {
obj.construct.apply (obj, argumentos);
}
regresar obj;
};
/**
* Ejemplo de uso
* Use este método para heredar, evitando el tedioso prototipo y nuevo.
* Sin embargo, el ejemplo que escribí solo puede heredar la función de la clase principal (puede entenderse como un método miembro).
* Si desea heredar contenido más rico, mejore el método de clonos.
*
*
*/
/**
* Animales (padre)
* @Type {{Construct: Construct, Eat: Eat}}
*/
var animal = {
construct: function (nombre) {
this.name = name;
},
comer: function () {
console.log ("Mi nombre es"+this.name+". ¡Puedo comer!");
}
};
/**
* Bird (subclase)
* Aves anuladas el método de EAT de clase principal y extender el método de mosca
* @Type {subclase | void}
*/
var bird = animal.extend ({
comer: función (comida) {
console.log ("Mi nombre es"+this.name+". Puedo comer"+comida+"!");
},
volar: function () {
console.log ("¡Puedo volar!");
}
});
/**
* Crear instancia de pájaro
* @Type {Jim}
*/
var birdjim = bird.create ("jim"),
birdtom = bird.create ("tom");
birdjim.eat ("gusano"); // Mi nombre es Jim. ¡Puedo comer gusano!
birdjim.fly (); // ¡Puedo volar!
birdtom.eat ("arroz"); // Mi nombre es Tom. ¡Puedo comer arroz!
birdtom.fly (); // ¡Puedo volar!