Zamawianie funkcji rekursywnej skutkuje tablicami tablic

Question

Obecnie zajmuję się kwestią pisania funkcji recruzywnej, aby zamówić niektóre dane JSONA. Mam kilka zagnieżdżonych tablic obiektów, które muszę uporządkować w pojedyncze slajdy. Struktura jest podobna do następującej:

[ 
{ 
    "title": "a", 
    "children": [ 
     { 
      "title": "a-a", 
      "children": [ 
       { 
        "title": "a-a-a" 
       }, 
       { 
        "title": "a-a-b" 
       } 
      ] 
     }, 
     { 
      "title": "a-b", 
      "children": [ 
       { 
        "title": "a-b-a" 
       }, 
       { 
        "title": "a-b-b" 
       } 
      ] 
     } 
    ] 
}, 
{ 
    "title": "b", 
    "children": [ 
     { 
      "title": "b-a", 
      "children": [ 
       { 
        "title": "b-a-a" 
       }, 
       { 
        "title": "b-a-b" 
       } 
      ] 
     }, 
     { 
      "title": "b-b", 
      "children": [ 
       { 
        "title": "b-b-a" 
       }, 
       { 
        "title": "b-b-b" 
       } 
      ] 
     } 
    ] 
} 
] 

Pisałem rekurencyjną funkcję:

var catalog = { 

init: function() { 

    var _this = this; 

    $.getJSON("catalog.json", function(data) { 

     _this.slides = []; 
     _this.parseCategories(data.catalog.category,-1,0); 

    }); 

}, 

parseCategories: function(array, depth, prevParent) { 
    ++depth; 

    if (!this.slides[depth]) this.slides[depth] = []; 
    if (!this.slides[depth][prevParent]) this.slides[depth][prevParent] = []; 

    this.slides[depth][prevParent].push(array); 

    for (var i = 0; i < array.length; i++) { 

     if (array[i].category) { 

      this.parseCategories(array[i].category, depth, i); 
     } 
    } 

} 

} 

catalog.init(); 

This Wyjścia:

Jednak zamiast pobierania danych dla mój trzeci slajd w formacie:

aaa

ABA

aca

Chciałbym dostać

AA- [A, B, C]

Zastanawiałem się, czy to było możliwe, ponieważ nie jestem bardzo dobry w obsłudze procesów rekurencyjnych. Mam nadzieję, że było jasne i dziękuję za przeczytanie tego. Po prostu potrzebuję zachować oryginalną strukturę danych, ale usunąć pierwszy poziom głębi dla każdej iteracji (przesuń suwak, który reprezentuje zwiększającą się głębokość w mojej strukturze danych).

Answer 1

Niedawno napisałem algorytm rekursywnie obsługi danych takich jak ten. Oto jsfiddle i główną funkcją

console.log('starting'); 
// data in tree format. 
var output = {}; 
// data in slide format ["a-a-a", "a-a-b", "b-b-a", "b-b-b"] 
var outputStrs = []; 
parseData(data, output); 
console.log(output); 
console.log(outputStrs); 

function parseData(data, store) { 
    // go through each element 
    for (var i = 0; i < data.length; i++) { 
     var element = data[i]; 
     // used to keep track of where we are in the tree. 
     var splitElement = element.title.split('-'); 
     var titleStart = splitElement[0]; 
     // console.log(element); 
     if (_.has(element, 'children') && _.isArray(element.children)) { 
      // if there is a children, then recursively handle it. 
      store[titleStart] = {}; 
      parseData(element.children, store[titleStart]); 
     } else { 
      // if we are at the end, then add in the data differently. 
      var titleEnd = splitElement[splitElement.length-1]; 
      store[titleEnd] = titleEnd; 
      // create the slides 
      var slide = []; 
      for (var j = 0; j < splitElement.length; j++) { 
       if (j !== splitElement.length - 1) { 
        slide.push(titleStart); 
       } else { 
        slide.push(titleEnd); 
       } 
      } 
      slide = slide.join('-'); 
      if (!_.contains(outputStrs, slide)) outputStrs.push(slide); 
     } 
    } 
} 

Dzięki tym danym wyjście powinno przypominać

a 
    a 
     a 
     b 
b 
    b 
     a 
     b 

I outputStrs będzie przypominać AA- [a, b, c]

Nadzieja to pomaga! !!