Javascript 深度扩展，扩展到对象数组中？

我想知道这样的事情是否可能——一个查看对象数组的扩展

假设我有：

 myObj = [
    {"name" : "one", "test" : ["1","2"]},
    {"name" : "two", "test" : ["1","2"]}
   ]

我正试图扩展到这一点

 {"name" : "one" , "test" : ["1","3"]}

因此，结果将是-

 myObj = [
    {"name" : "one", "test" : ["1","2", "3"]},
    {"name" : "two", "test" : ["1","2"]}
   ]

---

这就像扩展，如果没有对象，它只会创建一个。这样的事情可能吗？谢谢

看起来您想要的是：

函数deepSetMerge（基本，下一个）{
var dataEntry=base.filter（函数（it）{
返回它。name==next.name；
})[0];
如果（数据输入）{
var diff=next.test.filter（函数（it））{
返回dataEntry.test.indexOf（it）=-1；
});
dataEntry.test=dataEntry.test.concat（diff.sort（）；
}否则{
base.push（下一步）；
}
}
风险值数据=[{
“名称”：“一”，
“测试”：[“1”、“2”]
}, {
“姓名”：“两个”，
“测试”：[“1”、“2”]
}];
变量添加={
“名称”：“一”，
“测试”：[“1”、“3”]
};
var obj={
“名称”：“完全独一无二”，
“测试”：[1,2,9,17.0]
};
deepSetMerge（数据，添加）；
deepSetMerge（数据，obj）；
document.getElementById（'results'）.textContent=JSON.stringify（数据）
看起来您想要的是：


函数deepSetMerge（基本，下一个）{
var dataEntry=base.filter（函数（it）{
返回它。name==next.name；
})[0];
如果（数据输入）{
var diff=next.test.filter（函数（it））{
返回dataEntry.test.indexOf（it）=-1；
});
dataEntry.test=dataEntry.test.concat（diff.sort（）；
}否则{
base.push（下一步）；
}
}
风险值数据=[{
“名称”：“一”，
“测试”：[“1”、“2”]
}, {
“姓名”：“两个”，
“测试”：[“1”、“2”]
}];
变量添加={
“名称”：“一”，
“测试”：[“1”、“3”]
};
var obj={
“名称”：“完全独一无二”，
“测试”：[1,2,9,17.0]
};
deepSetMerge（数据，添加）；
deepSetMerge（数据，obj）；
document.getElementById（'results'）.textContent=JSON.stringify（数据）
看起来您想要的是：


函数deepSetMerge（基本，下一个）{
var dataEntry=base.filter（函数（it）{
返回它。name==next.name；
})[0];
如果（数据输入）{
var diff=next.test.filter（函数（it））{
返回dataEntry.test.indexOf（it）=-1；
});
dataEntry.test=dataEntry.test.concat（diff.sort（）；
}否则{
base.push（下一步）；
}
}
风险值数据=[{
“名称”：“一”，
“测试”：[“1”、“2”]
}, {
“姓名”：“两个”，
“测试”：[“1”、“2”]
}];
变量添加={
“名称”：“一”，
“测试”：[“1”、“3”]
};
var obj={
“名称”：“完全独一无二”，
“测试”：[1,2,9,17.0]
};
deepSetMerge（数据，添加）；
deepSetMerge（数据，obj）；
document.getElementById（'results'）.textContent=JSON.stringify（数据）
看起来您想要的是：


函数deepSetMerge（基本，下一个）{
var dataEntry=base.filter（函数（it）{
返回它。name==next.name；
})[0];
如果（数据输入）{
var diff=next.test.filter（函数（it））{
返回dataEntry.test.indexOf（it）=-1；
});
dataEntry.test=dataEntry.test.concat（diff.sort（）；
}否则{
base.push（下一步）；
}
}
风险值数据=[{
“名称”：“一”，
“测试”：[“1”、“2”]
}, {
“姓名”：“两个”，
“测试”：[“1”、“2”]
}];
变量添加={
“名称”：“一”，
“测试”：[“1”、“3”]
};
var obj={
“名称”：“完全独一无二”，
“测试”：[1,2,9,17.0]
};
deepSetMerge（数据，添加）；
deepSetMerge（数据，obj）；
document.getElementById（'results'）.textContent=JSON.stringify（数据）
作为一个通用的扩展实现，这将是非常棘手和昂贵的。这就是为什么通常避免深潜的原因。最好了解您的数据模型并以这种方式使用它

使用您的示例，我将建立有关数据模型的一些假设：

我们的对象将有一个
名称
属性，该属性是唯一的，可以搜索
test
属性的值是一个数组（使这更容易实现，但它可以是一个对象，您可以对其使用典型的扩展实现）
在这种情况下，您可以这样处理：

var myObj = [
  {name: 'one', test: ['1', '2']},
  {name: 'two', test: ['1', '2']}
];

function extendTestValue(data, value) {
  var names = data.map(function(item) {
    return item.name;
  });
  var index = names.indexOf(value.name);
  if (index < 0) {
    data.push(value);
  } else {
    value.test.forEach(function(item) {
      if (data[index].test.indexOf(item) < 0) {
        data[index].test.push(item);
      }
    });
  }
  return data;
}

var myObj=[
{name:'one'，test:['1'，'2']}，
{name:'two'，test:['1'，'2']}
];
函数extendTestValue（数据、值）{
变量名称=data.map（函数（项）{
返回item.name；
});
var index=names.indexOf（value.name）；
如果（指数<0）{
数据推送（值）；
}否则{
value.test.forEach（函数（项）{
if（数据[index].test.indexOf（项）<0）{
数据[索引].test.push（项）；
}
});
}
返回数据；
}
作为一种通用扩展实现，这将非常棘手且成本高昂。这就是为什么通常避免深度潜水。最好了解您的数据模型并以这种方式使用它

使用您的示例，我将建立有关数据模型的一些假设：

我们的对象将有一个
名称
属性，该属性是唯一的，可以搜索
test
属性的值是一个数组（使这更容易实现，但它可以是一个对象，您可以对其使用典型的扩展实现）
在这种情况下，您可以这样处理：

var myObj = [
  {name: 'one', test: ['1', '2']},
  {name: 'two', test: ['1', '2']}
];

function extendTestValue(data, value) {
  var names = data.map(function(item) {
    return item.name;
  });
  var index = names.indexOf(value.name);
  if (index < 0) {
    data.push(value);
  } else {
    value.test.forEach(function(item) {
      if (data[index].test.indexOf(item) < 0) {
        data[index].test.push(item);
      }
    });
  }
  return data;
}

var myObj=[
{name:'one'，test:['1'，'2']}，
{name:'two'，test:['1'，'2']}
];
函数extendTestValue（数据、值）{
变量名称=data.map（函数（项）{
返回item.name；
});
var index=names.indexOf（value.name）；
如果（指数<0）{
数据推送（值）；
}否则{
value.test.forEach（函数（项）{
if（数据[index].test.indexOf（项）<0）{
数据[索引].test.push（项）；
}
});
}
返回数据；
}
作为一种通用扩展实现，这将非常棘手且成本高昂。这就是为什么通常避免深度潜水。最好了解您的数据模型并以这种方式使用它

使用您的示例，我将建立有关数据模型的一些假设：

我们的对象将有一个
名称
属性，该属性是唯一的，可以搜索
test
属性的值是一个数组（makes）