闭包与回调

最新推荐文章于 2022-11-16 09:00:00 发布

bigMonsterInIAm

最新推荐文章于 2022-11-16 09:00:00 发布

阅读量144

点赞数

分类专栏：闭包与回调

闭包与回调专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、闭包

闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。

闭包有三个特性：

1.函数嵌套函数;

2.函数内部可以引用外部的参数和变量;

3.参数和变量不会被垃圾回收机制回收。

闭包是指有权访问另一个函数作用域中的变量的函数，创建闭包的最常见的方式就是在一个函数内创建另一个函数，通过另一个函数访问这个函数的局部变量。使用闭包有一个优点，也是它的缺点，就是可以把局部变量驻留在内存中，可以避免使用全局变量。全局变量在每个模块都可调用，这势必将是灾难性的。所以推荐使用私有的，封装的局部变量。一般函数执行完毕后，局部活动对象就被销毁，内存中仅仅保存全局作用域。但闭包的情况不同！

示例一：

//闭包就是一个函数的返回值为另外一个函数，在outer外部可以通过这个返回的函数访问outer内的局部变量.

 
         function 
         outer(){ 
        
         var 
         val = 0; 
        
         return 
         function 
         (){ 
        
         val += 1; 
        
         document.write(val +  
         "<br />" 
         ); 
        
         }; 
        
         } 
        
         var 
         outObj = outer(); 
        
         outObj(); 
         //1，执行val += 1后，val还在 
        
         outObj(); 
         //2 
        
         outObj =  
         null 
         ; 
         //val 被回收 
        
         var 
         outObj1 = outer(); 
        
         outObj1(); 
         //1 
        
         outObj1(); 
         //2

闭包会使变量始终保存在内存中，如果不当使用会增大内存消耗（如果上例中定义很多outer()，则内存中会保存很多val变量）。

javascript的垃圾回收原理：

（1）、在javascript中，如果一个对象不再被引用，那么这个对象就会被GC回收；

（2）、如果两个对象互相引用，而不再被第3者所引用，那么这两个互相引用的对象也会被回收。

那么使用闭包有什么好处呢？使用闭包的好处是：

1.希望一个变量长期驻扎在内存中

2.避免全局变量的污染

3.私有成员的存在

二、回调

回调函数原理：我现在出发，到了通知你”。这是一个异步的流程，“我出发”这个过程中（函数执行），“你”可以去做任何事，“到了”（函数执行完毕）“通知你”（回调）进行之后的流程。

示例一：

1

2

3

4

5

6

7

 
         function 
         doSomething(callback){ 
        
         callback(1,2); 
        
         } 
        
         function 
         numberAdd(a,b){ 
        
         document.write(a+b); 
        
         } 
        
         doSomething(numberAdd); 
         //3

示例二：

1

2

3

 
         function 
         Thing(name){ 
        
         this 
         .name = name; 
        
         }

//在Thing类里加入doSomething方法，这里使用了构造器调用模式

 
         Thing.prototype.doSomething =  
         function 
         (callback){ 
        
         callback( 
         this 
         .name); 
        
         }; 
        
         function 
         showName(name){ 
        
         document.write(name); 
        
         } 
        
         var 
         t =  
         new 
         Thing( 
         "zhangsan" 
         ); 
        
         t.doSomething(showName); 
         //zhangsan

如果你有一个数字组成的数组，你想写个排序的公共方法，但是排序方式（从小到大或从大到小）是调用该排序方法的人决定。实现该排序方法可以用回调来实现，当然你可以写2个方法，一个是从小到大的排序，一个是从大到小的排序方法。回调个人认为就是将决定权交给了实际业务开发工程师，由他来决定怎么去处理，这种思路跟我们平常接触的不同，有点不习惯，但是这种思路在异步编程中特别能看出它的好处，不知道我这么理解是否正确。下面示例代码就是回调的典型使用场合：

 
         var 
         arr = [25,13,33,8,23,32]; 
        
         Array.prototype.sort =  
         function 
         (callback){ 
        
         var 
         arr =  
         this 
         ; 
        
         var 
         i = 0; 
         //i在这里定义与在for循环的括号内（for(var i = 0; i < ...)）定义是一样的 
        
         for 
         (; i < arr.length-1; i++){ 
        
         var 
         j = i + 1; 
        
         for 
         (; j < arr.length;j++){ 
        
         if 
         (callback(arr[i],arr[j])){ 
        
         var 
         temp = arr[i]; 
        
         arr[i] = arr[j]; 
        
         arr[j] = temp; 
        
         } 
        
         }  
        
         } 
        
         return 
         arr; 
        
         }; 
        
         //a-b>0表示数组从小到大排序 
        
         arr.sort( 
         function 
         (a,b){ 
        
         return 
         a - b > 0; 
        
         }); 
        
         document.write(arr.join( 
         "," 
         ) +  
         "<br />" 
         ); 
         //8,13,23,25,32,33 
        
         //b-a>0表示数组从大到小排序 
        
         arr.sort( 
         function 
         (a,b){ 
        
         return 
         b - a > 0; 
        
         }); 
        
         document.write(arr.join( 
         "," 
         )); 
         //33,32,25,23,13,8