Is wrapping new within the constructor good or bad?

I watched John Resig's Best Practices in JavaScript Library Design presentation; one slide suggested "tweaking" the object constructor so it instantiates itself.

function jQuery(str, con) {
    if (window === this) {
        return new jQuery(str, con);
    }
    // ...
}

With that, new jQuery("#foo") becomes jQuery("#foo").

I thought it was rather interesting, but I haven't written a constructor like that in my own code.

A little later I read a post here on SO. (Sorry, I don't remember which or I'd supply a link. I will update the question if I can find it again.) One of the comments said it was 开发者_StackOverflowbad practice to hide new from the programmer like that, but didn't go into details.

My question is, it the above generally considered good, bad, or indifferent, and why?

This is a defensive technique for when people forget to use the new operator in front of a 'class' function.
The logic is that if the function is called without new, then the global scope will still be the current scope (instead of the new instances), and so we just call the same function using the new operator.

But if you ask me, the correct thing would be to throw an error and actually let the developer know that it has made a mistake instead of just 'accepting' it.

But hey, I guess its according to the jQuery mantra:
'instead of enabling users to write quality code, enable/force them to write illogic and invalid code'.

IMO I think that is a practical and completely valid defensive technique.

If you are building a constructor function, for sure you want to use the newly created object instance (this), and nothing good will happen if this points to the global object.

Fortunately in the future, in the ECMAScript 5 Edition on strict mode, this will simply contain undefined when a function is called with no base object nor the new operator...

See also:

• Is JavaScript 's “new” Keyword Considered Harmful?

You are returning an object from a function. I see no problem in that.

It is the same as doing:

function getObject(){ return new SomeObject; }

The only difference is that you are actually returning yourself. But, it doesn't really seem misleading if you clearly document it. People who are used to jQuery will probably praise you for the increased usability.