Javascript 创建绑定生成的obj的新实例

我正在基于

Base

类创建一个新类，该类与

ext

obj中的外部方法绑定

function Base(info) {
    var self = this;
    self.name = info.name;
    self.createNewInstance = function (data) {
        //I would like to identify the parent constructor
        // in this case, the obj containing `filter` and `find` methods
        // and use that to generate a new instance
        return new self.constructor(data);
    };
    return self;
}

var ext = {
        filter: function () {/*...*/},
        find: function () {/*...*/}
    },
    FinalClass = Base.bind(ext),
    instance1 = FinalClass({name: 'John'}),
    instance2 = instance1.createNewInstance({name: 'Mark'});

console.log(instance1); 
//--> {name: 'John', filter: [Function], find: [Function], createNewInstance: [Function]}
console.log(instance2); 
//--> {name: 'Mark'}

但正如您所看到的，我想从

FinalClass

类内部创建新实例，该类将能够使用绑定方法，而不仅仅是

Base

类方法。 因此，

instance2

还将具有

filter

、

find

和

createNewInstance

方法

我将使用不同类型的类来继承相同的

Base

类，因此在其中硬编码bind方法恐怕无法工作：(

这有可能实现吗

---

提前感谢

我恐怕对javascript的工作原理有一些误解。让我们分析一下代码：

var ext = {
        filter: function () {/*...*/},
        find: function () {/*...*/}
    },
    FinalClass = Base.bind(ext),

因此，这里有一个绑定到

ext

的

Base

函数。这意味着每次调用

FinalClass

，

这个

将是

ext

    instance1 = FinalClass({name: 'John'}),

这里调用

FinalClass

传递一个

name

等于“John”的对象。因为在

Base

中，您有：

function Base(info) {
    var self = this;
    self.name = info.name;
    // ...
    return self;
}

    instance2 = instance1.createNewInstance({name: 'Mark'});

而

这个

是

FinalClass

中的

ext

的实例，它意味着您正在向

ext

对象添加一个新属性

name

。我想您不希望这样。 然后返回

self

，这意味着再次返回

ext

在此之后，您有：

function Base(info) {
    var self = this;
    self.name = info.name;
    // ...
    return self;
}

    instance2 = instance1.createNewInstance({name: 'Mark'});

让我们看看这个方法：

self.createNewInstance = function (data) {
    return new self.constructor(data);
};

由于

instance1

不是使用

new

操作符创建的，而且它本身是

ext

，这意味着它的构造函数是

对象

，而不是您可能期望的

最终类

我相信您可以找到一种更好的方法来使用原型继承和。但是，您应该能够使用类似于以下代码的代码来获得所需的结果：

function Base(info) {
    this.name = info.name;

    this.createNewInstance = function (data) {
        return new this.constructor(data);
    };

    return this;
}

var ext = {
        filter: function () {/*...*/},
        find: function () {/*...*/}
    };

function FinalClass(info) {
    var object = Object.create(ext);
    object.constructor = FinalClass;

    return Base.call(object, info);
}

var instance1 = FinalClass({name: 'John'}),
    instance2 = instance1.createNewInstance({name: 'Mark'});

console.log(instance1);
console.log(instance2);
// notice that `filter` and `find` won't probably be listed because are not "own properties", but the objects have them:
console.log(instance1.filter);
console.log(instance2.filter);

您还可以在

Base

中编写一个实用方法，它概括了一些有用的东西，因此您的代码如下所示：

function Base(info) {
    this.name = info.name;

    this.createNewInstance = function (data) {
        return new this.constructor(data);
    };

    return this;
}

Base.create = function(extension) {
    return function Extendend () {
        var object = Object.create(extension);
        object.constructor = Extendend;

        return Base.apply(object, arguments);
    }
}

var ext = {
        filter: function () {/*...*/},
        find: function () {/*...*/}
    };

var FinalClass = Base.create(ext);

var instance1 = FinalClass({name: 'John'}),
    instance2 = instance1.createNewInstance({name: 'Mark'});

---

希望能有所帮助，如果您有疑问或我误解了您的问题，请告诉我！

哇，非常感谢ZER0这正是我想要的，感谢您将这个伟大的答案组合在一起