js闭包

291 阅读3分钟

闭包指的是:

能够访问另一个函数作用域的变量的函数。

清晰的讲:

闭包就是一个函数,这个函数能够访问其他函数的作用域中的变量

虽然定义很简单,但是有很多坑点,比如this指向、变量的作用域,稍微不注意可能就造成内存泄露。

从堆栈的角度看待js函数

  基本变量的值一般都是存在栈内存中,而对象类型的变量的值存储在堆内存中,栈内存存储对应空间地址。   

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

  

如果再执行:

b = {m: 30 } 

堆内存就有新的对象{m:30},栈内存的b指向新的空间地址( 指向{m:30} ),而堆内存中原来的{m:20}就会被程序引擎垃圾回收掉,节约内存空间。

函数也是用堆栈存储的:

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

上面代码执行顺序:

  • 在执行fn前,此时我们在全局执行环境(浏览器就是window作用域),全局作用域里有个变量a;

  • 进入fn,此时栈内存就会push一个fn的执行环境,这个环境里有变量b和函数对象fn1,这里可以访问自身执行环境和全局执行环境所定义的变量

  • 进入fn1,此时栈内存就会push 一个fn1的执行环境,这里面没有定义其他变量,但是我们可以访问到fn和全局执行环境里面的变量,因为程序在访问变量时,是向底层栈一个个找,如果找到全局执行环境里都没有对应变量,则程序抛出underfined的错误。

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

坑一:引用的变量可能发生变化

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

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

坑二:this指向

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

坑三:内存泄露问题

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,当执行完showId后,el无法释放
    };
    el = null;    // 主动释放el
}

好处一:

// 使用闭包实现递归
function newFactorial = (function f(num){
    if(num<1) {return 1}
    else {
       return num* f(num-1)
    }
})

好处二:用闭包模仿块级作用域。

es6没出来之前,用var定义变量存在变量提升问题

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 使用const 和 let

参考: www.jianshu.com/p/26c81fde2…