Javascript 从嵌套JS对象中删除空对象的属性后删除空对象

我有一个嵌套的JS对象，看起来像这样：

data = {
    "name": "root",
    "children": [{
            "name": "bob",
            "children": []
        },
        {
            "name": "susan",
            "children": []
        },
        {
            "name": "chris",
            "children": []
        },
        {
            "name": "bobo",
            "children": []
        },
        {
            "name": "heather",
            "children": []
        }
    ]
}

我可以使用以下递归函数删除任何属性，无论其深度如何：

function search_and_delete(obj, search_term) {
    for (var k in obj) {
        if (typeof obj[k] == "object" && obj[k] !== null) {
            search_and_delete(obj[k], search_term)
        } else {
            if (typeof(obj.name) !== 'undefined') {
                if (obj.name === search_term) {
                    delete obj.name
                    delete obj.children
                }
            }
        }
    }
}

例如：

search_and_delete(data, 'bob')

…产生以下结果：

{
    "name": "root",
    "children": [
       {},   // <------ how do I remove this
       {
            "name": "susan",
            "children": []
       },
       {
            "name": "chris",
            "children": []
       },
       {
            "name": "bobo",
            "children": []
       },
       {
            "name": "heather",
            "children": []
       }
    ]
}

它是这样做的：

---

一个选项是将父数组向下传递给递归调用，这样就可以

从中拼接找到的项

因为改变数组将改变每个属性指向的对象，这将使在

中为..使用

变得困难-使用
对象。值
来迭代对象（或数组）：


const数据={
“名称”：“根”，
“儿童”：[{
“姓名”：“鲍勃”，
“儿童”：[]
},
{
“姓名”：“苏珊”，
“儿童”：[]
},
{
“姓名”：“克里斯”，
“儿童”：[]
},
{
“姓名”：“波波”，
“儿童”：[]
},
{
“姓名”：“希瑟”，
“儿童”：[]
}
]
}
函数搜索和删除（对象、搜索项、父项）{
if（obj.name==搜索项）{
父拼接（父索引Of（obj），1）；
}否则{
Object.values（obj.forEach）（val）=>{
if（val&&typeof val==“对象”）{
搜索和删除（val、搜索词、obj）
}
});
}
}
搜索和删除（数据“bob”）；
控制台日志（数据）一个选项是将父数组向下传递给递归调用，这样您就可以
从中拼接找到的项

因为改变数组将改变每个属性指向的对象，这将使在
中为..使用
变得困难-使用
对象。值
来迭代对象（或数组）：


const数据={
“名称”：“根”，
“儿童”：[{
“姓名”：“鲍勃”，
“儿童”：[]
},
{
“姓名”：“苏珊”，
“儿童”：[]
},
{
“姓名”：“克里斯”，
“儿童”：[]
},
{
“姓名”：“波波”，
“儿童”：[]
},
{
“姓名”：“希瑟”，
“儿童”：[]
}
]
}
函数搜索和删除（对象、搜索项、父项）{
if（obj.name==搜索项）{
父拼接（父索引Of（obj），1）；
}否则{
Object.values（obj.forEach）（val）=>{
if（val&&typeof val==“对象”）{
搜索和删除（val、搜索词、obj）
}
});
}
}
搜索和删除（数据“bob”）；
控制台日志（数据）使用广度优先搜索消除应删除元素的处理子元素的简单筛选器实现


数据={
“名称”：“根”，
“儿童”：[
{“name”：“bob”，“children”：[]}，
{“姓名”：“苏珊”}，
{“姓名”：“克里斯”，“儿童”：[]}，
{“name”：“bobo”，“children”：[]}，
{“姓名”：“希瑟”}，
{“name”：“yoink”，“children”：
[{“姓名”：“鲍勃”，“孩子们”：[]}，
{“姓名”：“苏珊”，“孩子们”：[]}
]
},
{“姓名”：“鲍勃”，“孩子们”：
[{“姓名”：“苏珊”，“孩子们”：[]}，
{“姓名”：“克里斯”，“儿童”：[]}
]
},
{“姓名”：“鲍勃”}，
]
}
函数搜索和删除（obj，搜索项）{
if（obj.name==搜索项）{
返回未定义
}
if（obj.children）obj.children=obj.children.filter（elem=>search_和_delete（elem，search_term））
返回obj
}
log（搜索和删除（数据'bob'））
log（search_和delete（data，'root'））
一个简单的过滤器实现，它使用广度优先搜索来消除应该删除的元素的处理子元素


数据={
“名称”：“根”，
“儿童”：[
{“name”：“bob”，“children”：[]}，
{“姓名”：“苏珊”}，
{“姓名”：“克里斯”，“儿童”：[]}，
{“name”：“bobo”，“children”：[]}，
{“姓名”：“希瑟”}，
{“name”：“yoink”，“children”：
[{“姓名”：“鲍勃”，“孩子们”：[]}，
{“姓名”：“苏珊”，“孩子们”：[]}
]
},
{“姓名”：“鲍勃”，“孩子们”：
[{“姓名”：“苏珊”，“孩子们”：[]}，
{“姓名”：“克里斯”，“儿童”：[]}
]
},
{“姓名”：“鲍勃”}，
]
}
函数搜索和删除（obj，搜索项）{
if（obj.name==搜索项）{
返回未定义
}
if（obj.children）obj.children=obj.children.filter（elem=>search_和_delete（elem，search_term））
返回obj
}
log（搜索和删除（数据'bob'））
log（搜索和删除（数据，'root'））
@Tibrogargan不，我试过了，不起作用。Javascript的删除操作不能删除整个对象，只能删除对象的属性。@controlnetic使用
filter
。您正在执行深度优先搜索，该搜索将搜索节点的所有子节点，即使该节点应被删除。它仍然不是JSON结构，而是JavaScriptobject@CertainPerformanceJavaScript数组在默认情况下是稀疏的。@Tibrogargan完全不是。稀疏数组很少见，必须有意识地创建（比如使用
删除
，或者在以前的标记还不存在时分配给数组的索引），而且几乎总是坏的迹象code@CertainPerformance它们仍然是稀疏数组，即使它们没有缺少的元素。@Tibrogargan不，我试过这个，但不起作用。Javascript的删除操作不能删除整个对象，只能删除对象的属性。@controlnetic使用
filter
。您正在执行深度优先搜索，该搜索将搜索节点的所有子节点，即使该节点应被删除。它仍然不是JSON结构，而是JavaScriptobject@CertainPerformanceJavaScript数组在默认情况下是稀疏的。@Tibrogargan完全不是。稀疏阵列很少见，必须制作成delibe
search_and_delete(data, "Interpolator", data)