如何在javascript中合并复杂对象？

Question

我有 3 个不同的对象（obj1,2,3），如下所示，我正在尝试形成 finalObj，它是 3 个对象的联合（唯一树列表）..

我不确定实现这一目标的最佳方法是什么..

编辑：文本是这里的关键。如果已经存在具有相同文本的父节点，我们只需忽略并移动到其子节点并检查该子节点是否存在，否则将该子节点附加到现有父节点等等...

var obj1 = [{
    text: "TreeRoot",
    items: [
        { text: "Subgroup1"},
        { text: "Subgroup2"}
    ]
}]

var obj2 = [{
    text: "TreeRoot",
    items: [
        { text: "Subgroup3"}
    ]
}]

var obj3 = [{
    text: "Subgroup3",
    items: [{
        text: "subgroup5",
        items: [{
            text: "subgroup6",
            items: [{
                text: "subgroup7",
                items: [{
                    text: "subgroup8"
                }]
            }]
        }]
    }]
}]



var finalObj = [{
    text: "TreeRoot",
    items: [
        { text: "Subgroup1"},
        { text: "Subgroup2"},
        {
            text: "Subgroup3",
            items: [{
                text: "subgroup5",
                items: [{
                    text: "subgroup6",
                    items: [{
                        text: "subgroup7",
                        items: [{
                            text: "subgroup8"
                        }]
                    }]
                }]
            }]
        }
    ]
}]

Answer 1

var table = {}; // items by id
function recurse(items) {
    for (var i=0; i<items.length; i++) {
        var item = items[i],
            id = item.text;
        if (id in table) 
            table[id].items = (table[id].items && item.items)
              ? table[id].items.concat(item.items) // merge
              : table[id].items || item.items;
        else
            table[id] = item;
        if (item.items)
            recurse(item.items);
    }
}
recurse(obj1), recurse(obj2), recurse(obj3);

// assuming there are no cycles and only one parent per node in the graph
for (var text in table) (function recurse(text) {
    var items = table[text].items;
    if (!items) continue;
    for (var i=0; i<items.length; i++) {
        var id = items[i].text;
        if (id in table) {
            items[i] = table[id];
            recurse(id);
            delete table[id];
        }
    }
})(text);

// now, table consists only of the root keys (should be only one):
for (var id in table)
    var finalObj = table[id];

Answer 2

这里的诀窍是以利用 javascript 对象的自然特征并促进合并的方式构造对象。

obj1、obj2 和 obj3 中的所有数组都是多余的，因为它们每个都包含不超过一项。

不要使用属性text 和items 构造对象，而是使用文本作为键，将项目作为其属性，从而提供更紧凑的数据结构。

var obj1 = {
    "Subgroup1": null,
    "Subgroup2": null
};
var obj2 = {
    "Subgroup3": null
};
var obj3 = {
    "Subgroup3": {
        "subgroup5": {
            "subgroup6": {
                "subgroup7": {
                    "subgroup8": null
                }
            }
        }
    }
};

现在您可以使用 jQuery 的$.extend() 功能了。

var finalObj = $.extend(true, {}, obj1, obj2, obj3);

给出：

var finalObj = {
    "Subgroup1": null,
    "Subgroup2": null,
    "Subgroup3": {
        "subgroup5": {
            "subgroup6": {
                "subgroup7": {
                    "subgroup8": null
                }
            }
        }
    }
};

与您的原始文件相比，几乎不会丢失任何信息。发生的损失是Subgroup1、Subgroup2、Subgroup3 的 order，它们现在是 finalObj 的无序属性，而不是数组的有序元素。同样，如果在任何级别有多个子组，它们也将是无序的。

• 如果您能忍受这种限制，那么上述方法将为您省去很多心痛。
• 如果您不能忍受这种约束，那么稍加考虑，仍然可以按正确的顺序提取子组。

Answer 3

不确定这是否是合并树对象的正确方法，但只是想得到您的反馈/建议...

我有一个递归函数，它根据 id 返回节点。我检查 parent id 和 child id ，如果 parent id 存在但找不到 child id 我将孩子添加到 parent。如果父 ID 不存在我创建一个新节点，如果孩子已经退出，我只是忽略那个孩子...

这样，我可以联合我的节点（通过循环）...欢迎提出建议！！！！

         var arrayObject=[];

            var ob =    {
                text: "root",
                id: 1,
                items: [
                    {
                        text: "child one",
                        id: 11,
                        items: [
                            {
                                text: "grand child 1",
                                id: 111,
                                items: []},
                            {
                                text: "grand child 2",
                                id: 112,
                                items: []}
                        ]},
                    {
                        text: "child two",
                        id: 12,
                        items: []}
                ]
            };

            function findObjectById(root, id) {
                if (root.items) {
                    for (var k in root.items) {
                        if (root.items[k].id == id) {
                            return root.items[k];
                        }
                        else if (root.items.length) {
                            return findObjectById(root.items[k], id);
                        }
                    }
                }
            };
            var newChild={
                text: "child x",
                id: 115,
                items: []
            };

            for(var i=0;i<2;i++){
                if(i==0){
                    var checkParent = findObjectById(ob, 11);
                    alert(JSON.stringify(checkParent));

                }else{
                    var checkParent = findObjectById(ob, 116);
                }
                if(checkParent) {
                    var checkChild=findObjectById(checkParent, newChild.id);
                    alert(JSON.stringify(checkChild));
                    if(!checkChild){
                        checkParent.items.push(newChild);
                    }
                    arrayObject.push(ob)
                }else{

                    arrayObject.push(newChild);
                }
            }