JavaScript中能否修改对象初始化器构造函数？如何生成持久不可变集合？

简单来说：你没法修改对象初始化器（比如{}）背后的构造逻辑，但可以调整对象的constructor属性，或者重写全局的Object构造函数——不过后者不会影响字面量创建的对象。

对象初始化器是JavaScript的语法糖，它的行为是由JS引擎内置实现的，并不是直接调用全局的Object构造函数。举个例子：

// 保存原生Object构造函数
const OriginalObject = Object;

// 重写全局Object构造函数
Object = function CustomObject() {
  return { isCustom: true };
};

// 用字面量创建对象
const objFromLiteral = {};
console.log(objFromLiteral instanceof OriginalObject); // true，还是原生对象
console.log(objFromLiteral instanceof Object); // false，不匹配重写后的构造函数

// 用new Object()创建对象
const objFromNew = new Object();
console.log(objFromNew.isCustom); // true，用了重写后的构造函数

如果你只是想修改对象的constructor属性（仅作为标识，不改变创建逻辑），可以直接赋值：

const obj = {};
obj.constructor = MyCustomConstructor;

但这只是修改了对象的一个属性，不会改变这个对象的实际类型或创建它的过程。

同样，没法直接修改字面量初始化器（{}、[]）的内置逻辑，让它们直接生成不可变对象——因为这些语法的行为是引擎硬编码的。不过你有几个替代方案，能达到类似的可读性和效果：

1. 立即冻结对象（浅不可变） #

创建对象后直接用Object.freeze()冻结，这是最直接的方法：

// 不可变对象
const immutableObj = Object.freeze({ name: "John Doe", age: 34 });
// 不可变数组
const immutableArr = Object.freeze([1, 2, 3]);

注意：Object.freeze()是浅冻结，如果对象里嵌套了其他对象/数组，那些嵌套结构还是可变的。如果需要深冻结，你得自己写递归冻结的函数：

function deepFreeze(obj) {
  Object.freeze(obj);
  for (const key in obj) {
    if (obj.hasOwnProperty(key) && typeof obj[key] === 'object' && !Object.isFrozen(obj[key])) {
      deepFreeze(obj[key]);
    }
  }
  return obj;
}

const deepImmutableObj = deepFreeze({ user: { name: "John Doe" } });

2. 自定义工厂函数 #

写一个简单的工厂函数，封装冻结逻辑，可读性也很好：

const immutable = obj => Object.freeze(obj);
const immutableArr = arr => Object.freeze(arr);

// 使用方式
const b = immutable({ name: "John Doe", age: 34 });
const nums = immutableArr([1, 2, 3]);

3. 用Proxy实现持久化不可变结构 #

如果需要持久化不可变（即修改时返回新对象，不改变原对象），可以用Proxy拦截修改操作：

function createImmutable(obj) {
  return new Proxy(Object.freeze(obj), {
    set(target, prop, value) {
      // 返回新的不可变对象，不修改原对象
      return createImmutable({ ...target, [prop]: value });
    },
    deleteProperty(target, prop) {
      const { [prop]: _, ...rest } = target;
      return createImmutable(rest);
    }
  });
}

const original = createImmutable({ name: "John Doe" });
const updated = original.name = "Jane Doe"; // 不会修改original，返回新对象
console.log(original.name); // "John Doe"
console.log(updated.name); // "Jane Doe"

关于Map的不可变处理 #

原生Object.freeze()无法冻结Map的内部数据（因为Map的状态不是存在对象属性里的），所以要实现不可变Map，同样可以用Proxy拦截set、delete等方法：

function createImmutableMap(map) {
  const immutableMap = new Map(map);
  return new Proxy(immutableMap, {
    set(target, prop, value) {
      if (prop === 'set') {
        // 拦截set方法，返回新的不可变Map
        return function(key, val) {
          const newMap = new Map(target);
          newMap.set(key, val);
          return createImmutableMap(newMap);
        };
      }
      return Reflect.set(target, prop, value);
    },
    // 同理拦截delete、clear等方法
    get(target, prop) {
      if (prop === 'delete') {
        return function(key) {
          const newMap = new Map(target);
          newMap.delete(key);
          return createImmutableMap(newMap);
        };
      }
      if (prop === 'clear') {
        return function() {
          return createImmutableMap(new Map());
        };
      }
      return Reflect.get(target, prop);
    }
  });
}

const originalMap = createImmutableMap([['name', 'John']]);
const updatedMap = originalMap.set('age', 34);
console.log(originalMap.get('age')); // undefined
console.log(updatedMap.get('age')); // 34

内容的提问来源于stack exchange，提问作者dilvan