一个后台项目里有个「编辑」弹窗:点某一行,把这一行的数据赋给表单,用户改完点保存,再合并回列表。上线后发现一个问题——用户打开弹窗改了内容,然后点「取消」,列表里的那一行居然也变了。

// 打开弹窗
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();
}

这一版把「取消污染」修掉了,但上线后陆续冒出六个问题:

  1. Object.assign(rows[idx], draft) 原地改了列表元素,对象引用没变。用 React 这类靠引用比较决定要不要重渲染的框架,用户点完保存看到的还是旧价格,刷新一次才对。这类问题最容易被当成「缓存」。
  2. draft 里 stock 是 undefined(表单清空后没重新赋值),这个键存在、值是 undefined,Object.assign 照样覆盖,列表里原本的库存被清空,下次打开编辑框是空的。
  3. updatedAt 在打开时被转成了 Date 对象,JSON 拷贝后变成字符串。保存接口要的是毫秒时间戳,直接返回 400,错误信息是 updatedAt must be a number。
  4. 商品 id 是 19 位数字(历史接口就是这么返的)。这个数超过了安全整数范围,JSON.parse 时末位就已经变成 0,拷贝只是把错的 id 又抄了一遍。保存时 PUT 到一个不存在的 id,返回 404;更糟的情况是刚好撞上另一条记录。
  5. 后端允许 extra 存自定义字段。用递归合并的时候没过滤键名,遇到 {"__proto__": {"isAdmin": true}},合并后 draft.isAdmin 是 true,权限判断被绕过。
  6. 批量改价一次选中 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 分不清「没有键」和「值为空」。

下面几条都可以在控制台里直接验证,每条不超过两分钟:

  1. 打印 Object.keys({ b: 1, 2: "two", a: 2, 1: "one" }),确认整数键排在最前面,其余按插入顺序。
  2. 写 const row = { a: { b: 1 } }; const copy = { ...row }; copy.a.b = 2;,打印 row.a.b 是 2;再换成 structuredClone(row) 重复一遍,这次原对象应该还是 2。
  3. 准备 { x: undefined } 和 {} 两个对象,分别用 Object.hasOwn 判断 x,确认「值为空」和「没有键」是两回事。
  4. 打印 Object.getPrototypeOf(Object.create(null)),结果是 null;再在这个对象上调 hasOwnProperty,看它报什么错。
  5. 在项目里搜 Object.assign(,挑一处合并配置的代码,检查源对象里有没有值为 undefined 的字段。

下一篇讲数组与常用方法,建议接着读。对象和数组在这一点上是同一类东西:都是引用类型,赋值和传参传的都是地址,这篇里的拷贝问题在数组上一模一样地存在。区别在于数组还有一整套方法,而其中一半会改原数组、一半返回新数组,sort、splice、reverse 都属于前者。把这篇的「引用共享」想清楚,下一篇那些「调用完原数组怎么变了」的疑问就少一半。