Javascript 如何从包含嵌套对象的数组中删除重复项

我有一个嵌套对象数组（我用它来填充我的树），如下所示

var obj1= {
        text: "TreeRoot",
        items: [ {
            text: "subgroup1" ,
            items: [ {
                text: "subgroup2",
                items: [ {
                    text: "subgroup3",
                    items: [ {
                        text: "subgroup4",
                        items: [ {
                            text: "subgroup5"
                        }]
                    }]
                }]
            }]
        }]
    };

var obj2 = {
        text: "TreeRoot",
        items: [ {
            text: "subgroup1" ,
            items: [ {
                text: "subgroup2",
                items: [ {
                    text: "subgroup3",
                    items: [ {
                        text: "subgroup4",
                        items: [ {
                            text: "subgroup5"
                        }]
                    }]
                }]
            }]
        }]
    };


 var obj3= {
        text: "TreeRoot",
        items: [ {
            text: "subgroup1" ,
            items: [ {
                text: "subgroup2"
                }]
            }]
        }]
    };

var finalArray=[];
finalArray.push(obj1);
finalArray.push(obj2);
finalArray.push(obj3);

现在，我需要使用文本从最终数组中删除重复对象（即，我应该从数组中删除obj2）

这就是我试过的

var arr = {};

for ( var i=0; i < finalPath.length; i++ )
     arr[finalArray[i]['text']] = finalArray[i];

finalArray= new Array();
for ( key in arr )
    finalArray.push(arr[key]);

var-arr={}；
for（var i=0；i

有人能告诉我最好的方法吗

编辑：

我认为下面的解决方案是可行的，但还没有完全测试它

var arr = {};

for ( var i=0; i < finalArray.length; i++ ){
    if(finalArray[i].items){
        for(var j=0;j<finalArray[i].items.length;j++){
            arr[finalArray[i].items[j]['text']] = finalArray[i];
        }
    }else{
        arr[finalArray[i]['text']] = finalArray[i];
    }
}


finalArray= new Array();
for ( key in arr )
    finalArray.push(arr[key])

var-arr={}；
对于（变量i=0；i对于（var j=0；j很抱歉，但我认为如果对象的深度大于2，代码将失败。
至少，这种逻辑似乎很奇怪。
为什么不定义一个测试来检查两个对象是否相等？您可以使用递归测试，或者只需在json版本上测试相等性：
比如：

function are_equal(obj1,obj2) {
return JSON.stringify(obj1)==JSON.stringify(obj2);
}

然后在此处使用响应：

我还没有测试过，希望这有帮助。
试试下面的代码：

var ObjList = [......]; /*All your objects*/
var dict = {}; /*Dictionary for duplicate elimination*/
for (var obj in ObjList) 
{
  dict[JSON.stringify(obj)] = JSON.stringify(obj);
}
var newObjList = [];
for (var key in dict)
{
  newObjList.push(key);
}

现在，
newObjList
拥有了所有独特的项，不管树有多深。
JSON似乎使用起来非常简单，并且保持了代码的整洁，但可能需要大量处理

还有另一种解决问题的方法，您可以创建一个递归函数，该函数将遍历数组并比较每个分支

function areEqual(a, b) {
    if( (a.items && !b.items) || (!a.items && b.items) ) return false;
    else if(!a.items && !b.items) return a.text == b.text ? true : false;
    else return (a.text == b.text) ? areEqual(a.items[0], b.items[0]) : false;
}

这段代码使用您提供的数据，但是如果您想测试其他值（不仅仅是文本），可能需要调整函数

编辑：

这是该函数的简化版本，如果需要比较多个元素（而不仅仅是文本），则更好

确定两个对象是否相等的规则是什么？如果对象包含相同数量的节点/文本，则表示这两个对象相等。。。
function areEqual(a, b) {
    if( (a.items && !b.items) || (!a.items && b.items) ) return false;
    else if(!a.items && !b.items) return a.text == b.text ? true : false;
    else return (a.text == b.text) ? areEqual(a.items[0], b.items[0]) : false;
}

areEqual(obj1, obj2) : true
areEqual(obj1, obj3) : false

function areEqual(a, b) {
    var conditions = a.text == b.text /* && a.another_var == b.another_var */;

    if( typeof(a.items) != typeof(b.items) ) return false;
    if(a.items && b.items && conditions) return areEqual(a.items[0], b.items[0]);
    return conditions;
}