JavaScript覆盖方法

假设您有以下代码：

function A() {
    function modify() {
       x = 300;
       y = 400;
    }

    var c = new C();
}

function B() {
    function modify(){
       x = 3000;
       y = 4000;
    }

    var c = new C();
}

C = function () {
   var x = 10;
   var y = 20;

   function modify() {
      x = 30;
      y = 40;
   };

   modify();
   alert("The sum is: " + (x+y));
}

现在的问题是，如果有任何方式，我可以覆盖的方法modify，从C与在方法A和B。在Java中，您将使用super-keyword，但是如何在JavaScript中实现类似的功能？

编辑：原始答案已经写了六年了，很多变化了！

• 如果您使用的是JavaScript的较新版本（可能已通过Babel这样的工具进行了编译），则可以使用real classes。
• 如果您使用的是Angular或React提供的类类组件构造函数，则需要查看该框架的文档。
• 如果您使用的是ES5，并使用原型手工制作“假”类，则下面的答案仍然像从前一样正确。

祝好运！

JavaScript继承与Java有点不同。这是本机JavaScript对象系统的外观：

// Create a class
function Vehicle(color){
  this.color = color;
}

// Add an instance method
Vehicle.prototype.go = function(){
  return "Underway in " + this.color;
}

// Add a second class
function Car(color){
  this.color = color;
}

// And declare it is a subclass of the first
Car.prototype = new Vehicle();

// Override the instance method
Car.prototype.go = function(){
  return Vehicle.prototype.go.call(this) + " car"
}

// Create some instances and see the overridden behavior.
var v = new Vehicle("blue");
v.go() // "Underway in blue"

var c = new Car("red");
c.go() // "Underway in red car"

不幸的是，这有点丑陋，并且没有一种非常好的“超级”方法：您必须手动指定要调用的父类的方法。结果，有各种各样的工具可以使创建类更好。尝试查看Prototype.js，Backbone.js或类似的库，其中包含用于在js中进行OOP的更好语法。

由于这是Google的热门话题，因此我想提供一个更新的答案。

使用ES6类使继承和方法重写容易得多：

'use strict';

class A {
    speak() {
        console.log("I'm A");
    }
}

class B extends A {
    speak() {
        super.speak();

        console.log("I'm B");
    }
}

var a = new A();
a.speak();
// Output:
// I'm A

var b = new B();
b.speak();
// Output:
// I'm A
// I'm B

当在继承类中使用时，super关键字引用父类。同样，父类上的所有方法都绑定到子实例的实例，因此您不必编写super.method.apply(this);。

关于兼容性：ES6兼容性表仅显示（主要）主要播放器支持类的最新版本。从今年1月开始，V8浏览器就已经安装了它们（Chrome和Opera），而使用SpiderMonkey JS引擎的Firefox将在下个月正式发布Firefox 45时上课。在移动端，Android仍不支持此功能，而五个月前发布的iOS 9已部分支持。

幸运的是，这里有Babel，这是一个JS库，用于将Harmony代码重新编译为ES5代码。ES6中的类和许多其他很酷的功能可以使您的Javascript代码更具可读性和可维护性。

应该避免仿效经典OO而改用原型OO。traits是一个很好的原型OO工具库。

而不是覆盖方法并建立继承链（应该始终主张对象组合胜于对象继承），您应该将可重用函数捆绑为特征，并使用这些特征创建对象。

现场例子

var modifyA = {
    modify: function() {
        this.x = 300;
        this.y = 400;
    }
};

var modifyB = {
    modify: function() {
        this.x = 3000;
        this.y = 4000;
    }
};

C = function(trait) {
    var o = Object.create(Object.prototype, Trait(trait));

    o.modify();
    console.log("sum : " + (o.x + o.y));

    return o;
}

//C(modifyA);
C(modifyB);

您的示例中的Modify（）是私有函数，只能在A，B或C定义内的任何位置访问。您需要将其声明为

this.modify = function(){}

C没有引用其父级，除非将其传递给C。如果将C设置为继承自A或B，它将继承其公共方法（而不是像您定义了Modify（）那样的私有函数）。一旦C从其父级继承了方法，就可以覆盖继承的方法。

modify()如果要覆盖，最后一次调用的方法将在全局上下文中调用，modify()您首先必须继承A或B。

也许您正在尝试这样做：

在这种情况下C继承A

function A() {
    this.modify = function() {
        alert("in A");
    }
}

function B() {
    this.modify = function() {
        alert("in B");
    }
}

C = function() {
    this.modify = function() {
        alert("in C");
    };

    C.prototype.modify(); // you can call this method where you need to call modify of the parent class
}

C.prototype = new A();

除非您将所有变量都设置为“ public”，否则就不要这么做，即Function直接或通过prototype属性使它们成为变量的成员。

var C = function( ) {
    this.x = 10 , this.y = 20 ;
    this.modify = function( ) {
        this.x = 30 , this.y = 40 ;
        console.log("(!) C >> " + (this.x + this.y) ) ;
    } ;
} ;

var A = function( ) {
    this.modify = function( ) {
       this.x = 300 , this.y = 400 ;
       console.log("(!) A >> " + (this.x + this.y) ) ;
    } ;
} ;
    A.prototype = new C ;

var B = function( ) {
    this.modify = function( ) {
       this.x = 3000 , this.y = 4000 ;
       console.log("(!) B >> " + (this.x + this.y) ) ;
    } ;
} ;


new C( ).modify( ) ;
new A( ).modify( ) ;
new B( ).modify( ) ; 

• 在这里测试

您会注意到一些变化。

最重要的是，现在在此行中隐含了对所谓的“超类”构造函数的调用：

<name>.prototype = new C ;

无论A和B现在有个别修改成员x和y这不会是我们是否有书面的情况... = C相反。

然后，x，y和modify都是“公共”的成员，这样分配不同的Function他们

 <name>.prototype.modify = function( ) { /* ... */ }

将以Function该名称“覆盖”原始文件。

最后，对的调用modify无法在Function声明中完成，因为当我们将假定的“超类”设置为假定的“子类”的prototype属性时，将再次执行对“超类”的隐式调用。

但是，好吧，这或多或少就是您在JavaScript中执行此类操作的方式。

HTH，

FK