闭包的原理及其作用

闭包原理

1. 闭包的概念
   红宝书：闭包指的是那些引用了另一个函数作用域中变量的函数，通常是在嵌套函数中实现的。
   MDN：一个函数和对其周围状态（lexical environment，词法环境）的引用捆绑在一起（或者说函数被引用包围），这样的组合就是闭包（closure）。也就是说，闭包让你可以在一个内层函数中访问到其外层函数的作用域。在 JavaScript 中，每当创建一个函数，闭包就会在函数创建的同时被创建出来。

2. 闭包的原理

   举个例子:

    function createComparisonFunction(propertyName){
        return function(object1,object2){
            let value1=object1[propertyName];
            let value2=object2[propertyName];
            if(value1<value2){
                return -1;
            }else if(value1>value2){
                return 1;
            }else{
                return 0;
            }
        }
    }

    在内部的匿名函数中，引用了外部函数的变量propertyName。因为内部函数的**作用域链**包含createComparisonFunction（）函数的作用域链，所以它始终保持对外部函数中变量propertyName的**引用**。

    一般情况下，变量取值到 创建 这个变量 的函数的作用域中取值。但是如果在当前作用域中没有查到值，就会向上级作用域去查，直到查到全局作用域，这么一个查找过程形成的链条就叫做作用域链。在调用一个函数时，会为这个函数调用创建执行上下文，并创建一个作用域链。然后用arguments和其他命名参数来初始化这个函数的活动对象。外部函数的活动对象是内部函数作用域链上的第二个对象。这个作用域链一直向外串起所有包含函数的活动对象，直到全局执行上下文终止。

一个一般函数的作用域链。举个例子。

    function compare(value1,value2){
        if(value1<value2){
                return -1;
            }else if(value1>value2){
                return 1;
            }else{
                return 0;
            }
    }
    let result=compare(5,10);

假设在全局中调用compare()，图展示了其执行后的结果.在第一次调用compare()时，会为它创建一个包含arguments、value1和value2的活动对象，这是其作用域链上的第一个对象。全局上下文的变量对象是作用域链上的第二个对象，其中包含this、result和compare。函数内部的代码访问变量时，就会使用给定的名称从作用域链中查找变量。函数执行完毕后，局部的活动对象会被销毁，内存中就只剩下全局作用域。
闭包的情况就不一样了。

    function createComparisonFunction(propertyName){
        return function(object1,object2){
            let value1=object1[propertyName];
            let value2=object2[propertyName];
            if(value1<value2){
                return -1;
            }else if(value1>value2){
                return 1;
            }else{
                return 0;
            }
        }
    }
    let compare=createComparisonFunction('name');
    let result=compare({name:'Nicholas'},{name:'Matt'});

内部的匿名函数会向外搜索变量，函数外部的变量是对函数内部可见的。在createComparisonFunction()中，匿名函数的作用域链包含了createComparisonFunction()函数中的活动对象。如图所示。
在createComparisonFunction()返回匿名函数后，其作用域链被初始化为包含createComparisonFunction()的活动对象和全局变量对象。带来的副作用是：createComparisonFunction()活动对象不能在它执行完毕后销毁，因为匿名函数的作用域链中仍然会有对它的引用。在createComparisonFunction()执行完毕后其执行上下文的作用域链会被销毁，但是它的活动对象仍然会被保留在内存中，直到匿名函数被销毁才会被使用。所以不能滥用闭包，容易造成内存泄漏。

闭包的作用

1. 记忆性
   当闭包产生式，函数所处环境的状态会始终保持在内存中，不会再外层函数调用后被自动清除，这就是闭包的记忆性。
   使用闭包的记忆性来实现体温检测是否合格的真实业务场景:如下
   ·创建一个体温检测函数checkTemp(userTemp)，可以检查体温是否正常，函数会被返回体温检测结果
   ·但，不同的小区有不同的体温检测标准:
   ·比如:A小区体温合格线是37.5℃，而B小区体温合格线是37.0℃。具体代码实现如下:

    function creatCheckTemp(standardTemp){
        function checkTemp(userTemp){
            if(userTemp<=standardTemp){
                console.log('你的体温正常：小于等于'+standardTemp);
            }else{
                console.log('你的体温异常：大于'+standardTemp);
            }
        }

        return checkTemp;
    }

    var checkTempA=creatCheckTemp(37.5);
    var checkTempB=creatCheckTemp(37.0);

    checkTempA(37.7);
    checkTempA(37.4);

    checkTempB(37.4);
    checkTempB(37.0);

输出结果：

你的体温异常：大于37.5
你的体温正常：小于等于37.5
你的体温异常：大于37
你的体温正常：小于等于37

2. 模拟私有变量和私有方法
   可以使用闭包来模拟私有方法。私有方法不仅仅有利于限制对代码的访问：还提供了管理全局命名空间的强大能力，避免非核心的方法弄乱了代码的公共接口部分。举个例子：

    function personInf() {
        var name = '李雷';
        var age = 18;
        function ageChange(val) {
            age += val;
        }
        return {
            getName: function () {
                return name;
            },
            setName: function (newName) {
                name = newName;
                return name;
            },
            ageIncrement:function(){
                ageChange(1);
            },
            getAge:function(){
                return age;
            }
        }
    }
    var name='韩梅梅';
    console.log(name);
    console.log(person.age);
    var person=personInf();
    console.log(person.getName());
    console.log(person.setName('爱写信的李华'));
    person.ageIncrement();
    console.log(person.getAge());

韩梅梅//避免了全局污染 避免了命名冲突 全局变量和personInf（）里面的变量都叫name，但是相互没有影响
undefined//这句将会报错，不能直接获取到私有变量
李雷//通过getName()方法获取到person的name
爱写信的李华
19

这跟Java中的变量私有化很相似：

public class Student {
    String name;
    private int age;
    //设置设置私有化变量,此时必须设置成公有public
    public void setAge(int a){
        age = a;
    }
    
    //设置获得私有化变量 ,此时必须设置成公有public
    public int getAge(){
        if (age<0){
            return false;}
        return age;
    }
 
    //方法私有化
    private String getname(){
      return name;}

参考资料

这个博主的帖子写的很详细
你不知道的闭包原理
闭包的应用场景
闭包的九大使用场景