闭包 我的理解是 能够有权访问另一个函数作用域中变量的函数
通常我们知道 普通的函数在调用完成之后，活动对象不会从内存中销毁，其执行环境的作用域链会被销毁，造成资源的浪费 而闭包的好处就在于执行完就会被回收 不会造成资源的极大的浪费 性能也会相应的提升~
闭包的几种写法
//当只有一个返回的内部函数时候 //第一种写法
function test1(a,b){ return function(c){
console.log(a + b + c);
} }
var m1 = test1(2,4);
m1(5); //输出 11 //第二种写法 function test2(a,b){
var name = 'xsdsfsfsdxcxcx'; function xx(c){
console.log(a + b + c);
}
return xx;
}
var m2 = test2(2,4);
m2(5); //输出 11
若有多个需要返回的内部函数 可使用对象的方法一一列举出来 又称模块模式
// 多个返回的内部函数
function test2(a,b){
var name = 'xsdsfsfsdxcxcx'; function xx(c){
console.log(a + b + c);
}
function ss(){
// js中replace默认只替换查找到的第一个值 若要替换多个值需要使用正则
var _replace = name.replace('x','aa');
console.log(_replace);
}
function allReplace(){
var re = /x/g;
var _replace = name.replace(re,'X');
console.log(_replace);
}
return {
xx : xx,
ss : ss,
allReplace: allReplace
}
}
var m2 = test2(2,4);
m2.ss(); //输出 aasdsfsfsdxcxcx
m2.xx(3); //输出 9
m2.allReplace(); //输出 XsdsfsfsdXcXcX
简单的案例看下 静态方法和实例方法的区别
1 var test1 = function(){
2
3 }
4 test1.Show = function(){
5 alert('静态方法！');
6 }
7 test1.prototype.Display = function(){
8 alert('实例方法！');
9 }
10
11 test1.Show(); //静态方法 只能直接用类名进行调用 不能使用this
//函数才有prototype属性 对象是没有的
12 test1.Display(); //报错 这是一个是实例方法 必须先实例化后才能进行调用
13
14
15 var Demo = new test1();
16 Demo.Display(); //实例方法
再来看一段代码
var dom = function(){
var Name = "Default";
this.Sex = "Boy";
this.success = function(){
alert("Success");
};
};
alert(dom.Name); //undefined 这是因为每个function都会形成一个作用域 而这些变量声明在函数中 所以就处于这个函数的作用域中 外部是无法访问的 必须new一个实例
alert(dom.Sex); //undefined
再来一段代码
var html = {
Name:'Object',
Success:function(){
this.Say = function(){
alert("Hello,world");
};
alert("Obj Success");
}
};
//html是一个对象，不是函数，所以没有Prototype属性，其方法也都是公有方法，html不能被实例化。
//我们可以这样使用它 html.Name 和 html.Success()
//当然我们也可以将这个对象作为一个值赋给其他变量 比如 var a = html
那么问题来了 我们该如何访问Success方法中的Say方法呢 难道是html.Success.Say()吗？ 当然这样式错误的啦 因为在Say方法中又开始了一个新的function形成新的作用域 肯定是访问不到里面的内容啦
得做点修改 比如
1 var s = new html.Success();
2 s.Say(); //Hello,world
3
4
5 //或者写在外面
6 html.Success.prototype.Show = function(){
7 alert("HaHa");
8 };
9 var s = new html.Success();
10 s.Show();
说了这么多 那么闭包的用途到底是什么呢？
事实上通过使用闭包 我们可以做很多事情 比如模拟面向对象的代码风格 更优雅 更简洁的表达出代码 这是一个有点追求美感的程序员应该做的 而且在某些方面可以提升代码的执行效率
1 匿名自执行函数
var data = {
arr : [2,5,2,4,333],
tree : {}
}
(function(x){
var row,
new_arr = [];
for(var i = 0; i < x.arr.length; i ++){
row = x.arr[i];
new_arr.push(row);
}
return new_arr;
})(data) //输出 [2,5,2,4,333]
创建了一个匿名函数 并立即执行 由于外部无法直接访问内部的变量 因此在函数执行完成后会立刻释放资源 还不会污染全局变量
2 缓存作用
将计算结果缓存在内部 之后再调用的话就可以直接使用
3 封装
var package = function(){
var name = '张三';
return {
getName : function(){
return name;
},
setName : function(names){
name = names;
return name;
}
}
}();
package.getName(); //张三
package.setName('李四'); // 李四
package.name; //undefined
4 类和继承
function Mother(){
var eye = 'default';
return {
getName : function(){
return eye;
},
setName : function(newName){
name = newName;
return name;
}
}
}
var M = new Mother();
M.getName();
M.setName('beautiful!');
var Person = function(){
}
//继承
Person.prototype = M;
Person.prototype.Say = function(){
console.log('这是私有方法！');
}
var p = new Person();
p.getName();
p.setName('hah');
p.Say();