When Should I Automatically Create An Object Even If `new` Is Forgotten?

Let us say I have the following object constructor: function Foo(bar) { this.bar = bar; } If I run the function in the global scope without the new keyword then bar will be se

Solution 1:

This can be useful for when you would like to internally construct an object wrapper.

A little known library internally uses this approach, jQuery.

They do not use the instanceof approach any longer though. Every time jQuery is called, it automatically does this:

// Define a local copy of jQuery
jQuery = function( selector, context ) {
 // Need init if jQuery is called (just allow error to be thrown if not included)returnnew jQuery.fn.init( selector, context );
}

Everything it does internally references this local copy. At the very end of its work, it then attaches it to the global scope

window.jQuery = window.$ = jQuery;

So every time you call $() it internally uses new. It is also assuming that you do not use new externally, but it really doesn't care if you do or not.

---

edit

jsFiddle Demo

//Foo entrancefunctionFoo(bar){
 //construct a new Foo object to returnreturnnewFoo.prototype.build(bar);
}

//constructor for returning new prototypeFoo.prototype.build = function(bar){
 //initialize base settingsthis.bar = bar;
 //chain objectreturnthis;
};

//this is the complex part//tie the prototype of Foo.prototype.build.prototype to Foo.prototype//so that is "seems" like Foo is the parent of the prototype assignments//while allowing for the use of returning a new object in the Foo entranceFoo.prototype.build.prototype = Foo.prototype;

//simple expansions at this point, nothing looks too different//makes a function for a constructed Foo that logs helloFoo.prototype.hello = function(){
 console.log("Hello "+this.bar+" :)");
 //returns this for chainingreturnthis;
};

//more extensions, this one changes this.bar's valueFoo.prototype.setBar = function(arg){
 //accesses the current Foo instance's .bar propertythis.bar = arg;
 //returns this for chianingreturnthis;
};

//should be seeing a patternFoo.prototype.goodbye = function(){
 console.log("Bye "+this.bar+" :(");
 returnthis;
};

var foo = Foo(42);
//console.log(bar); // ERRORconsole.log(foo.bar); // 42
foo.hello(); //Hello 42 :)
foo.hello().setBar(9001).goodbye(); //Hello 42 :) Bye 9001 :(Foo(12).hello(); //Hello 12 :)

Solution 2:

While I don't have anything against that style, I would not personally use it just to be consistent. Sure, I can make all my constructors like this but it would seem like a lot more code to write.

If I'm worried about accidentally invoking a constructor without new, I would rather use JSHint to warn me about it. See http://www.jshint.com/docs/options/#newcap.

Solution 3:

I have one good reason to avoid it: if you're not forgetting to use new, then it's just unnecessary overhead. You may never notice this unless you're creating thousands of instances of a given object, but it's still there.

I recommend limiting the number of places in your code where new-based object creation is done - if you're not relying on it every place you need a new object, then you don't have to worry about forgetting it in one of them. There are numerous patterns that can help you here, but the simplest one is to just make one function somewhere that's responsible for object creation, and defer to that every time - whether it creates 1 instance or 1,000,000 instances is up to you.

That said, if this doesn't make sense then this sort of guard is an excellent fallback. Note that it bears a lot of similarity to how JavaScript's built-in type constructors double as type converters when used without new - so I would consider user-defined types as a particularly apt place to use this technique.

See also: Is JavaScript's "new" keyword considered harmful?

Solution 4:

Advocates of "readability" might describe it as an anti-pattern but you know your own code better than anyone else - if it works for you then go for it. Personally I'd rather have one way of doing one thing - it makes it clear and concise. If another developer enters the fray and tries to use my object with out instantiating it I'd rather it throw an error to tell him/her they are being daft.