根据多个属性过滤 N 级嵌套对象数组

Question

data = [
    {
      name: "Parent Level 1",
      questions: [
        {
          name: "question 1"
        }
      ],
      children: [
        {
          name: "Child 1 - P1",
          questions: [
            {
              name: "ability to code"
            },
            {
              name: "ability to do something"
            }
          ],
          children: [
            {
              name: "Child -2 P1",
              questions: [
                {
                  name: "figure out"
                }
              ]
            }
          ]
        }
      ]
    },
    {
      name : 'Parent Level 2',
      questions : [
        {name : 'question 1 P-2'}
      ]
    },
    {
      name : 'Parent Level 3',
      children: [
        {
          name : 'Child Level -1 P-3',
          children: [
          {
             name : 'Child Level 2- P-3',
             questions : [
              {
       name : 'Question level 2
              }
             ]
           }
          ]
          questions: [
            {name : 'hello there'}
          ]
        }
      ]
    }
  ];

Problem:

I need to perform a keyword search on the question, and if a question is found at a node - 3 let's say then we need to return that node and all the parent nodes of that object.

For example, if I search for 'hello there', the final tree should be:

[
    {
      name : 'Parent Level 3',
      children: [
        {
          name : 'Child Level -1 P-3',
          children: [
          {
             name : 'Child Level 2- P-3',
             questions : []
           }
          ]
          questions: [
            {name : 'hello there'}
          ]
        }
      ]
    }
  ];

We can have children or questions [] at any node.

I am able to find the questions matching the search string, but I am not able to remove the unwanted nodes from the tree. Here is the code for that:

searchNode (data) {
    for (let d of data) {
      this.search(d)
    }
 }

 search(data) {
    let search = 'ability'
    if(!!data.questions && data.questions.length > 0) {
      data.questions = data.questions.filter((question) => {
        return question.name.includes(search)
      })
    }
    if(data.children && data.children.length > 0) {
      searchNode(data.children)
    }
  }

search(data)

Answer 1

This should work for you. The demo code is in stackblitz. Check the result in the console.

Stackblitz demo

searchString = 'hello';
filteredData = [];

ngOnInit(): void {
    this.filteredData = [];
    this.data.forEach(node => {
        if (this.checkQtn(node)) {
            this.filteredData.push(node);
        }
    });
    console.log(this.filteredData);
}

checkQtn(node): Boolean {
    let response: Boolean = false;
    if (node.questions) {
        let qtns = [];
        qtns = node.questions;
        qtns.forEach(el => {
            const eachQtn: string = el.name;
            if (eachQtn.includes(this.searchString)) {
                response = true;
            }
        });
    }
    if (!response && node.children) {
        for (let i = 0; i < node.children.length && !response; i++) {
            response = this.checkQtn(node.children[i]);
        }
    }
    return response;
}