JS作用域、变量提升和闭包

作用域

作用域可以理解为JS引擎执行代码的时候,查找变量的规则。

确定变量访问范围的阶段的角度,可以分为2类,词法作用域和动态作用域。js是词法作用域

变量查找的范围的角度,可以分为3类,全局作用域、函数作用域和块级作用域


词法作用域

词法作用域是在词法分析阶段就确定的作用域,变量的访问访问仅由声明时候的区域决定。

动态作用域则是在调用的而时候决定,它是基于调用栈的。

var a = 2;
function foo() {
    console.log( a );
}
function bar() {
    var a = 3;
    foo();
}
bar(); // 2

如果处于词法作用域,变量a首先在foo()函数中查找,没有找到。于是顺着作用域链到全局作用域中查找,于是输出2。

如果处于动态作用域,变量a首先在foo()函数中查找,没有找到。于是会顺着调用栈在调用foo()函数的地方,也就是bar()函数中查找,于是输出3。

但上述代码输出2,由此可以证明js是词法作用域。


全局作用域、函数作用域和块级作用域

全局作用域:

直接编写在script标签中的JS代码,或者一个单独的JS文件中的,都是全局作用域。

全局作用域在页面打开时创建,页面关闭时销毁。

在全局作用域中有一个全局对象window,代表一个浏览器的窗口,由浏览器创建,可以直接使用。


函数作用域:

JS函数作用域是指在函数内部声明的变量,在函数内部和函数内部声明的函数中都可以访问到。

访问规则:访问变量时,现在函数内部找,找不到则在外层函数找,直到最外层的全局作用于,这个查找的过程就是‘作用域链’。


块级作用域(es6)

使用let/const关键字创建的变量都具有块级作用域。

块级作用域的变量只有在语句块内可以访问。所谓语句块就是用{ }包起来的区域。

块级作用域有几个特性:不存在变量提升、暂时性死区、不允许重复声明。

不存在变量提升和不允许重复声明很好理解,那什么是暂时性死区呢?

答:只要块级作用域内存在let命令,它所声明的变量就绑定了这个区域,不再受外部影响。在代码块内,使用let命令声明函数之前,该变量都是不可用的,这在语法上称为“暂时性死区”。

var tmp = 123;

if (true) {
  tmp = 'abc'; // ReferenceError
  let tmp;
}

变量提升

JS在执行之前,会先进行预编译,主要做两个工作:

  • 1、将全局作用域或者函数作用域内的所有函数声明提前。
  • 2、将全局作用域或者函数作用域内的所有var声明的变量提前声明,并且复制undefined

这就是变量提升。

// 将全局作用域或者函数作用域内的所有函数声明提前。
function test() {
    exec();
    function exec() {
        console.log('exec');
    }
}
// 等价于
function test() {
    function exec() {
        console.log('exec');
    }
    exec();
}

// 将全局作用域或者函数作用域内的所有var声明的变量提前声明,并且复制undefined
function test1() {
    console.log(name);
    var name = 'test';
}
// 等价于
function test1() {
    var name;
    console.log(name);
    name = 'test';
}

注意:

  • 函数声明可以提升,但是函数表达式不提升,具名的函数表达式的标识符也不会提升。
  • 同名的函数声明,后面的覆盖前面的。
  • 函数声明的提升,不受逻辑判断的控制。
// 函数表达式和具名函数表达式标识符都不会提升
test(); // TypeError test is not a function
log(); // TypeError log is not a function
var test = function log() { console.log('test') };

// 同名函数声明,后面的覆盖前面的
function test() {
  console.log(1);
}
function test() {
  console.log(2);
}
test(); // 2

// 函数声明的提升,不受逻辑判断的控制
// 注意这是在ES5环境中的规则,在ES6中会报错
function test() {
  log();
  if (false) {
    function log() {
      console.log('test');
    }
  }
}
test(); // 'test'

在块级作用域中声明函数会是什么效果呢?

ES6环境中,如果在语句块中声明函数,按照正常的规范,函数声明应该被封闭在语句块里面,但是为了兼容老代码,因此语法标准允许其他的实现:

  • 允许在块级作用域内声明函数。
  • 函数声明类似于var,即会提升到全局作用域或函数作用域的头部。
  • 同时,函数声明还会提升到所在的块级作用域的头部。
function f() { console.log('I am outside!'); }

(function () {
  if (false) {
    // 重复声明一次函数f
    function f() { console.log('I am inside!'); }
  }
  f(); // Uncaught TypeError: f is not a function
}());


// 等价于
function f() { console.log('I am outside!'); }
(function () {
  var f = undefined;
  if (false) {
    function f() { console.log('I am inside!'); }
  }
  f(); // Uncaught TypeError: f is not a function
}());

闭包

函数和函数内部能访问到的变量的总和,就是一个闭包。

如何生成闭包?函数内嵌套函数,并且函数执行完后,内部函数会被引用,这样内部函数可以访问外部函数中定义的变量,于是就生成了一个闭包。(函数嵌套 + 内部函数被引用)

闭包的作用是什么?可以让内部的函数访问到外部函数的变量,避免变量在全局作用域中存在被修改的风险。

注意事项:不用的时候解除引用,避免不必要的内存占用。

缺点:使用时候不注意的话,容易产生内存泄漏。


闭包实现一个计数器

var count = 0;
function createCounter() {
  function increase() {
      count++;
  }

  function getCount() {
      return count;
  }

  return {
      increase: increase,
      getCount: getCount
  };
}

var counter = createCounter();
counter.increase();

console.log(counter.getCount());
console.log(count);

上述实现方法,变量count放在全局,很容易被其他模块修改从而导致不可预知的问题。因此我们希望count变量不会被其他模块访问到,于是需要把count放在函数作用域中:

function createCounter() {
    var count = 0;
    function increase() {
        count++;
    }

    function getCount() {
        return count;
    }

    return {
        increase: increase,
        getCount: getCount
    };
}

var counter = createCounter();
counter.increase();

console.log(counter.getCount());
console.log(count);

这样函数createCounter中的increate和getCount两个函数可以访问到createCounter内部定义的count,这样就形成了闭包。而count只能被createCounter内部定义的函数访问到,因此不会有被随意修改的风险。

通常情况下函数中定义的变量在函数执行完成后会被销毁,例如:

function createCounter() {
    var count = 0;

    function increase() {
        count++;
    }

    function getCount() {
        return count;
    }

    return {
        increase: increase,
        getCount: getCount
    };
}

createCounter();

通常执行完createCounter()方法之后,内部的所有变量都被从内存中销毁(因为没有其他地方使用了)。但是如果生成了闭包(即有对内部嵌套函数的引用),则内部变量不会被销毁(因为还有其他地方在用,嵌套的内部函数还在使用)。

还是以上面createCounter闭包为例,由于createCounter返回的方法们被引用,因此形成闭包,所以内部变量count不会被销毁,而是会继续被increase和getCount使用。

生成闭包之后,如果我们不再需要使用counter可以执行counter = null;这样失去了对内部嵌套函数的引用,浏览器就会将方法内资源都销毁调了。因此当我们使用完闭包之后如果后续不再需要使用,最好通过取消引用来释放闭包的资源。


学习参考:https://www.yuque.com/baiyueguang-rfnbu/tr4d0i/gu0blp#WW3FR

posted @ 2022-09-06 09:39  笔下洛璃  阅读(79)  评论(0编辑  收藏  举报