匿名函数和闭包

//匿名函数和闭包
//普通函数
/*function box(){
return 'hehe';
}
alert(box());
//匿名函数
function (){
return 'hehe';//这里会报错，匿名函数是无法运行的，因为它没有名称是无法调用的
}
//把匿名函数赋值给变量
var box=function(){


return'leee';
};
alert(box);
alert(box());


//通过自我执行来执行匿名函数
(function(){//(匿名函数)（执行）
alert( 'hehe');
})();


var box=(function(){//把匿名函数自我执行的返回值赋值给变量
return 'leee';
})();
alert(box);


//自我执行后用alert（）打印
alert((function(){//(匿名函数)（执行）
return 'hehe';
})());


//自我执行函数的传参
(function(age){
alert(age);
})(100);


//函数里面放一个匿名函数
function box(){


return function(){//闭包
return 'lee';
};
}
alert(box()());




//函数里面放一个匿名函数
function box(){


return function(){//闭包
return 'lee';
};
}
var b=box();
alert(b());


//通过闭包返回局部变量
function box(){
var age=100;
return function(){
return age;
};
}


alert(box()());


//使用全局变量进行累加
var age=100;
function box(){
age++
}
alert(age);
box();
alert(age);
box();
alert(age);


//使用局部变量进行累加
function box(){
var age=100;
age++;
return age;
}
alert(box());//在这里只能执行一次，它不能实现累加，无论你执行多少次它都是101，因为你每次执行的时候它都重新初始化了。
alert(box());
alert(box());
alert(box());




//使用匿名函数实现驻留内存中从而累加
function box(){


var age=100;
return function(){
age++;
return age;
};
}
var b=box();
alert(b());
alert(b());
alert(b());


b=null;//解除引用，进行垃圾回收






//循环里的匿名函数的取值问题
function box(){
var arr=[];
for(var i=0;i<5;i++){
arr[i]= function(){//arr[0]=0.......arr[4]=4
return i;
};
//循环已经执行完毕了，i最终是4，然后在++就是5了了
}
return arr;
}
//alert(box()[]);
var b=box();
for(var i=0;i<5;i++){
alert( b[i]());
}




//改0
function box(){
var arr=[];
for(var i=0;i<5;i++){
arr[i]= i;
};


return arr;
}
var b=box();
for(var i=0;i<5;i++){
alert( b[i]);
}




//改1
function box(){
var arr=[];
for(var i=0;i<5;i++){
arr[i]=(function(num){//通过自我执行及时执行匿名函数
return function(){//因为闭包可以将变量驻留在内存中，和上一节课的累加是一个道理
return num;
};
})(i);
}
//已经执行完毕了为啥可以1,2,3,4呢


return arr;
}
var b=box();
for(var i=0;i<5;i++){
alert( b[i]());
}




function box(){
var arr=[];
for(var i=0;i<5;i++){
arr[i]=(function(num){//通过自我执行及时执行匿名函数赋给一个变量（）（）第一个圆括号可以去掉。
return function(){//因为闭包可以将变量驻留在内存中，和上一节课的累加是一个道理
return num;
};
})(i);
}
//已经执行完毕了为啥可以1,2,3,4呢


return arr;
}
var b=box();
for(var i=0;i<5;i++){
alert( b[i]());
}




//关于this对象
var box={
getThis:function(){
return function(){
return this;
};
}
};
alert(box.getThis()());




//闭包在运行时指向的是window
var user='The Window';
var box={
user:'The Box',
getUser:function(){
//这里的作用域是box
var that=this;//把box的作用域交下面的就行了
return function(){
//这里的作用域是window
return that.user;
};
}


};
alert(user);
//对象冒充
alert(box.getUser().call(box));
//
alert(box.getUser()());


function box(){
var odiv=document.getElementById('odiv');
var text=odiv.innerHTML;
odiv.onclik=function(){
alert (text);
};
odiv=null;//解除引用等待垃圾回收
}
box();


*/
//模仿块级作用域（js没有块级作用域）
/*function box(){
for(var i=0;i<5;i++){}


alrt(i);
}
box();




function box(){
for(var i=0;i<5;i++){}
var i;//就算重新声明，也不会影响之前初始化声明的数据
alrt(i);
}
box();




function box(){
(function(){//包含自我执行的匿名函数，就可以实现私有作用域
for(var i=0;i<5;i++){
alert(i);
}
//这里面可以用ABC等变量
})();//出了这个作用域变量就会被立即销毁


//这里可以继续使用abc等变量，和上面的完全没有联系
alrt(i);//这里就不认识了
}
box();




//全局变量
var age=100;
alert(age);
 age=null;
alert(age);




//用私有作用域来限制这个全局
(function(){
var age=100;//私有变量
alert(age);


})();
alert(age);//ps这里是不会执行的






function Box(){


this.name=100;//属性，它是公有的
this.run=function(){//方法，它也是公有的
return '运行中。。。。。。';
};
}
var box=new Box();
alert(box.age);
alert(box.run());




function Box(){


var age=100;//私有变量
function run(){//私有函数
return '运行中';
}
this.publicGo=function(){//对外可见的公共接口，特权方法
return age+run();
};
this.getAge=function(){
return age;
};
}
var box=new Box();
alert(box.publicGo());
alert(box.getAge());




//通过构造函数传参
function Box(value){
var user=value;
this.getUser=function(){//方法没有共享
return user;
};
}
var box=new Box('lee');
alert(box.getUser());


var box1=new Box('1212');
alert(box1.getUser());




function Box(value){
var user=value;
this.getUser=function(){
return user;
};
this.setUser=function(value){
 user=value;
};
}
var box=new Box('lee');
alert(box.getUser());


var box1=new Box('1212');
alert(box1.getUser());
 box.setUser('hahha');
 alert(box.getUser());


(function(){
var user='';//私有变量
Box=function(value){//全局构造函数
user=value;
};
Box.prototype.getUser=function(){//通过原型方法来实现共享


return user;
}
})();


var box=new Box('lee');
alert(box.getUser());


var box1=new Box('1212');
alert(box.getUser())




//模块模式
//什么叫做单例，就是永远只实例化一次，其实就是字面量对象声明方式
var box={//第一次实例化，无法第二次实例化，那么就是单例
user:'hehe',
run:function(){
return '运行中';
}
};




var box=function(){
var user='haha';//私有变量
function run(){//私有函数
return 'yunxing';
}
return {
publicGo: function(){//对外公关接口的特权方法
return user+run();
}


};
}();
alert(box.publicGo())




var box=function(){
var user='haha';//私有变量
function run(){//私有函数
return 'yunxing';
}
var obj= {
publicGo: function(){//对外公关接口的特权方法
return user+run();
}


};
return obj;
}();
alert(box.publicGo())




//之前两个都是返回的{}，都是Object,那么我想返回自定义的呢？
function Desk(){}
var box=function(){
var user='haha';//私有变量
function run(){//私有函数
return 'yunxing';
}
var desk=new Desk();
desk.publicGo=function(){
return user+run();
};


return desk;
}();
alert(box.publicGo())








*/