Pattern for enforcing new in javascript

Question

I have been reading JavaScript Patterns book by Stoyan Stefanov and one of the patterns to enforcing the new operator for constructor functions goes like this

function Waffle() {
if (!(this instanceof Waffle)) {
return new Waffle();
}
this.tastes = "yummy";
}
Waffle.prototype.wantAnother = true;

when writing this way you can invoke Waffle either one of these ways

var first = new Waffle(),
second = Waffle(); 

I think this is a helpful feature not sure if it's implemented in future versions of ecma/javascript

I came up with something on my own that I thought could just copy and paste each time when creating a constructor function

something like this

function checkInstance (name) {
    if (name.constructor.name === undefined) {
       return "construct it"
    } else {
       return false;
    }
}

function Waffle() {
    var _self = checkInstance.call(this, this);
    if (_self === "construct it") {
       return new Waffle()
    }
    this.tastes = "yummy"
}

var waffle = Waffle()
waffle

Therefore I can invoke Waffle either way new Waffle or Waffle() and still have it return an object

My problem that I'm having is here

  if (_self === "construct it") {
       return new Waffle()
       }

Is there anyway I can refer to new Waffle() without referring to the actual name of the constructor function meaning so I could copy and paste this each time and not have to change anything. Meaning I could I save Waffle() as a variable and do something like

return new var

I wish I could use this.name but that doesn't work either until it is invoked.

I have a feeling I can't but wanted to at least ask some of the people here on stack overflow if it was a possibility

Again your comments and feedback is appreciated

Answer 1

I have a better solution. This is what you're currently doing:

function Waffle() {
    if (!(this instanceof Waffle))
        return new Waffle;
    this.tastes = "yummy";
}

Waffle.prototype.wantAnother = true;

This pattern isn't really nice because you're mixing the code to construct a new object with the code to check if the new keyword is being used.

I've mentioned before that you shouldn't use the new keyword in JavaScript as it breaks functional features. Instead let's create another function which does the same thing:

Function.prototype.new = (function () {
    return function () {
        functor.prototype = this.prototype;
        return new functor(this, arguments);
    };

    function functor(constructor, args) {
        return constructor.apply(this, args);
    }
}());

This function allows you to create an instance of a function as follows:

var waffle = Waffle.new();

However we don't want to use new at all. So to do away with it we'll create a function which wraps a constructor as follows:

function constructible(constructor) {
    function functor() { return Function.new.apply(constructor, arguments); }
    functor.prototype = constructor.prototype;
    return functor;
}

Now we can define the Waffle function as follows:

var Waffle = constructible(function () {
    this.tastes = "yummy";
});

Waffle.prototype.wantAnother = true;

Now you can create objects with or without using new:

var first = new Waffle;
var second = Waffle();

Note: The constructible function is pretty slow. Use the following version of constructible instead - it's a little faster:

function constructible(constructor) {
    constructor = Function.bind.bind(constructor, null);
    function functor() { return new (constructor.apply(null, arguments)); }
    functor.prototype = constructor.prototype;
    return functor;
}

---

Personally I wouldn't use either of these two methods. I would just remember to write new, or (more likely) I would restructure my code as follows:

var waffle = {
    create: function () {
        var waffle = Object.create(this);
        waffle.tastes = "yummy";
        return waffle;
    },
    wantAnother: true
};

var first = waffle.create();
var second = waffle.create();

If you want to know more about this pattern then read the following answer: https://stackoverflow.com/a/17008403/783743

Answer 2

You could use something like this:

var Waffle = (function() {
    function Waffle() {
        this.tastes = "yummy"
    }

    return exportCtor( Waffle );
})();


var waffle = Waffle();

alert(waffle.tastes);

console.log(Waffle);

/*
function ConstructorProxy() {
    "use strict";
    return new Constructor();
}
*/

http://jsfiddle.net/ywQJF/

It handles variable arguments too

Answer 3

arguments.callee, which refers to the current function, is the most simple solution. It's is deprecated, though, so use it at your own risk.

function Waffle() {
    if (!(this instanceof arguments.callee))
        return new arguments.callee();

    this.tastes = 'yummy';
}

It's a hard problem also because you probably want to preserve the arguments you're passing, as Vinothbabu mentioned. But if you real intention is enforcing new, you could simply throw an error, which is a simple two lines of code:

if (!(this instanceof Waffle))
    throw new Error('Constructor called without new');

You could even wrap it in a function:

function cons(C) {
    var c = function () {
        if (!(this instanceof c))
            throw new Error('Constructor called without new');

        C.apply(this, arguments);
    };
    c.prototype = C.prototype;
    return c;
}

var Waffle = cons(function () {
    this.tastes = 'yummy';
});
Waffle.prototype.wantAnother = function () {
    return true;
};

new Waffle(); // { tastes: 'yummy', 'wantAnother': true }
Waffle(); // throws error

Now Waffle must be called with new -- otherwise, it throws an error.

Answer 4

There is simpler way how to enforce creation of new object even without new:

function Waffle() {
    return {tastes:"yummy"};
}

var a = Waffle();
var b = new Waffle();

alert(a.tastes); // yummy
alert(b.tastes); // yummy

Explanation

Using new with function, there are two possibilities:

• the function returns object: the object is the result of the new function() expression
• the function doesn't return object: the function itself with new context is returned

See the ECMA script documentation

Workaround: prototype and arguments

function Waffle(taste,how) {
    return {
        tastes: taste+" "+how,
        __proto__: Waffle.prototype
    }
}
Waffle.prototype.wantmore = "yes";

var a = Waffle("yummy","much");
var b = new Waffle("gummy","little");

console.log(a.tastes,b.tastes); // yummy much, gummy little
console.log(a.wantmore,b.wantmore); // yes, yes

This deserves a fiddle.

Note: constructor.name (which you used in your pattern) is not standard

Note 2: __proto__ is also not standard, but is supported by modern browsers and will be standardized in ES6.

Answer 5

The best approach, in my opinion, is not to enable yourself to invoke things incorrectly:

function Waffle() {
  if (!(this instanceof Waffle)) {
    throw "Waffles need to be fresh or they're gross. Use 'new'.";
  }
}

But, if you simply must enable yourself to write inconsistent code, make initialization a separate step.

function Waffle(options) {
  var o = options || {};
  if (this instanceof Waffle) {
    this.init = function() {
      /* this is really your constructor */
      console.log("initializing ... ");
    }

    if (!o.__do_not_initialize) {
      this.init(arguments);
    }
  } else {
    var rv = new Waffle( { __do_not_initialize: true } );
    rv.init(arguments);
    return rv;
  }
}

If you want to force consistency the other way -- never using the new keyword, create a builder function:

function BuildWaffle(options) {
  var o = options || {};

  if (this instanceof WaffleBuilder) {
    throw "BuildWaffle cannot be instantiated.";
  }

  var Waffle = function Waffle() { /* whatever */ }
  Waffle.prototype.doStuff = function() { /* whatever else */ }

  var rv = new Waffle(options);
  return rv;
}

Answer 6

if (!(this instanceof Waffle)) {
    return new Waffle();
}

This has two problems...

1. one that it won 't work in an anonymous function which has no name
2. it loses all arguments sent to the constructor.

Using a more generic approach might look something more like this:

if (!instanceExists(this, arguments)) {
    return requireInstance(this, arguments);
}

This approach ensures that the constructor is called with new, without having to state the function' s name, andadds all arguments sent to the constuctor so they aren 't lost during the process.

Here 's the full code for the above:

Function.prototype.callNew = function (args) {
    var a = [];
    for (var i = 0; i < args.length; i++) a.push("a[" + i + "]");
    var fn = new Function("var a=arguments;return new this(" + a.join(",") + ");");
    return fn.apply(this, args);
}

function instanceExists(t, args) {
    if (t instanceof args.callee) {
        return true;
    } else {
        return false;
    }
}

function requireInstance(t, args) {
    var fn = args.callee;
    if (!instanceExists(t, args)) {
        return fn.callNew(args);
    }
}

function Waffle(one, two, three) {
    if (!instanceExists(this, arguments)) {
        return requireInstance(this, arguments);
    }
    this.one = one;
    this.two = two;
    this.three = three;
}

Waffle.prototype.serve = function () {
    var out = [];
    for (var j in this) {
        if (!this.hasOwnProperty(j)) continue;
        out.push(j + ': ' + this[j]);
    }
    return ' {
    ' + out.join(",\n") + '
}
';
}

A fiddle for you to play with. http://jsfiddle.net/RkPpH/

var waffle = Waffle(1, 2, 3);
alert(waffle.serve());

Answer 7

I didn't get a sense of whether this was client or server-side, but a pattern I use sometimes goes as follows. I use this in Node but have attempted to make it a possible client-side solution as well - the Node-specific stuff is commented out but there for reference depending on your environment.

First, I create something to be used along the lines of a traditional OO base or super class like so:

//// Node:
//module.exports.Base = Base;

function Base(opts) {
    var self = this;
    if (!(self instanceof Base)) return new Base(opts);
    self.opts = opts || {};
}

Upon which you can define your methods, in usual the fashion. You can even manually throw if the method should be provided by subclasses implementing something like abstract:

// commonMethod is available to subclasses:
Base.prototype.commonMethod = function () {
    var self = this;
    //access self.opts to get the constructor arguments.
    //makes self always point to the right object.
}

// Provide abstractMethod, but subclass is responsible for implementation:
Base.prototype.abstractMethod = function () {
    //or throw an error if this should be implemented by subclasses:
    throw new Error('implement me');
}

Now you can do this:

//// If using Node:
//var inherits = require('util').inherits;
//var Parent = require('./Base').Base;

function Sub (opts) {
    var self = this;
    //// If using node and you  want super_ to be called prior to creating a new Sub:
    //if(Sub.super_) Sub.super_.call(this, opts);

    // Always do this:
    if (!(self instanceof Sub)) return new Sub(opts);

    //// If using node and you are ok with super_ called after creating new Sub:
    //if(Sub.super_) Sub.super_.call(this, opts);
    //// otherwise:
    parent(opts);
}

//// If using Node:
//inherits(Sub, Base);
//// Otherwise:
Sub.prototype.constructor = Base;
Sub.prototype.parent = Base.prototype;

//and provide the implementation of abstractMethod:
Sub.prototype.abstractMethod() {
    //...
}

And to formally answer the specific question, all of the

if (!(self instanceof Sub)) return new Sub(opts);

is where you get the guaranteed new situation.