Ordinamento della funzione ricorsiva in array di matrici

Question

Attualmente mi occupo di emettere per iscritto una funzione recrudente per ordinare alcuni dati JSON. Ho diversi array annidati di oggetti che ho bisogno di ordinare in singole diapositive. La struttura è simile al seguente:

[ 
{ 
    "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" 
       } 
      ] 
     } 
    ] 
} 
] 

Ho scritto una funzione ricorsiva:

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(); 

Questo uscite:

Tuttavia invece di recuperare i dati per il mio terzo slide under format:

aaa

aba

aca

vorrei ottenere

AA- [a, b, c]

mi chiedevo se era possibile dal momento che io non sono molto bravo a gestire i processi ricorsivi. Spero di essere stato chiaro e grazie per aver letto questo. Fondamentalmente ho bisogno di mantenere la mia struttura dati originale, ma rimuovere il primo livello di profondità per ogni iterazione (scorrere in un cursore che rappresenta l'aumento della profondità nella mia struttura dati).

Answer 1

Recentemente ho scritto un algoritmo per gestire in modo ricorsivo i dati come questo. Ecco un jsfiddle e la funzione principale

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); 
     } 
    } 
} 

Con questi dati l'uscita dovrebbe essere simile a

a 
    a 
     a 
     b 
b 
    b 
     a 
     b 

E outputStrs assomiglierà AA- [a, b, c]

Spero che questo aiuti! !!