的Javascript嵌套数组元素得到

Question

我有这样的数组：

"pages": [{ 
    "key": "1", 
    "pages": [{ 
     "key": "2", 
     "pages": [{ 
      "key": "3" 
     }] 
    }, 
     { 
      "key": "4", 
      "pages": [{ 
       "key": "5" 
      }] 

     }] 
}] 

其中键1和4是在相同的水平和1包含2含有3和键4中包含5我想要的结果是在订单[3,2,5,1,4]。我已经尝试了以下递归，但我无法获得正确的顺序。

function fnGetAll (oTopDetailPage, array) { 
    var i; 

    for (i=0; i<oTopDetailPage.length; i++) { 
     array.push(oTopDetailPage[i]); 
     if(oTopDetailPage[i].pages) { 
      fnGetAllSubPages(oTopDetailPage[i].pages, array); 
     } 
    } 
    return array; 
} 

Answer 1

如果你想要一个Depth-first search，你可以先迭代孩子，然后把实际的密钥。

结果是一个数组，它与给定的数组有一点不同。

function getDepthFirst(object) { 
 
    var result = []; 
 
    object.pages.forEach(function iter(a) { 
 
     Array.isArray(a.pages) && a.pages.forEach(iter); 
 
     result.push(a.key); 
 
    }); 
 
    return result; 
 
} 
 

 
var data = { pages: [{ key: 1, pages: [{ key: 2, pages: [{ key: 3 }] }, { key: 4, pages: [{ key: 5 }] }] }] }; 
 
    
 
console.log(getDepthFirst(data)); // [3, 2, 5, 4, 1]

补遗用于获取的[3, 5, 2, 4, 1]一个反向级顺序遍历结果，与一个临时数组，其从相同的水平收集所有数据，并从所有水平恢复的项目阵列，从最高到最低。

该回调函数在实际水平上使用闭包。

function getData(object) { 
 
    var temp = []; 
 
    object.pages.forEach(function iter(level) { 
 
     return function (a) { 
 
      Array.isArray(a.pages) && a.pages.forEach(iter(level + 1)); 
 
      temp[level] = temp[level] || []; 
 
      temp[level].push(a.key); 
 
     }; 
 
    }(0)); 
 
    return temp.reduceRight(function (r, a) { 
 
     return r.concat(a); 
 
    }); 
 
} 
 

 
var data = { pages: [{ key: 1, pages: [{ key: 2, pages: [{ key: 3 }] }, { key: 4, pages: [{ key: 5 }] }] }] }; 
 

 
console.log(getData(data)); // [3, 5, 2, 4, 1]

Answer 2

你的根容器是一点都不奇怪，因为它是无效的JavaScript。我假设它是{pages: ... }并附上{}，但即使这样也没有意义，因为根容器不包含key属性。

你应该先解决您的节点，这样你有一个统一的结构，例如

type Node = Node { key: String, pages: [Node] } 

然后实现您的深度优先搜索是微不足道

const dfs = ({key, pages = []}) => 
 
    [...pages.reduce((acc, p) => acc.concat(dfs(p)), []), key] 
 
    
 
const data = { 
 
    "key": "1", 
 
    "pages": [{ 
 
     "key": "2", 
 
     "pages": [{ 
 
      "key": "3" 
 
     }] 
 
    }, 
 
    { 
 
     "key": "4", 
 
     "pages": [{ 
 
      "key": "5" 
 
     }] 
 
    }] 
 
} 
 
    
 
console.log(dfs(data)) 
 
// [ '3', '2', '5', '4', '1' ]

---

如果您正在通过-h构造数据而且，不要。相反，我建议你制作一个简单的构造函数来统一构建数据。因为现在每个节点都保证有key和pages属性，所以我们可以删除dfs中pages = []的默认参数值。这比较好，因为我们可以避免任何可能试图容纳失踪财产的防御性编程。

const dfs = ({key, pages}) => 
 
    [...pages.reduce((acc, p) => acc.concat(dfs(p)), []), key] 
 
    
 

 
const makeNode = (key, ...pages) => ({key, pages}) 
 

 
const data = 
 
    makeNode('1', 
 
    makeNode('2', 
 
     makeNode('3')), 
 
    makeNode('4', 
 
     makeNode('5'))) 
 
    
 
console.log(dfs(data)) 
 
// [ '3', '2', '5', '4', '1' ]