JavaScript 构建构造函数的构造函数

Question

这是我想要的一个简单示例：

var ConstBuilder = function() {
    var constructor = function() {} ;
    constructor.prototype = {} ;
    return constructor ;
} ;

ConstBuilder.prototype = {
    add : function(name, value) {
        this.prototype[name] = value ;
    }
} ;

var A = new ConstBuilder() ;
A.add('test', function() {
    console.log('test') ;
}) ;

var a = new A() ;
a.test() ;

此代码将失败，因为 A 不是 ConstBuilder 的实例（因为 A 来自返回的 var constructor = function() {} 并且不会在其原型 (add) 中定义方法。

但这对于将超级构造函数的原型修改为具有以下内容很有用：

ConstBuilder.prototype.remove = function(name) {
    delete this.prototype[name] ;
} ;

A.remove('test') ;

a.test ; // undefined

有没有办法让一个函数作为另一个函数的实例？所以这个函数可能会隐式地“继承”其构造函数原型中定义的所有方法。

或者，如果您有其他建议，我的目标是构建可模块化的构造函数 - 就像带有原型的实例一样。

Answer 1

请确保您了解.prototype 属性和内部继承原型之间的区别。

---

代码将失败，因为 A 不是 ConstBuilder 的实例。有没有办法让一个函数作为另一个函数的实例？

A 是每个构造函数都需要的Function。因此，如果您只在 Function.prototype 上定义您的 add 和 remove 方法，它将起作用：

Function.prototype.add = function(name, value) {
    this.prototype[name] = value;
};
Function.prototype.remove = function(name) {
    delete this.prototype[name];
};

function A() {}
A.add('test', function(){console.log('test');});
var a = new A();
a.test(); // test

A.remove('test');
a.test; // undefined

但是，不可能让函数继承自 Function.prototype 以外的其他东西 - 请参阅 Can a JavaScript object have a prototype chain, but also be a function?。如果不想修改原生的Function.prototype对象，还是可以使用mixin pattern：

var Constr = (function() {
    function add(name, value) {
        this.prototype[name] = value;
    }
    function remove(name) {
        delete this.prototype[name];
    }
    return function mixin(c) {
        c.add = add;
        c.remove = remove;
        return c;
    };
})();

var A = Constr(function() {…});
A.add("test", …);
var a = new A();
a.test(); // test

我的目标是构建可模块化的构造函数

您可以使用builder pattern，就像您刚刚尝试过的那样。

function ConstBuilder() {
    this.prototype = {};
};

ConstBuilder.prototype = {
    add: function(name, value) {
        this.prototype[name] = value;
    },
    remove: function(name) {
        delete this.prototype[name];
    },
    getConstructor: function() {
        var constructor = function() {};
        constructor.prototype = this.prototype;
        this.prototype.constructor = constructor;
        return constructor;
    }
};

var A = new ConstBuilder().add('test', function() {
    console.log('test');
}).getConstructor();
var a = new A();
a.test(); // test

以后要删除函数，您需要保存对builder 的引用。

Answer 2

我认为您正在寻找如何进行 JavaScript 的“原型继承”的示例。当 JavaScript 查找对象的属性时，它首先检查对象本身。接下来它检查原型。但是，由于 JavaScript 中的一切都是对象，而原型也是对象

function Root(){}
Root.prototype.fromRoot = function() { console.log("I'm on Root's prototype."); };
function Child(){}
Child.prototype = new Root();
Child.prototype.fromChild = function() { console.log("I'm on Child's prototype."); };

var r = new Root();
var c = new Child();

r.fromRoot();  // works
c.fromRoot();  // works
c.fromChild(); // works
r.fromChild(); // fails

Answer 3

function a (x,y,construct)
    {
    if (!construct) return;
    this.x=x;
    this.y=y;
    }

a.prototype.methoda=function ()
    {
    return x+y;
    }

function b (x,y,d,e)
    {
    a.call (this,x,y,true) //--- this would inherit all own Objects and Properties of a and become own properties of b
    this.d=d;
    this.e=e;
    }

  b.prototype=new a ();  //--- this would only inherit the prototype, construct becomes false and isnt worked through, which if not would result in adding propertiy x and y to prototype instead of directly to instance of b,
  b.prototype.constructor=b;

  var test=new b (1,2,3,4);
  b.methoda ();

第二种方式

function a (x,y)
    {
    if (arguments.callee.doNotConstruct) return;
    this.x=x;
    this.y=y;
    }

a.prototype.methoda=function ()
    {
    return x+y;
    }


function b (x,y,d,e)
    {
    a.call (this,x,y) //--- this would inherit all own Objects and Properties of a and become own properties of b
    this.d=d;
    this.e=e;
    }
  a.doNotConstruct=true;
  b.prototype=new a ();  //--- this would only inherit the prototype, construct becomes false and isnt worked through, which if not would result in adding propertiy x and y to prototype instead of directly to instance of b,
  a.doNotConstruct=false;

  b.prototype.constructor=b;

  var test=new b (1,2,3,4);
  b.methoda ();

把它放在一个函数中

 function prototypeInheritance (inheritor,parent)
 {
 parent.doNotConstruct=true;
 inheritor=new parent ();
 inheritor.prototype.constructor=inheritor;
 inheritor.parent=parent;
 parent.doNotConstruct=false;
 }

您可以在继承构造函数中使用 (arguments.callee.parent) 调用父属性，并且可以在父构造函数中使用 arguments.callee.doNotConstruct 来检查 doNotConstruct