JavaScript build a constructor of constructors

Question

Here is a simple example of what I want :

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() ;

This code will fail as A is not an instance of ConstBuilder (because A comes from a returned var constructor = function() {} and won't have the methods defined in its prototype (add).

But this would be useful to modify the super constructor's prototype to have things like :

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

A.remove('test') ;

a.test ; // undefined

Is there a way to have a function as an instance of another ? So this function may implicitely "inherit" all the methods defined in its constructor's prototype.

Or if you have other suggestions, I aim to build modulable constructors - as instances with prototypes are.

Answer 1

Please make sure you have understood the difference between the .prototype property and the internal inheritance-prototype.

---

The code will fail as A is not an instance of ConstBuilder. Is there a way to have a function as an instance of another?

A is, as every constructor needs to be, a Function. So if you just define your add and remove methods on the Function.prototype, it will work:

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

There is no possibility however to let a function inherit from something else than Function.prototype - see Can a JavaScript object have a prototype chain, but also be a function?. If you don't want to modify the native Function.prototype object, you still can use the 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

I aim to build modulable constructors

You could use the builder pattern, as you just have seem to tried.

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

To remove functions later, you would need to save a reference to the builder.

Answer 2

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 ();

second way

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 ();

put this in a function

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

you can call the parent property with (arguments.callee.parent) in the inheritor constructor and you can check doNotConstruct with arguments.callee.doNotConstruct in the parent constructor

Answer 3

I think that you are looking for an example of how to do JavaScript's "prototypical inheritance". When JavaScript looks for a property on an object, it first checks the object itself. Next it checks the prototype. However, since everything in JavaScript is an object and the prototype is an object

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