如何检测函数是否被调用为构造函数？

1)查询 this.constructor:

function x(y)
{
if (this.constructor == x)
alert('called with new');
else
alert('called as function');
}

2)是的，返回值在 new上下文中使用时被丢弃

两种方式，本质上是一样的。您可以测试 this的作用域，也可以测试 this.constructor的作用域。

如果将方法作为构造函数进行调用，则 this将成为该类的新实例，如果将方法作为方法进行调用，则 this将成为方法的上下文对象。类似地，如果作为 new 调用，那么对象的构造函数就是方法本身，否则就是系统 Object 构造函数。这很明显，但这个应该有帮助:

var a = {};


a.foo = function ()
{
if(this==a) //'a' because the context of foo is the parent 'a'
{
//method call
}
else
{
//constructor call
}
}


var bar = function ()
{
if(this==window) //and 'window' is the default context here
{
//method call
}
else
{
//constructor call
}
}


a.baz = function ()
{
if(this.constructor==a.baz); //or whatever chain you need to reference this method
{
//constructor call
}
else
{
//method call
}
}

注意: 这个答案是用 二零零八年写的，当时 javascript 还在 ES3和 一九九九年中。从那以后，增加了许多新功能，因此现在有了更好的解决方案。由于历史原因，这个答案被保留了下来。

下面代码的好处是您不需要两次指定函数的名称，而且它也适用于匿名函数。

function x() {
if ( (this instanceof arguments.callee) ) {
alert("called as constructor");
} else {
alert("called as function");
}
}

更新 正如 Claudiu在下面的注释中指出的那样，如果将构造函数分配给它创建的同一个对象，上面的代码将不起作用。我从来没有写过这样的代码，也见过更新的代码。

克劳迪亚斯的例子:

var Z = new x();
Z.lolol = x;
Z.lolol();

通过向对象添加属性，可以检测对象是否已初始化。

function x() {
if ( (this instanceof arguments.callee && !this.hasOwnProperty("__ClaudiusCornerCase")) ) {
this.__ClaudiusCornerCase=1;
alert("called as constructor");
} else {
alert("called as function");
}
}

如果删除添加的属性，即使上面的代码也会中断。但是如果你删除它，它就会坏掉。

目前，ecmascript 中没有检测函数是否被作为构造函数调用的本机支持。这是到目前为止我想到的最接近的方法，它应该可以工作，除非你删除属性。

在我对 http://packagesinjavascript.wordpress.com/的测试中，我发现测试 if (this = = window)在所有情况下都可以跨浏览器工作，所以这就是我最终使用的测试。

Stijn

使用 this instanceof arguments.callee(可以选择用函数替换 arguments.callee，这样可以提高性能)检查某些内容是否被作为构造函数调用。不要使用 this.constructor，因为它可以很容易地改变。

注意: 这在 ES2015和更高版本中是可能的。请参阅 Daniel Weiner 的回答。

我不认为你想要的是可能的[在 ES2015之前]。函数中没有足够的可用信息来进行可靠的推断。

查看 ECMAScript 第3版规范，在调用 new x()时所采取的步骤基本上如下:

• 创建一个新对象
• Assign its internal [[Prototype]] property to the prototype property of x
• 正常调用 x，将新对象作为 this传递给它
• 如果对 x的调用返回一个对象，则返回它，否则返回新对象

Nothing useful about how the function was called is made available to the executing code, so the only thing it's possible to test inside x is the this value, which is what all the answers here are doing. As you've observed, a new instance of* x when calling x as a constructor is indistinguishable from a pre-existing instance of x passed as this when calling x as a function, 除非 you assign a property to every new object created by x as it is constructed:

function x(y) {
var isConstructor = false;
if (this instanceof x // <- You could use arguments.callee instead of x here,
// except in in EcmaScript 5 strict mode.
&& !this.__previouslyConstructedByX) {
isConstructor = true;
this.__previouslyConstructedByX = true;
}
alert(isConstructor);
}

显然这并不理想，因为现在对于由 x构造的每个对象都有一个额外的无用属性，可能会被覆盖，但我认为这是您能做的最好的事情。

(*) “ instance of”是一个不准确的术语，但是非常接近，比“通过调用 x作为构造函数创建的对象”更简洁

我认为是正确的。我认为，一旦您认为需要能够区分两种调用模式，那么就不应该使用“ this”关键字。this是不可靠的，它可以是全局对象，也可以是完全不同的对象。事实上，拥有这些不同激活模式的功能，其中一些按照你的意愿工作，另一些则完全疯狂，是不受欢迎的。我觉得你是因为这个才想弄清楚这件事的。

有一种惯用的方法可以创建一个构造函数，无论如何调用它，它的行为都是相同的。不管是 Thing ()、 new Thing ()还是 foo。东西。是这样的:

function Thing () {
var that = Object.create(Thing.prototype);
that.foo="bar";
that.bar="baz";
return that;
}

Create 是一个新的 ecmascript 5标准方法，可以像下面这样在普通的 javascript 中实现:

if(!Object.create) {
Object.create = function(Function){
// WebReflection Revision
return function(Object){
Function.prototype = Object;
return new Function;
}}(function(){});
}

Object.create will take an object as a parameter, and return a new object with that passed in object as its prototype.

然而，如果你真的想让一个函数根据调用方式的不同而有不同的表现，那么你就是一个坏人，你不应该编写 javascript 代码。

扩展 Gregs 解决方案，这个解决方案与您提供的测试用例完美地结合在一起:

function x(y) {
if( this.constructor == arguments.callee && !this._constructed ) {
this._constructed = true;
alert('called with new');
} else {
alert('called as function');
}
}

编辑: 添加一些测试用例

x(4);             // OK, function
var X = new x(4); // OK, new


var Z = new x();  // OK, new
Z.lolol = x;
Z.lolol();        // OK, function


var Y = x;
Y();              // OK, function
var y = new Y();  // OK, new
y.lolol = Y;
y.lolol();        // OK, function

来自 John Resig:

function makecls() {


return function(args) {


if( this instanceof arguments.callee) {
if ( typeof this.init == "function")
this.init.apply(this, args.callee ? args : arguments)
}else{
return new arguments.callee(args);
}
};
}


var User = makecls();


User.prototype.init = function(first, last){


this.name = first + last;
};


var user = User("John", "Resig");


user.name

在看到这个线程之前，我从未想过构造函数可能是实例的属性，但我认为下面的代码涵盖了这种罕见的情况。

// Store instances in a variable to compare against the current this
// Based on Tim Down's solution where instances are tracked
var Klass = (function () {
// Store references to each instance in a "class"-level closure
var instances = [];


// The actual constructor function
return function () {
if (this instanceof Klass && instances.indexOf(this) === -1) {
instances.push(this);
console.log("constructor");
} else {
console.log("not constructor");
}
};
}());


var instance = new Klass();  // "constructor"
instance.klass = Klass;
instance.klass();            // "not constructor"

For most cases I'll probably just check instanceof.

没有可靠的方法可以区分在 JavaScript code.¹中如何调用函数

但是，函数调用将 this分配给全局对象，而构造函数将 this分配给新对象。这个新对象永远不可能是全局对象，因为即使一个实现允许您设置全局对象，您仍然没有机会这样做。

You can get the global object by having a function called as a function (heh) returning this.

My intuition is that in the specification of ECMAScript 1.3, constructors that have a defined behavior for when called as a function are supposed to distinguish how they were called using this comparison:

function MyClass () {
if ( this === (function () { return this; })() ) {
// called as a function
}
else {
// called as a constructor
}
}

无论如何，任何人都可以使用函数的或构造函数的 call或 apply，并将 this设置为任何值。但是通过这种方式，您可以避免“初始化”全局对象:

function MyClass () {
if ( this === (function () { return this; })() ) {
// Maybe the caller forgot the "new" keyword
return new MyClass();
}
else {
// initialize
}
}

_{1.如果主机(又名实现)实现了与内部属性 [[Call]]和 [[Construct]]等价的属性，那么它可能能够区分这两者。前者用于函数或方法表达式，后者用于 new表达式。}

Checking for the instance type of the [this] within the constructor is the way to go. The problem is that without any further ado this approach is error prone. There is a solution however.

假设我们正在处理函数 ClassA () ，基本方法是:

    function ClassA() {
if (this instanceof arguments.callee) {
console.log("called as a constructor");
} else {
console.log("called as a function");
}
}

上面提到的解决方案有几种方法不会像预期的那样起作用，考虑以下两种方法:

    var instance = new ClassA;
instance.classAFunction = ClassA;
instance.classAFunction(); // <-- this will appear as constructor call


ClassA.apply(instance); //<-- this too

为了克服这些问题，一些人建议: a)在实例的某个字段中放置一些信息，比如“ Construction torFinish”，并对其进行检查; 或者 b)在列表中跟踪已构建的对象。我对两者都感到不舒服，因为更改 ClassA 的每个实例对于一个类型相关的特性来说都太具侵入性，而且成本太高。如果 ClassA 有许多实例，那么收集列表中的所有对象可能会提供垃圾收集和资源问题。

方法是能够控制 ClassA 函数的执行，简单的方法是:

    function createConstructor(typeFunction) {
return typeFunction.bind({});
}


var ClassA = createConstructor(
function ClassA() {
if (this instanceof arguments.callee) {
console.log("called as a function");
return;
}
console.log("called as a constructor");
});


var instance = new ClassA();

这将有效地防止使用[ This ]值欺骗的所有尝试。绑定函数将始终保持其原始的[ this ]上下文，除非使用 新的操作符调用它。

高级版本提供了将构造函数应用于任意对象的能力。有些用法可以将构造函数用作类型转换器，或者在继承场景中提供基类构造函数的可调用链。

    function createConstructor(typeFunction) {
var result = typeFunction.bind({});
result.apply = function (ths, args) {
try {
typeFunction.inApplyMode = true;
typeFunction.apply(ths, args);
} finally {
delete typeFunction.inApplyMode;
}
};
return result;
}


var ClassA = createConstructor(
function ClassA() {
if (this instanceof arguments.callee && !arguments.callee.inApplyMode) {
console.log("called as a constructor");
} else {
console.log("called as a function");
}
});

如果你不想在对象中放入一个 __previouslyConstructedByX属性——因为它会污染对象的公共接口并且很容易被覆盖——只要不返回一个 x的实例:

function x() {


if(this instanceof x) {
console.log("You invoked the new keyword!");
return that;
}
else {
console.log("No new keyword");
return undefined;
}


}


x();
var Z = new x();
Z.lolol = x;
Z.lolol();
new Z.lolol();

现在，x函数永远不会返回 x类型的对象，所以(我认为) this instanceof x只有在使用 new关键字调用该函数时才会计算为 true。

缺点是这有效地扰乱了 instanceof的行为-但是取决于你使用它的次数(我不倾向于这样做) ，这可能不是一个问题。

如果你的目标是返回 30，你可以返回一个 Number的实例，而不是 x的实例:

function x() {


if(this instanceof x) {
console.log("You invoked the new keyword!");
var that = {};
return new Number(30);
}
else {
console.log("No new");
return 30;
}


}


console.log(x());
var Z = new x();
console.log(Z);
Z.lolol = x;
console.log(Z.lolol());
console.log(new Z.lolol());

当我试图实现一个返回字符串而不是对象的函数时，也遇到了同样的问题。

这似乎足以检查函数开始时是否存在“ this”:

function RGB(red, green, blue) {
if (this) {
throw new Error("RGB can't be instantiated");
}


var result = "#";
result += toHex(red);
result += toHex(green);
result += toHex(blue);


function toHex(dec) {
var result = dec.toString(16);


if (result.length < 2) {
result = "0" + result;
}


return result;
}


return result;
}

无论如何，最后我只是决定将我的 RGB ()伪类转换成 RGB ()函数，所以我不会尝试实例化它，因此根本不需要安全检查。但这取决于你想做什么。

也许我错了，但(以寄生虫为代价)下面的代码似乎是一个解决方案:

function x(arg) {
//console.debug('_' in this ? 'function' : 'constructor'); //WRONG!!!
//
// RIGHT(as accepted)
console.debug((this instanceof x && !('_' in this)) ? 'function' : 'constructor');
this._ = 1;
return 30;
}
var result1 = x(4),     // function
result2 = new x(4), // constructor
Z = new x();        // constructor
Z.lolol = x;
Z.lolol();              // function

事实上，解决方案是非常可能和简单的... 不明白为什么这么多的文字，写了这么小的东西

更新: 感谢 黄昏太阳的解决方案现在已经完成，甚至对于测试 克劳迪建议! 谢谢大家! ! ！

function Something()
{
this.constructed;


if (Something.prototype.isPrototypeOf(this) && !this.constructed)
{
console.log("called as a c'tor"); this.constructed = true;
}
else
{
console.log("called as a function");
}
}


Something(); //"called as a function"
new Something(); //"called as a c'tor"