Este método não é original pelo autor. Acabei de resumir com base nos antecessores e criei um método de herança concisa e prática de JavaScript.
O JavaScript tradicional herda as cadeias de protótipo com base em protótipos e requer muitas novas operações. O código não é conciso o suficiente, a legibilidade não é muito forte e parece estar facilmente contaminada por cadeias de protótipo.
O método de herança resumido pelo autor é conciso e claro. Embora não seja a melhor maneira, espero que possa inspirar os leitores.
Ok, não diga muita bobagem, basta olhar para o código, os comentários são detalhados, você pode entender isso à primeira vista ~~~
A cópia do código é a seguinte:
/**
* Criado por Yang Yuanon 14-11-11.
* Não use o protótipo para implementar a herança
*
*/
/**
* Javascript Object Copying, apenas copiando uma camada e apenas cópia dos atributos da função, não universal!
* @param obj objeto para copiar
* @returns objeto
*/
Object.prototype.clone = function () {
var _s = this,
newobj = {};
_s.each (function (chave, valor) {
if (object.prototype.tostring.call (value) === "[função do objeto]") {
newobj [key] = value;
}
});
retornar newobj;
};
/**
* Itera através de todas as suas próprias propriedades
*
* Função de retorno de chamada @param. O retorno de chamada conterá dois parâmetros: Nome do atributo de chave e valor do atributo de valor
*/
Object.prototype.each = function (retorno de chamada) {
var key = "",
_This = this;
para (chave em _This) {
if (object.prototype.hasownProperty.call (_This, key)) {
retorno de chamada (key, _this [key]);
}
}
};
/**
* Crie subclasses
* @param ext obj, contém métodos que precisam ser reescritas ou estendidos.
* @returns objeto
*/
Object.prototype.extend = function (ext) {
var criança = this.cone ();
Ext.Each (função (chave, valor) {
criança [chave] = valor;
});
criança de volta;
};
/**
* Crie um objeto (instância)
* Os argumentos @param podem aceitar qualquer número de parâmetros como uma lista de parâmetros do construtor
* @returns objeto
*/
Object.prototype.create = function () {
var obj = this.clone ();
if (obj.construct) {
obj.Construct.Apply (OBJ, argumentos);
}
retornar obj;
};
/**
* Exemplo de uso
* Use esse método para herdar, evitando o protótipo tedioso e o novo.
* No entanto, o exemplo que escrevi pode herdar apenas a função da classe pai (pode ser entendida como um método de membro).
* Se você deseja herdar conteúdo mais rico, melhore o método do clone.
*
*
*/
/**
* Animais (pai)
* @Type {{Construct: Construct, Eat: Eat}}
*/
var animal = {
Construct: function (nome) {
this.name = nome;
},
Eat: function () {
console.log ("Meu nome é"+this.name+". Eu posso comer!");
}
};
/**
* Pássaro (subclasse)
* Os pássaros substituíram o método da classe dos pais e estendem o método de mosca
* @Type {subclass | void}
*/
var bird = animal.extend ({
Eat: function (alimento) {
console.log ("Meu nome é"+this.name+". Eu posso comer"+comida+"!");
},
fly: function () {
console.log ("Eu posso voar!");
}
});
/**
* Crie a instância do pássaro
* @Type {Jim}
*/
var Birdjim = Bird.create ("Jim"),
BirdTom = Bird.create ("Tom");
Birdjim.Eat ("Worm"); // Meu nome é Jim. Eu posso comer worm!
Birdjim.fly (); // eu posso voar!
BirdTom.Eat ("Rice"); // Meu nome é Tom. Eu posso comer arroz!
Birdtom.fly (); // eu posso voar!