闭包和匿名函数

//普通函数
function box() {

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

//匿名函数
function () {



//单独的匿名函数，是无法运行的

return 'Lee';


//就算能运行，也无法调用，因为没有名称
}

//把匿名函数赋值给变量
var box = function () {

return 'Lee';
};

alert(box());


//通过自我执行来执行匿名函数
(function () {




//(匿名函数)();
第一圆括号放匿名函数，第二个圆括号执行

alert('Lee');
})();


(function () {

alert('Lee');
})();


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

return 'Lee';
})();

alert(box);

//自我执行后用alert()打印
alert((function () {

return 'Lee';
})());

//自我执行匿名函数的传参

(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());
alert(box());
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());
alert(b());
//alert(age);
b = null;


//解除引用，等待垃圾回收
alert(b());



//循环里的匿名函数的取值问题

function box() {

var arr = [];



for (var i = 0; i < 5; i ++) {


arr[i] = function () {




//arr[0] = 0，arr[1] = 1 .... arr[4] = 4



return i;


};

}



//循环已经执行完毕了，i最终是4++ = 5 ,那么最终就是5



return arr;
}

//alert(box()[0]);
var b = box();
//alert(b.length);
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 num;


})(i);

}



return arr;
}

var b = box();
for (var i = 0; i < 5; i ++) {

alert(b[i]);
}

//改2
function box() {

var arr = [];



for (var i = 0; i < 5; i ++) {


arr[i] = (function (num) {



//num其实在这里




return function () {



//因为闭包可以将变量驻留在内存中，和上一节课的累加是一个道理




return num;



}


})(i);

}



//已经执行完毕了，num为什么可以0,1,2,3,4



return arr;
}

var b = box();
for (var i = 0; i < 5; i ++) {

alert(b[i]());
}
var b = function () {

alert('Lee');
}();


function box() {

var arr = [];



for (var i = 0; i < 5; i ++) {


arr[i] = function (num) {



return function () {



//因为闭包可以将变量驻留在内存中，和上一节课的累加是一个道理




return num;



}


}(i);

}



//已经执行完毕了，num为什么可以0,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()());


var user = 'The Window';

var box = {

user : 'The Box',

getUser : function () {


//这里作用域的this是Box


var that = this;


return function () {



//这里作用域的this是window



return that.user;


}

}
};

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



function box() {

var oDiv = document.getElementById('oDiv');

var text = oDiv.innerHTML;

oDiv.onclick = function () {


alert(text);

};

oDiv = null;




//解除引用，等待垃圾回收

alert(oDiv);
}
box();


//块级作用域(私有作用域)

function box() {

for (var i = 0; i < 5; i ++) {


//块级作用域(JS没这个东西)




}

alert(i);
}

box();

function box() {

for (var i = 0; i < 5; i ++) {


//块级作用域(JS没这个东西)




}

var i = 111;




//就算重新声明，也不会影响之前声明初始化的数据

alert(i);
}

box();

//使用块级作用域(私有作用域)

function box() {

(function () {







//包含自我执行的匿名函数，就可以实现私有作用域


for (var i = 0; i < 5; i ++) {





alert(i);


}


// 这里面用了a,b,c等变量

})();

被销毁了




//这里可以继续似乎用a,b,c等变量，和上面的a,b,c完全没有联系

//出了这个私有作用域，变量立即被销毁

alert(i);







//这里就不认识了
}

box();

//全局变量

var age = 100;

alert(age);

age = null;

//私有作用域来表示

(function () {

//这里就是全局的私有作用域

var age = 100;

alert(age);
})();



(function () {

var a;

var b;
})():


//私有变量

function box() {

var age = 100;


//私有变量
}

box();

function Box() {

this.age = 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.getAge());

//通过构造函数传参

function Box(value) {

var user = value;



//私有变量

this.getUser = function () {


return user;

};
}

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

var box2 = new Box('kkk');
alert(box.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());
box.setUser('OOO');
alert(box.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 box2 = new Box('kkk');
alert(box.getUser());

(function () {

var user = ''



//私有变量

//function Box() {}

//构造函数，但在函数里写构造函数，不支持，因为私有作用域里的函数，外部无法访问

Box = function (value) {//全局，构造函数


user = value;

};

Box.prototype.getUser = function () {


return user;

};

Box.prototype.setUser = function (value) {


user = value;

}
})();

var box = new Box('Lee');

//第一次实例化
alert(box.getUser());
var box2 = new Box('kkk');

//第二次实例化
alert(box.getUser());
box2.setUser('OOO');
alert(box.getUser());

//什么叫单例，就是永远只实例化一次，其实就是字面量对象声明方式

var box = {




//第一次实例化，无法第二次实例化，那么就是单例

user : 'Lee',

run : function () {


return '运行中..';

}
};


var box = function () {

var user = 'Lee';



//私有变量

function run() {



//私有函数


return '运行中...';


}

return {


publicGo : function () {

//对外公共接口的特权方法



return user + run();


}

};
}();

alert(box.publicGo());


var box = function () {

var user = 'Lee';



//私有变量

function run() {



//私有函数


return '运行中...';


}

var obj = {


publicGo : function () {

//对外公共接口的特权方法



return user + run();


}

};

return obj;
}();

alert(box.publicGo());

//之前两个，都是返回的{} 也就是Object，那么我想返回自定义的呢？Box，Desk



function Desk() {}


var box = function () {

var user = 'Lee';



//私有变量

function run() {



//私有函数


return '运行中...';


}

var desk = new Desk();

desk.publicGo = function () {


return user + run();

};

return desk;
}();


alert(box.publicGo());