在javascript中如何判断一个方法是new调用还是一般调用

在看The.Art.and.Science.of.JavaScript 的时候，看到了这个问题，就是在javascript中如何判断一个方法是new调用还是一般调用，在书中给出的代码是

function Element(){
   if(this==window || 'Element' in this){
      console.log("normal");
}else{
     console.log("new");
}

}

可是这个代码不能解决两个问题:

1比如加上下面的代码：

 Element.prototype.Element=1; 

这时如果调用new Element()时，由于Element 已经存在于this里面，因此会打印出normal;

这个很好解决。我是这样写的:

function Element(){
if(this.__proto__==Element.prototype)
{console.log("new");}else{console.log("normal");}}

可是这时又有了第二个问题。

比如下面的代码:

var test= new Element();

test.temp=Element;

test.temp();

这时的调用，也应该是normal的调用，可是依然打印出new.

实在想不出来怎么解决第二种情况，因此发出来看那位能够解决这个问题.

楼主第二个方法，那个__proto__属性只有ff支持，所以也不完美。
一开始我这么写

function Element(){  
    if(this.constructor===arguments.callee){ // this instanceof arguments.callee 也是一样的效果
        console.log("new");
    }else{
        console.log("normal");
    }
} 

看起来还不错，但是：

a = new Element;
a.Element = Element;
a.Element() //完蛋，告诉我是new

然后，又想，既然new的话，this肯定是个新对象，这个对象不会是window，也不会是window的属性，那好，这样

function Element(){ 
    var flag = "new"
    if(this===window){
       flag = "normal";
    }else{
        for(var i in window){
            if(this===window[i]){
                flag = "normal";
            }
        }
    }
    console.log(flag)
} 

貌似不错，但是，但是：

a = {b:{Element:Element}}
a.b.Element() //依然是new！现在this是b，当然不在window下，new的this肯定不在window下，但是反过来说不一定，晕倒

由于js中的函数是游离的，this可以动态改变，所以要真正解决这个问题应该很困难，但是如果限定在一定的范围内，比如说，不在对象引用构造函数本身，那this instanceof arguments.callee这样的判断就足够了。之所以探讨这个问题，是因为看了Pro javascript design paterns，里面有实现Interface，但是我觉得他那个检测太弱了，准备自己实现一个更严格的Interface，用来限定某个对象的属性类型、方法参数个数以及返回值。这样又引出一个问题，我们知道java里面的Interface是不可以实例化的，所以js实现的话需要判断一下Interface这个函数是不是被new了，如果是，就抛异常……

我个人一直是这么写的：

function ClassA() {
  assert (this instanceof ClassA);
  // constructing our instance
}

有时候也会这样：

function CustomError(msg) {
  if (this instanceof CustomError) {
    // constructiing...
  } else {
    return new CustomError(msg);
  }
}

我这样写：

function Element(){  
  if(this.name==undefined){  
      console.log("new");  
}else{  
     console.log("normal");  
}
}

讨论下这个问题,new之前创建了一个空对象,并且隐藏继承了构造函数的原形,然后以这个空对象为this执行构造函数,如果构造函数当中没有return object,那就是返回this对象,所以其实就是普通的运行构造函数,想要区分,比较好的就是

function test(){
if (this instanceof arguments.callee && (!this.testTimeStamp || this.testTimeStamp<new Date().getTime())) 
{
this.testTimeStamp=new Date().getTime();
..........
}
else
{
一般.......
}
}

再怎么写也只能找到更多的必要条件 没有充分条件

至于这个 this.testTimeStamp=new Date().getTime(); 纯粹是自找麻烦
想要伪造很容易 delete了testTimeStamp怎么办？

自造构造函数不使用new，直接return新建对象，这样new不new是一样的，就省的费劲判断了。o(∩_∩)o...

对于我的需求，也就是“当函数被用作new的时候，抛出异常”来说，我上面的解决办法就已经很完美了，因为都不存在之前被new出来的实例对象，那么后面那个故意让其失效的方法就不能运作了，所以这样就够了：

function Test(){
    if(this instanceof arguments.callee){
        throw new Error("不能做实例化操作！");
    }
    console.log("普通调用");
}

因为此时已经不可能有一个Test的实例对象来调用本身了，也就是说下面这段代码被避免了：

var t = new Test();
t.Test = Test;
t.Test();

如果不阻止构造函数实例化对象，那么上面的代码是可以运行的，但是现在没有意外了：）

LS最后写的这个,感觉比我写的那个有水准.
this.name VS arguments.callee
呵呵,当然是arguments.callee看上去更美丽了.

而且，就算不阻止构造函数实例化对象，换个角度来看，这段代码也没超出我们的预期，因为把Test赋值给一个对象作为其属性然后调用，实际上已经不再算是原始的构造函数了吧，虽然也是引用……