Javascript 比较两个对象数组，并基于一个对象数组进行排序，并在不'；不匹配

我有两个javascript数组

array1 = [{id: 4, value:'xyz'}, {id: 2, value:'pqr'}, {id: 5, value:'abc'}]
array2 = [
         [{id: 5, value:'abc'}, {id: 4, value:'xyz'}],
         [{id: 5, value:'abc'}, {id: 2, value:'pqr'}],
         [{id: 4, value:'xyz'}, {id: 2, value:'pqr'}],
         [{id: 2, value:'pqr'}, {id: 5, value:'abc'}]
]

array2是对象数组的数组， 数组2中的所有这些数组首先应该按照数组1序列进行排序，然后如果特定id在该索引中不存在，则应该推送带有null的对象

output = [
         [{id: 4, value:'xyz'}, {id: null, value:null}, {id: 5, value:'abc'}],
         [{id: null, value:null}, {id: 2, value:'pqr'}, {id: 5, value:'abc'}],
         [{id: 4, value:'xyz'}, {id: 2, value:'pqr'}, {id: null, value:null}],
         [{id: 4, value:'xyz'}, {id: 2, value:'pqr'}, {id: null, value:null}],
         [{id: null, value:null}, {id: 2, value:'pqr'}, {id: 5, value:'abc'}]
].

这是我的密码

export const mapOrder = (array, order, key) => {
    let arr = [];
    array.sort((a, b) => {
        let A = a[key];
        let B = b[key];
        if (order.indexOf(A) > order.indexOf(B)) {
            return 1;
        }
        return -1;
    });
    if (order.length > 0) {
        for (let i = 0; i < order.length; i++) {
            for (let j = 0; j < array.length; j++) {
                if (order[i] === array[j].UserId) {
                    arr.push(array[j]);
                } else {
                    arr.push({ id: null, value: null})
                }
            }
        }
        array = arr;
    }
    return arr;
};

export const mapOrder=（数组、顺序、键）=>{
设arr=[]；
array.sort（（a，b）=>{
设A=A[键]；
设B=B[key]；
if（order.indexOf（A）>order.indexOf（B））{
返回1；
}
返回-1；
});
如果（订单长度>0）{
for（设i=0；i

首先可以循环第二个数组并将ID保存到新的集合，然后循环第一个数组，如果集合中存在当前项目的ID，则返回当前对象或返回ID为

且值为null的对象`


constarray1=[{id:4，值：'xyz'}，{id:2，值：'pqr'}，{id:5，值：'abc'}]
常量数组2=[{id:5，值：'abc'}，{id:4，值：'xyz'}]
功能测试（arr1、arr2）{
常量集=新集（）
arr2.forEach（i=>set.add（i.id））
返回arr1.map（（i）=>set.has（i.id）？i:{id:null，value:null}）
}
log（test（array1，array2））
您可以从您的array2创建一个映射，其中来自array2中对象的每个id都指向一个具有特定
id
值的对象数组。然后，您可以在
array1
上使用
.flatMap（）
，并通过在地图上使用
.get（）
获取当前迭代对象的
id
的所有对象。如果
.get（）
不返回任何内容，则可以提供默认对象（其中id和value为
null
）：


const数组1=[{id:4，值：'xyz'}，{id:2，值：'pqr'}，{id:5，值：'abc'}]；
常量数组2=[{id:5，值：'abc'}，{id:4，值：'xyz'}]；
//将数组分组到映射中
const group=array2.reduce（（映射，对象）=>
map.set（obj.id，（map.get（obj.id）| |[]））.concat（obj）），
新地图
);
const res=array1.flatMap（（{id}）=>grouped.get（id）| |（{id:null，value:null}））；
控制台日志（res）您可以先收集对象中的对象，然后让它们映射收集的对象或获取占位符


var array1=[{id:4，值：'xyz'}，{id:2，值：'pqr'}，{id:5，值：'abc'}]，
array2=[{id:5，值：'abc'}，{id:4，值：'xyz'}]，
结果=array1.map(
（o=>（{id}）=>o[id]|{id:null，value:null}）
（array2.reduce（（r，o）=>（{…r[o.id]：o}），{}））
);
控制台日志（结果）
。作为控制台包装器{max height:100%！important；top:0；}
什么不起作用？@NinaScholz我添加了代码如果使用一个集合而不是数组，则可以避免二次复杂性。