一个购物车模块,方法写在对象里:
const cart = {
items: [],
add(item) {
this.items.push(item);
}
};
cart.add("苹果"); // 正常,items 变成 ["苹果"]
const add = cart.add; // 把方法取出来单独用
add("香蕉"); // 报错:Cannot read properties of undefined (reading 'items')
同一个函数,直接通过 cart.add() 调用能跑,取出来单独调用就崩了。原因是 this 不是函数自己的属性,它在每次调用时由「怎么调」决定。cart.add() 是「通过 cart 调」,this 就是 cart;add() 是「裸调」,严格模式下 this 是 undefined。
这个机制在回调里到处惹事:传给 setTimeout、注册成事件监听、作为数组方法的回调,方法一离开原来的对象,this 就变了。
这篇讲什么:this 的四条绑定规则和优先级、箭头函数为什么能救场又为什么不能乱用、class 怎么写和怎么继承。读完你能做到:看到 this 为 undefined 的报错能马上定位是哪种调用方式导致的;知道什么时候该用箭头函数、什么时候不能;能读懂项目里的 class 代码,包括私有字段和静态方法。
this 由调用方式决定,不由定义位置决定
先记住一句话:普通函数的 this,看它「怎么被调用」,跟它在哪定义没关系。规则有四条,按优先级从低到高排:
fn()。严格模式下 this 是 undefined,非严格模式是全局对象(浏览器里是 window)。obj.fn(),this 是 obj。取出来单独调用就退化成默认绑定。fn.call(obj)、fn.apply(obj)、fn.bind(obj),强行指定 this。new Fn(),this 是新创建的对象,优先级最高。function whoAmI() {
console.log(this === undefined ? "undefined" : this.name);
}
const obj = { name: "张三", whoAmI };
obj.whoAmI(); // 张三 隐式绑定
const fn = obj.whoAmI;
fn(); // undefined 默认绑定(严格模式)
obj.whoAmI.call({ name: "李四" }); // 李四 显式绑定
function Person(name) { this.name = name; }
const p = new Person("王五");
console.log(p.name); // 王五 new 绑定
优先级不是背出来的,遇到冲突时看谁最后起作用。bind 固定过的函数,再 call 也改不回来:
function show() {
console.log(this.name);
}
const bound = show.bind({ name: "张三" });
bound.call({ name: "李四" }); // 张三,bind 已经固定
new bound(); // undefined,new 的优先级更高
最后那行说明 new 的优先级高于 bind:用 new 调一个绑定过的函数,this 仍然是新创建的对象,绑定失效。实际项目里很少这么写,但知道有这么回事,看到奇怪的题面不至于被绕进去。
隐式绑定看的是「点号前面那个对象」,链式调用时只有最后一个点号算数:
const app = {
name: "app",
user: { name: "张三", show() { console.log(this.name); } }
};
app.user.show(); // 张三
const show = app.user.show;
show(); // undefined,取出来就丢了
const { show: destructured } = app.user;
destructured(); // undefined,解构同样丢
事件监听是另一个高发区。用普通函数注册,this 是绑定事件的元素;用箭头函数,this 是定义时外层的值:
const panel = {
name: "面板",
bind(button) {
button.addEventListener("click", function () {
console.log(this); // button 元素
});
button.addEventListener("click", () => {
console.log(this.name); // 面板,外层 this
});
}
};
还有两种常见写法也会丢 this:把方法挂到全局再调用,比如 window.save = cart.add 之后执行 save();或者把方法赋给另一个对象的同名属性。判断时只看调用那一刻点号左边是谁,别顺着函数定义的位置找。
call 和 apply 的区别只在传参:fn.call(obj, a, b) 逐个传,fn.apply(obj, [a, b]) 用数组传。参数个数不定时 apply 方便,现在也可以写 fn.call(obj, ...args),区别更小。它们和 bind 的不同在于:call 和 apply 是立刻执行,bind 是返回一个等着被调用的新函数。
「严格模式」这里不是细节,它直接决定裸调时 this 是 undefined 还是 window。ES 模块里的代码默认就是严格模式,所以现在项目里裸调基本都会拿到 undefined,报错倒是干脆,至少不会悄悄改全局变量。
this。原因和取舍放在下一节。箭头函数:借用外层的 this,但不是万能药
箭头函数没有自己的 this,函数体里用到 this 时,往外层作用域找——就是「定义它的那个普通函数」的 this。所以它一旦写出来,this 就固定了,call、apply、bind 都改不了。
const counter = {
count: 0,
start() {
// 这里如果用普通函数,setTimeout 里的 this 会变成 undefined
setTimeout(() => {
this.count++;
console.log(this.count); // 1
}, 1000);
}
};
counter.start();
但反过来,把箭头函数写在对象字面量的方法位置,就是典型的误用:
const bad = {
name: "张三",
greet: () => {
console.log(this.name); // undefined,this 是外层的
}
};
const good = {
name: "张三",
greet() {
console.log(this.name); // 张三
}
};
我的使用原则:需要随着调用对象变化 this 的,用普通函数(对象方法、class 方法、原型方法);需要固定住外层 this 的,用箭头函数(定时器回调、Promise 回调、事件回调)。判断标准不是「新语法更好」,而是「这个函数要不要自己的 this」。
class 里有个常用折中:把方法写成实例字段的箭头函数,既保住 this,又不用每次手动 bind:
class SearchBox {
keyword = "";
handleInput = (event) => {
this.keyword = event.target.value; // this 永远是当前实例
};
mount() {
document.querySelector("#search").addEventListener("input", this.handleInput);
}
}
const box = new SearchBox();
box.mount();
代价是这个函数不在原型上,每个实例创建时都要新建一份。100 个实例无所谓,1 万个实例就是 1 万个额外的函数对象;如果组件会被大量创建,还是用普通方法加 bind,或者在构造函数里绑定一次。
箭头函数的限制也要知道:它不能当构造函数,new (() => {}) 会报 TypeError: ... is not a constructor;它没有自己的 arguments,要用剩余参数 (...args) =>;它也没有 prototype 属性。看到这几类报错,先确认是不是把箭头函数放在了需要普通函数的位置。
还有一个容易误判的点:箭头函数里的 this 是「定义时外层作用域」的 this。对象字面量的 { greet: () => this.name } 并不构成一层 this,它外层是模块或全局。模块顶层 this 是 undefined,所以报错;普通脚本里 this 是 window,读到的可能是 window.name(通常是空串),不一定报错,但结果一样不对。
回调丢 this 的三种修法
回到开头购物车的例子,在真实项目里有三种常见写法,各有适用场景:
// 写法一:bind,创建一个 this 固定的新函数
const add = cart.add.bind(cart);
add("香蕉"); // 正常
// 写法二:包一层箭头函数,调用时还是通过 cart 调
button.addEventListener("click", () => cart.add("香蕉"));
// 写法三:把方法本身改成箭头函数属性(仅当不需要动态 this)
const cart2 = {
items: [],
add: (item) => { cart2.items.push(item); } // 直接引用 cart2
};
写法一适合需要把函数存起来、之后还要解绑的场景(removeEventListener 必须传同一个函数引用)。写法二最直观,事件回调里很常用。写法三能用但不推荐,对象还没创建完就引用了自己,改个变量名就容易漏改。
bind 创建新函数,解绑时不能写 removeEventListener("click", cart.add),因为那是另一个函数。得把绑定后的函数存到一个变量,绑和解都用它。bind 除了固定 this,还能预填参数,剩下的参数调用时再传:
function request(url, method, body) {
console.log(method, url, body);
}
const post = request.bind(null, "/api/orders", "POST");
post("{\"id\":1}"); // POST /api/orders {"id":1}
事件委托里则要注意 this 和 event.target 不是一回事。监听绑在父容器上,this 和 event.currentTarget 都是父容器,event.target 才是真正被点的子元素。想拿子元素,用 event.target.closest("button"),别对着 this 找。
在前端框架里,内联箭头函数还有一个副作用:每次渲染都创建一个新函数,作为 prop 传给子组件时,浅比较会认为它变了,导致子组件多做一次更新。列表很长时这不是小开销。要么把处理函数提到组件外,要么用框架提供的缓存手段固定引用;class 组件里则用实例字段箭头函数。
class:写法变了,本质还是原型
上一篇文章讲过原型链,class 就是那套机制的语法糖。它解决的是「构造函数加一堆 prototype.xxx = ...」写法散乱的问题:
class Cart {
constructor(userId) {
this.userId = userId;
this.items = [];
}
add(item) {
this.items.push(item);
}
get total() {
return this.items.reduce((sum, item) => sum + item.price, 0);
}
}
const cart = new Cart("u1001");
cart.add({ name: "苹果", price: 5 });
cart.add({ name: "香蕉", price: 3 });
console.log(cart.total); // 8,注意不加括号,它是 getter
console.log(Object.getPrototypeOf(cart) === Cart.prototype); // true
console.log(cart.hasOwnProperty("items")); // true,实例自己的
console.log(cart.hasOwnProperty("add")); // false,方法在原型上
几个容易搞混的点:
| 写法 | 位置 | 说明 |
|---|---|---|
constructor | 每个实例一份 | 用 new 时自动执行,初始化实例字段 |
| 普通方法 | 原型上共享 | add() 所有实例共用一份 |
get total() | 原型上 | 取值时自动执行,用的时候不加括号 |
static 方法 | 类本身 | 用 Cart.create() 调,不在实例上 |
#field | 实例上 | 私有字段,类外面访问不到,适合不想暴露的内部状态 |
class Counter {
#count = 0; // 私有字段,外部读不到
static from(initial) { // 静态工厂方法
const c = new Counter();
c.#count = initial;
return c;
}
inc() {
this.#count++;
return this.#count;
}
}
const c = Counter.from(5);
c.inc(); // 6
console.log(c.#count); // 语法错误:私有字段只能在类内部访问
new 调用,直接写 Cart() 会报错。常见的「方法丢失 this」问题在 class 里一样存在:const add = cart.add 之后单独调用,this 照样是 undefined。几个语法层面的差异,调试时会碰到:class 声明不会像函数声明那样提升,在声明之前使用会报 ReferenceError: Cannot access 'Cart' before initialization;class 必须用 new 调用,直接写 Cart() 会报 TypeError: Class constructor Cart cannot be invoked without 'new'。看到这两个报错,基本就是调用位置或调用方式的问题。
实例字段的初始化顺序也值得记一下。字段在构造函数体执行前初始化,所以构造函数里能直接读到:
class Cart {
items = [];
constructor(userId) {
this.userId = userId;
console.log(this.items.length); // 0,字段已经初始化
}
}
普通方法定义在原型上,而且是不可枚举的,Object.keys(cart) 看不到 add;JSON.stringify(cart) 也只序列化实例自己的字段,getter 和原型方法都不会出现在结果里。排查「接口收到的对象少了字段」时,先想想它是不是 getter。
getter 里不要做重活。每次读 cart.total 都会重新遍历一遍 items,如果在模板的循环里反复读,100 行列表可能把同样的求和算上千次。要么在数据变化时算一次存起来,要么改成普通方法 getTotal(),让调用方知道这里有计算成本。
继承:extends 和 super
继承解决的是「几个类大部分相同、少部分不同」。写法是 extends 加 super:
class ApiError extends Error {
constructor(message, code) {
super(message); // 必须先调,父类负责初始化 Error 的部分
this.name = "ApiError";
this.code = code;
}
toString() {
return this.name + "(" + this.code + "): " + this.message;
}
}
const err = new ApiError("库存不足", 4001);
console.log(err.message); // 库存不足
console.log(err.toString()); // ApiError(4001): 库存不足
console.log(err instanceof Error); // true,原型链一路向上
console.log(err instanceof ApiError); // true
继承里最容易出事的两处:一是子类构造函数里 super() 之前不能访问 this,因为父类还没把 this 建好;二是 super.method() 调的是父类原型上的方法,不要在子类里写成 Parent.prototype.method.call(this),那是绕远路。
静态方法也会被继承,而且里面的 this 指向当前类,不是定义时的父类。这个特性常用来写工厂方法:
class Base {
static create() {
return new this();
}
}
class Special extends Base {
constructor() {
super();
this.kind = "special";
}
}
const s = Special.create();
console.log(s instanceof Special); // true,this 是 Special
console.log(s.kind); // special
如果写成 return new Base(),拿到的永远是父类实例,子类的字段不会初始化。这类问题不报错,只是类型判断和行为对不上,排查时容易往业务逻辑上想。
继承层级控制在三层以内是个实用标准。超过三层,改一个父类方法要往上往下都想一遍;更麻烦的是子类覆盖了一半、另一半靠父类默认值,行为很难从子类代码直接读出来。需要复用能力时,组合通常更清楚:把校验、格式化拆成独立函数或对象,在需要的地方调用。
什么时候不该用 class
class 不是默认选择。项目里很多「类」其实只是「一组数据加几个纯函数」,用普通对象和函数更轻:
适合用 class
需要创建很多结构相同的实例、有内部状态需要在方法之间共享、确实存在继承关系(比如 ApiError 继承 Error)。
不适合用 class
只有一个实例、只有数据没有行为、或者需求里根本没有「多实例」的概念。为了「看起来面向对象」把配置包成类,读代码的人还得先 new 一下才知道里面有什么。
还有一个现实问题:继承层数一多,改父类会影响所有子类,排查问题要顺着链条上下看。三层以内一般还好,再深就该考虑用组合,把能力拆成独立的函数或对象,需要什么拼什么。
反过来,class 在「大量同构实例」的场景里是有优势的:方法放在原型上共享,1 万个实例也只有一份方法代码。用对象字面量加方法,每个对象都会带一份函数引用,内存反而更大。所以不是「class 一律不好」,而是看有没有真的多实例和共享行为。
还有两个实际限制。跨 iframe、跨模块副本时,instanceof 会失效:同一个类在两份代码里定义,构造函数不是同一个,判断结果为 false。需要可靠判断时,用「鸭子类型」检查关键字段,或者让类提供静态的 isXxx(value) 方法。另一个是序列化,class 实例 JSON.stringify 之后只剩自己的可枚举字段,方法、getter、私有字段都丢了,反序列化回来也只是普通对象,不再是实例。
完整场景走查:批量上传发票
需求:财务后台上传发票,一次最多 200 个文件,单个不超过 10MB。要求按顺序上传,避免把出口带宽打满;每成功一个更新进度;用户可以中途取消;失败的单个文件跳过,不影响后面的。
第一版用一个 class 包起来,思路很直接:
class InvoiceUploader {
constructor(files, onProgress) {
this.files = files;
this.onProgress = onProgress;
this.done = 0;
}
start() {
this.files.forEach((file) => {
this.send(file); // 没有 await,200 个请求一起发出去
});
}
send(file) {
const form = new FormData();
form.append("file", file);
fetch("/api/invoices/upload", { method: "POST", body: form })
.then((res) => res.json())
.then(() => {
this.done += 1;
this.onProgress(this.done / this.files.length);
});
}
}
const uploader = new InvoiceUploader(files, (ratio) => {
progressBar.style.width = (ratio * 100) + "%";
});
uploader.start();
三个文件测试时一切正常,上线遇到 200 个文件就散了。
第一,forEach 里没有等上一个请求完成,200 个 fetch 同时发出去。HTTP/1.1 下浏览器对同一域名只开 6 个连接,其余排队;服务端网关 30 秒没收到完整请求就断开,排在后面的文件大量失败。就算上了 HTTP/2,200 个并发流也会把服务端连接池占满。
第二,失败也被算进进度。fetch 只在网络层失败时 reject,接口返回 500 时 res.json() 可能成功也可能抛错,代码没判 res.ok。有一次接口限流返回 429,进度条照样往前走,最后显示 100%,实际只成功了一半。
第三,没有取消。用户点「返回」后组件已经卸载,回调还在往一个不存在的 DOM 节点写进度,控制台报 Cannot read properties of null。
第四,onProgress 如果被存起来之后用普通函数调用,比如内部改成 setTimeout(this.onProgress, 300),this 就丢了。这类改动往往发生在「加个节流」的时候,原来能跑的代码突然报错。
改回来分三步:串行执行、失败隔离、可取消。
class InvoiceUploader {
#files;
#done = 0;
#cancelled = false;
#timer = null;
constructor(files) {
this.#files = files;
}
get progress() {
return this.#files.length === 0 ? 1 : this.#done / this.#files.length;
}
cancel() {
this.#cancelled = true;
}
report = () => {
console.log(`${this.#done}/${this.#files.length}`);
};
async start() {
for (const file of this.#files) {
if (this.#cancelled) break;
await this.#send(file);
clearTimeout(this.#timer);
this.#timer = setTimeout(this.report, 300);
}
return {
done: this.#done,
total: this.#files.length,
cancelled: this.#cancelled
};
}
async #send(file) {
const form = new FormData();
form.append("file", file);
let res;
try {
res = await fetch("/api/invoices/upload", { method: "POST", body: form });
} catch (err) {
console.warn("网络失败,跳过", file.name, err);
return;
}
if (!res.ok) {
console.warn(`上传失败 ${res.status}`, file.name);
return;
}
this.#done += 1;
}
}
const uploader = new InvoiceUploader(files);
uploader.start().then((result) => console.log(result));
// { done: 198, total: 200, cancelled: false }
几个改动对应上面的问题:for...of 加 await 保证同一时间只有一个请求;#send 内部 try/catch 加 res.ok 判断,把失败挡在单个文件这一层;cancel() 只置标志,循环在下一个文件前检查,已经发出的请求不强行中断,避免服务端留下半截文件;report 用实例字段箭头函数,传给 setTimeout 也不会丢 this。
代价是速度。200 个文件、每个平均 600 毫秒,串行要两分钟;如果服务端允许,可以改成 4 个并发的小池子,时间压到三十多秒,但要先确认限流阈值。串行不是唯一答案,是在「不压垮服务端」和「用户等待」之间选的默认值。
进度也不能只报一个百分比。200 个文件成功 196 个、失败 4 个,进度条走到 100% 会让用户以为全好了。返回值里带上失败文件列表,界面单独提示「4 个文件上传失败,点击重试」,比一个数字有用得多。
错误现象对照
下面这些现象在业务代码里出现频率很高,先看报错原文,再按第三列动手查。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
调用方法时报 Cannot read properties of undefined (reading 'items') | 方法被取出来裸调,或者作为回调传入,this 变成 undefined | 看调用处有没有对象前缀,回调是不是用了普通函数 |
事件回调里 this 是按钮,不是组件实例 | 普通函数注册监听,this 指向绑定事件的元素 | 确认回调是箭头函数,还是需要用 event.currentTarget |
this.$refs.form 或 this.state 为 undefined | 回调里的 this 不是组件实例,常见于 function 回调和解构赋值 | 检查该函数定义位置,以及是否被单独传递 |
TypeError: Class constructor Cart cannot be invoked without 'new' | 调用 class 时漏了 new | 看调用处,补 new 或改用工厂函数 |
ReferenceError: Cannot access 'Cart' before initialization | class 声明没有提升,在声明之前就用了 | 确认调用代码在 class 定义之后,或把定义上移 |
TypeError: ... is not a constructor | 对箭头函数使用了 new | 看构造函数是不是写成了箭头函数 |
边界与代价
this 的规则本身不贵,贵在依赖隐式绑定带来的不可见耦合。判断标准很简单:这个函数会不会被单独传递、延迟调用、挂到别的对象上?只要有一个答案是「会」,就别依赖调用时的点号。
回调里需要动态 this 时(比如同一份处理函数要同时服务多个 DOM 元素,靠 this 区分触发者),不要用箭头函数,改用普通函数加 event.currentTarget。反过来,定时器、Promise、数组方法的回调,基本都应该用箭头函数或提前 bind。用 bind 时记住它返回新函数,解绑、比较引用、当依赖项时都要用同一个引用。
class 的代价主要在继承和实例数量上。继承超过三层,阅读和修改成本明显上升;一个类被 1 万个实例创建、又在每个实例上放箭头函数字段,内存会比原型方法高一个量级。纯数据结构不要包成 class,普通对象加一个构造函数或工厂函数就够;需要私有状态时,闭包或 # 字段都可以,前者更轻,后者更符合类型检查工具的预期。
跨模块、跨 iframe 时,instanceof 不可靠,因为构造函数可能来自两份不同的模块实例。判断类型优先看结构特征,比如有没有约定的字段或方法,而不是死盯 instanceof。需要序列化传输的对象也别用 class,JSON 只保留可枚举的自有字段,方法、getter、私有字段都会在往返中丢掉。
还有性能上的误区:call、apply、bind 本身的开销可以忽略,别为了「省一次 bind」把代码写得难读。真正贵的是在渲染循环里每次创建新函数、新闭包,以及深继承带来的多轮查找。优化应该放在这些地方,而不是把方法都改成箭头函数。
小结
this 看调用方式:裸调、obj.fn()、call/apply/bind、new,优先级从低到高。this,适合回调里固定外层;对象方法和 class 方法别写成箭头函数。class 是原型的语法糖:实例字段在实例上,方法在原型上共享;# 是真正的私有。下面几条可以今天就在控制台里验证,每条都用不了十分钟:
- 复现开头购物车的错误:把
cart.add取出来单独调用,确认报错文本;再用bind修好。 - 给按钮注册一个普通函数监听和一个箭头函数监听,分别在回调里打印
this,对比两者是谁。 - 写一个带
#count私有字段的 class,在类外部读一次,把语法错误原文记下来。 - 让
ApiError继承Error,检查instanceof和err.stack,确认继承链没断。 - 用
setTimeout调用一个对象的普通方法,观察this丢失;再换成箭头函数字段,确认问题消失。
下一篇讲模块化。到这里,值、函数、对象、this 这些零件都齐了,模块化解决的是「这些零件怎么分文件、怎么互相引用」。它和这篇还有一层关系:ES 模块顶层默认是严格模式,裸调函数的 this 会变成 undefined,把代码从普通脚本搬进模块时,原来靠 window 兜底的写法会立刻暴露出来。这是从单文件脚本走向真实项目时,最先撞上的一课。