匿名函数:没有名字的函数;
闭包:可访问一个函数作用域里的变量的函数;
一 匿名函数
// 普通函数 function box(){ // 函数名是box; return 'lee'; } box(); // =>lee; 调用函数;// 匿名函数 function(){ // 匿名函数,会报错; return 'lee'; }// 通过表达式自我执行 (function(name){ console.log(name); // =>lee; })(lee); // ()表示执行函数,并且可以传参;// 把匿名函数赋值给变量 var box = function(){ // 将匿名函数赋给变量; return 'lee'; }; console.log(box()); // 调用方式和函数调用相似;// 函数里的匿名函数 function box(){ return function(name){ // 函数里的匿名函数,产生闭包; return name; }; }; console.log(box()(lee)); // 函数box()调用匿名函数,并传参;
二 闭包
闭包:有权访问另一个函数作用域中的变量的函数;
创建闭包的常见方式:在一个函数内部创建另一个函数;通过另一个函数访问这个函数的局部变量;
// 通过闭包可以返回局部变量 function box(){ var user = 'lee'; return function(){ // 通过匿名函数返回box()的局部变量user; return user; }; } console.log(box()()); // =>lee; 直接调用box()()来获得匿名函数的返回值; var b = box(); console.log(b()); // =>lee; 另一种调用匿名函数方式;// 优点:可以把局部变量驻留在内存中,可以避免使用全局变量; // (全局变量污染导致应用程序不可预测性,每个模块都可调用必将引来灾难;所以推荐使用私有的,封装的局部变量);
// 缺点:// 通过全局变量来累加 var age = 100; // 全局变量; function box(){ age++; // 模块级可以调用全局变量,进行累加; }; box(); // 执行函数,累加一次; console.log(age); // =>101; 输出全局变量; box(); // 执行函数,累加一次; console.log(age); // =>102; 输出全局变量;// 通过局部变量无法实现累加 function box(){ var age = 100; age++; // 实现累加; return age; } console.log(box()); // =>101; console.log(box()); // =>101; 无法实现累加,因为第二次调用函数时,函数内部变量age又被初始化了;// 通过闭包可以实现局部变量的累加 function box(){ var age = 100; return function(){ // 匿名函数内实现累加; age++; return age; // 并返回累加后的变量; }; // 此时box()函数的局部变量age的值已经被修改为累加后的值; } var b = box(); // 给box()函数赋值给变量; console.log(b()); // =>101; 调用匿名函数,累加一次; console.log(b()); // =>102; 第二次调用匿名函数,累加两次;// ps:由于闭包里作用域返回的局部变量资源不会被立刻销毁回收,所以可能会占用更多的内存;所以过度使用闭包会导致性能下降;(将闭包引用在私有作用域中即可实现变量销毁)// 作用域链的机制导致一个问题,在循环中里的匿名函数取得的任何变量都是最后一个值; ?
// 循环里包含匿名函数 function box(){ var arr = []; for(var i=0; i[function,function,function,function,function]; 得到函数box()返回的数组arr; console.log(b.length); // =>5; 得到函数集合数组长度; for(var i=0; i5,5,5,5,5; 输出每个函数的值,都是最后一个值; } // 上面的例子输出的结果都是5,也就是循环后得到的最大i值; // 因为b[i]调用的是匿名函数,匿名函数并没有自我执行,等到调用的时候,box()已执行完毕,i早已变成5;// 循环里包含匿名函数-改1,自我执行匿名函数 function box(){ var arr = []; for(var i=0; i[0,1,2,3,4]; 此时b代表box()返回的数组; for (var i = 0; i < b.length; i++) { console.log(b[i]); // 0 1 2 3 4; 这里返回的是数值; }; // 例子中,我们让匿名函数进行自我执行,导致最终返回给a[i]的是数组而不是函数了;最终导致b[0]-b[4]中保留了0,1,2,3,4的值;// 循环里包含匿名函数-改2,匿名函数里再做个匿名函数; function box(){ var arr = []; for(var i=0; iobject; // 也可以从上一个作用域中的得到对象 getuserfunction:function(){ var that = this; // 从对象的方法里得到this;此时that指向obj对象; return function(){ return that.user; } } console.log(obj.getuserfunction()()); // =>object;
四 内存泄漏
// 由于ie的jscript对象和dom对象使用不同的垃圾收集方式,因此闭包在ie中会导致内存泄漏问题,也就是无法销毁驻留在内存中的元素; function box(){ var odiv = document.getelementbyid('odiv'); // odiv用完之后一直驻留在内存中; odiv.onclick = function(){ alert(odiv.innerhtml); // 这里用odiv导致内存泄漏; }; odiv = null; // 解除引用; } box(); // 由于匿名函数保存了一个对box()的活动对象的引用,因此就会导致无法减少odiv的引用数; // 只要匿名函数存在,odiv的引用数至少也是1;因此它所占用的内存就永远不会被回收; // ps:如果没有使用解除引用,那么要等到浏览器关闭才得以释放;
五 模仿块级作用域(定义并立即调用一个匿名函数)
// js没有块级作用域的概念;// 这意味着在块语句(for语句/if语句)中定义的变量,实际上是在包含函数中而非语句中创建的; function box(count){ for(var i=0; i count=2; i=2时循环停止,此时i=2; console.log(i); // =>2; i不会因为离开了for块就失效; } box(2); function box(count){ for(var i=0; ibox is not defined; // 在全局作用域中使用块级作用域可以减少闭包占用的内存问题;因为没有指向匿名函数的引用 // 只要函数执行完毕,就可以立即销毁其作用域链了;
六 私有变量
// javascript没用私有属性的概念;所有的属性都是公用的;// 不过有一个私有变量的概念:在任何函数中定义的变量,都可以认为是私有变量,因为不能在函数外部访问这些变量;// 私有变量包括函数的参数/局部变量和在函数内部定义的其他函数; function box(){ var age = 100; // 私有变量,外部无法访问; }// 而通过内部创建一个闭包,那么闭包通过自己的作用域链也可以访问这些变量;// 而利用这一点,可以创建用于访问私有变量的公用方法;特权方法; function box(){ // 构造函数; var age = 100; // 私有变量; function run(){ // 私有函数; return '运行中...'; }; this.get = function(){ // 对外公共的特权方法; return age+run(); // 将闭包赋值给变量; }; } var box = new box(); console.log(box.get());// 可以通过构造方法传参来访问私有变量 function person(name){ var user = name; // 这句其实可以省略; this.getuser = function(){ return user; }; this.setuser = function(name){ user = name; } } var p = new person('lee'); console.log(p.getuser()); // =>lee; console.log(p.setuser('jack')); console.log(p.getuser()); // =>jack; // 但是,构造函数模式的缺点是针对每个实例都会创建同样一组新方法;而使用静态私有变量来实现特权方法就可以避免这个问题;
七 静态私有变量
// 通过块级作用域(私有作用域)中定义私有变量或函数,同样可以创建对外公共的特权方法; (function(){ // 创建私有作用域; var age = 100; // 静态私有变量; function run(){ return '运行中...'; }; box = function(){}; // 使用函数表达式定义构造函数; box.prototype.go = function(){ // 公有(特权)方法;在原型上定义的; return age+run(); }; })(); var box = new box(); console.log(box.go()); // 100运行中...;// 上面的对象声明,采用的是box = function(){}而不是functiong box(){};并且在声明box时没有使用var关键字// 导致:初始化未经声明的变量,总是会创建一个全局变量;因此,box就成了一个全局变量,能够在私有作用域之外被访问到;// 因为如果用函数声明定义构造函数,那么就变成私有函数了,无法在全局访问到了,所以要使用函数式定义构造方法; (function(){ var user = ; person = function(value){ // 此处定义的person是全局变量; user = value; // 这里的构造函数有权访问私有变量name; }; person.prototype.getuser = function(){ return user; }; person.prototype.setuser = function(value){ user = value; } })(); var person = new person(); person.setuser('lee'); console.log(person.getuser()); // =>lee;// 使用了prototype导致方法共享了,而user也就变成静态属性了;// 所谓静态属性:即共享于不同对象中的属性;?
八 模块模式
// 简言之,如果必须创建一个对象并以某些数据对其进行初始化,同时还要公开一些能够访问这些私有数据的方法,那么就可以使用模块模式;// 之前采用的都是构造函数的方式来创建私有变量和特权方法;// 那么对象字面量方式就采用模块模式来创建; var box = { // 字面量对象,也是单例对象:只有一个实例的对象; age:100, // 这是公有属性,将要改成私有; run:function(){ return '运行中...'; }; };// 模块模式私有化变量和函数: var box = function(){ var age = 100; function run(){ return '运行中...'; } return { // 将一个字面量对象作为函数的值返回; go:function(){ // 返回的对象字面量中只包含可以公开的属性和方法; return age+run(); // 由于这个对象是在匿名函数内部定义的,因此它的公有方法有权访问私有变量和函数; } }; // 从本质上讲,这个对象字面量定义的是单例的公共接口; }();// 这种模式在需要对单例进行某些初始化,同时又需要维护其私有变量时是非常有用的; // 上面直接返回对象的例子,也可以这么写: var box = function(){ var age = 100; function run(){ return '运行中...'; } var obj = { // 创建字面量对象; go:function(){ return age+run(); } }; return obj; // 返回刚创建的对象; }();// 字面量的对象声明,其实在设计模式中可以看作是一种单例模式;// 所谓单例模式,就是永远保持对象的只有一个实例;// 增强的模块模式:适合返回自定义对象,也就是构造函数; function desk(){}; var box = function(){ var age = 100; function run(){ return '运行中...'; }; var desk = new desk(); desk.go = function(){ return age+run(); }; return desk; }(); console.log(box.go()); // =>100运行中;
九 小结
在javascript编程中,函数表达式是一种非常有用的技术;使用函数表达式可以无须对函数命名,从而实现动态编程;
1.函数表达式
函数表达式不同于函数声明;函数声明要求有名字,但函数表达式不需要;
没有名字的函数表达式叫做匿名函数;2.闭包
当在函数内部定义了其他函数时,就创建了闭包.闭包有权访问包含函数内部的所有变量;原理如下:
在后台执行环境中,闭包的作用域链包含着它自己的作用域、包含函数的作用域和全局作用域；
通常，函数的作用域及其所有变量都会在函数执行结束后被销毁；
但是，当函数返回了一个闭包时，这个函数的作用域将会一直在内存中保存到闭包不存在为止；3.块级作用域
使用闭包可以在javascript中模仿块级作用域(javascript本身没有块级作用域的概念);要点如下:
创建并立即调用一个函数,这样既可以执行其中的代码,又不会在内存中留下对该函数的引用;
结果就是函数内部的所有变量都会被立即销毁--除非将某些变量赋值给了包含作用域(即外部作用域)中的变量;4.私有变量
闭包还可以用于在对象中创建私有变量,要点如下:
即使javascript中没有真是的私有对象属性的概念,但是可以使用闭包来实现公有方法,而通过公有方法可以访问包含作用域中定义的变量;
可以使用构造函数模式、原型模式来实现自定义类型的特权方法，也可以使用模块模式来实现单例的特权方法；