w wyl123ly 的博客
MD

JavaScript-02-函数与作用域

49 KB 2026.10.11 原文件

JavaScript-02-函数与作用域

本篇讲什么

函数是 JavaScript 的一等公民,也是理解这门语言的分水岭。本篇解决四个最容易困惑的问题:

① 函数声明与函数表达式为什么"调用位置可以不同"(提升的差异);

② 箭头函数到底和普通函数差在哪(this、arguments、构造函数能力);

③ this 究竟指向谁(四条绑定规则与优先级,以及最常见的"丢失 this"场景);

④ 闭包是什么、为什么能"记住"外层变量、以及循环里 var 与 let 的经典陷阱。

另外覆盖:参数机制、作用域与作用域链、变量提升的完整机制、IIFE 的历史作用、纯函数与副作用、高阶函数、柯里化、递归与尾调用优化现状。

读完后你应该能准确说出"这段代码里 this 是什么""这个变量是从哪来的",并写出没有副作用的函数。


一、是什么:函数的四种写法

JS 里"定义函数"有四种主要写法,它们的提升行为、this、能否 new 都不一样。

写法语法提升有自己的 this能 newarguments典型用途
函数声明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只提升声明进入作用域时初始化为 undefinedundefined(不报错)
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)和闭包对照阅读
  • 算法-查找与分治 —— 递归与分治的算法视角
  • 算法-复杂度分析 —— 本篇 、 与主定理的定义

参考来源