Javascript &引用；“多重继承”；在原型遗传中

当两个基函数没有继承关系时，如何创建从两个函数继承并尊重其原型更改的函数

该示例演示了我想要的行为，因为

c

获得了对

A.prototype

和

B.prototype

的修改

function A() { }
function B() { }
B.prototype = Object.create(A.prototype);
function C() { }
C.prototype = Object.create(B.prototype); 

A.prototype.foo = "foo";
B.prototype.bar = "bar";

var c = new C();
console.log(c.foo); //prints foo
console.log(c.bar); //prints bar

然而，我没有B继承A的那种奢侈

function A() { }
function B() { }
function C() { }
C.prototype = //something that extends A and B even though B does not extend A.

A.prototype.foo = "foo";
B.prototype.bar = "bar";

var c = new C();
console.log(c.foo); //should print foo
console.log(c.bar); //should print bar

这是不可能的

尝试使用mixin模式，或者让一个属性C从B继承，另一个属性从a继承。 然后通过这些属性进行访问。

这是不可能的

尝试使用mixin模式，或者让一个属性C从B继承，另一个属性从a继承。 然后通过这些属性进行访问。

这是不可能的

尝试使用mixin模式，或者让一个属性C从B继承，另一个属性从a继承。 然后通过这些属性进行访问。

这是不可能的

尝试使用mixin模式，或者让一个属性C从B继承，另一个属性从a继承。

---

然后通过这些属性进行访问。

您可以更改代码以执行类似操作

C.prototype.perform = function (key) {
    var args = Array.prototype.slice(arguments, 1);
    if (key in this)
        return this[key].apply(this, args);
    if (key in B.prototype)
        return B.prototype[key].apply(this, args);
    if (key in A.prototype)
        return A.prototype[key].apply(this, args);
    undefined(); // throw meaningful error
}

C.prototype.get = function (key) {
    if (key in this)
        return this[key];
    if (key in B.prototype)
        return B.prototype[key];
    if (key in A.prototype)
        return A.prototype[key];
}

然后像这样使用它

var c = new C();
c.perform('toString');
c.get('foo');

---

您可以更改代码来执行类似的操作

C.prototype.perform = function (key) {
    var args = Array.prototype.slice(arguments, 1);
    if (key in this)
        return this[key].apply(this, args);
    if (key in B.prototype)
        return B.prototype[key].apply(this, args);
    if (key in A.prototype)
        return A.prototype[key].apply(this, args);
    undefined(); // throw meaningful error
}

C.prototype.get = function (key) {
    if (key in this)
        return this[key];
    if (key in B.prototype)
        return B.prototype[key];
    if (key in A.prototype)
        return A.prototype[key];
}

然后像这样使用它

var c = new C();
c.perform('toString');
c.get('foo');

---

您可以更改代码来执行类似的操作

C.prototype.perform = function (key) {
    var args = Array.prototype.slice(arguments, 1);
    if (key in this)
        return this[key].apply(this, args);
    if (key in B.prototype)
        return B.prototype[key].apply(this, args);
    if (key in A.prototype)
        return A.prototype[key].apply(this, args);
    undefined(); // throw meaningful error
}

C.prototype.get = function (key) {
    if (key in this)
        return this[key];
    if (key in B.prototype)
        return B.prototype[key];
    if (key in A.prototype)
        return A.prototype[key];
}

然后像这样使用它

var c = new C();
c.perform('toString');
c.get('foo');

---

您可以更改代码来执行类似的操作

C.prototype.perform = function (key) {
    var args = Array.prototype.slice(arguments, 1);
    if (key in this)
        return this[key].apply(this, args);
    if (key in B.prototype)
        return B.prototype[key].apply(this, args);
    if (key in A.prototype)
        return A.prototype[key].apply(this, args);
    undefined(); // throw meaningful error
}

C.prototype.get = function (key) {
    if (key in this)
        return this[key];
    if (key in B.prototype)
        return B.prototype[key];
    if (key in A.prototype)
        return A.prototype[key];
}

然后像这样使用它

var c = new C();
c.perform('toString');
c.get('foo');

---

令人失望的是，你不能这样做，但你可以通过循环将所有属性复制到C的原型中。这令人失望：（我将继续使用mixin。请参阅。令人失望的是，你不能这样做，但你可以通过循环将所有属性复制到C的原型中。这令人失望：（我将继续使用mixin。请参阅。令人失望的是，您不能这样做，但您可以使用循环将所有属性复制到C的原型中。这令人失望：（我将继续使用mixin。请参阅。令人失望的是，您不能这样做，但您可以使用循环将所有属性复制到C的原型中。这令人失望：（我将继续使用mixin。看。这是一种有趣的方法！然而，我认为我的用例不能保证这种复杂性。这是一种有趣的方法！然而，我认为我的用例不能保证这种复杂性。这是一种有趣的方法！然而，我认为我的用例不能保证这种复杂性。这是一种有趣的方法。）但是，我认为我的用例不能保证这种复杂性。