Question

我需要Javascript中两个类之间的继承关系。我喜欢在Constructor中声明属性;对于方法，原型：

function Animal(){
   this.someProperty = 'someProperty';
   this.init();
}
Animal.prototype = {
   init : function(){ }
   anotherMethod : function(){ }
}

我认为声明这样的方法会带来更多的可读性：

 Animal.prototype.init = function(){ }
 Animal.prototype.anotherMethod = function(){}

但是当我需要从另一个班级继承一些课程时，我找不到按照自己的方式去做的方法。这不起作用：

  Cat.prototype = new Animal();
  Cat.prototype = {
      init : function(){ }
  }

我知道我可以像下一个那样做：

  Cat.prototype = new Animal();
  Cat.prototype.init = function(){ }
  Cat.prototype.anotherMethod = function(){ }

但是，有没有办法按我的方式去做？

Answer 1

查看一些继承方法以使继承工作：

来自第一个链接的示例可能总结它，这是相似但有点不同：

function Mammal(name){ 
    this.name=name;
    this.offspring=[];
} 
Mammal.prototype.haveABaby=function(){ 
    var newBaby=new Mammal("Baby "+this.name);
    this.offspring.push(newBaby);
    return newBaby;
} 
Mammal.prototype.toString=function(){ 
    return '[Mammal "'+this.name+'"]';
} 


Cat.prototype = new Mammal();        // Here's where the inheritance occurs 
Cat.prototype.constructor=Cat;       // Otherwise instances of Cat would have a constructor of Mammal 
function Cat(name){ 
    this.name=name;
} 
Cat.prototype.toString=function(){ 
    return '[Cat "'+this.name+'"]';
} 


var someAnimal = new Mammal('Mr. Biggles');
var myPet = new Cat('Felix');
alert('someAnimal is '+someAnimal);   // results in 'someAnimal is [Mammal "Mr. Biggles"]' 
alert('myPet is '+myPet);             // results in 'myPet is [Cat "Felix"]' 

myPet.haveABaby();                    // calls a method inherited from Mammal 
alert(myPet.offspring.length);        // shows that the cat has one baby now 
alert(myPet.offspring[0]);

有一些框架专注于原型继承，它将为您管理一些管道。

Answer 2

如果要保持与当前使用的语法类似的语法，则应扩展原型而不是替换原型。

例如，使用lodash，您可以使用assign，如下所示：

ps >

Answer 3

这样做

<html></html>

你覆盖了第一个声明，因此它不会获得Animal方法。

在javascript中，您只能使用原型

进行继承

  Cat.prototype = new Animal();
  Cat.prototype = {
      init : function(){ }
  }

Answer 4

首先，使用Object.create

设置继承

接下来，如果你想使用一个 Object 来扩展另一个 Object ，你可以使用Object.getOwnPropertyDescriptor将它的属性描述符复制到另一个上。 Object.defineProperty，例如

function copyAtoB(A, B) {
    var d = Object.getOwnPropertyNames(A),
        i;
    for (i = 0; i < d.length; ++i)
        Object.defineProperty(
            B,
            d[i],
            Object.getOwnPropertyDescriptor(A, d[i])
        );
    return B;
}


function Animal() {
    this.isAnimal = true;
    // etc
}
Animal.prototype = Object.create(null); // Animal doesn't inherit from anything
copyAtoB({
    foo: function () { console.log('foo'); }
}, Animal.prototype);


function Cat() {
    Animal.call(this); // the Animal constructor helps build cats
    this.isCat = true;
    // etc
}
Cat.prototype = Object.create(Animal.prototype); // Cat inherits from Animal
copyAtoB({
    bar: function () { console.log('bar'); }
}, Cat.prototype);

现在我们有了

var cat = new Cat();
cat.isCat; // true
cat.isAnimal; // true
cat.foo(); // logs "foo"
cat.bar(); // logs "bar"

Answer 5

您可以使用扩展方法。

Cat.prototype.extend({
  init : function(){ }
}, new Animal());

function extend(destination, source) {
  Object.keys(source).forEach(function (key) {
    if(typeof destination[key] === 'undefined') {
      destination[key] = source[key]    
    }
  }
}

Javascript的原型，如何继承一个类？

5 个答案: