Javascript 将两个数组中的对象合并到一个数组中

我有一个关于在数组中合并对象的问题。最大的问题是如何在合并这些数组后保存此数组结构，因为如果我使用。

push（）

在这些数组之后迭代，我会收到一个大数组。看看我的数据：

[ 
 [ 
   { name: '1' },
   { name: '2' },
   { name: '3' },
 ],
 [
   { name: '4' },
   { name: '5' },
   { name: '6' },
  ] 
]

及

我想说的是如何将这两个数组合并成一个数组

[ 
 [ 
   { name: '1', correct: false },
   { name: '2', correct: true },
   { name: '3', correct: false },
 ],
 [ 
   { name: '4', correct: true },
   { name: '5', correct: false },
   { name: '6', correct: false },
 ] 
]

我尝试了以下循环，但我收到了一个大数组，但我需要两个数组

for(i in nameArray) {
   for(j in nameArray[i]){
       var mergeObj = Object.assign(nameArray,correctArray[j]) //I get undefned
       correctArray.push(nameArray[i][j])
   }
}

---

很接近，但是有对象数组，所以需要

correctary[i][j]

const nameArray=[
[{name:'1'}，{name:'2'}，{name:'3'}]，
[{name:'4'}，{name:'5'}，{name:'6'}]
];
const correctary=[
[{correct:false}，{correct:true}，{correct:false}]，
[{correct:true}，{correct:false}，{correct:false}]
];
nameArray.forEach（（a，i）=>
a、 forEach（（o，j）=>Object.assign（o，correctary[i][j]））
);
log（nameArray）对于新的独立数组，可以在矩阵中使用并构建新对象


var array1=[[{name:'1'}，{name:'2'}，{name:'3'}]，{name:'4'}，{name:'5'}，{name:'6'}]]，
array2=[{correct:false}，{correct:true}，{correct:false}]，{correct:true}，{correct:false}，{correct:false}]]，
结果=[array1，array2]。减少（（r，a）=>
（a.forEach（（b，i）=>
（r[i]=r[i]| |[]，b.forEach（（c，j）=>
赋值（r[i][j]=r[i][j]|{}，c）），r），[]；
控制台日志（结果）
.as控制台包装{max height:100%！important；top:0；}
这是另一个稍微有点夸张的版本，展示了如何在更复杂的数据集情况下处理嵌套程度的示例


const nameArray=[
[ 
{name:'1'}，
{name:'2'}，
{name:'3'}，
],
[
{name:'4'}，
{name:'5'}，
{name:'6'}，
] 
];
const correctary=[
[ 
{正确：错误}，
{正确：正确}，
{正确：错误}，
],
[ 
{正确：正确}，
{正确：错误}，
{正确：错误}，
] 
];
var resultArray=[]
每个功能（arr、fn）{
设len=arr.length，i=-1
而（++i{
如果（！目标[索引]）{
设newElem=elem.length？[]：{}
目标[索引]=newElem
}
if（元素长度）{
addToArray（目标[索引]，元素）
}否则{
让keys=对象。keys（elem）
每个（键，键=>{
if（target[index][key]）console.warn（`key${key}已经存在，正在覆盖`）
目标[索引][键]=元素[键]
})
}
})
}
addToArray（结果数组、名称数组）
addToArray（结果数组、更正数组）
log（JSON.stringify（resultArray，null，2））
我认为解决问题的最佳方法是递归函数。与此类似的内容：


var a=[
[ 
{name:'1'}，
{name:'2'}，
{name:'3'}，
],
[
{name:'4'}，
{name:'5'}，
{name:'6'}，
] 
]
变量b=[
[ 
{正确：错误}，
{正确：正确}，
{正确：错误}，
],
[ 
{正确：正确}，
{正确：错误}，
{正确：错误}，
] 
]
变量c=[
[ 
{你好：“世界”}
]
];
函数合并递归（x，y）{
/**
*忽略函数
*/
if（x instanceof函数）{
x=未定义；
}
if（y instanceof函数）{
y=未定义；
}
/**
*忽略未定义项
*/
如果（x==未定义）{
返回y；
}
如果（y==未定义）{
返回x；
}
/**
*获取密钥并删除重复的密钥
*/
var kx=Object.keys（x）.filter（（k）=>！（x[k]函数实例））；
var ky=Object.keys（y）.filter（（k）=>！（y[k]函数实例））；
var ks=kx.concat(
ky滤波器(
（e） =>kx.indexOf（e）=-1
)
);
/**
*定义结果的类型
*/
var结果；
if（x instanceof Array&&y instanceof Array）{
结果=[]；
ks=ks.map（（k）=>1*k）；//转换为数字
}否则{
结果={}；
}
/**
*递归地创建合并对象
*/
forEach（（k）=>result[k]=mergeRecursive（x[k]，y[k]）；
返回结果；
}
var example1=合并递归（a，b）；
console.log（“示例1”）；
console.log（示例1）；
var example2=mergeRecursive（example1，c）；
console.log（“示例2”）；
console.log（示例2）
你能解释一下为什么所有forEach返回'r'（reduce的参数）？
r
是
reduce
回调中的一个变量，以空数组开始。为了将该数组带入reduce的下一次迭代，并作为结果返回该数组，必须返回该数组。结构是这样的
[].reduce（（r，a）=>（/*…*/，r））带有逗号运算符。好的，谢谢，如果我很好地理解删除“r”，我将在r[I]中收到错误，因为在迭代中是空数组吗？不，它取回调的最后一个值，并将其作为
r
for(i in nameArray) {
   for(j in nameArray[i]){
       var mergeObj = Object.assign(nameArray,correctArray[j]) //I get undefned
       correctArray.push(nameArray[i][j])
   }
}

let arr1 = [[ { name: '1' }, { name: '2' }, { name: '3' }],[{ name: '4' }, { name: '5' }, { name: '6' }]]

let arr2 = [[{ correct: false },{ correct: true },{ correct: false }],[{ correct: true },{ correct: false },{ correct: false }]]

let arr3 = arr1.map((ele,ind)=>{
   return ele.map((e,i)=>Object.assign(e,arr2[ind][i]))
})