遍历JSON数据中的嵌套数组

Question

I have the data like this:

    {
        {
            "text" : "parent1",
            "nodes" :[
                {
                    "text": "child1",
                    "nodes": [
                        {
                            "text": "grandchild1",
                            "nodes":[
                                {
                                    "text": "hello",
                                    "nodes": []
                                }
                            ]
                        },
                        {
                            "text": "hello",
                            "nodes":[]
                        }
                    ]
                }
            ]
        },
        {
            "text" : "parent2",
            "nodes" :[
                {
                    "text": "child2",
                    "nodes": [
                        {
                            "text": "grandchild2",
                            "nodes": [
                                {
                                    "text": "grandgrandchild1",
                                    "nodes": [
                                        {
                                            "text": "hello",
                                            "nodes": []
                                        }
                                    ]
                                }
                            ]
                        }
                    ]

                }
            ]
        }
    }

What I want is, creating a path array that contains the path of the elements whose "text" value is "hello". For example, according to this data:

var paths: any[][] = [
    ["parent1","child1","grandchild1","hello"],
    ["parent1","child1","hello"],
    ["parent2","child2","grandchild2","grandgrandchild1","hello"]
];

I want this "paths" array. Please notice, if the element's text value is "hello", then this element's "nodes" length is 0. I think I'm making a mistake in recursion.

Answer 1

You need to

• Traverse the object using recursion,
• Assign paths along the way
• and finally keep record those paths when the current text matches the text.

Demo

 var obj = [{ "text": "parent1", "nodes": [{ "text": "child1", "nodes": [{ "text": "grandchild1", "nodes": [{ "text": "hello", "nodes": [] }] }, { "text": "hello", "nodes": [] } ] }] }, { "text": "parent2", "nodes": [{ "text": "child2", "nodes": [{ "text": "grandchild2", "nodes": [{ "text": "grandgrandchild1", "nodes": [{ "text": "hello", "nodes": [] }] }] }] }] } ]; var helloPaths = []; var valueToSearch = "hello"; function traverseAndCreatePath( obj, parent, valueToSearch ) { if ( Array.isArray( obj ) ) { obj.forEach( function(item){ traverseAndCreatePath( item, parent, valueToSearch ); }); } else { if ( parent ) { obj.path = parent.path.slice(); obj.path.push( obj.text ); } else { obj.path = [ obj.text ]; } if ( obj.text == valueToSearch ) { helloPaths.push( obj.path.slice() ); } if ( obj.nodes && obj.nodes.length ) { obj.nodes.forEach( function(item){ traverseAndCreatePath( item, obj, valueToSearch ); }); } } return obj; } traverseAndCreatePath( obj, null, valueToSearch ); console.log( helloPaths ); 

Answer 2

This is a Depth First Traversal

 var counter = 0; var finalArray = [] function test(arr, node) { arr.push(node.text); if (node.hasOwnProperty("nodes") && Array.isArray(node.nodes) && node.nodes.length != 0) { node.nodes.forEach(function(nodeChild) { test(arr, nodeChild); }) } else { finalArray[counter] = arr.slice(); counter++; } arr = arr.slice(0, -1); } var b =[ { "text" : "parent1", "nodes" :[ { "text": "child1", "nodes": [ { "text": "grandchild1", "nodes":[ { "text": "hello", "nodes": [] } ] }, { "text": "hello", "nodes":[] } ] } ] }, { "text" : "parent2", "nodes" :[ { "text": "child2", "nodes": [ { "text": "grandchild2", "nodes": [ { "text": "grandgrandchild1", "nodes": [ { "text": "hello", "nodes": [] } ] } ] } ] } ] } ] b.forEach(function(nodeVal) { test([], nodeVal) }) console.log(finalArray); 

Answer 3

Your function should recieve:

1. A list of nodes of any length

And return:

2. A list of paths of any length

For the base of this behavior, we'll use reduce . It loops over the list once, and can keep adding to the result when needed.

const helloPathsFromNodes = (nodes = [], paths = []) =>
  nodes.reduce(
    /* TODO */ ,
    paths
  )

For each node, you check whether it's the end of an individual path to determine if you need to recurse. To keep track of the current path, we'll need to pass along an additional parameter ( path ) and add to it along the way:

if (node.text === "hello") return [...path, "hello"]
else return goDeeper([...path, node.text])

Putting this together, you get:

 const helloPathsFromNodes = (nodes = [], paths = [], path = []) => nodes.reduce( (acc, { text, nodes }) => text === "hello" ? [...acc, [...path, text]] : helloPathsFromNodes(nodes, acc, [...path, text]), paths ); console.log(helloPathsFromNodes(getData())); // Example Data function getData() { return [ { "text" : "parent1", "nodes" :[ { "text": "child1", "nodes": [ { "text": "grandchild1", "nodes":[ { "text": "hello", "nodes": [] } ] }, { "text": "hello", "nodes":[] } ] } ] }, { "text" : "parent2", "nodes" :[ { "text": "child2", "nodes": [ { "text": "grandchild2", "nodes": [ { "text": "grandgrandchild1", "nodes": [ { "text": "hello", "nodes": [] } ] } ] } ] } ] } ] };