JavaScript-02-函数与作用域
本篇讲什么
函数是 JavaScript 的一等公民,也是理解这门语言的分水岭。本篇解决四个最容易困惑的问题:
① 函数声明与函数表达式为什么"调用位置可以不同"(提升的差异);
② 箭头函数到底和普通函数差在哪(
this、arguments、构造函数能力);③
this究竟指向谁(四条绑定规则与优先级,以及最常见的"丢失this"场景);④ 闭包是什么、为什么能"记住"外层变量、以及循环里
var与let的经典陷阱。另外覆盖:参数机制、作用域与作用域链、变量提升的完整机制、IIFE 的历史作用、纯函数与副作用、高阶函数、柯里化、递归与尾调用优化现状。
读完后你应该能准确说出"这段代码里
this是什么""这个变量是从哪来的",并写出没有副作用的函数。
一、是什么:函数的四种写法
JS 里"定义函数"有四种主要写法,它们的提升行为、this、能否 new 都不一样。
| 写法 | 语法 | 提升 | 有自己的 this | 能 new | arguments | 典型用途 |
|---|---|---|---|---|---|---|
| 函数声明 | function f() {} | 完整提升(可提前调用) | 有(动态) | 能 | 有 | 模块内的顶层工具函数 |
| 函数表达式 | const f = function () {} | 不提升(TDZ) | 有(动态) | 能 | 有 | 需要条件赋值、作为参数传递 |
| 箭头函数 | const f = () => {} | 不提升 | 无(取词法作用域) | 不能 | 没有 | 回调、需要保持外层 this |
| 方法简写 | { f() {} } | 不适用 | 有(动态) | 不能 | 有 | 对象方法与 class 方法 |
// ===== 可运行示例:声明 vs 表达式,唯一的硬差别是提升 =====
'use strict';
console.log(declared()); // '我是函数声明' —— 可以在定义之前调用
function declared() { return '我是函数声明'; }
// console.log(expressed()); // ReferenceError: Cannot access 'expressed' before initialization
const expressed = function () { return '我是函数表达式'; };
console.log(expressed()); // '我是函数表达式'
// 为什么会这样?函数声明在"进入作用域"时就被完整创建;
// 而函数表达式本质是"赋值语句",只是右值恰好是个函数。
// 变量名按 let/const 规则提升但不初始化 → 声明前访问落在暂时性死区(TDZ)里。
// ===== 函数表达式的一个真实优势:按条件选择实现 =====
'use strict';
const isNode = typeof process !== 'undefined' && process.versions?.node != null;
// 用表达式可以做条件赋值,函数声明做不到(同一作用域重复声明会互相覆盖)
const now = isNode
? () => Number(process.hrtime.bigint() / 1000000n) // Node:高精度单调时钟
: () => Date.now(); // 浏览器:毫秒时间戳
console.log(typeof now(), now() > 0);
// 另一个优势:具名函数表达式让栈信息可读,便于调试
const parse = function parseConfig(text) { // 内部名字 parseConfig 只在该函数内部可见
return JSON.parse(text);
};
try {
parse('{bad json}');
} catch (e) {
console.log(e.stack.split('\n')[1].trim()); // 栈里显示 at parseConfig,而不是 at anonymous
}
二、为什么这样设计
| 设计决策 | 动机 | 代价 |
|---|---|---|
| 函数声明完整提升 | 早期网页脚本要求"先调用后定义"也能跑,符合直觉 | 同一作用域里的重复声明会静默覆盖,最后一个生效 |
this 在调用时决定 | 让同一个函数被不同对象复用("方法借用") | 把函数当值传递时 this 会丢,是 JS 最经典的 bug 来源 |
箭头函数没有自己的 this | 回调里想用外层对象的 this,否则必须写 const self = this | 不能用作构造函数,也不能用作需要动态 this 的方法 |
函数级作用域(var) | 实现简单 | 循环变量泄漏、块内变量跑到块外 |
| 闭包 | 函数可以携带创建时的环境,天然支持"私有变量"与"状态保持" | 被闭包引用的变量不会被回收,滥用会内存泄漏 |
| 参数默认值、剩余参数晚到(ES2015) | 早期只能靠 arguments 与 arguments.length 手工判断 | 老代码风格混乱,需要认识 arguments 的坑 |
一句话抓住本质
this不是"函数自己的属性",而是"调用表达式提供的上下文"。 记住这句话,四条绑定规则就只是它的四种表现形式。闭包不是语法特性,而是"函数 + 它出生时的作用域"这个组合的必然结果。 只要作用域链还在,"记住变量"就毫无魔法。
三、核心内容
3.1 函数是一等公民
"一等公民(first-class citizen)"的含义:函数可以像数字、字符串一样被赋值、被传递、被返回、被放进数据结构。这是 JS 回调风格、数组方法链、事件驱动的语言基础。
// ===== 可运行示例:函数的四种"当值用"的姿势 =====
'use strict';
const double = (n) => n * 2;
// ① 赋值给变量
const f = double;
// ② 作为参数传入(高阶函数)
console.log([1, 2, 3].map(double)); // [2, 4, 6]
// ③ 作为返回值返回(工厂函数)
const makeMultiplier = (k) => (n) => n * k; // 返回的箭头函数"记住"了 k —— 闭包
const triple = makeMultiplier(3);
console.log(triple(7)); // 21
// ④ 放进数据结构
const pipeline = [double, (n) => n + 1, (n) => n ** 2];
console.log(pipeline.reduce((acc, fn) => fn(acc), 3)); // ((3*2)+1)^2 = 49
// 函数也是对象:有自己的属性
function withProps() {}
withProps.version = '1.0.0'; // 可以挂属性,常用于缓存
withProps.version; // '1.0.0'
console.log(withProps.name, withProps.length); // 'withProps' 0 —— name 与形参个数
3.2 箭头函数
// ===== 语法速览 =====
const a1 = () => 42; // 单表达式:隐式 return,别写花括号
const a2 = (x) => x * 2; // 单参数可省括号(团队风格通常保留)
const a3 = (x, y) => { const s = x + y; return s; }; // 多语句必须显式 return
const a4 = () => ({ ok: true }); // ⚠️ 返回对象字面量必须加圆括号
console.log(a1(), a2(3), a3(1, 2), a4()); // 42 6 3 { ok: true }
箭头函数与普通函数的四个硬差别:
| 维度 | 普通函数 | 箭头函数 |
|---|---|---|
this | 调用时动态决定 | 创建时继承外层(词法绑定),且无法被 call/apply/bind 改变 |
arguments | 有自己的 arguments 对象 | 没有,只能看到外层的(推荐用剩余参数代替) |
| 构造函数 | 可 new | 不可 new(抛 TypeError,也没有 prototype 属性) |
yield / 生成器 | 可作生成器函数 | 不能 |
// ===== 可运行示例:箭头函数的 this 是"定义时"确定的 =====
'use strict';
const counter = {
count: 0,
// 普通方法:this 由调用方式决定 → counter.start() 时 this 是 counter
startBad() {
setTimeout(function () {
// 回调不是通过 counter 调用的,所以拿不到 counter 这个 this。
// Node 会把"当前定时器对象"作为 this 传进来,浏览器里则是 window——
// 无论哪种都不是 counter,因此 this.count++ 的结果永远落不到 counter 上。
console.log('普通回调里的 this 是 counter 吗?', this === counter);
// this.count++; // 想读 counter.count 就会出错:TypeError / NaN
}, 0);
},
startGood() {
setTimeout(() => {
// 箭头函数没有自己的 this,用的是 startGood 的 this,也就是 counter
this.count++;
console.log('箭头回调里的 this.count =', this.count);
}, 0);
},
};
counter.startBad(); // 普通回调里的 this 是 counter 吗? false
counter.startGood(); // 箭头回调里的 this.count = 1
// ===== 箭头函数不能当构造函数的证据 =====
const Arrow = () => { this.x = 1; };
// new Arrow(); // TypeError: Arrow is not a constructor
console.log(Arrow.prototype); // undefined —— 没有 prototype,new 无从谈起
// ===== 箭头函数没有 arguments =====
function outer() {
const arrow = () => arguments.length; // 拿到的是 outer 的 arguments
return arrow();
}
console.log(outer(1, 2, 3)); // 3
// 想给箭头函数"参数列表"就用剩余参数,它同时适用于两种函数
const sum = (...nums) => nums.reduce((a, b) => a + b, 0);
console.log(sum(1, 2, 3, 4)); // 10
箭头函数的三个禁忌场景
1. 对象方法:
{ count: 0, inc: () => this.count++ }里的this是外层(模块或全局),不是这个对象 → 用方法简写inc() {}。2. 需要动态
this的场景:事件处理器里想用this指向触发元素、Vue选项式 API 的methods依赖this指向组件实例。3.
prototype上的方法:Foo.prototype.bar = () => {}会让所有实例共享外层的this,几乎一定是 bug。
3.3 参数机制
| 机制 | 语法 | 关键点 |
|---|---|---|
| 普通参数 | f(a, b) | 少传 → undefined;多传 → 被忽略(但可用 arguments 或剩余参数取到) |
| 默认参数 | f(a = 1) | 只在实参为 undefined 时生效;默认值可以是表达式,且从左到右求值,可引用前面的参数 |
| 剩余参数 | f(...rest) | 必须是最后一个参数,收集成真数组 |
| 展开传参 | f(...arr) | 把可迭代对象拆成实参序列 |
| 解构参数 | f({ a, b = 2 } = {}) | 选项对象模式,必须给整体默认值 = {},否则不传参会抛错 |
// ===== 可运行示例:默认参数的三条规则 =====
'use strict';
// ① 默认值由 undefined 触发,null 不触发
function f1(x = '默认') { return x; }
console.log(f1(), f1(undefined), f1(null), f1('')); // 默认 undefined 默认 默认 null ''(空串是有效值)
// ② 默认值可以是表达式,且按顺序求值,能引用前面的参数
function f2(a, b = a * 2, c = b + 1) { return [a, b, c]; }
console.log(f2(3)); // [3, 6, 7]
console.log(f2(3, 10)); // [3, 10, 11]
// ③ 每次调用都会重新求值,所以默认值可以是"新对象",避免共享可变默认值
function addItem(list = []) { list.push('x'); return list; }
console.log(addItem()); // ['x']
console.log(addItem()); // ['x'] —— 每次都是新数组(对比 Python 的可变默认参数陷阱)
// ④ 选项对象模式:给整个对象一个默认值,才能"一个参数都不传"
function createUser({ name = '匿名', age = 0, tags = [] } = {}) {
return { name, age, tags };
}
console.log(createUser()); // { name: '匿名', age: 0, tags: [] }
console.log(createUser({ name: '赵六', age: 28 })); // { name: '赵六', age: 28, tags: [] }
// ⑤ 剩余参数把"多出来的实参"收成真数组(可直接用数组方法)
function tag(strings, ...values) { return [strings.length, values]; }
console.log(tag`a${1}b${2}c`); // [3, [1, 2]]
// ⑥ arguments 的局限:是类数组、不是真数组,箭头函数里根本没有
function legacy() {
console.log(Array.isArray(arguments)); // false —— 类数组对象
// arguments.map(...) // TypeError: arguments.map is not a function
const real = Array.from(arguments); // 必须先转成真数组
return real.map((n) => n * 2);
}
console.log(legacy(1, 2, 3)); // [2, 4, 6]
arguments的四个坑(新代码请直接用剩余参数)1. 不是数组:没有
map/filter,要Array.from(arguments)或[...arguments]。2. 箭头函数里没有:拿到的是外层的
arguments,容易误读。3. 它和形参"联动":非严格模式下
arguments[0] = 9会同时改掉形参a(严格模式下取消联动),行为诡异。4. 默认参数与
arguments不一致:用了默认参数后,arguments反映的是"真正传进来的实参",不是"经过默认值填充后的值"。```js
function g(a = 1) { return [a, arguments[0]]; }
console.log(g()); // [1, undefined] —— 形参有默认值,arguments 依然空
```
3.4 this 的四种绑定规则
this 在函数被调用时确定,与"函数在哪定义"无关(箭头函数例外)。判定顺序是从上到下的优先级。
| 优先级 | 规则 | 触发形式 | this 指向 |
|---|---|---|---|
| 1(最高) | new 绑定 | new Fn() | 新创建的实例对象 |
| 2 | 显式绑定 | fn.call(obj) / fn.apply(obj) / fn.bind(obj) | 传入的 obj |
| 3 | 隐式绑定 | obj.fn() | 调用点前面的那个对象 obj |
| 4(最低) | 默认绑定 | fn() | 严格模式:undefined;非严格模式:globalThis |
箭头函数不参与以上规则:它的 this 在定义时由外层作用域决定,call/apply/bind 都无法改变。
// ===== 可运行示例:四条规则逐个验证(Node.js 可直接运行)=====
'use strict'; // 严格模式下"默认绑定"是 undefined,最能看出问题
function show(label) {
// 用 typeof 保护:严格模式下默认绑定时 this 是 undefined,直接读属性会抛错
console.log(label, this === undefined ? 'undefined' : this.tag ?? this);
}
// ① 默认绑定:裸调用
function plain() { 'use strict'; return this; }
console.log('默认绑定:', plain()); // undefined
// ② 隐式绑定:调用点前面有对象
const obj = { tag: '我是 obj', method: show };
obj.method('隐式绑定:'); // 隐式绑定: 我是 obj
// ③ 显式绑定:call / apply / bind
const other = { tag: '我是 other' };
obj.method.call(other, '显式绑定 call:'); // 显式绑定 call: 我是 other
obj.method.apply(other, ['显式绑定 apply:']); // 显式绑定 apply: 我是 other
const bound = obj.method.bind(other); // bind 返回一个永久绑定的新函数
bound('显式绑定 bind:'); // 显式绑定 bind: 我是 other
// ④ new 绑定:优先级最高
function Person(name) { this.name = name; this.tag = `实例 ${name}`; }
const p = new Person('小明');
console.log('new 绑定:', p.tag); // new 绑定: 实例 小明
// ⑤ 优先级验证:bind 过的函数再被 new,new 依然赢
const BoundPerson = Person.bind({ name: '被忽略' });
const p2 = new BoundPerson('小红');
console.log('new 覆盖 bind:', p2.name); // new 覆盖 bind: 小红
call / apply / bind 的区别:
| 方法 | 是否立即执行 | 参数形式 | 返回值 |
|---|---|---|---|
fn.call(thisArg, a, b) | 是 | 逐个传 | 函数返回值 |
fn.apply(thisArg, [a, b]) | 是 | 数组传 | 函数返回值 |
fn.bind(thisArg, a) | 否 | 逐个传(可预置部分参数) | 新函数,this 被永久锁定 |
// ===== call/apply 的历史用途:借用方法 =====
'use strict';
// 类数组对象想用数组方法,可以"借用"
function toArray() {
return Array.prototype.slice.call(arguments); // arguments 本身没有 slice
}
console.log(toArray(1, 2, 3)); // [1, 2, 3]
// 现代写法更清楚(Array.from 就是为这个场景设计的)
function toArray2(...args) { return args; }
console.log(toArray2(1, 2, 3)); // [1, 2, 3]
// ===== bind 的两个真实用途 =====
class Logger {
constructor(prefix) { this.prefix = prefix; }
log(msg) { console.log(`[${this.prefix}] ${msg}`); }
}
const logger = new Logger('APP');
// 用途一:把方法传给"裸调用"的函数(定时器、事件监听、回调)
const detached = logger.log;
// detached('会丢失 this'); // TypeError: Cannot read properties of undefined
const safe = logger.log.bind(logger);
safe('绑定后可用'); // [APP] 绑定后可用
// 用途二:预置参数(偏函数应用),基于通用函数造出专用函数
function request(method, url, body) { return { method, url, body }; }
const get = request.bind(null, 'GET'); // this 用不上,传 null 占位
console.log(get('/api/users')); // { method: 'GET', url: '/api/users', body: undefined }
丢失 this 的四个经典场景:
// ===== 可运行示例:this 是怎么丢的,以及三种修法 =====
'use strict';
const user = {
name: '阿强',
greet() { return `你好,我是 ${this.name}`; },
};
// 场景一:方法被赋值给变量后再裸调用 → 默认绑定
const g = user.greet;
try {
g(); // 严格模式下 this 是 undefined → 读 name 抛错
} catch (e) {
console.log('裸调用报错:', e.constructor.name); // 裸调用报错: TypeError
}
const gFixed = user.greet.bind(user); // 修法:bind 锁定 this
console.log(gFixed()); // 你好,我是 阿强
// 场景二:作为回调传入(forEach 会"裸调用"回调,this 丢失)
try {
[1].forEach(user.greet);
} catch (e) {
console.log('作为回调报错:', e.constructor.name); // 作为回调报错: TypeError
}
[1].forEach(user.greet.bind(user)); // 修法 A:bind
[1].forEach(() => console.log(user.greet())); // 修法 B:包一层箭头函数(最常用)
// 修法 C:让函数自己带上下文,完全不依赖 this(闭包捕获对象)
const user2 = { name: '阿珍' };
user2.safeGreet = () => `你好,我是 ${user2.name}`;
console.log(user2.safeGreet()); // 你好,我是 阿珍
// 场景三:把方法"借"出去时调用点变了
const borrowed = { name: '路人', greet: user.greet };
console.log(borrowed.greet()); // 你好,我是 路人 —— this 指向 borrowed,不是 user
// 场景四:setTimeout 的回调由宿主环境调用,调用点不在你的代码里
setTimeout(function () {
// Node 会把"当前定时器对象"当 this 传进来,浏览器里则是 window —— 都不是你的对象。
// 想在里面用外层对象,要么用箭头函数,要么提前 bind。
console.log('setTimeout 回调里的 this === user 吗?', this === user); // false
}, 0);
判定
this的三步法1. 函数是箭头函数吗?是 →
this等于定义处外层的this,结束。2. 调用点前面有
new/.call/.apply/.bind吗?有 → 按优先级表取。3. 调用点写成
obj.fn()吗?是 →this是obj;否则 → 严格模式undefined,非严格模式globalThis。另外:
class的方法体强制严格模式,所以class里丢失this会直接抛TypeError而不是给出全局对象 —— 这是好事,错误暴露得更早。
3.5 作用域与作用域链
| 作用域类型 | 由什么创建 | 例子 |
|---|---|---|
| 全局作用域 | 脚本/模块的最外层 | 顶层 const、globalThis |
| 函数作用域 | 每次函数调用 | 函数体内的 var、参数 |
| 块级作用域 | {}、if、for、try | 块内的 let/const、class |
| 模块作用域 | 每个 ES Module 文件 | import/export 的顶层绑定 |
词法作用域(Lexical Scope):变量的可见性由源码书写位置决定,与调用位置无关。JS 用的是词法作用域(也叫静态作用域)。
作用域链(Scope Chain):每个函数在被创建时,会记录"自己所在的词法环境",于是形成一条从内到外的链条 当前 → 外层 → 更外层 → 全局。查找变量就是沿着这条链逐级向外找,找到即停,全找不到就抛 ReferenceError。
// ===== 可运行示例:证明 JS 是词法作用域,而不是动态作用域 =====
'use strict';
const value = 'global';
function whereAmI() {
// 这里的 value 在"书写位置"上属于全局 → 永远取全局的 value
return value;
}
function caller() {
const value = 'caller 内部的局部变量';
return whereAmI(); // 调用位置在 caller 里,但 whereAmI 看不到 caller 的 value
}
console.log(caller()); // 'global'
// 对比:如果是动态作用域(如早期 Lisp、bash 的变量查找),结果会是 caller 的局部值。
// 词法作用域的好处:读函数定义就能确定每个变量的来源,不需要追踪所有调用点。
// ===== 作用域链的查找顺序:由内向外的"最近优先" =====
const a = 'global a';
function outer() {
const a = 'outer a';
const b = 'outer b';
function inner() {
// inner 自己不定义 a、b,于是沿链向外找
// console.log(a, b, c) 的形式会先执行 a、b 的求值,报错信息会只指向第一个未定义的名字
const local = 'inner local';
return `${a} | ${b} | ${local}`;
}
return inner();
}
console.log(outer()); // 'outer a | outer b | inner local'
// console.log(local); // ReferenceError: local is not defined —— 内层变量不会漏到外层
// ===== let/const 的块级作用域:同一段代码里的两个独立变量 =====
{
const scoped = '块内';
console.log(scoped);
}
// console.log(scoped); // ReferenceError:块外用不了
3.6 闭包
定义:闭包(Closure)是函数 + 该函数创建时所处的词法环境的组合。只要这个函数还能被调用,它引用的外层变量就会一直存活。
为什么能"记住"外层变量? 因为变量存在堆上的环境记录(Environment Record)里,而不是存在"栈帧"里。函数对象内部有一个指向该环境的隐藏引用,所以外层函数返回后,它的环境只要还被内层函数引用,就不会被垃圾回收。
// ===== 可运行示例:闭包的三个经典应用 =====
'use strict';
// 应用一:计数器(把状态藏在闭包里,外部无法直接篡改)
function createCounter(start = 0) {
let count = start; // 私有状态,只有下面两个函数能碰
return {
inc: () => ++count, // 箭头函数:this 与本例无关,写起来更短
dec: () => --count,
get value() { return count; }, // getter:读取时实时求值,避免快照过期
};
}
const c = createCounter(10);
c.inc(); c.inc(); c.dec();
console.log(c.value); // 11
console.log('count' in c); // false —— 外部拿不到 count,真正做到私有
// 应用二:私有变量 + 模块模式(IIFE 的典型用法,见 3.8 节)
const Store = (function () {
const items = []; // 模块私有
return {
add(item) { items.push(item); return items.length; },
list() { return items.slice(); }, // 返回副本,防止外部改到内部数组
};
})();
Store.add('a'); Store.add('b');
const snapshot = Store.list();
snapshot.push('外部乱改');
console.log(Store.list()); // ['a', 'b'] —— 内部状态没被污染
// 应用三:防抖(debounce)—— 闭包保存定时器句柄与最后一次参数
function debounce(fn, delayMs) {
let timerId = null; // 每次调用共享同一个 timerId
return function (...args) {
if (timerId !== null) clearTimeout(timerId); // 取消上一次待执行的调用
timerId = setTimeout(() => {
timerId = null; // 执行完清空,避免误 clear
fn.apply(this, args); // 保留调用者的 this 与参数
}, delayMs);
};
}
let callCount = 0;
const record = debounce(() => { callCount++; }, 20);
for (let i = 0; i < 5; i++) record(); // 连续调用 5 次
setTimeout(() => {
console.log('防抖后实际执行次数:', callCount); // 1 —— 只有最后一次生效
}, 60);
// 节流(throttle):单位时间内最多执行一次,用"上次执行时间"做闸门
function throttle(fn, intervalMs) {
let lastTime = 0; // 闭包保存上次执行时刻
return function (...args) {
const nowTime = Date.now();
if (nowTime - lastTime >= intervalMs) {
lastTime = nowTime;
return fn.apply(this, args);
}
return undefined; // 被节流掉时返回 undefined,调用方需能接受
};
}
let throttledCount = 0;
const tick = throttle(() => throttledCount++, 1000);
tick(); tick(); tick();
console.log('节流后立即执行次数:', throttledCount); // 1
经典陷阱:循环中 var 与 let 的差异
// ===== 可运行示例:为什么 var 输出 3 3 3,而 let 输出 0 1 2 =====
'use strict';
// 反例:var 只有一个绑定,三个闭包共享它;循环早已结束,值停在 3
const withVar = [];
for (var i = 0; i < 3; i++) {
withVar.push(function () { return i; });
}
console.log('var:', withVar.map((f) => f())); // [3, 3, 3]
// 正解一(现代首选):let 在每次迭代都创建一个新的绑定
const withLet = [];
for (let j = 0; j < 3; j++) {
withLet.push(function () { return j; });
}
console.log('let:', withLet.map((f) => f())); // [0, 1, 2]
// 正解二(ES5 时代的写法):IIFE 把当前值"快照"成函数参数
const withIife = [];
for (var k = 0; k < 3; k++) {
withIife.push((function (captured) { // 形参 captured 每次调用都是新的
return function () { return captured; };
})(k)); // 立刻用当前的 k 调用
}
console.log('IIFE:', withIife.map((f) => f())); // [0, 1, 2]
// 正解三:用 forEach 的回调参数(回调每次调用都有独立的作用域)
const withEach = [];
[0, 1, 2].forEach((n) => {
withEach.push(() => n); // n 是回调的形参,天然隔离
});
console.log('forEach:', withEach.map((f) => f())); // [0, 1, 2]
// 补充:解决"这个数组每个元素都是一个函数"的另一种思路 —— 用 bind 预置参数
const withBind = [];
for (var m = 0; m < 3; m++) {
withBind.push((function (v) { return v; }).bind(null, m));
}
console.log('bind:', withBind.map((f) => f())); // [0, 1, 2]
闭包的两个真实代价
1. 内存不会自动释放:被闭包引用的变量会一直存活。大对象被闭包"顺手"捕获是最隐蔽的内存泄漏:
```js
function attach() {
const hugeData = new Array(1e6).fill('x');
return {
// 只用到 hugeData.length,却把整个数组都关进来了
size: () => hugeData.length,
};
}
// 修法:先取出需要的标量,再让闭包只捕获标量
function attachFixed() {
const hugeData = new Array(1e6).fill('x');
const size = hugeData.length; // 只留下需要的值
return { size: () => size }; // 闭包只引用 size,hugeData 可被回收
}
```
2. 调试变难:闭包里的变量不在当前栈帧上,断点里需要展开
Scopes→Closure才能看到。3. 不要在循环里用闭包累积数据后忘了清空,长时间运行的定时器 + 闭包很容易让内存曲线一路上涨。
3.7 变量提升(Hoisting)的完整机制
提升指的是:在代码执行前,引擎会先扫描当前作用域,把声明登记到环境中。注意——提升的是声明,不是赋值。
| 声明形式 | 提升内容 | 初始化时机 | 声明前访问的结果 |
|---|---|---|---|
function f() {} | 函数对象整体 | 进入作用域时立即完成 | 可正常调用 |
var x | 只提升声明 | 进入作用域时初始化为 undefined | undefined(不报错) |
let x / const x | 提升声明(但不初始化) | 执行到该语句时 | ReferenceError(TDZ) |
class C {} | 同 let | 执行到该语句时 | ReferenceError(TDZ) |
| 函数参数 | 相当于已初始化的 let | 调用时 | — |
// ===== 可运行示例:提升的三种表现 =====
'use strict';
// ① 函数声明:整体提前可用
console.log(typeof hoistedFn); // 'function'
function hoistedFn() {}
// ② var:声明提前、值为 undefined
console.log(typeof hoistedVar); // 'undefined'(注意不是 'function'——没有赋值)
var hoistedVar = function () {};
// ③ let/const/class:在 TDZ 里
try {
// eslint-disable-next-line no-use-before-define
console.log(tdzLet);
} catch (e) {
console.log('TDZ:', e.constructor.name); // TDZ: ReferenceError
}
let tdzLet = 1;
// ④ 同一个作用域里的重复函数声明:最后一个生效(不是报错!)
function dup() { return '第一个'; }
function dup() { return '第二个'; }
console.log(dup()); // '第二个' —— ES5 非严格模式如此;严格模式下同样如此
// ⑤ 函数声明在块里的行为(ES6 后按块级作用域处理,但非严格模式仍是历史遗留语义)
{
function blockFn() { return '块内声明'; }
console.log(blockFn()); // '块内声明'
}
// console.log(blockFn()); // 严格模式下 ReferenceError(非严格模式可能取到全局的那个)
关于"先调用后定义"的实践建议
依赖函数声明的提升确实能让代码跑起来,但可读性差:读者要往下翻才能知道这个函数做什么。
推荐两条规则:① 工具函数按"使用顺序"排,或集中放在文件末尾的
// helpers区;② 需要提前引用时优先用函数声明而不是函数表达式,避免 TDZ 报错。
3.8 立即执行函数表达式(IIFE)
写法:(function () { / ... / })(); —— 关键是让 function 关键字不处在语句开头,否则会被解析成函数声明而报错。
// ===== 四种等价写法 =====
(function () { console.log('IIFE 写法一'); })();
(function () { console.log('IIFE 写法二'); }());
(() => { console.log('IIFE 写法三(箭头)'); })();
!(function () { console.log('IIFE 写法四(一元运算符开头)'); })();
历史作用(为什么 ES5 时代到处是它):
| 解决的问题 | 说明 |
|---|---|
| 没有块级作用域 | var 只有函数作用域,想造一个"临时作用域"只能用函数,然后立刻调用 |
| 没有模块系统 | 用 IIFE 包住代码,把私有变量关在里面,只 return 需要暴露的部分(模块模式) |
| 避免全局污染 | 多个 <script> 共享全局作用域,IIFE 内的变量不会挂到 window 上 |
| 循环中捕获变量 | IIFE 把当次迭代的值变成函数参数(见 3.6 节"正解二") |
把 undefined 当参数传入 | 老浏览器里 undefined 可被重写,(function (undefined) {})(void 0) 能确保它是真 undefined |
现在还需要吗? 大部分场景已被 let/const、ES Module、以及"块 + 大括号"取代:
// ===== 现代替代方案 =====
// ① 只要块级作用域?直接用块(但注意:块里的 let 外部访问不到,这一点和 IIFE 等价)
{
const temp = compute();
console.log(temp);
}
// ② 要模块私有?用 ES Module,文件天然是自己的作用域
// (示例:module.js 里 export 出去的才是公开 API,其余都私有)
// ③ 要顶层 await 又想包一层?用模块作用域即可,不需要 IIFE:
// const data = await fetch('/api').then((r) => r.json());
function compute() { return 42; }
// ④ IIFE 仍不可替代的场景:需要"立刻求值并对返回值做进一步操作"的表达式
const config = (() => {
const env = process.env.NODE_ENV ?? 'development';
return env === 'production'
? { apiBase: 'https://api.example.com', debug: false }
: { apiBase: 'http://localhost:3000', debug: true };
})(); // 注意末尾的 () —— 立刻执行并把结果赋给 config
console.log(config.debug); // true(除非你在生产环境运行)
3.9 纯函数与副作用
| 概念 | 定义 | 例子 |
|---|---|---|
| 纯函数 | ① 相同输入必得相同输出;② 不修改任何外部状态 | (a, b) => a + b、arr.slice() |
| 副作用 | 函数执行时对外部世界产生了可观察影响 | 改全局变量、写文件、发请求、console.log、改传入的对象 |
| 引用透明 | 表达式可以直接替换成它的求值结果而不改变程序行为 | 纯函数天然满足 |
// ===== 可运行示例:不纯 → 纯 的重构 =====
'use strict';
const cart = [{ price: 10, qty: 2 }, { price: 5, qty: 1 }];
// ❌ 不纯:修改了传入的数组,还调用了 Date(时间不确定,同一输入结果会变)
function applyDiscountImpure(items, rate) {
items.forEach((it) => { it.price = it.price * rate; }); // 副作用:改了调用方的数据
return items;
}
// ✅ 纯:不改输入、不读外部可变状态、返回全新对象
function applyDiscount(items, rate) {
return items.map((it) => ({ ...it, price: it.price * rate })); // 展开复制,原对象不动
}
const discounted = applyDiscount(cart, 0.9);
console.log(cart[0].price); // 10 —— 原数据未被污染
console.log(discounted[0].price); // 9 —— 新数据
// ✅ 时间也是"输入":把 Date.now() 作为参数传入,函数就变纯了,测试才能断言
function formatTime(timestampMs, locale = 'zh-CN') {
return new Date(timestampMs).toLocaleString(locale);
}
console.log(formatTime(0, 'zh-CN').length > 0); // true —— 结果只依赖入参
为什么工程上要追求纯函数
可测试(不用准备外部状态就能断言)、可缓存(相同输入可复用结果,即记忆化 memoization)、可并行、易重构(改动不会隔空影响别处)。
实践上不必"全函数皆纯"——副作用是必需的(写文件、发请求总要有人做)。正确做法是把副作用集中到少量边界函数里,核心计算逻辑保持纯净。
3.10 高阶函数与柯里化
高阶函数(Higher-Order Function):接收函数作为参数,或返回一个函数的函数。JS 的数组方法几乎全是高阶函数。
| 方法 | 作用 | 是否改变原数组 | 返回值 | 能否中途停止 |
|---|---|---|---|---|
forEach | 遍历 | 否 | undefined | 不能(break 无效) |
map | 一对一映射 | 否 | 等长新数组 | 不能 |
filter | 条件筛选 | 否 | 子集新数组 | 不能 |
reduce | 归约成单值 | 否 | 累积值 | 不能 |
some | 是否存在满足项 | 否 | boolean | 能(短路) |
every | 是否全部满足 | 否 | boolean | 能(短路) |
find | 找第一个匹配项 | 否 | 元素或 undefined | 能(短路) |
sort | 排序 | 是(原地) | 同一数组引用 | 不能 |
flat / flatMap | 展平 | 否 | 新数组 | 不能 |
柯里化(Currying):把接受多个参数的函数变换成"一系列每次只接受一个参数的函数"。
它的价值不是"少写括号",而是可以预先固定部分参数,得到可复用的专用函数(偏函数应用)。
// ===== 可运行示例:高阶函数 + 柯里化 =====
'use strict';
// ① 高阶函数:把"行为"作为参数传入,让遍历逻辑与业务逻辑解耦
const users = [
{ name: '张三', age: 28, active: true },
{ name: '李四', age: 17, active: false },
{ name: '王五', age: 35, active: true },
];
const by = (key) => (a, b) => (a[key] > b[key] ? 1 : a[key] < b[key] ? -1 : 0);
console.log(users.filter((u) => u.active).map((u) => u.name)); // [ '张三', '王五' ]
console.log([...users].sort(by('age')).map((u) => u.age)); // [17, 28, 35](先复制,避免 sort 改原数组)
// 用 reduce 一次遍历同时算出多个统计量(比多次 filter 更高效)
const stats = users.reduce((acc, u) => {
acc.total++;
if (u.active) acc.active++;
acc.ageSum += u.age;
return acc; // 必须返回累积器,否则下一步拿到 undefined
}, { total: 0, active: 0, ageSum: 0 });
console.log(stats); // { total: 3, active: 2, ageSum: 80 }
// ② 手写柯里化:把 f(a,b,c) 变成 f(a)(b)(c)
function curry(fn) {
// 用 fn.length 拿到形参个数(不含剩余参数与带默认值的参数),决定何时真正执行
return function curried(...args) {
if (args.length >= fn.length) return fn.apply(this, args);
return (...rest) => curried.apply(this, [...args, ...rest]);
};
}
const add3 = curry((a, b, c) => a + b + c);
console.log(add3(1)(2)(3)); // 6
console.log(add3(1, 2)(3)); // 6 —— 也允许一次传多个,这叫"偏函数应用"
console.log(add3(1)(2, 3)); // 6
// ③ 柯里化的真实价值:先固定"配置",再复用
const log = curry((level, module, message) => `[${level}][${module}] ${message}`);
const logError = log('ERROR'); // 固定级别
const logErrorDb = logError('database'); // 再固定模块
console.log(logErrorDb('连接超时')); // [ERROR][database] 连接超时
console.log(logError('cache', '未命中')); // [ERROR][cache] 未命中 —— 复用中间层
// ④ 记忆化:闭包 + 纯函数 = 缓存
function memoize(fn) {
const cache = new Map(); // 闭包持有缓存,外部无法清空(除非常备一个 clear)
return function (...args) {
const key = JSON.stringify(args); // 简单键:只适合可序列化的参数
if (!cache.has(key)) cache.set(key, fn.apply(this, args));
return cache.get(key);
};
}
let calls = 0;
const slowSquare = memoize((n) => { calls++; return n * n; });
console.log(slowSquare(9), slowSquare(9), '真实计算次数:', calls); // 81 81 真实计算次数: 1
3.11 递归与尾调用优化
// ===== 可运行示例:递归的基线条件与调用栈 =====
'use strict';
// 阶乘:每次递归产生一个新栈帧,空间复杂度 O(n)(正文的复杂度记号见 [[算法-复杂度分析]])
function factorial(n) {
if (n <= 1) return 1; // 基线条件必须写在最前面,否则无限递归
return n * factorial(n - 1); // 归:结果要等子调用返回后才能算
}
console.log(factorial(10)); // 3628800
// 尾递归形式:把中间结果作为参数往下传,理论上可复用同一个栈帧
function factorialTail(n, acc = 1n) { // 用 BigInt 累积,支持更大的 n
if (n <= 1n) return acc;
return factorialTail(n - 1n, acc * n); // 这是"尾调用":调用结果直接返回,没有后续计算
}
console.log(factorialTail(25n).toString()); // 15511210043330985984000000
// 普通递归的栈深上限(Node 默认约 1 万层,具体值随版本与栈大小变化)
function depth(n) { return n === 0 ? 0 : depth(n - 1) + 1; }
console.log('深度 5000 结果:', depth(5000));
try {
depth(100000); // 超出调用栈容量
} catch (e) {
console.log('爆栈错误:', e.constructor.name); // RangeError
}
尾调用优化(TCO)在 JS 里事实上不可用****
ES2015 规范确实定义了严格模式下的尾调用优化(
Proper Tail Calls),要求实现复用栈帧。但现实是:- V8(Chrome / Node.js)没有实现它,官方给出的理由是调试体验变差(栈帧被复用后
console.trace与断点会丢失信息),社区也有过专门讨论。- Safari / JavaScriptCore 是唯一实现的引擎,所以同一段代码在不同浏览器里的栈深表现不一致。
- 结论:不要依赖 TCO 写深递归。超过一万层就改写为迭代 + 显式栈(用数组模拟),或者用蹦床函数(trampoline)。
```js
// 蹦床:把递归改写成"循环执行返回的函数",栈深恒定为
function trampoline(fn) {
return (...args) => {
let result = fn(...args);
while (typeof result === 'function') result = result(); // 只要返回函数就继续跑
return result;
};
}
const sumTo = trampoline(function step(n, acc = 0) {
return n === 0 ? acc : () => step(n - 1, acc + n); // 返回"下一步"而不是直接递归
});
console.log(sumTo(200000)); // 20000100000 —— 十万层也不会爆栈
```
复杂度上,朴素递归求斐波那契是 ,改用迭代或记忆化后降到 :
四、注意事项与常见坑
this与函数的十个高频陷阱1.
obj.method传给回调就丢this→ 用箭头函数包一层,或bind。2. 箭头函数当对象方法:
this指向外层而非对象 → 用方法简写。3.
class方法解构出来单独调用 →TypeError(不是静默的undefined),必要时在构造函数里this.method = this.method.bind(this),或用#private+ 箭头函数字段。4.
forEach/map的第二个参数能指定this,但箭头函数会忽略它 → 别混用。5.
new的优先级高于bind,bind的thisArg在new下会被丢弃。6. 非严格模式的默认绑定是
globalThis,会给全局对象偷偷加属性 → 类与模块默认就是严格模式,能早暴露错误。7.
return与换行:return后换行会被自动分号插入(ASI)切断,函数返回undefined。8. 箭头函数返回对象字面量必须加括号:
() => ({a:1}),否则{}被当成函数体。9. 循环里绑定事件/定时器用
var→ 全部指向最后一个值,改用let。10. 默认参数引用后面的参数会报错:
(a = b, b = 1) => {}在调用时抛ReferenceError(求值顺序是从左到右)。
三个"静默失效"的场景
-
sort()会原地修改数组并返回同一引用,const sorted = arr.sort()会让arr也变。要复制:[...arr].sort()。-
reduce忘记return累积器,下一步的acc变成undefined,报错位置往往离真正原因很远。- 闭包捕获的是变量本身而不是当时的快照,所以"循环里 push 函数"必须靠
let或 IIFE 制造新绑定。
五、练习题
练习 1(
this判定)不运行代码,写出下面每处的
this指向,再用 Node 验证:①
function f(){ return this; } f();(严格/非严格各一次)②
const o = { f }; o.f();③
const g = o.f; g();④
const B = o.f.bind({ tag: 'x' }); new B();
练习 2(闭包计数器)
用闭包写一个
createIdGenerator(prefix),每次调用返回${prefix}-1`、`${prefix}-2……并且外部无法把计数器改回 0。再写一个reset()把它归零。
练习 3(循环陷阱)
用
var写一个循环,往数组里 push 三个函数,使arr.map(f => f())得到[0, 1, 2],要求不使用let、不使用forEach。
练习 4(柯里化与偏函数)
实现
curry(fn)支持f(1)(2)(3)与f(1, 2)(3)两种调用;然后用它基于(protocol, host, path) => string造出httpsApi('/users')。
练习 5(纯函数重构)
下面这个函数有三个副作用,请改写为纯函数,并说明调用方需要如何配合:
```js
let total = 0;
function addPrice(items, index) {
items[index].price *= 1.1;
total += items[index].price;
console.log('当前总计', total);
return total;
}
```
六、常见问题 FAQ
我该用箭头函数还是普通函数?
判据只有一条:需不需要自己的
this(或arguments、或作为构造函数)。需要 → 普通函数/方法简写;不需要 → 箭头函数(回调里几乎总是它)。不要在class/对象的方法上用箭头函数,除非你确实想让它继承外层this。
bind和箭头函数都能解决this丢失,选哪个?优先箭头函数:在调用点就能看出问题,不产生额外的函数对象与包装层。
bind适合三类场景:① 需要把已存在的方法引用直接交给别人(如事件监听、Promise.then);② 需要预置参数;③ 需要在构造函数里做一次永久绑定(老式 React class 组件的做法)。注意每次bind都会创建一个新函数,别在渲染/循环里反复bind。
闭包会导致内存泄漏吗?
只有当"被闭包引用的变量"本应被回收却被继续持有时才算泄漏。常见情形:长期存活的定时器/事件监听里捕获了大对象;或者把闭包存进全局数组后忘了清理。规范做法是:① 闭包只捕获真正需要的值;② 组件卸载/对象销毁时
clearTimeout、removeEventListener、断开Map引用。现代引擎对未被引用的变量会做优化,不必为了"释放"而写x = null这种噪音代码。
函数声明和函数表达式在实践上该怎么选?
顶层工具函数、需要被提前调用、需要清晰的函数名(便于栈跟踪) → 函数声明。需要条件赋值、只需用一次的回调、要赋值给
const防止被覆盖 → 函数表达式或箭头函数。唯一的硬约束是提升差异:函数表达式在定义前调用会抛 TDZ 错误,而函数声明可以。
相关笔记
- JavaScript-01-基础语法与类型 ——
var/let/const、TDZ 与原始类型,本篇的提升机制在那里有对照表 - JavaScript-03-对象与原型链 —— 对象方法、
class、prototype与new的四个步骤 - JavaScript-04-异步编程 —— 事件循环与回调,理解"
setTimeout里的this为什么会丢"需要这一篇 - JavaScript-07-ES6新特性 —— 解构、展开、默认值在参数中的组合用法
- Python-03-函数与模块 —— 与 Python 的作用域规则(LEGB)和闭包对照阅读
- 算法-查找与分治 —— 递归与分治的算法视角
- 算法-复杂度分析 —— 本篇 、 与主定理的定义
参考来源
- MDN:函数(Functions)
- MDN:
this - MDN:
arguments对象 - MDN:剩余参数
- MDN:默认参数
- MDN:
Function.prototype.bind() - MDN:
Function.prototype.call() - MDN:
var - MDN:
function声明 - MDN:严格模式
- ECMAScript 语言规范(TC39 官方最新版)
- 现代 JavaScript 教程:闭包
- 现代 JavaScript 教程:老旧的 var
- 现代 JavaScript 教程:箭头函数
- 现代 JavaScript 教程:函数基础
- 现代 JavaScript 教程:函数对象与调度
- 现代 JavaScript 教程:柯里化
- 现代 JavaScript 教程:递归与堆栈
- Node.js 官方文档