js的事件处理与闭包：

var i = 0;
for(i=0;i<5;i++){
(function(i){
setTimeout(function(){alert(i)},3000);
})(i)
}
// 上面打印出的i的顺序是随机的

上面的这里的i指的是简单的数据类型，非引用类型。

=============================

var ss = 0;
var sss = {
age : 18,
a : {
age:28
}
}
function box(id){
var self = this;
self.ss++;
sss.age++;
sss.a.age++;
var ccc = $.extend({},sss);
(function(self,sss){
$(id).click(function(){
alert(self.ss+"sss=>"+sss.age+"sss.a=>"+sss.a.age);
});
})(self,ccc)

}
box('#box1');
box('#box2');

这里的var ccc = $.extend({},sss);指的是浅拷贝。
浅拷贝也是拷贝。
只是他默认把所有的数据类型的第一层都默认为简单的数据类型。
如果第一层中有引用类型，他也当简单的数据类型处理了。
var ccc = ssss;
这个不叫拷贝，也不叫浅拷贝，这个叫引用。

#box1  //1 19 30

#box2 //2 20 30

//====================

var ss = '';
function yan(bb){
    ss = bb;
(function(ss){
    setInterval(function(){
        console.log(ss);
    },2000);
})(ss)
}

yan('a');
yan('b');
yan('c');
//==============
var ss1 = '';
function yan(bb1){
    ss1 = bb1;

    setInterval(function(){
        (function(ss1){
        console.log(ss1);
        })(ss1)
    },2000);

}

yan('a1');
yan('b1');
yan('c1');

　　

对于闭包的理解，函数中的函数，为什么闭包可以把，局部变量变为全局变量，因为，闭包是一个函数，函数可以操作变量，这个变量首先考虑就近的局部变量，这个函数最后返回，还是通过赋给window变量，都一样。我们通过调用这个函数，直接操作了局部变量，所以说局部变量变为了全局的。

 

 

js new的时候，会自动执行一次构造函数，并且，默认返回this（一般情况下this就是window，这句话有漏洞，或者说没有返回），如果，返回的不是this的话，如果是一个对象的话，那么也是一个新的对象。如果返回一个闭包的话，那么也是一个新的。

function box(config){
        var self = this;
        this.width = config.width;
        this.height = config.height;
        var defaultConfig = {
            width: "100",
            height:"100"
        }
        defaultConfig = $.extend(true, defaultConfig, config);
        var detail = {
            add:function(){
                defaultConfig.width++;
            },
            log:function(){
                alert(defaultConfig.width+"  "+defaultConfig.height);
            },
            domain:function(){
                alert(self.width+"  "+self.height);
            }
        }
        return detail;
    }

如果不用New的话，

var a = box(config);
    a.log();//200 300
    a.domain();//200 300
    var config = {
        width:2000,
        height:3000
    }
    var b = box(config);
    b.log();//2000 3000 
    b.domain();//2000 3000
    a.add();//200 300
    a.domain();//2000 3000

如果用New的话

var config = {
        width:200,
        height:300
    }
    var a = new box(config);
    a.log();//200 300
    a.domain();//200 300
    var config = {
        width:2000,
        height:3000
    }
    var b = new box(config);
    b.log();//2000 3000 
    b.domain();//2000 3000
    a.log();//200 300
    a.domain();//200 300  这里是主要的差别

　　还有一点需要注意的。

     随便写一个函数，函数中的this，指向window.

   因为总体就是一个window对象，

所以一个变量就是window.变量

所以一个函数就是window.函数

函数里边this，也是window. 但是var就不是了。