Javascript 从n个对象数组中合并n个对象

我有两个对象数组，我想创建一个新的对象数组，其中每个对象都是前两个对象的合并版本，例如：

const one = [
  { id: 1, title: 'One' },
  { id: 2, title: 'Two' }
]

const two = [
  { status: 'Open' },
  { status: 'Close' }
]

从以上阵列中，我预计：

const result = [
  { id: 1, title: 'One', status: 'Open' },
  { id: 1, title: 'Two', status: 'Close' }
]

这里的问题是，我不知道如何创建一个函数，该函数实际上可以接收n个对象数组并创建一个新数组，例如，如果我想合并第三个数组：

const three = [
  { items: 10 },
  { items: 2 }
]

我希望使用以下数组：

const result = [
  { id: 1, title: 'One', status: 'Open', items: 10 },
  { id: 1, title: 'Two', status: 'Close', items: 2 }
]

---

我认为实际上我可以创建一个接收排列的函数，但我不知道如何将接收到的每个数组中的每个对象合并到该函数中。

将每个数组作为参数传入，然后在其中一个数组上使用

.map

将其映射到

对象。分配新数组中的每个项目：


const merge=（…arrs）=>arrs[0]。映射（（\ux，i）=>(
//从每个数组中提取第[i]项：
Object.assign（{}，…arrs.map（arr=>arr[i]））
));
常数一=[
{id:1，标题：'One'}，
{id:2，标题：'Two'}
];
常数二=[
{状态：'打开'}，
{状态：'关闭'}
];
常数三=[
{项目：10}，
{项目：2}
];
log（合并（一，二））；
log（合并（一、二、三））
将每个数组作为参数传入，然后对其中一个数组使用
.map
映射到
对象。分配新数组中的每个项：


const merge=（…arrs）=>arrs[0]。映射（（\ux，i）=>(
//从每个数组中提取第[i]项：
Object.assign（{}，…arrs.map（arr=>arr[i]））
));
常数一=[
{id:1，标题：'One'}，
{id:2，标题：'Two'}
];
常数二=[
{状态：'打开'}，
{状态：'关闭'}
];
常数三=[
{项目：10}，
{项目：2}
];
log（合并（一，二））；
log（合并（一、二、三））如果您知道需要合并的数组数量，可以使用

或者，您也可以为此使用Lodash的。这样，就可以将任意数量的数组作为参数传递

试试这个：


const one=[
{id:1，标题：'One'}，
{id:2，标题：'Two'}
];
常数二=[
{状态：'打开'}，
{状态：'关闭'}
];
常数三=[
{项目：10}，
{项目：2}
];
//正常合并
函数合并（一、二、三）{
返回1.map(
（项目、索引）=>({
…项目，
…两个[索引]，
…三[索引]
})
);
}
//洛达斯合并
函数mergeWithLodash（…数组）{
返回u.merge（…数组）；
}
log（合并（一、二、三））；
log（'mergeWithLodash:'，mergeWithLodash（一，二，三））
如果您知道需要合并的数组数量，可以使用

或者，您也可以为此使用Lodash的。这样，就可以将任意数量的数组作为参数传递

试试这个：


const one=[
{id:1，标题：'One'}，
{id:2，标题：'Two'}
];
常数二=[
{状态：'打开'}，
{状态：'关闭'}
];
常数三=[
{项目：10}，
{项目：2}
];
//正常合并
函数合并（一、二、三）{
返回1.map(
（项目、索引）=>({
…项目，
…两个[索引]，
…三[索引]
})
);
}
//洛达斯合并
函数mergeWithLodash（…数组）{
返回u.merge（…数组）；
}
log（合并（一、二、三））；
log（'mergeWithLodash:'，mergeWithLodash（一，二，三））
您可以使用“Array.reduce”或“Array.map”来实现这一点，如下所示


const one=[
{id:1，标题：'One'}，
{id:2，标题：'Two'}
]
常数二=[
{状态：'打开'}，
{状态：'关闭'}
]
常数三=[
{项目：10}，
{项目：2}
]
//使用REDUCE
函数mergeArrays1（数组）{
返回数组[0]。reduce（（a，d，i）=>a.concat（Object.assign（…arrays.map（d=>d[i]），[]））
}
//使用地图
函数mergeArrays2（数组）{
返回数组[0].map（（d，i）=>Object.assign（…数组.map（d=>d[i]））
}
log（mergeArrays1（[1,2,3]））
console.log（mergeArrays2（[one，two，three]）
您可以使用“Array.reduce”或“Array.map”来实现这一点，如下所示


const one=[
{id:1，标题：'One'}，
{id:2，标题：'Two'}
]
常数二=[
{状态：'打开'}，
{状态：'关闭'}
]
常数三=[
{项目：10}，
{项目：2}
]
//使用REDUCE
函数mergeArrays1（数组）{
返回数组[0]。reduce（（a，d，i）=>a.concat（Object.assign（…arrays.map（d=>d[i]），[]））
}
//使用地图
函数mergeArrays2（数组）{
返回数组[0].map（（d，i）=>Object.assign（…数组.map（d=>d[i]））
}
log（mergeArrays1（[1,2,3]））
console.log（mergeArrays2（[1,2,3]）
这没有考虑到需要合并的数组数量未知的可能性。这没有考虑到需要合并的数组数量未知的可能性。您好，我已经为Reduce和Map添加了一个答案，后来意识到你的地图解决方案已经存在（和我的一样）。。我之前没看到。所以请不要介意..嗨，我已经为Reduce和Map添加了一个答案，后来意识到你的Map解决方案已经存在（和我的一样）。。我之前没看到。所以请不要介意，还原法似乎稍微快一点！然后，您可以继续使用Reduce解决方案。尽管如此，我认为这两者之间的差异是不明显的。似乎reduce解决方案稍微快一点！然后，您可以继续使用Reduce解决方案。尽管如此，我认为这种差异几乎不明显。