执行上下文、作用域、闭包、this

0 阅读5分钟

词法作用域

函数能看到什么,取决于他在哪里定义,而不取决于他在哪里被调用。

这就叫做词法作用域,例如:

let x = 1;

function a() {
  console.log(x);   // 打印多少?
}

function b() {
  let x = 2;
  a();              // 在 x = 2 的环境里调用 a
}

b();

这里输出的就是 1,也就是函数定义时候看到的那个 x 变量。

执行上下文

每次调用一个函数,JS 都会创建一个执行上下文,包含了:

  • 变量环境:函数的参数、内部声明的变量、函数声明
  • 词法环境:指向外层作用域
  • this 值

作用域链

作用域是静态的,代码运行的时候就确定了,和运行时(在哪调用,谁调用)无关。

查找变量的顺序:当前作用域 → 外层作用域 → 再外层 → … → 全局作用域。

如果全都找不到,则报错 ReferenceError。

闭包

定义:闭包 = 函数 + 它定义时所处的词法环境。

例如:

function counter() {
  let count = 0;

  return function () {
    count++;
    return count;
  };
}

const c = counter();
c();  // 1
c();  // 2
c();  // 3

这里还可以访问其中的 count,是因为内部函数还在引用 count。只要有引用,count 就不会被垃圾回收。

闭包常见用途

// ① 私有变量(外部拿不到 count,只能通过 c() 操作)
function counter() {
  let count = 0;
  return () => ++count;
}

// ② 函数工厂
function multiply(n) {
  return (x) => x * n;
}
const double = multiply(2);
double(5);   // 10

// ③ 防抖、节流(D5 会手写,核心就是闭包)
function debounce(fn, delay) {
  let timer; // ← 被闭包保存下来
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => fn(...args), delay);
  };
}

循环里的 var

面试中可能见到过这个题:

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

这里输出是 3 3 3,因为 var 是函数作用域,整个循环只有一个 i,所以三个 setTimeout 回调共享同一个 i,等他们执行的时候,循环已经结束了,i 也就是 3。

所以我们需要改成 let,也就是:

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

这样输出才是预期的 1 2 3,因为 let 是块级作用域,每轮循环都会创建一个新的 i,三次回调捕获的分别是自己的那个 i,而不是和 var 一样共享。

闭包的内存问题

闭包引用的变量不会被回收,所以如果闭包长期挂在一个长期存活的对象上,则内存在页面生命周期内会一直增加。

所以有两个习惯:

  • 组件卸载时清除定时器、解绑事件
  • React 的 useEffect 返回清理函数

this

this 的值由怎么调用决定,和在哪里定义无关。

例如:

function f() { console.log(this); }

// ① 直接调用
f();                       // 严格模式 undefined / 非严格 window

// ② 作为对象的方法调用
const obj = { name: 'obj', f };
obj.f();                   // this = obj

// ③ new 调用
new f();                   // this = 新创建的对象

// ④ 显式指定
f.call(obj);               // this = obj
f.apply(obj);              // this = obj
f.bind(obj)();             // this = obj

箭头函数是例外

箭头函数没有自己的 this,他用的是定义时外层的 this。

const obj = {
  name: 'obj',
  regular() { console.log(this.name); },
  arrow: () => console.log(this.name),
};

obj.regular();   // 'obj'       ← this 是 obj
obj.arrow();     // undefined   ← 箭头函数没有自己的 this,取的是外层(模块/全局)

经典问题

const obj = {
  name: 'obj',
  say() {
    setTimeout(function () {
      console.log(this.name);
    }, 0);
  },
};

obj.say(); // undefined

这是因为 setTimeout 的回调是被直接调用的,而不是 obj.xxx() 的形式,所以回调里的 this 已经不是 obj 了。

对应的有三种解决方案:

// ① 箭头函数(最常用)
setTimeout(() => console.log(this.name), 0);

// ② 提前保存 this
const self = this;
setTimeout(function () { console.log(self.name); }, 0);

// ③ bind
setTimeout(function () { console.log(this.name); }.bind(this), 0);

练习

预测输出

var a = 1;
function f() {
  console.log(a);
  var a = 2;
}
f();

输出 undefined。因为这里出现了变量提升,执行的时候,声明被移动到函数顶部,但是赋值留在原地。上面的代码执行时会变成:

var a = 1;
function f() {
  var a;
  console.log(a);
  a = 2;
}
f();

此外,有两个需要注意的点:

  1. 只要函数里出现过 var a,那么整个函数的 a 都是局部的 a,和外面的全局 a 无关,这叫变量遮蔽。
  2. 声明被提升,但是值是 undefined。所以这里不会报错,而是会输出 undefined。

对照一下 let 和 const,如果是 let 定义变量,则会直接报错:

console.log(b); // ReferenceError: Cannot access 'b' before initialization
let b = 5;

let 和 const 也会提升,但是不会初始化。从作用域开始到声明语句之间,这个变量处于 暂时性死区(TDZ),访问会直接报错。

总结一下:

提升?提升后的值声明前访问
var✅undefined得到 undefined
let / const✅未初始化(TDZ)报错
function 声明✅整个函数可以直接调用

纠错

下面这段代码需要输出 0 1 2,写出两种改法:

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

第一种就是把 var 改成 let,也就是:

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

第二种则是通过 IIFE,立即执行函数:

for (var i = 0; i < 3; i++) {
  (function (j) {
    setTimeout(() => console.log(j), 0);
  })(i); // ← 把当前的 i 作为参数传进去
}

即每一轮都创造一个新的函数作用域,这样就可以保存里面的值了。

useEffect 的依赖数组和闭包是什么关系

useEffect 的回调是一个闭包,它捕获的是执行这次 effect 时的变量值,依赖数组控制 effect 何时重新执行,也就控制了闭包什么时候重新创建、捕获的是哪一版的变量。

依赖写 [],闭包就永远停留在一开始的情况,不会读取新的值。