Object.assign，仅值

Question

我有两个对象。一个是源对象，另一个是源对象的深层副本。每个中都存在相同的键，但深层副本可能具有与源对象不同的值。例如：

{
  id: 123,
  people: [{
      name: "Bob",
      age: 50
   }, {
      name: "Alice",
      age: 40
  }]
}

and

{
  id: 123,
  people: [{
      name: "Bob",
      age: 51 // bob is older now
   }, {
      name: "Alice",
      age: 40
  }]
}

请注意，对象更深，键/对象/数组/值更多。

我想将更新后的副本中的 values（和仅值）应用回源对象。

重要的是我需要维护源对象的原始参考点。这意味着我不能执行以下任何操作：

sourceObject = updatedCopiedObject;

因为它会覆盖源对象并中断对源对象的引用

Object.assign(sourceObject, updatedCopiedObject);

因为，正如文档所说：

目标对象中的属性将被 如果它们具有相同的密钥，则来源。稍后来源的属性将 类似地覆盖之前的。

换句话说，它也覆盖了源对象的引用。

我需要做的正是 Object.assign 所做的，但不会覆盖属性 - 只需更改属性匹配的值。

我不知道任何内置方法会以必要的递归/深度方式执行此操作。我可以写一个方法，但我想先看看是否已经有解决这个问题的方法。

Answer 1

您可以使用Object.entries() 将对象的属性和值作为数组的键值对进行迭代。如果该值是一个对象，则递归调用相同的函数来重新分配属性值，否则将该值设置为源对象的属性值

let source = {
  id: 123,
  people: [{
      name: "Bob",
      age: 50
   }, {
      name: "Alice",
      age: 40
  }]
}



let copy = {
  id: 123,
  people: [{
      name: "Bob",
      age: 51 // bob is older now
   }, {
      name: "Alice",
      age: 40
  }]
}

const reassign = (s, c) => {
  for (let [key, prop] of Object.entries(c)) {
    if (typeof prop !== "object") {
      s[key] = prop;
    } else {
      reassign(s[key], prop)
    }
  }
  return [s, c]
}

console.log(reassign(source, copy));

Answer 2

您可以使用迭代和递归的方法来分配值。

此提议迭代源对象并在必要时创建新的目标属性，如果未找到嵌套对象则分配值。

function update(target, source) {
    Object.keys(source).forEach(function(key) {
        if (source[key] && typeof source[key] === 'object') {
            return update(target[key] = target[key] || Array.isArray(source[key]) ? [] : {}, source[key]);
        }
        if (target[key] !== source[key]) {
            target[key] = source[key];
        }
    });
}

var obj1 = { id: 123, people: [{ name: "Bob", age: 50 }, { name: "Alice", age: 40 }] }, obj2 = { id: 123, people: [{ name: "Bob", age: 51 }, { name: "Alice", age: 40 }] };

update(obj1, obj2);
console.log(obj1);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 3

我不知道任何内置方法会以必要的递归/深度方式执行此操作。我可以写一个方法，但我想先看看是否已经有解决这个问题的方法。

不，没有。

Answer 4

guest271314 的回答帮助我编写了一个递归解决方案，用于将“仅值”从一个对象分配给另一个对象。对于我的应用程序，我需要对其进行一些更改以处理对象中的数组：

assignObject (target = {}, source) {
  let value = null
  let keys = Object.keys(source)
  for (let key of keys) {
    value = source[key]
    if (typeof value === 'object' && value !== null) {
      if (Object.prototype.toString.call(value) === '[object Array]') {
        target[key] = value
      } else {
        assignObject(target[key], value)
      }
    } else {
      target[key] = value
    }
  }
  return target
}