彻底搞懂JS闭包各种坑

不念不忘少年蓝@ 2022-12-21 04:57 91阅读 0赞

转载自简书博主：[https://www.jianshu.com/p/26c81fde22fb][https_www.jianshu.com_p_26c81fde22fb] 仅供学习用途

闭包是js开发惯用的技巧，什么是闭包？**闭包指的是：能够访问另一个函数作用域的变量的函数**。清晰的讲：闭包就是一个函数，这个函数能够访问其他函数的作用域中的变量。eg:

function outer() {
         var  a = '变量1'
         var  inner = function () {
                console.info(a)
         }
        return inner    // inner 就是一个闭包函数，因为他能够访问到outer函数的作用域
    }

很多人会搞不懂匿名函数与闭包的关系，实际上，闭包是站在作用域的角度上来定义的，因为inner访问到outer作用域的变量，所以inner就是一个闭包函数。虽然定义很简单，但是有很多坑点，比如this指向、变量的作用域，稍微不注意可能就造成内存泄露。我们先把问题抛一边，思考一个问题：**为什么闭包函数能够访问其他函数的作用域** ?

从堆栈的角度看待js函数  
　　基本变量的值一般都是存在栈内存中，而对象类型的变量的值存储在堆内存中，栈内存存储对应空间地址。基本的数据类型: Number 、Boolean、Undefined、String、Null。

var  a = 1   //a是一个基本类型
    var  b = {m: 20 }   //b是一个对象

对应内存存储：

![756e14ef56e0ab8dca2a7aff761619c6.webp][]

当我们执行 b=\{m:30\}时，堆内存就有新的对象\{m：30\}，栈内存的b指向新的空间地址( 指向\{m：30\} )，而堆内存中原来的\{m：20\}就会被程序引擎垃圾回收掉，节约内存空间。我们知道js函数也是对象，它也是在堆与栈内存中存储的，我们来看一下转化：

var a = 1;
    function fn(){
        var b = 2
        function fn1(){
            console.log(b)
        }
        fn1()
    }
    fn()

![03897f840421fe9a7b9ad505ba69267c.webp][]

\*\*  
栈是一种先进后出的数据结构：  
1 在执行fn前，此时我们在全局执行环境(浏览器就是window作用域)，全局作用域里有个变量a；  
2 进入fn，此时栈内存就会push一个fn的执行环境，这个环境里有变量b和函数对象fn1，这里可以访问自身执行环境和全局执行环境所定义的变量  
3 进入fn1，此时栈内存就会push 一个fn1的执行环境，这里面没有定义其他变量，但是我们可以访问到fn和全局执行环境里面的变量，因为程序在访问变量时，是向底层栈一个个找，如果找到全局执行环境里都没有对应变量，则程序抛出underfined的错误。

4 随着fn1()执行完毕，fn1的执行环境被杯销毁，接着执行完fn()，fn的执行环境也会被销毁，只剩全局的执行环境下，现在没有b变量，和fn1函数对象了，只有a 和 fn(函数声明作用域是window下)  
\*\*

在函数内访问某个变量是根据函数作用域链来判断变量是否存在的，而函数作用域链是程序根据函数所在的执行环境栈来初始化的，所以上面的例子，我们在fn1里面打印变量b，根据fn1的作用域链的找到对应fn执行环境下的变量b。所以**当程序在调用某个函数时，做了一下的工作：准备执行环境，初始函数作用域链和arguments参数对象**

我们现在看回最初的例子outer与inner

function outer() {
         var  a = '变量1'
         var  inner = function () {
                console.info(a)
         }
        return inner    // inner 就是一个闭包函数，因为他能够访问到outer函数的作用域
    }
    var  inner = outer()   // 获得inner闭包函数
    inner()   //"变量1"

当程序执行完var inner = outer()，其实outer的执行环境并没有被销毁，因为他里面的变量a仍然被被inner的函数作用域链所引用，当程序执行完inner(), 这时候，inner和outer的执行环境才会被销毁调；《JavaScript高级编程》书中建议：由于闭包会携带包含它的函数的作用域，因为会比其他函数占用更多内容，过度使用闭包，会导致内存占用过多。

--------------------

现在我们明白了闭包，已经对应的作用域与作用域链，回归主题：  
**坑点1： 引用的变量可能发生变化**

function outer() {
          var result = []
          for (var i = 0;i<10;i++){
            result[i] = function () {
                console.info(i)
            }
         }
         return result
    }

看样子result每个闭包函数对打印对应数字，1,2,3,4,...,10, 实际不是，因为每个闭包函数访问变量i是outer执行环境下的变量i，随着循环的结束，i已经变成10了，所以执行每个闭包函数，结果打印10， 10， ..., 10  
怎么解决这个问题呢？

**坑点2: this指向问题**

var object = {
         name: "object",
         getName: function() {
            return function() {
                 console.info(this.name)
            }
        }
    }
    object.getName()()    // underfined
    // 因为里面的闭包函数是在window作用域下执行的，也就是说，this指向windows

**坑点3：内存泄露问题**

function  showId() {
        var el = document.getElementById("app")
        el.onclick = function(){
          alert(el.id)   // 这样会导致闭包引用外层的el，当执行完showId后，el无法释放
        }
    }
    
    // 改成下面
    function  showId() {
        var el = document.getElementById("app")
        var id  = el ? el.id : null
        el.onclick = function(){
          alert(id) 
        }
        el = null    // 主动释放el
    }

**技巧1： 用闭包解决递归调用问题**

function  factorial(num) {
       if(num<= 1) {
           return 1
       } else {
          return num * factorial(num-1)
       }
    }
    var anotherFactorial = factorial
    factorial = null
    anotherFactorial(4)   // 报错 ，因为最好是return num* arguments.callee（num-1），arguments.callee指向当前执行函数，但是在严格模式下不能使用该属性也会报错，所以借助闭包来实现
    
    
    // 使用闭包实现递归
    function newFactorial = (function f(num){
        if(num<1) {return 1}
        else {
           return num* f(num-1)
        }
    }) //这样就没有问题了，实际上起作用的是闭包函数f，而不是外面的函数newFactorial

\*\* 技巧2：用闭包模仿块级作用域\*\*  
es6没出来之前，用var定义变量存在变量提升问题，eg:

for(var i=0;i<10; i++){
        console.info(i)
    }
    alert(i)  // 变量提升，弹出10
    
    //为了避免i的提升可以这样做
    (function () {
        for(var i=0; i<10;i++){
             console.info(i)
        }
    })()
    alert(i)   // underfined   因为i随着函数的退出，执行环境销毁，变量回收

当然现在大多用es6的let 和const 定义。

作者：下一站深圳  
链接：https://www.jianshu.com/p/26c81fde22fb  
来源：简书  
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

[https_www.jianshu.com_p_26c81fde22fb]: https://www.jianshu.com/p/26c81fde22fb
[756e14ef56e0ab8dca2a7aff761619c6.webp]: /images/20221120/6d59f69f399649b3b0c4267b9bd30ac7.png
[03897f840421fe9a7b9ad505ba69267c.webp]: https://img-blog.csdnimg.cn/img_convert/03897f840421fe9a7b9ad505ba69267c.webp