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

我有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"
                        }]
                    }]
                }]
            }]
        }
    ]
}]

var表={}；//按id列出的项目
函数递归（项）{
对于（var i=0；i
var table={}；//按id列出的项
函数递归（项）{
对于（var i=0；i来说，这里的诀窍是以一种利用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
，它们现在是
finalObj
非有序数组元素的无序属性。类似地，如果在任何级别上有多个子组，它们都是也将是无秩序的


如果你能接受这个限制，那么上述方法将为你省去很多心痛
如果您不能接受这个约束，那么，稍微考虑一下，子组仍然可以按正确的顺序提取
这里的诀窍是以一种利用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
，它们现在是
finalObj
非有序数组元素的无序属性。类似地，如果在任何级别上有多个子组，它们都是也将是无秩序的


如果你能接受这个限制，那么上述方法将为你省去很多心痛
如果您不能接受这个约束，那么，稍微考虑一下，子组仍然可以按正确的顺序提取
不确定这是否是合并树对象的正确方法，但只是想得到您的反馈/建议

我有一个递归函数，它根据id返回节点。我检查父id和子id，如果父id存在但找不到子id，我将子id添加到父id。如果父id不存在，我创建一个新节点，如果子id已经存在，我只会忽略该子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);
                }
            }

var arrayObject=[]；
var ob={
文本：“根”，
id:1，
项目：[
{
文本：“儿童一号”，
id:11，
项目：[
{
文字：“孙儿一号”，
id:111，
项目：[]}，
{
文字：“孙子2号”，
身份证号码：112，
项目：[]}
]},
{
文本：“儿童2”，
id:12，
项目：[]}
]
};
函数findObjectById（根，id）{
if（root.items）{
for（root.items中的变量k）{
if（root.items[k].id==id）{
返回root.items[k]；
}
else if（root.items.length）{
返回findObjectById（root.items[k]，id）；
}
}
}
};
var newChild={
文本：“子x”，
身份证号码：115，
项目：[]
};
对于（var i=0；i我不确定这是否是合并树对象的正确方法，但只是想得到您的反馈/建议

我有一个递归函数，它根据id返回节点。我检查父id和子id，如果父id存在但找不到子id，我将子id添加到父id。如果父id不存在，我创建一个新节点，如果子id已经存在，我只会忽略该子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);
                }
            }

var arrayObject=[]；
var ob={
文本：“根”，
id:1，
项目：[
{
文本：“儿童一号”，
id:11，
项目：[
{
文字：“孙儿一号”，
id:111，
项目：[]}，
{
文字：“gr