在 Javascript (ES5) 中尝试简单的 OPP 继承方法

Question

出于好奇，我在 Javascript 中使用原型继承和 OOP 继承。大多数结果涉及使用函数模拟“类”和“扩展”概念，而其他结果则使用原型和构造函数。

我写了这段代码：

function Warrior(weaponName) {
    var weapon = weaponName;
    this.getWeapon = function() {
        return weapon;
    };
    this.setWeapon = function(value) {
        weapon = value;
    };
    this.displayInfo = function() {
        return {
            "weapon": this.getWeapon(),
        };
    };
}

function Archer() {
    var accuracy = "86%";
    this.parent = Archer.prototype; // Inheritance workaround
    this.getAccuracy = function() {
        return accuracy;
    };
    this.setAccuracy = function(value) {
        accuracy = value;
    };
    this.displayInfo = function() {
        var form = this.parent.displayInfo();
        form.accuracy = this.getAccuracy();
        return form;
    };
}
Archer.prototype = new Warrior("bow");
var w = new Warrior("sword");
var a = new Archer();
console.log(w.displayInfo());
console.log(a.displayInfo());

我这样做是为了在显示来自 Warrior 类的信息时，它会将对象显示为

{ weapon: "sword" }

当显示来自Archer的信息时，对象是：

{ weapon: "sword", accuracy: "86%" }

“子类”从“超类”获取信息并添加到其中。从 Archer 调用“getWeapon()”或“setWeapon”也可以。即使我添加了第三类“Kyudoka”，它扩展了“Archer”并拥有它自己的属性，链条也没有问题。

但是与我在研究时发现的更复杂的代码相比，我觉得这可能是一个幼稚的实现（“继承解决方法”行）并且我遗漏了一些东西（考虑到 JS 有很多微妙之处）。

这是一个理论问题，我没有在任何系统中使用此代码。

Answer 1

javascript中主要有3种继承，根据Javascript the Good Parts一书：Pseudoclassical，Prototypal 和 功能性。

您刚刚发布的内容适合 Pseudoclassical 继承，您可以在其中使用构造函数模拟 Class 行为。

我发现 Functional 模式更加有用和灵活，它允许您保护变量（将它们设为私有）。

var constructor = function (spec, my) {
  var that, other private instance variables;
  my = my || {};
  //Add shared variables and functions to my
  that = a new object;
  //Add privileged methods to that
  return that;
}

原型基本上是让您的对象直接从其他有用的对象继承，这就像将它们（有用的对象）作为您的新对象构造函数原型。

Object.beget = function (o) {
  var F = function () {};
  F.prototype = o;
  return new F();
};

var a = {}
//Add shared variables to a
var b = Object.beget(a);
//Add new methods to b

每个模式都有很多考虑因素，例如 Crockford 在他的书中说“函数式模式具有很大的灵活性。它比伪经典模式需要更少的努力， 并为我们提供了更好的封装和信息隐藏以及对超级方法的访问。”，但我也看到过相反的争论，例如 http://bolinfest.com/javascript/inheritance.php

编辑 ------

如果您想了解实现超级方法的不同方法，在 函数式 模式中，您可以执行以下操作：

Function.prototype.method = function (name, func) {
  this.prototype[name] = func;
  return this;
};

Object.method('superior', function (name) {
  var that = this,
  method = that[name];
  return function ( ) {
    return method.apply(that, arguments);
  };
});

var archer = function (spec, accuracy) {
  var that = warrior(spec),
  super_displayInfo = that.superior('displayInfo');
  that.getAccuracy = function() {
    return accuracy;
  };
  that.setAccuracy = function(value) {
    accuracy = value;
  };
  that.displayInfo = function (n) {
    var form = super_displayInfo()
    form.accuracy = that.getAccuracy();
    return form;
  };
  return that;
};

Answer 2

把函数放到原型上...

function Warrior(weaponName) {
    this.weapon = weaponName;
}

Warrior.prototype = {

    getWeapon : function() {
        return this.weapon;
    },

    setWeapon : function(value) {
        this.weapon = value;
    },

    displayInfo : function() {
        return { "weapon" : this.getWeapon() };
    }
};

//----------------------------------

function Archer(weaponName) {
    Warrior.call(this, weaponName);
    this.accuracy = "86%";
}

Archer.prototype = Object.create(Warrior.prototype);
Archer.prototype.constructor = Archer;

Archer.prototype.getAccuracy = function() {
    return this.accuracy;
};

Archer.prototype.setAccuracy = function(value) {
    this.accuracy = value;
};

Archer.prototype.displayInfo = function() { 
    return "weapon: " + this.getWeapon() + ", accuracy: " + this.getAccuracy();
};


//----------------------------------

var w = new Warrior("sword");
var a = new Archer("axe");
console.log(w.displayInfo()); // Object {weapon: "sword"}
console.log(a.displayInfo()); // weapon: axe, accuracy: 86%

编辑：固定递归