一个后台项目里有个「编辑」弹窗:点某一行,把这一行的数据赋给表单,用户改完点保存,再合并回列表。上线后发现一个问题——用户打开弹窗改了内容,然后点「取消」,列表里的那一行居然也变了。
// 打开弹窗
form.data = row; // 直接把列表里的对象给了表单
// 用户改输入框,双向绑定时执行
row.name = "新名字"; // 列表里那一行同时被改
// 点取消:没有恢复逻辑,因为「本来以为没动过」
row.name = "旧名字"; // 手动恢复,但数据源已经脏了
问题不在弹窗组件,而在于 form.data = row 只是复制了引用,表单和列表指向同一个对象。要修它就得先拷贝一份。而「拷贝」这件事,浅拷贝和深拷贝的差别,正好是对象和原型链这套知识里最实用的部分。
这篇讲什么:对象的属性怎么访问、Object 上那些常用方法各自解决什么问题、原型链是什么(为什么你没写过 toString 却能用它)、以及深浅拷贝怎么选。读完你能做到:拿到接口数据后知道该怎么复制才不会互相污染;看懂别人代码里的 Object.assign 和展开运算符到底复制了几层。
属性的两种访问方式
对象就是一组键值对。访问有两种写法,点号和方括号,大部分时候等价:
const user = { name: "张三", age: 28 };
user.name; // "张三"
user["name"]; // "张三"
const key = "age";
user[key]; // 28
user.key; // undefined,找的是字面量 "key" 这个属性
区别就出在最后那行:点号后面是固定的名字,方括号里可以是变量、表达式。所以键名是动态的时候必须用方括号。键名本身不是合法标识符时也只能用方括号:
const stats = { "user-count": 12 };
stats["user-count"]; // 12
// stats.user-count 会被解析成「stats.user 减 count」
还有一个容易忽略的规则:对象的键最终都是字符串(或者 Symbol)。你写 { 1: "一" },键会被转成 "1"。整数形式的键在遍历时会按数值升序排在前面,其他键按插入顺序:
const obj = { b: 1, 2: "two", a: 2, 1: "one" };
console.log(Object.keys(obj)); // ["1", "2", "b", "a"]
需要严格按插入顺序,或者键的类型不止字符串,用 Map。它保留了插入顺序,键可以是对象。
实际取值时还有两个常用写法。属性链可能断的时候用可选链,别一层层写 &&:
const city = user?.address?.city ?? "未填写";
解构也能给默认值,但规则和函数参数一样,只认 undefined。接口把空值返回成 null 时,默认值不生效:
const { age = 30 } = { age: null };
console.log(age); // null
键的类型上,Symbol 也能当键。它不出现在 Object.keys、JSON.stringify 和 for...in 里,适合放一些不想被序列化的内部标记。计算属性名用方括号,对象字面量里也能写:
const key = "price";
const product = { [key]: 99 };
console.log(product.price); // 99
Object 上那些方法,各自管什么
Object 自带的方法不少,常用的其实就这几个,按用途记比按字母背有用:
| 方法 | 作用 | 典型场景 |
|---|---|---|
Object.keys(obj) | 取可枚举的自有键,返回数组 | 遍历对象、统计字段 |
Object.values(obj) | 取值,返回数组 | 求和、批量校验 |
Object.entries(obj) | 取键值对,返回二维数组 | 同时要键和值时最好用 |
Object.assign(target, ...sources) | 把后面对象的属性合并进第一个对象 | 浅合并配置、默认值 |
Object.freeze(obj) | 冻结,不能增删改属性 | 常量配置;只冻结第一层 |
Object.hasOwn(obj, key) | 判断是不是自己的属性 | 替代 hasOwnProperty |
Object.create(proto) | 以指定对象为原型创建新对象 | 手动做原型继承、创建无原型对象 |
举两个实际会用的组合:
const config = { retry: 0, timeout: 3000 };
const defaults = { retry: 2, timeout: 5000, baseURL: "/api" };
// 用展开运算符合并(等价于 Object.assign({}, defaults, config))
const merged = { ...defaults, ...config };
console.log(merged); // { retry: 0, timeout: 3000, baseURL: "/api" }
// 键值一起处理
const prices = { apple: 5, banana: 3 };
const total = Object.values(prices).reduce((sum, n) => sum + n, 0);
console.log(total); // 8
注意 Object.assign 会修改第一个参数。想生成新对象,第一个参数传 {},或者直接用展开运算符。两者都是浅合并:遇到嵌套对象,值还是同一个引用。
还有一个反向的 Object.fromEntries,把 entries 的二维数组变回对象,配合 map 做字段改名很顺手:
const raw = { user_name: "张三", user_age: 28 };
const user = Object.fromEntries(
Object.entries(raw).map(([k, v]) => [k.replace("user_", ""), v])
);
console.log(user); // { name: "张三", age: 28 }
Object.freeze 只冻结第一层。嵌套对象照样能改,而且非严格模式下改了不报错,只有严格模式才抛 TypeError:
const config = Object.freeze({ retry: 3, db: { host: "127.0.0.1" } });
config.retry = 5; // 严格模式抛 TypeError,非严格静默失败
config.db.host = "10.0.0.1"; // 成功,db 没有被冻结
console.log(config.db.host); // "10.0.0.1"
所以别把 freeze 当成运行时的不可变保证,它更适合在开发阶段把「不该改却改了」变成显式报错。
展开运算符和 Object.assign 结果看着一样,有一处行为差别:Object.assign 走的是赋值,会触发目标对象上已有的 setter;展开运算符是定义新属性,不触发。目标是个普通对象时没区别,目标是带 getter/setter 的实例时,结果会不一样。
原型链:方法是从哪找来的
先看一个现象:你没在对象上写过 toString,但它能用:
const user = { name: "张三" };
console.log(user.toString()); // "[object Object]"
因为对象除了自己的属性,还挂着一个「原型」对象。访问属性时,引擎先找对象自己有没有,没有就去原型上找,原型没有就去原型的原型上找,直到链条尽头 null。这条链就是原型链。
name 这类直接写在花括号里的属性Object.prototype,上面有 toString、hasOwnProperty 等公共方法null,再往上没有了之所以这么设计,是为了让方法共享。一千个用户对象不需要各自存一份 toString,它们都指向同一个原型,方法只存一份。省内存,也方便统一修改。
查找是逐层进行的,所以原型链越长,属性访问越慢。单次访问的差异可以忽略,放在十万次循环里能量出来。真正要避免的是「无意中把链拉得很长」:每层继承都往链上加一环,自己写的继承超过三层,就该想想是不是该换成组合。
还有一个反直觉的点:in 会沿着原型链找,Object.hasOwn 只看自己。调试时看到 "toString" in {} 是 true,不用惊讶。
如果对象只当字典用、键完全可控,可以用 Object.create(null) 建一个没有原型的对象。它没有 toString,也没有 hasOwnProperty,键名就不会撞上原型方法;代价是调试打印出来是 [Object: null prototype],而且不能直接调 obj.hasOwnProperty()。
几个词容易混,用一句话区分:
prototype
函数才有的属性。用 new 调用这个函数创建对象时,新对象的原型就是 函数.prototype。它是「给将来的实例准备的原型」。
__proto__
对象才有的内部链接,指向它自己的原型。平时读它用 Object.getPrototypeOf(obj),改它不推荐(性能和语义都有问题)。
constructor
原型对象上的一个属性,指回创建它的函数。它更多是给人看的线索,不要拿它做类型判断。
再补一句 __proto__:它不是普通属性,而是 Object.prototype 上的一个访问器。读它拿到原型,写它会把对象的原型整个换掉,而不是新增一个键,所以看到 obj.__proto__ = x 要格外小心。改原型用 Object.setPrototypeOf,但它在运行时会触发引擎对这个对象去优化,热路径里别用;要在创建时就定原型,用 Object.create(proto)。
function User(name) {
this.name = name;
}
User.prototype.greet = function () {
return "你好," + this.name;
};
const u = new User("张三");
u.greet(); // "你好,张三"
Object.getPrototypeOf(u) === User.prototype; // true
u.hasOwnProperty("greet"); // false,方法在原型上
u.hasOwnProperty("name"); // true
class 是同一套东西的新写法
现在更常见的是 class,但它不是新的对象模型,只是原型写法的语法糖:
class User {
constructor(name) {
this.name = name;
}
greet() {
return "你好," + this.name;
}
}
const u = new User("张三");
u.greet(); // "你好,张三"
Object.getPrototypeOf(u) === User.prototype; // true
// greet 仍然挂在 User.prototype 上,所有实例共享一个
继承也一样,extends 的本质是把子类的原型链接到父类上:
class Admin extends User {
constructor(name, level) {
super(name); // 调用父类构造函数,必须先写
this.level = level;
}
greet() {
return super.greet() + "(管理员)";
}
}
const a = new Admin("李四", 3);
a.greet(); // "你好,李四(管理员)"
console.log(a instanceof Admin); // true
console.log(a instanceof User); // true,原型链一路往上都能命中
关于 this、class 字段和箭头函数方法,下一篇this 与 class会细讲。这里只需要建立「方法和实例是分开的,方法在原型上共享」这个直觉。
class 还有两个和原型写法不同的地方。一是 static 方法挂在类本身,不在 prototype 上,实例访问不到;二是 class 里定义的方法默认不可枚举,而对象字面量里的方法是可枚举的,这会影响 for...in 和 Object.keys 的结果:
class User {
static create(name) { return new User(name); }
greet() { return "hi"; }
}
console.log(typeof User.create); // "function"
console.log(User.prototype.create); // undefined
console.log(Object.keys(User.prototype)); // [],方法不可枚举
继承时的构造器:派生类不写 constructor,会自动调用 super(...args);写了就必须在用到 this 之前先调 super(),否则报 Must call super constructor。
深拷贝和浅拷贝:到底复制了几层
回到开头的事故。下面三种写法都只复制第一层:
const row = { id: 1, name: "张三", address: { city: "杭州" } };
const copy1 = { ...row };
const copy2 = Object.assign({}, row);
const copy3 = { id: row.id, name: row.name, address: row.address };
copy1.address.city = "上海";
console.log(row.address.city); // "上海",嵌套对象还是同一个
第一层的 id、name 是原始值,复制了值;address 是对象,复制的是引用。所以改嵌套对象,原对象跟着变。这叫浅拷贝。
深拷贝是每一层都开新对象。常见做法有三种,各有代价:
| 做法 | 能处理 | 不能处理 / 代价 |
|---|---|---|
JSON.parse(JSON.stringify(obj)) | 纯数据对象(字符串、数字、布尔、数组、普通对象) | 丢 undefined、函数、Symbol;Date 变字符串;循环引用报错 |
structuredClone(obj) | 多数内置类型,包括 Date、Map、Set,支持循环引用 | 不支持函数、DOM 节点;老浏览器要确认兼容性 |
| 自己写递归 | 完全可控 | 容易漏类型,性能一般,除非有特殊需求否则别造轮子 |
const row = { id: 1, createdAt: new Date("2026-01-01") };
// JSON 方案:日期变字符串
const a = JSON.parse(JSON.stringify(row));
console.log(typeof a.createdAt); // "string"
// structuredClone:日期保持原样
const b = structuredClone(row);
console.log(b.createdAt instanceof Date); // true
// 嵌套也真的独立了
b.createdAt.setFullYear(2027);
console.log(row.createdAt.getFullYear()); // 2026
选型的经验:接口返回的纯 JSON 数据,用 structuredClone 最省心;只改第一层字段的表单场景,浅拷贝就够,别为了「保险」整份深拷,数据大时很费时间;对象里有函数或类实例,得自己处理,任何通用拷贝都不可靠。
JSON 这套还有两个不显眼的坑:JSON.stringify(1n) 直接抛 TypeError: Do not know how to serialize a BigInt;NaN 和 Infinity 会变成 null。数据里只要有 BigInt,整个拷贝就失败。
structuredClone 的边界也明确:函数、Symbol、DOM 节点、Proxy 都拷不了,会抛 DataCloneError;类实例会被拷成普通对象,原型丢了,之后再调实例方法就是 undefined。
成本上,深拷贝和对象规模成正比。一份 4MB 的嵌套数据,structuredClone 在本机大概二三十毫秒,放进输入框的每次按键里就会掉帧。判断标准:只改第一层字段的表单,浅拷贝;超过 1MB 或嵌套超过四层,别整份拷,按字段挑;需要保留 Date、Map 这类类型,别用 JSON。
判断属性存不存在,别只看 undefined
const user = { name: undefined };
console.log(user.name); // undefined,属性存在但值是 undefined
console.log(user.age); // undefined,属性不存在
// 三种判断的区别
"name" in user; // true,包括原型链
Object.hasOwn(user, "name"); // true,只看自己
Object.hasOwn(user, "age"); // false
user.age !== undefined; // false,但 name 也会被判成 false
接口字段如果是「可能没有这个键」和「有键但值为空」,业务上要区分时,就用 Object.hasOwn 或者 in。只关心「拿到能不能用」时,判 undefined 就够了,别把简单问题复杂化。
数组也能用 in,但它判断的是下标存不存在,不是值:0 in [undefined] 是 true,2 in [1, 2] 是 false。稀疏数组和「值恰好是 undefined」是两件事,接口给你 [null, null] 还是 [],别用 length 去猜业务含义。
完整场景走查:商品编辑抽屉
接着开头那个「取消后列表也被改」的事故往下走。需求是商品编辑:列表接口返回 200 条商品,每条最多 30 个 SKU;点「编辑」打开抽屉,改标题、价格、库存和 SKU;保存走 PUT /api/products/{id};点取消要恢复原样。
知道引用共享之后,第一版通常会改成「先拷贝」:
let draft = null;
function openEditor(row) {
draft = JSON.parse(JSON.stringify(row)); // 以为深拷贝就万事大吉
renderForm(draft);
}
async function save() {
await api.put("/api/products/" + draft.id, draft);
const idx = rows.findIndex(r => r.id === draft.id);
rows[idx] = Object.assign(rows[idx], draft); // 合并回列表
closeEditor();
}
这一版把「取消污染」修掉了,但上线后陆续冒出六个问题:
Object.assign(rows[idx], draft)原地改了列表元素,对象引用没变。用 React 这类靠引用比较决定要不要重渲染的框架,用户点完保存看到的还是旧价格,刷新一次才对。这类问题最容易被当成「缓存」。- draft 里
stock是 undefined(表单清空后没重新赋值),这个键存在、值是 undefined,Object.assign照样覆盖,列表里原本的库存被清空,下次打开编辑框是空的。 updatedAt在打开时被转成了 Date 对象,JSON 拷贝后变成字符串。保存接口要的是毫秒时间戳,直接返回 400,错误信息是updatedAt must be a number。- 商品 id 是 19 位数字(历史接口就是这么返的)。这个数超过了安全整数范围,
JSON.parse时末位就已经变成 0,拷贝只是把错的 id 又抄了一遍。保存时 PUT 到一个不存在的 id,返回 404;更糟的情况是刚好撞上另一条记录。 - 后端允许
extra存自定义字段。用递归合并的时候没过滤键名,遇到{"__proto__": {"isAdmin": true}},合并后draft.isAdmin是 true,权限判断被绕过。 - 批量改价一次选中 200 条,每条 30 个 SKU,同步深拷贝 6000 个对象,主线程卡四十毫秒左右,输入框开始掉字。
改法不是换个更厉害的拷贝函数,而是把「编辑态」和「列表数据」分开:draft 只装可编辑字段,提交时只组装后端要的字段,合并回列表时生成新对象。
function toDraft(row) {
return {
id: row.id, // 保持原始类型,不要转数字
title: row.title,
price: row.price,
stock: row.stock,
updatedAt: new Date(row.updatedAt),
skus: row.skus.map(s => ({
id: s.id,
specText: s.specText,
price: s.price,
stock: s.stock
})),
extra: Object.fromEntries(
Object.entries(row.extra ?? {}).filter(([k]) => k !== "__proto__")
)
};
}
function toPayload(draft) {
return {
title: draft.title.trim(),
price: Number(draft.price),
stock: Number(draft.stock),
updatedAt: draft.updatedAt.getTime(), // 明确给时间戳
skus: draft.skus.map(s => ({
id: s.id,
specText: s.specText,
price: Number(s.price),
stock: Number(s.stock)
}))
};
}
function applySaved(rows, saved) {
return rows.map(row => (row.id === saved.id ? { ...row, ...saved } : row));
}
三个函数各管一件事:toDraft 只拷需要编辑的字段,SKU 逐个新建对象,所以既独立又只花了必要的那点开销;toPayload 明确转换类型,时间转时间戳,金额转数字,不把前端内部结构直接扔给后端;applySaved 返回新数组和新对象,引用变了,视图一定会更新。
合并时用服务端返回的 saved,而不是本地的 draft,是因为后端可能会改字段(比如四舍五入价格、补上更新时间)。用本地的值合并,页面显示和服务端就悄悄不一致了。
批量编辑那 200 条,不要一次性全转成 draft。只保存选中的 id 列表,用户点开哪条再转哪条;批量提交时按 id 逐个组装 payload,每处理一条让出一帧,或者干脆交给后端的批量接口。六千个对象的转换不是不能做,是不该在点击的那一帧里做。
id 那条要单独说一下:前端能做的是「不转数字、原样传回去」,真正的修法是让后端把 19 位 id 当字符串返回。前端单方面用 BigInt 或者字符串补位,只会让类型在整条链路上更乱。
错误现象对照
对象相关的问题大多不报错,只是数据悄悄变了。下面这张表按「看到什么、实际是什么、先查哪里」整理。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 点「取消」后列表里那一行也变了 | 表单直接持有列表对象的引用,或者只做了第一层浅拷贝 | 查赋值处是 form = row 还是 { ...row };再往下看嵌套对象是否还共享 |
保存后某个字段变成 undefined,或者整个字段消失 |
Object.assign 用含 undefined 的源覆盖了原值;或者 JSON 深拷贝删掉了值为 undefined 的键,后端把它当成「清空」 |
打印合并前后两边的 keys 和值,确认源对象里到底有没有这个键 |
提交返回 400,提示 updatedAt must be a number |
JSON 深拷贝把 Date 变成了字符串,类型和格式都变了 | typeof draft.updatedAt;查这一步用的是 JSON 还是 structuredClone |
| 商品 id 末位变成 0,保存 404 或者改错记录 | 19 位数字超过安全整数,JSON.parse 时就丢了精度 |
对比接口原文和 Number(id) 之后的值;确认后端是否用字符串返回 |
| 保存成功,列表还是旧数据,刷新后才对 | 原地修改了数组元素,对象引用没变,靠引用比较的框架不会重渲染 | 看是不是 rows[idx] = Object.assign(rows[idx], x) 这种写法 |
对象上莫名多出 isAdmin: true 这类属性 |
合并时遇到 __proto__ 键,改掉的是原型而不是新增属性 |
Object.getPrototypeOf(obj) 是不是还等于 Object.prototype;Object.keys 里有没有这个键 |
for...in 遍历出一堆没定义过的键 |
遍历连原型上的可枚举属性一起带出来了 | 换成 Object.keys 或加 Object.hasOwn 过滤 |
这七条里只有第四条和第六条会让人怀疑「被攻击了」,其余都像普通的显示 bug。所以看到「数据不对但没报错」,先怀疑拷贝和合并,再怀疑后端。
边界与代价
对象是 JavaScript 里最顺手的结构,但它在几种情况下会变成负担,判断标准如下。
- 键的数量和变动频率。几千个键的配置对象没问题;十万级、频繁增删的字典用
Map。对象上大量delete会让引擎退化成字典模式,后续查找变慢,而Map的删除是常规操作。 - 深拷贝的边界。嵌套超过四层、体积超过 1MB、里面有 Date、BigInt、类实例、DOM 节点,任何一种都说明「整份拷」不合适,改成按字段挑。JSON 方案遇到 BigInt 直接抛错,遇到 Date 悄悄改类型,后者更危险。
- 原型链深度。自己写的继承超过三层,属性查找每层多一跳,
instanceof的语义也越来越难讲清,这时候用组合或者把方法挂到工具函数上更实在。 - class 还是工厂。需要
instanceof、需要私有字段、需要被序列化后还原,用 class;需要返回不同形状的对象、不希望调用方写new,用工厂函数。两者混用会让「这个对象该怎么创建」变成团队的记忆题。 Object.freeze的代价。它是浅的,嵌套照样能改;严格模式下写冻结属性会抛TypeError,非严格模式静默失败。拿它当运行时的不可变保证不靠谱,当开发期的报警器可以。- 副作用。改
Object.prototype、给第三方库返回的对象加属性、用for...in遍历,这三件事都会影响到你控制不到的代码。前两个别做,第三个换成Object.keys。
一句话的判断:这份数据要序列化、要传给后端,就用纯对象,别挂方法和原型;要作为键值容器高频增删,用 Map;需要行为和身份,用 class。三种混着用,问题迟早出现在拷贝那一层。
小结
null;class 只是这套机制的语法糖。Object.assign 都是浅拷贝;嵌套对象要独立,用 structuredClone,纯 JSON 之外的类型要单独确认。Object.hasOwn 或 in;只判 undefined 分不清「没有键」和「值为空」。下面几条都可以在控制台里直接验证,每条不超过两分钟:
- 打印
Object.keys({ b: 1, 2: "two", a: 2, 1: "one" }),确认整数键排在最前面,其余按插入顺序。 - 写
const row = { a: { b: 1 } }; const copy = { ...row }; copy.a.b = 2;,打印row.a.b是 2;再换成structuredClone(row)重复一遍,这次原对象应该还是 2。 - 准备
{ x: undefined }和{}两个对象,分别用Object.hasOwn判断x,确认「值为空」和「没有键」是两回事。 - 打印
Object.getPrototypeOf(Object.create(null)),结果是null;再在这个对象上调hasOwnProperty,看它报什么错。 - 在项目里搜
Object.assign(,挑一处合并配置的代码,检查源对象里有没有值为undefined的字段。
下一篇讲数组与常用方法,建议接着读。对象和数组在这一点上是同一类东西:都是引用类型,赋值和传参传的都是地址,这篇里的拷贝问题在数组上一模一样地存在。区别在于数组还有一整套方法,而其中一半会改原数组、一半返回新数组,sort、splice、reverse 都属于前者。把这篇的「引用共享」想清楚,下一篇那些「调用完原数组怎么变了」的疑问就少一半。