 <p>If your functions really do the same thing, then it's as simple as this:</p> <pre><code>var myObj = { _factory: function(err) { return function(f) { if (typeof f != 'function') throw new TypeError('Bad ' + err); this.fn = f; }; }, someFoo: function(v) { return new this._fooCon(function(x) { return x + ' Foo ' + v; }); }, someBar: function(v) { return new this._barCon(function(x) { return x + ' Bar ' + v; }); } }; myObj._fooCon = myObj._factory("Foo"); myObj._barCon = myObj._factory("Bar"); </code></pre> <p>If there's other behavior that differentiates them, then you could have <code>_factory</code> receive a function argument that is invoked within the constructor. That function could use <code>.call</code> or <code>.apply</code> to set the <code>this</code> value to the object being constructed.</p> <hr> <p>A different approach would be to use a constructor to create <code>myObj</code>, and take advantage of the variable scope so that you don't need to expose the <code>_xxxCon</code> constructors.</p> <p>This uses an anonymous function as a constructor, since we don't need it again.</p> <pre><code>var myObj = new function() { var _factory = function(err) { return function(f) { if (typeof f != 'function') throw new TypeError('Bad ' + err); this.fn = f; }; }; var _fooCon = _factory("Foo"); var _barCon = _factory("Bar"); this.someFoo = function(v) { return new _fooCon(function(x) { return x + ' Foo ' + v; }); }, this.someBar = function(v) { return new _barCon(function(x) { return x + ' Bar ' + v; }); } }; </code></pre> <p>You don't necessarily need the outer function to be used as a constructor, but you do need a function that returns an object to <code>myObj</code>.</p> <p>If you <em>did</em> want to expose the <code>_xxxCon</code> functions, then change <code>var</code> to <code>this.</code>, and put the <code>this.</code> back in <code>someFoo</code> and <code>someBar</code>.</p>