js树形结构递归获取数据

Question

```javascript
const data = [  
  {  
    isOpen: '1',  
    id: 1,  
    children: [  
      {  
        isOpen: '1',  
        id: '1_1',  
        parentId: 1,  
        children: [  
          {  
            id: '1_1_1',  
            parentId: '1_1',  
            isOpen: '1',  
            children: [  
              {  
                id: '1_1_1_1',  
                parentId: '1_1_1',  
                isOpen: '0'  
              },  
              {  
                id: '1_1_1_2',  
                parentId: '1_1_1',  
                isOpen: '0'  
              }  
            ]  
          },  
          {  
            id: '1_1_2',  
            parentId: '1_1',  
            isOpen: '1',  
            children: [  
              {  
                id: '1_1_2_1',  
                parentId: '1_1_2',  
                isOpen: '0'  
              }  
            ]  
          },  
          {  
            id: '1_1_3',  
            parentId: '1_1',  
            isOpen: '0'  
          }  
        ]  
      }  
    ]  
  }  
];  
  找出id1_1_1_1的父元素、祖父元素、曾祖父元素的id，然后合并到一个数组，但是得满足一个条件id1_1_1_1节点本身的isOpen等于1，同层级其他的isOpen等于0，不然的话就返回空数组，不再返回祖父和曾祖父元素id，要是条件满足再继续向上递归返回祖父和曾祖父的元素id

```

Answer 1

     
    const data = [
        {
            isOpen: '1',
            id: '1',
            text:'设置',
            children: [
                {
                    isOpen: '1',
                    id: '1_1',
                    parentId: 1,
                    children: [
                        {
                            id: '1_1_1',
                            parentId: '1_1',
                            isOpen: '1',
                        }
                    ]
                },
                {
                    isOpen: '1',
                    id: '1_2',
                    parentId: 1,
                    text: '模板',
                    children: [
                        {
                            id: '1_2_1',
                            parentId: '1_2',
                            isOpen: '1',
                            children: [
                                {
                                    id: '1_2_1_1',
                                    parentId: '1_2_1',
                                    isOpen: '0',
                                },
                                {
                                    id: '1_2_1_2',
                                    parentId: '1_2_1',
                                    isOpen: '1',
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    ];

    /**
     * 递归查找父节点Id，并压入数组
     * @param node 父节点
     * @param targetId 目标节点
     * @param parentIds  父节点集合
     * @param siblings 兄弟节点
     */
    function findParent(node, targetId, parentIds, siblings) {
        if (node.id === targetId && node.isOpen == '1'
            && siblings.filter(i => i.id != targetId && i.isOpen == '1').length==0//判断兄弟元素是否isOpen全为0
        )
            return true;//目标节点且满足条件

        if (!node.children || !node.children.length) return false;//无子元素，结束查找

        //继续查找子元素
        for (let child of node.children) {
            if (findParent(child, targetId, parentIds, node.children)) {
                parentIds.push({ siblings, id: node.id });
                return true;
            }
        }
    }
    /**
     * 获取父节点Id集合
     * @param data  树形数据
     * @param targetId 要查找的节点Id
     */
    function getParentIds(data, targetId) {
        let parentIds = [];

        data.forEach(node => findParent(node, targetId, parentIds, data));

        //过滤父节点兄弟
        for (var i = parentIds.length - 1; i >= 0; i--) {
            if (parentIds[i].siblings.filter(i => i.isOpen == '1').length > 1) parentIds.splice(i+1)
        }

        return parentIds.map(i=>i.id);
    }

    console.log(getParentIds(data, '1_2_1_2'));
    console.log(getParentIds(data, '1_1_1'));