词法作用域
函数能看到什么,取决于他在哪里定义,而不取决于他在哪里被调用。
这就叫做词法作用域,例如:
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();
此外,有两个需要注意的点:
- 只要函数里出现过 var a,那么整个函数的 a 都是局部的 a,和外面的全局 a 无关,这叫变量遮蔽。
- 声明被提升,但是值是 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 何时重新执行,也就控制了闭包什么时候重新创建、捕获的是哪一版的变量。
依赖写 [],闭包就永远停留在一开始的情况,不会读取新的值。