这段代码为什么会这样？

Question

这个是Delegate.js文件
var Tecent = Tecent || {};
//事件委托
Tecent.Delegate = Tecent.Delegate || ((function() {
    var Delegate = function() {
        this.Init();
    }
    Delegate.prototype = {
        fns: [],
        Init: function() {
            this.fns = [];
        },
        Add: function(fn, self) {
            for (var i = 0; i < this.fns.length; i++) {
                if (this.fns[i][0] === fn) {
                    return;
                }
            }
            this.fns.push([fn, self]);
        }，
        Call: function() { //执行委托方法
            var result;
            for (var i = 0; i < this.fns.length; i++) {
                var ret = this.fns[i][0].apply(this.fns[i][1], arguments);
                result = ret == undefined ? result : ret;
            }
            return result;
        }
    };    return Delegate;})());
在接下来的button.js文件里
这么写竟然是可以的
this.OnClick = new Tecent.Delegate();然后我自己做了一个简单的测试
var xyz = xyz || {};
        xyz = xyz || (function() {
            var refn = function(paramx,paramy) {
                return paramx + paramy;
            }
            return refn;
        } ());
        var thisxyz = new xyz();//这里错误了
想想也是应该错误的，因为刚才的函数已经定以后立即执行了，这个xyz本来就是返回的refn函数了，所以应该这么写就对了
var thisxyz =xyz;
alert(thisxyz(5,6));
结果正确，11但是我搞不懂，为什么this.OnClick = new Tecent.Delegate();这样就可以呢，Tecent.Delegate也是一个闭包，返回的也是一个函数，这个和我自己做的例子，到底有什么区别，百思不得其解啊，本人js不熟悉，往高人解答，谢谢

Answer 1

简化下先
Tecent.Delegate = Tecent.Delegate || ((function() {})());
//如果Tecent.Delegate定义了，则还是其本身；如果未定义 Tecent.Delegate为(function() {})()执行的返回值在这里Tecent.Delegate未定义，也就是说(function() {})()执行并且返回的Delegate。
那么Tecent.Delegate就指向了对象Delegate的构造函数，new Tecent.Delegate()也就顺理成章了。
我把你的代码改了下  var xyz = xyz || (function() {
  var refn = function(paramx,paramy) {
  this.value=paramx + paramy;
  return paramx + paramy;
  }
  return refn;
  } ());
  var thisxyz = new xyz(5,6);
  alert(thisxyz.value);你定义了var xyz = xyz || {};，那么xyz = xyz || (function(){}());其实只执行到xyz = xyz

Answer 2

var Tecent = Tecent || {};//第一次执行, Tecent = {}; Tecent.Delegate = Tecent.Delegate || ((function() { //第一次执行后者
var Delegate = function() {
this.Init(); //第一次执行时进入了此方法
}
Delegate.prototype = { //第一次执行时创立了Delegate类以及类里的各种属性和方法
fns: [],
Init: function() {
this.fns = [];
},
Add: function(fn, self) {
for (var i = 0; i < this.fns.length; i++) {
if (this.fns[i][0] === fn) {
return;
}
}
this.fns.push([fn, self]);
},
Call: function() { //执行委托方法
var result;
for (var i = 0; i < this.fns.length; i++) {
var ret = this.fns[i][0].apply(this.fns[i][1], arguments);
result = ret == undefined ? result : ret;
}
return result;
}
};
return Delegate; //返回这个类
})());

var xyz = xyz || {};//这里的xyz相当于一个命名空间, 它实际是一个json体, 它的Test属性实际上是一个refn类
xyz.Test = xyz.Test || (function() {
var refn = function(paramx, paramy){
this.value = paramx+paramy;
}
return refn;
} ());
var thisxyz = new xyz.Test(1, 2);
alert(thisxyz.value);
我改的稍稍有区别于1L. Lz理解下 

Answer 3

谢谢楼上2位，解释的很详细Tecent.Delegate就指向了对象Delegate的构造函数，new Tecent.Delegate()也就顺理成章了为什么这里new的时候，我跟踪代码，发现他并不再执行了Delegate.prototype =。
只执行var Delegate = function() {
  this.Init();
  }
这里呢？
而再加载js的时候，就执行这个Delegate.prototype =。

Answer 4

加载js时候是执行这个js里的代码，也就是执行
Tecent.Delegate = Tecent.Delegate || ((function() {})());
看到这个 (function(){})()，  又一个自执行函数(函数定义完后面的() 立即让他执行了)， 所以加载js时候又会执行里面的 Delegate.prototype =  ， 所以调试时会断下而这时候
var Delegate = function() { // 这句在加载js时是会断下的
  this.Init(); // 这句就不会了，因为加载时只定义这个方法，具体方法内部执行是在这个方法调用的时候  也就是调用构造函数时候  也就是 new Delegate时候
  }

Answer 5

Delegate.prototype是页面加载的时候运行js的时候运行的
new Tecent.Delegate()是你new的时候才运行var Delegate = function() { ...}的

Answer 6

Tecent.Delegate = Tecent.Delegate || ((function() {})());
其中function(){}内部的都是定义、声明,那么new的时候，是执行的构造函数
var Delegate = function() {
  this.Init();
  }
和Delegate.prototype全没关系的。
你说“发现他并不再执行了Delegate.prototype =。”，感觉你对prototype不是很理解。
要执行到Delegate.prototype，肯定是调用了prototype中的属性或方法。
还是这个链接，你看下http://blog.csdn.net/niuyongjie/archive/2009/11/15/4810835.aspx#