如何检测是否使用了'new'关键字？

Question

Is this particularly robust (to try and detect whether the 'new' keyword was used to create an object)?

this.constructor.toString().indexOf('window') === -1

Bear in mind I don't care too much about ancient browsers like IE6/7/8.

Answer 1

No, it's not only not robust, it's incorrect. It looks for the characters "window" anywhere in the constructor function, which gives both false positives (you can call a function without new without "window" appearing in it anywhere) and false negatives (just because the constructor contains "window" , that doesn't mean it wasn't called with new ).

In ES5 and earlier, you can't be absolutely sure new was used at all, but you can be close enough with:

if (this instanceof TheConstructorName) {
    // Yes, `new` was probably used
}

...but that can be defeated:

var f = new TheConstructorName(); // Really called with `new`
TheConstructorName.call(f);       // Tricks it

If you use strict mode, this will be undefined if someone just does TheConstructorName() , but you can't just rely on this being undefined , because someone could do TheConstructorName.call({}) or even var o = {c: TheConstructorName}; oc(); var o = {c: TheConstructorName}; oc(); , either of which set this to a value other than undefined , even in strict mode.

In ES2015+, you can be completely sure by looking at new.target :

if (new.target) {
    // Yes, `new` was used
}

You don't need to do that if you use class syntax, though; constructors created with class can't be called without new (directly or indirectly as super ).

Answer 2

You have a couple of solutions to check this...

ECMAScript 5

 function Foo() { if (!(this instanceof Foo)) { throw new Error('Oops!'); } console.log('OK'); } new Foo(); // OK Foo(); // Error 

 function Foo() { if (this.constructor !== Foo) { throw new Error('Oops!'); } console.log('OK'); } new Foo(); // OK Foo(); // Error 

ECMAScript 6

 function Foo() { if (!new.target) { throw new Error('Oops!'); } console.log('OK'); } new Foo(); // OK Foo(); // Error 

Answer 3

As was previously mentioned, instanceof is a pretty good way to detect whether the new keyword was used. Here is some code you can use in case someone forgets the new keyword, so they don't get weird results:

function Foo(bar) {
    if (!(this instanceof Foo)) {
        return new Foo(bar)
    }

    this.bar = bar
    return this
}

new Foo(1, 2) // OK
Foo(3, 4) // OK