Object.create与new实例化JavaScript对象有何不同

一、核心运行机制与底层步骤对比

要透彻理解两者的差异，最直接的切入点是观察执行调用时 JavaScript 引擎在底层分别做了哪些事情。一个核心分水岭是：构造函数的函数体代码是否被调用执行。

1. new 操作符的四步执行流程

当执行 const instance = new Constructor(args) 时，引擎在后台严格按照以下四个步骤运行：

1. 创建空内存对象：在堆内存中开辟一块新的对象空间，形成一个纯空对象 {}。
2. 绑定原型链：将这个新对象的内部隐藏属性 [[Prototype]]（在浏览器中体现为 __proto__）指向构造函数的 prototype 属性所引用的对象。
3. 执行构造函数绑定上下文：将构造函数内部的 this 绑定到刚刚创建的新对象上，并传入参数执行函数体代码。开发者在构造函数内编写的 this.name = name 等语句就是在此阶段完成自有属性初始化的。
4. 裁定返回值：检查构造函数的实际返回值。如果构造函数显式返回了一个非空对象类型（如 Object、Array），则最终表达式返回该对象；否则，默认返回前三步创建并初始化完成的新实例。

function Person(name) {
  this.name = name;
  this.greet = function() {
    return 'Hello, ' + this.name;
  };
}

// 使用 new 实例化
const p1 = new Person('Alice');
console.log(p1.name); // 'Alice'（自有属性已初始化）
console.log(p1 instanceof Person); // true

2. Object.create 的底层运作方式

Object.create(proto, [propertiesObject]) 是 ECMAScript 5 正式引入的原型规范 API。它的本质是“以传入的 proto 对象作为新创建对象的原型”。如果不考虑第二个可选的属性描述符参数，它的底层行为可以精确模拟如下：

// Object.create 的核心实现原理模拟
function createObject(proto) {
  if (typeof proto !== 'object' && typeof proto !== 'function' && proto !== null) {
    throw new TypeError('Object prototype may only be an Object or null');
  }
  function F() {}
  F.prototype = proto;
  return new F();
}

注意观察模拟代码：临时构造函数 F 是完全为空的函数，它不会挂载任何属性。如果直接调用 Object.create(Person.prototype)，Person 构造函数本身根本不会被执行。因此，新创建的对象除了通过原型链能访问到原型上的方法外，构造函数内部定义的自有属性（如 this.name）在新对象上是完全不存在的。

二、原型链形成与内存结构差异

除了是否调用构造函数，另一个深层次的差异体现在对象属性的物理分布与原型链拓扑结构上。

1. 属性存放位置：自有属性 vs 原型属性

在 new Constructor() 模式下，实例对象自身会持有一份独立的属性拷贝。这意味着如果有多个实例，它们各自占用独立的内存空间来存储 this.xxx。

而如果通过 Object.create(existingObj) 创建新对象，existingObj 身上的所有属性对于新对象而言都是原型链属性。新对象自身在创建伊始是空空如也的（Object.keys(newObj).length === 0），它完全依赖原型向上委托机制读取属性。

2. 原型指向的自由度与 Object.create(null)

使用 new 时，新对象的原型必须且只能指向构造函数的 prototype 对象，最终回溯到 Object.prototype。我们无法用 new 直接造出一个脱离 Object.prototype 的“完全纯净对象”。

而 Object.create() 支持传入任意合法的对象作为原型，更关键的是它支持传入 null：

// 创建纯净字典对象
const map = Object.create(null);
console.log(map.__proto__); // undefined
console.log(map.toString);  // undefined（没有继承任何 Object.prototype 上的内置方法）

由于 Object.create(null) 产出的对象不存在 toString、valueOf、hasOwnProperty 以及 constructor 等原型成员，它非常适合用来作为哈希映射字典（Hash Map），完全杜绝了原型污染和属性覆盖的风险。

三、参数传递与属性描述符控制力

除了原型链本身，两者在“如何为对象声明属性”这件事情上有着完全不同的设计维度。

1. new：依赖构造函数传参

new 的传参直接对应构造函数的形参列表，所有的属性赋值是在函数体中以普通赋值操作完成的：

function User(name, age) {
  this.name = name;
  this.age = age;
}
const user = new User('Bob', 25);

在这种模式下，通过普通赋值创建的属性默认都是可枚举（enumerable）、可写（writable）、可配置（configurable）的。如果想要更细粒度地控制属性权限，开发者必须在构造函数内部手动调用 Object.defineProperty。

2. Object.create：原生的属性描述符字典

Object.create 支持第二个参数 propertiesObject，该参数与 Object.defineProperties 的规范完全一致。它允许在创建对象的同时，以极其严密的元编程方式定义自有属性：

const proto = {
  sayType() { return 'Animal'; }
};

const dog = Object.create(proto, {
  name: {
    value: 'Puppy',
    writable: false,      // 只读，不可篡改
    enumerable: true,     // 允许 for...in 和 Object.keys
    configurable: false   // 不可删除
  },
  id: {
    value: 1001,
    enumerable: false    // 隐藏属性，遍历不可见
  }
});

console.log(dog.name); // 'Puppy'
dog.name = 'NewName';  // 静默失败（严格模式下报错 TypeError）
console.log(dog.name); // 依然是 'Puppy'

四、容易混淆的经典说法辨析

在日常开发与技术面试中，围绕这两个 API 常常存在几类似是而非的说法，需要结合运行条件精准甄别。

混淆说法一：“Object.create(Foo.prototype) 与 new Foo() 的作用完全一样”

合理之处：如果只通过 instanceof Foo 检测类型，或者只调用 Foo.prototype 上挂载的公共方法，两者的表现确实是一致的，因为两者的内部 [[Prototype]] 都指向同一个原型对象。

偏差与纠正：如果 Foo 的函数体内部定义了实例自有属性（例如 this.items = []），Object.create(Foo.prototype) 产出的对象上根本没有 items 属性，直接访问会返回 undefined，若后续调用依赖这些属性的原型方法则可能直接引发运行时报错。

混淆说法二：“ES6 Class 出现后，Object.create 已经没有用武之地”

合理之处：在定义常规业务实体（如用户、订单、组件）时，ES6 class 搭配 new 确实提供了更优雅、更符合直觉的语法糖，不再需要手动拼接原型链。

偏差与纠正：Object.create 拥有其不可替代的元编程场景：第一，创建防御原型污染的高安全度纯空字典 Object.create(null)；第二，在低层框架中进行轻量级的对象委派与装饰器包装，无需为此特意定义一个空类；第三，实现不需要经过类初始化的对象克隆与隔离。

五、ES5 经典寄生组合式继承中的精妙协作

事实上，new 与 Object.create 并不是对立的排他关系，在 JavaScript 语言演进史中最经典的“寄生组合式继承”方案中，正是二者的完美配合解决了早期原型继承的缺陷。

function Parent(name) {
  this.name = name;
  this.colors = ['red', 'blue'];
}
Parent.prototype.sayName = function() {
  console.log(this.name);
};

function Child(name, age) {
  // 1. 借用构造函数：初始化自有属性（独立拷贝）
  Parent.call(this, name);
  this.age = age;
}

// 2. 关键所在：使用 Object.create 建立原型链连接
// 若此处写成 Child.prototype = new Parent()，会导致 Parent 构造函数被多执行一次，
// 并在 Child.prototype 上引入无用的 name/colors 冗余属性。
Child.prototype = Object.create(Parent.prototype);

// 3. 修复丢失的构造函数指向
Child.prototype.constructor = Child;

Child.prototype.sayAge = function() {
  console.log(this.age);
};

上面的代码清晰展示了分工逻辑：通过 Parent.call(this) 负责自有属性的拷贝；而通过 Object.create(Parent.prototype) 纯净地搭建子类与父类的原型桥梁，完美避免了调用 new Parent() 带来的额外开销与属性污染。

六、实践总结与场景选型指南

在实际工程开发中，开发者可以根据以下决策准则进行清晰选择：

• 选择 new（或 ES6 class）：当需要基于一套规范模板批量生产具有自有状态和通用方法的对象实例时，例如业务数据模型、UI 视图组件、服务层 Service 等。
• 选择 Object.create(proto)：当需要对现有单例对象进行行为继承与委派，或者在手写继承逻辑时桥接父子类原型。
• 选择 Object.create(null)：当需要一个安全的哈希容器、查找表或缓存字典，且不允许任何默认原型方法干扰键名匹配时。