Javascript 操纵两个对象数组创建新数组并更新object1的属性，然后添加到新数组中，并根据需要修改嵌套对象

嗨，我正在尝试比较两个对象数组，并希望通过操纵它来实现对象的自定义数组

这是通过以下方式实现的

obj1=[
{
“id”：“类型1”，
“已删除”：“N”，
“数据”：[
{
“标签”：“类型1-a”，
“已删除”：“N”，
“数据ID”：12
},
{
“标签”：“类型1-b”，
“已删除”：“N”，
“数据ID”：34
}
]
},
{
“id”：“类型2”，
“已删除”：“N”，
“数据”：[
{
“标签”：“类型2-a”，
“已删除”：“N”，
“数据ID”：12
},
{
“标签”：“类型2-b”，
“已删除”：“N”，
“数据ID”：34
}
]
}
]
obj2=[
{
“id”：“类型1”，
“已删除”：“N”，
“数据”：[
{
“labelname”：“type1-a”，
“身份证”：12
},
{
“labelname”：“type1-c”，
“身份证”：34
},
{
“labelname”：“type1-d”，
“身份证”：36
}
]
},
{
“id”：“类型2”，
“已删除”：“N”，
“数据”：[
{
“labelname”：“type2-a”，
“身份证”：12
}
]
},
,
{
“id”：“类型3”，
“已删除”：“N”，
“数据”：[
{
“labelname”：“type3-a”，
“身份证”：12
},
{
“labelname”：“type3-b”，
“身份证”：34
}
]
}
]
const result=[…obj2.map（记录=>{
const record2=obj1.find（pr=>pr.id==record.id）|{}；
常量数据=[…（record.data | |[]）.map（pr=>（{…pr，
…（record2.data.find（npr=>npr.dataid==pr.id）|{}）
})),
…（record2.data | |[]）.filter（pr=>！record.data.some（npr=>npr.dataid==pr.id））.map（pr=>（{…pr，
删除：“Y”
}))
]
返回{
…记录，
…记录2，
数据
}
})，…obj1.filter（pr=>！obj2.some（npr=>npr.id==pr.id））.map（pr=>（{…pr，
删除：“Y”
}))]
控制台日志（结果）；
预期结果=
[
{
“id”：“类型1”，
“已删除”：“N”，
“数据”：[
{
“标签”：“类型1-a”，
“已删除”：“N”，
“数据ID”：12
},
{
“标签”：“类型1-b”，
“已删除”：“N”，
“数据ID”：34
},
{
“标签”：“类型1-d”，
“数据ID”：36，
“已删除”：“N”，
}
]
},
{
“id”：“类型2”，
“已删除”：“N”，
“数据”：[
{
“标签”：“类型2-a”，
“已删除”：“N”，
“数据ID”：12
},
{
“标签”：“类型2-b”，
“已删除”：“Y”，
“数据ID”：34
}
]
},
{
“id”：“类型3”，
“已删除”：“N”，
“数据”：[
{
“标签”：“类型3-a”，
“已删除”：“N”，
“数据ID”：12
},
{
“标签”：“类型3-b”，
“已删除”：“N”，
“数据ID”：34
}
]
}
]

如果我正确理解了逻辑，那么它不仅仅是像你上一个问题那样简单

在上一个问题中，默认对象的数据属性已替换为修改对象的数据属性。在这种情况下，您必须将修改对象的这些新数据元素添加到默认数据元素中（如果这些元素不存在），并将默认对象中存在但修改对象中不存在的数据元素标记为已删除

如果你想要一个高性能的算法，你需要考虑一些因素。 例如：

将源数组（obj1、obj2）减少为javascript对象，以避免使用find或filter方法进行不必要的双循环，并将复杂性从O（n*n）降低到O（n）

减少obj1的数据数组，目的是在获取值时将复杂性降低到O（1），并避免使用O（n）的查找方法

将obj1的每个数据元素设置为默认已删除。。。仅当未从obj2的数据对象中删除状态时，才更改状态

你可以尝试这样的方法，它比其他算法要复杂得多，但我相信这是解决这个问题最有效的方法之一

    let checkRemovals = (obj1, obj2) => {
        const defaultObject = obj1.reduce((acc, { id, ...rest }) => { acc[id] = rest; return acc }, {});
        const modifiedObject = obj2.reduce((acc, { id, ...rest }) => { acc[id] = rest; return acc }, {});
        
        // Basic actions in the default object
        obj1.forEach(({ id }) => {
            defaultObject[id].removed = !modifiedObject[id] ? 'Y' : 'N';
            
            if (defaultObject[id].data) {
                defaultObject[id].data = defaultObject[id].data.reduce((acc, { label, ...rest }) => {
                    acc[label] = { ...rest, removed: 'Y' };
                    return acc;
                }, {});
            }
        });
        
        // Update and add new elements
        obj2.forEach(({ id, data, ...rest }) => {
            // If it not exists in the default object, add it
            if (!defaultObject[id]) {
                defaultObject[id] = {
                    ...rest,
                    data: data.reduce((acc, { labelname, id, ...rest }) => {
                        acc[labelname] = { ...rest, dataid: id, removed: 'N' };
                        return acc
                    }, {})
                }
            }
            // If it exists, update it
            else {
                const mainID = id;
                
                data.forEach(({ id, labelname, ...rest }) => {
                    if (defaultObject[mainID].data[labelname]) {
                        defaultObject[mainID].data[labelname].removed = 'N';
                    }
                    else {
                        defaultObject[mainID].data[labelname] = { ...rest, dataid: id, removed: 'N' };
                    }
                });
            }
        });
        
        // Build the result
        const result = [];
        Object.keys(defaultObject).forEach(key => {
            const { data, ...rest } = defaultObject[key];
            
            result.push({
                ...rest,
                id: key,
                data: Object.keys(data).reduce((acc, key) => {
                    acc.push({ label: key, ...data[key] });
                    return acc;
                }, [])
            })
        });
        
        return result;
    }

---

我很难理解你的问题。在预期结果中，type3中的数据值与其中一个obj2 data.elements（labelname）的结构相同。标准是什么？因为在type1中，type1-d存储为label而不是labelname。你能再详细一点吗？对不起，我已经修改过了。。它应该与obj1的确切属性相匹配。。。基本上，在比较之前，我需要使用前面的问题映射器函数。该函数的作用是，如果我从obj1（默认对象）中删除任何内容，而obj2（修改对象）。。所以我想要比较obj2和obj1的结果，并检查数据对象中是否删除了任何内容。。。。如果在数据对象中删除了任何内容，则应将相应的属性设置为删除“y”Great。它解决了我的目的。。如果我使用上一个问题中提到的映射函数映射与obj1相同的obj2数据属性，然后只使用比较函数，是否可能？是的，可能！也可以更清楚，只是考虑更新比较函数来使用Obj2CAN的这些值，请您建议我3个分开的函数，这样我就可以保持可重用性1。映射obj2，使其看起来像obj1 2。比较整个对象并按Id检查它是否已删除3。检查有关删除的数据对象元素..我添加了有疑问的内容。。。但不知怎么的，它不起作用了。你能帮我做同样的事吗