如何使用我的递归函数

Question

我现在正在调试一个递归函数，但是我不知道我的代码出了什么问题。

我的递归函数如下所示：

  public findParent(parentId: number, node: any): any {
    if (node !== undefined && node.id === parentId) {
      return node;
    } else {
      if (node.predicates && node.predicates.length > 0) {
        for (const element in node.predicates) {
          if (node.predicates[element].predicates !== undefined && node.predicates[element].predicates.length > 0) {
            return this.findParent(parentId, node.predicates[element]);
          } else {
            continue;
          }
        }
      }
    }
  }

node对象看起来像这样：

"node": [
      {
        "id": 0,
        "level": 0,
        "field": "",
        "op": "AND",
        "parentId": null,
        "predicates": [
          {
            "field": "",
            "predicates": [],
            "level": 1,
            "parentId": 0,
            "id": 1.1,
            "op": ""
          },
          {
            "field": "",
            "predicates": [
              {
                "field": "",
                "predicates": [
                  {
                    "field": "",
                    "predicates": [],
                    "level": 3,
                    "parentId": 2.4,
                    "id": 4.5
                  },
                  {
                    "field": "",
                    "predicates": [],
                    "level": 3,
                    "parentId": 2.4,
                    "id": 4.7
                  }
                ],
                "level": 2,
                "parentId": 1.2,
                "id": 2.4,
                "op": "AND"
              },
              {
                "field": "",
                "predicates": [
                  {
                    "field": "",
                    "predicates": [],
                    "level": 3,
                    "parentId": 2.5,
                    "id": 3.7
                  },
                  {
                    "field": "",
                    "predicates": [],
                    "level": 3,
                    "parentId": 2.5,
                    "id": 4.3
                  }
                ],
                "level": 2,
                "parentId": 1.2,
                "id": 2.5,
                "op": "AND"
              },
              {
                "field": "",
                "predicates": [],
                "level": 2,
                "parentId": 1.2,
                "id": 3.1
              },
              {
                "field": "",
                "predicates": [],
                "level": 2,
                "parentId": 1.2,
                "id": 3.4
              }
            ],
            "level": 1,
            "parentId": 0,
            "id": 1.2,
            "op": "AND"
          }
        ]
      }
    ]

我期望的是，如果我给函数一个父Id，我想得到完整的对象和他的子/子对象。

例如，如果parentId为: 2.5，

              {
                "field": "",
                "predicates": [
                  {
                    "field": "",
                    "predicates": [],
                    "level": 3,
                    "parentId": 2.5,
                    "id": 3.7
                  },
                  {
                    "field": "",
                    "predicates": [],
                    "level": 3,
                    "parentId": 2.5,
                    "id": 4.3
                  }
                ],
                "level": 2,
                "parentId": 1.2,
                "id": 2.5,
                "op": "AND"
              },

将被返回。

但是现在这个函数不起作用了。

Answer 1

代码中的主要问题是，在没有检查递归调用是否找到解决方案的情况下从递归返回。为了更好地理解这一点，请考虑以下内容

你的算法如下：0 -> 1.1 -> 1.2 -> 2.4。现在，它迭代2.4的谓词。它们都没有谓词，所以调用返回到1.2。现在，注意它也是调用，立即返回(return this.findParent(parentId, node.predicates[element]);)，所以算法返回得更远，永远不会检查2.4的兄弟节点。换句话说，算法在到达只有叶子节点的节点后直接返回根。我希望这是比较清楚的。

另外，为什么要检查节点的子节点，而不是只调用节点的递归？这是故意的吗？我已经针对parentId = 1.1对它进行了测试，它也返回undefined，因为该节点没有子节点。此外，在迭代数组时，for ... of比for ... in要好得多。

干杯!