JavaScript学习笔————认识闭包的各种坑

闭包是js开发惯用的技巧，闭包指的是：可以访问到另一个函数局部变量的函数。可见闭包其实是一个函数；这个函数可以访问到其他函数的作用域。

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

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

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

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

对应内存存储：

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

        var a = 1;

        function fn() {
            var b = 2

            function fn1() {
                console.log(b)//2
            }
            fn1()
        }
        fn()

 

栈是一种先进后出的数据结构：

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参数对象。

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

坑点1： 引用的变量可能发生变化

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

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

       function outer() {
            var result = []
            for (var i = 0; i < 10; i++) {
                result[i] = (function (num) {
                    return function () {
                        console.log(num); // 此时访问的num，是上层函数执行环境的num，数组有10个函数对象，每个对象的执行环境下的number都不一样
                    }
                })(i)
                console.log(i);
            }
            return result
            console.log(result);
        }
    

坑点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 () {
                aler(el.id) // 这样会导致闭包引用外层的el，当执行完showId后，el无法释放
            }
        }

        // 改成下面
        function showId() {
            var el = document.getElementById("app")
            var id = el.id
            el.onclick = function () {
                aler(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：用闭包模仿块级作用域

for(var i=0;i<10; i++){
    console.log(i)
}
alert(i)  // 变量提升，弹出10

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