Javascript 查找满足嵌套JSON逻辑的最佳节点

下面是JSON，我使用它生成以下UI：

{
    "Text" : "1. Parent group"
    "Logic" : "all of the following",
    "Id":"1" //some unique id
    "children": [
        {
            "Text' : "1.1 Level Child group"
            "Logic' : "1 or more of the following",
            "Id':"1.1" //some unique id,
            "children" :  [
                {
                    "Text' : "1.1.1 Level Child group"
                    "Logic' : "all of the following",
                    "Id':"1.1.1" //some unique id,
                    "children": [
                        {
                            "Text' : "1.1.1.1 Level Child"
                            "Id':"1.1.1.1" //some unique id,

                        },
                        {
                            "Text' : "1.1.1.2 Level Child"
                            "Id':"1.1.1.2" //some unique id,
                            "Logic" : "one or more of the following",
                            "children" : [
                                      { 
                                      "Text": "1.1.1.2.1 Level Child", 
                                      "Id": "1.1.1.2.1" 
                                      }, 
                                      { 
                                     "Text": "1.1.1.2.2 Level Child", 
                                      "Id": "1.1.1.2.2" 
                                      }, 
                              ]
                        }
                    ]
                },
                {
                    "Text' : "1.1.2 Level Child group"
                    "Id':"1.1.2" //some unique id,
                },
                {
                    "Text' : "1.1.3 Level Child group"
                    "Id':"1.1.3" //some unique id,
                },
                {
                    "Text' : "1.1.4 Level Child group"
                    "Logic' : "one or more of the following",
                    "Id':"1.1.4" //some unique id,
                    "children": [
                        {
                            "Text' : "1.1.4.1 Level Child"
                            "Id':"1.1.4.1" //some unique id,
                        },
                        {
                            "Text' : "1.1.4.2 Level Child"
                            "Id':"1.1.4.2" //some unique id,
                        }
                    ]
                },
                {
                    "Text' : "1.1.5 Level Child group"
                    "Logic' : "all of the following",
                    "Id':"1.1.5" //some unique id,
                    "children": [
                        {
                            "Text' : "1.1.5.1 Level Child"
                            "Id':"1.1.5.1" //some unique id,
                        },
                        {
                            "Text' : "1.1.5.2 Level Child"
                            "Id':"1.1.5.2" //some unique id,
                        }
                    ]
                }

            ]
        },
        {
            "Text" : "1.2 Level Child"
            "Id":"1.2" //some unique id
        }
    ]
}

1.父组（以下所有项） 1.1级子组（1个或更多） 1.1.1级别子组（以下所有项） 1.1.1.1级别子项//可选 1.1.1.2子级//可选 1.1.2子级//可选 1.1.3级别子级//可选 1.1.4级别子组（以下一项或多项） 1.1.4.1级别子级//可选 1.1.4.2级别子级//可选 1.1.5级别子组（以下所有内容） 1.1.5.1级别子级//可选 1.1.5.2级别子级//可选 1.2级子级//可选 节点工作逻辑：

用户只能选择没有子节点的节点

如果逻辑为“以下所有内容”，并且仅当其所有嵌套子节点都被选中时，才会隐式选择节点

如果逻辑为“n个或多个以下项”，则仅当选择了其“n”嵌套子项时，才会隐式选择节点

场景：如果用户选择1.1.2（它隐式满足1.1）和1.2，则“1.父组”为“满足”，因此选择它（使整个组满足）

场景：如果用户选择1.1.1.1，则用户必须选择1.1.1.2，以便1.1.1被“满足”，选择1.2，将使整个组成为“满足”

实际需要是在“未满足父组”时找到最佳ID:

如果选择任何节点和最顶端的父组仍然未“满足”。 然后单击一个按钮，我需要找到并返回最佳节点ID 他们的存在将使“母集团”得以“满足”

注意：在查找最佳节点ID时，如果选择了子组中的任何一个子组，我们应该考虑其重要性。

例如：

如果用户只选择了1.2，则最快的方法是 要满足的“父组”是选择1.1.2。但是如果1.1.1有孩子 选中，则我应优先考虑1.1.1节点，作为结果I 需要返回以下ID：[ 1.1.1.2、1.1.1、1.1]

---

我不确定应该使用哪种类型的算法来解决这个问题。

这里是一个简短的方法，通过查看约束，现在在数据集中，这些约束与

q:'some'

或

q:'every'

有关

功能选择（节点，已选择）{
功能iter（节点）{
如果（！node.children）返回[node.Id]；
var-temp=节点子节点映射（iter）；
if（node.q=='every'）返回[…temp.flat（），node.Id]；
var filtered=temp.filter（a=>a.some（v=>selected.includes（v））；
if（filtered.length）返回[…filtered.flat（），node.Id]；
返回[…temp.reduce（（a，b）=>b.length！selected.includes（v））；
}
var数据={q:'every'，文本：“1.父组”，逻辑：“以下所有”，Id:'1'，子组：[{q:'some'，文本：“1.1级子组”，逻辑：“以下1个或多个”，Id:'1.1'，子组：[{q:'every'，文本：“1.1.1级子组”，逻辑：“以下所有”，Id:'1.1.1'，子组：[{文本：“1.1.1.1级子组”，Id:'1.1.1.1”{Text:“1.1.1.2级儿童组”，Id:“1.1.1.2”}，{Text:“1.1.2级儿童组”，Id:“1.1.2”}，{Text:“1.1.3级儿童组”，Id:“1.1.3”}，{q:“某些”，Text:“1.1.4级儿童组”，逻辑：“以下一个或多个”，Id:“1.1.4”，儿童：[{Text:“1.1.4.1级儿童组”，Id:“1.1.1.4.2级儿童组，{“1.1.4.2”}，{q:“每一个”，文本：“1.1.5级儿童组”，逻辑：“所有以下”，Id:“1.1.5”，儿童：[{Text:“1.1.5.1级儿童”，Id:“1.1.5.1”}，{Text:“1.1.5.2级儿童”，Id:“1.1.5.1”}，{Text:“1.2级儿童”，Id:“1.2”}；
log（选择（数据，[“1.2]”）；
日志（选择（数据，[“1.2”，“1.1.1.1]”）；
console.log（选择（数据，[“1.1.1.1]”）；

---

。作为控制台包装器{max height:100%！important；top:0；}

您可以从添加有效数据开始。如何知道是否选择了节点？每次选择节点时，我都会在数组中维护节点id。它看起来如何？假设用户选择“1.2级子节点”。我所做的就是存储节点“id”“特定节点的。它看起来是这样的：[“1.2”]。如果希望添加名为“selected”的属性：根据选择或取消选择的节点，选择true或false。我能做到。如果用户选择某个东西，那么您从哪里获得所选节点？代码几乎可以完美地工作，除了应该给予直接子选择更多权重的用例之外。如果“1.1.1.2”有子项（参见更新的JSON），那么运行select（数据，[“1.1.2”，“1.1.1.2.2]”）应该返回[1.2,1]；因为选择了“1.1.2”，所以已经满足了“1.1”。为了修复它，我在

var filtered..

var all=node.q=='every'，is1orMore=node.q=='some'，childMetSoFar=0；if（node.children）{node.children.forEach（function（child）{if（！child.children&&selected.includes（child.Id））{childMetSoFar++}}）；if（is1orMore==true&&childMetSoFar>=1）{return[]；}

。但是选择失败（数据，[“1.2”，“1.1.4.2”]）=>[]，但返回[1.1,1]。对于第一个，为什么节点

“1.1”

不在结果集中？是否应该在结果集中包含一些条件节点？您在这里指的是哪种情况？这一种

select（data，[“1.1.2”，“1.1.1.2.2]”）

1. Parent group (all of the following) 1.1 Level Child group (1 or more ) 1.1.1 Level Child group (all of the following) 1.1.1.1 Level Child // selectable 1.1.1.2 Level Child // selectable 1.1.2 Level Child // selectable 1.1.3 Level Child // selectable 1.1.4 Level Child group (one or more of the following) 1.1.4.1 Level Child // selectable 1.1.4.2 Level Child // selectable 1.1.5 Level Child group (all of the following) 1.1.5.1 Level Child // selectable 1.1.5.2 Level Child // selectable 1.2 Level Child // selectable