2020-6：闭包（JavaScript）

闭包：作用域应用的特殊情况，

有2种表现

1.函数作为返回值被返回

        // 函数作为返回值
        
        function create(){
            const a = 100
            return function(){
                console.log(a)
            }
        }

        const fn = create()
        const a = 200
        
        fn() // 100
     

2.函数作为参数被传递

        // 函数作为参数被传递
        function print(fn){
            const a = 200
            fn()
        }
        const a = 100
        function fn(){
            console.log(a)
        }
        print(fn) // 100

        // 注：所有的自由变量的查找，是在函数定义的地方，向上级作用域查找，而不是在执行的地方

---

闭包：重用变量同时保护变量不被污染的机制。

外层函数被调用后，外层函数的作用域对象（因为被内层函数引用着）无法释放，则会产生闭包。
缺点在于不会自动释放，只能手动释放，易造成内存泄露，从而比普通函数占用更多的空间

    let funs = []
    for(let i = 0; i < 3; i++){
      funs[i] = (function(i){
        // 注意此处是按值传递
        return function(){
          console.log('i:',i)
        }
      })(i)
    }
    /* 执行后形成闭包
    funs = [
      function(){ (i=0)
        console.log('i:',i)
      },
      function(){ (i=1)
        console.log('i:',i)
      },
      function(){ (i=2)
        console.log('i:',i)
      },
    ]
    */
    funs[0]() // 0
    funs[1]() // 1
    funs[2]() // 2

    function fun(){
      for(let i = 0,arr = []; i < 3; i++){
        arr[i] = function(){
          console.log('i',i)
        }
      }
      return arr
    }
    let funs1 = fun()
    /*
    外层函数被调用1次，执行后形成一个闭包
    */
    funs1[0]() // 3
    funs1[1]() // 3
    funs1[2]() // 3