封装Car对象
var car=(function(){
var speed=0;
function set(s){
speed = s
}
function get(){
return speed
}
function speedUp(){
speed++
}
function speedDown(){
speed--
}
return {
set:set,
get : get,
speedUp:speedUp,
speedDown:speedDown
}
})()
car.set(30) //是对象的用法，返回的应该是对象，对象的返回值需要用函数
car.get()
car.speedUp()
car.speedDown()
car.get()
不能直接对speed进行操作，封装在一个包里，用函数去操作这个变量，这个变量就是局部变量了，car是全局变量，得不到释放，所以返回的对象得不到释放，所以对象应用的方法得不到释放，方法得不到释放，speed得不到释放，生成闭包。
如何连续输出0，1，2，3，4
原代码：
for(var i=0;i<5;i++){
setTimeout(function(){
console.log('delayer:'+i)
},0)
}
//"delayer:5"
"delayer:5"
"delayer:5"
"delayer:5"
"delayer:5"
setTimeout会把当前执行的加到任务队列里，for循环相当于设置了5个定时器，这时候i=5，再去执行。再说一次，for循环对于闭包，干扰更大，所以，实质上的影响不仅仅在于循环几次，最后要决定执行几次，还有这个i的值的影响。前面的闭包，尽量让i的赋值在函数内部的作用域，所以造了个闭包，并立即执行，i不需要引用for循环得到的i值。
如何利用呢？
for(var i=0;i<5;i++){
(function(j){
setTimeout(function(){
console.log('delayer:'+j)
},0)
})(i)
}
//"delayer:0" 又是立即执行的函数，这次i的赋值遵从for循环的取值，这是什么情况呢？
//就是循环时先把函数的变量i赋值，但是延时执行，for循环依然正常循环，虽然函数执行时，i已经是5了。
"delayer:1"
"delayer:2"
"delayer:3"
"delayer:4"
for(var i=0;i<5;i++){
(function(j){
setTimeout(function(){
console.log('delayer:'+j)
},10000 - 1000*j)
})(i)
}
//"delayer:4"
"delayer:3"
"delayer:2"
"delayer:1"
"delayer:0"
这里只是把定时器的顺序换了下，数字越大，延时越短，越靠前执行嘛。
for(var i=0;i<5;i++){
setTimeout(function(j){
return function(){
console.log('delayer:'+j)
}
}(i),0)
}
//"delayer:0"
"delayer:1"
"delayer:2"
"delayer:3"
"delayer:4"
定时器里的函数会立刻执行，跟上面的那个延时的不一样，上面的函数里有定时器啊，这个输出是立刻的。
执行过程中传递i，然后里面return的那个结果就是一个函数，setTimeout就能用这个函数，用的过程中，用到了j,中间加个临时变量存进去了，用到的时候，就从上一级去找，每当i赋值了，j=arguments[0]也拥有了值。
var makeCounter=function(){
var count = 0
return function(){
return count++
}
}
var counter = makeCounter()
var counter2=makeCounter()
console.log(counter()) //0
console.log(counter())//1
console.log(counter2())//0
console.log(counter2())//1
这里的意思，声明不一样的两个变量同时指向一个函数，通过作用后，两者得到了两个独立的作用域对象，互相不影响的。函数只是一种操作方法。
