Baumhierarchie mit Knoten und Links generieren JSON

Question

Ich möchte JavaScript-Funktion, die Knoten konvertieren und json zu Tree JSON verbindet.

Hier Knoten und Verbindungen JSON:

{ 
     "nodes": [ 
     {name: "Top Level", group: 1}, 
     {name: "Level 2: A", group: 1}, 
     {name: "Son of A", group: 1}, 
     {name: "Daughter of A", group: 1}, 
     {name: "Level 2: B", group: 1} 
     ], 
     "links": [ 
     {source: 0, target: 1, value: 1}, 
     {source: 0, target: 4, value: 1}, 
     {source: 1, target: 2, value: 1}, 
     {source: 1, target: 3, value: 1} 
     ] 
    } 

Array Hier Links, die "Quelle" und "Ziel" ist Knoten-Array-Index haben. Für zB {Quelle: 0, Ziel: 1, Wert: 1}: - Quelle: 0 bedeutet Knoten [0] und Ziel: 1 bedeutet Knoten [1]

Nach oben Umwandeln JSON dann Baum Hierarchie wie folgt aussehen:

[ 
    { 
    "name": "Top Level", 
    "parent": "null", 
    "children": [ 
     { 
     "name": "Level 2: A", 
     "parent": "Top Level", 
     "children": [ 
      { 
      "name": "Son of A", 
      "parent": "Level 2: A" 
      }, 
      { 
      "name": "Daughter of A", 
      "parent": "Level 2: A" 
      } 
     ] 
     }, 
     { 
     "name": "Level 2: B", 
     "parent": "Top Level" 
     } 
    ] 
    } 
]; 

Danke.

Answer 1

Eine einfache Lösung wäre wie folgt:

var data; // parse the JSON into here 
var buildNode = function(index) { 

    var children = data.links.filter(function(x) { 
     return x.source === index; 
    }).map(function(x) { 
     return buildNode(x.target); 
    }); 

    //with ES6 you can use .find to get the first matching item, instead of .filter and [0] 
    var parent = data.links.filter(function(x) { 
     return x.target === index; 
    })[0]; 
    var parentName = parent ? parent.name : undefined; 

    return { 
     name: data.nodes[index].name, 
     parent: parentName, 
     children: children 
    }; 
}; 

var tree = buildNode(0); 

---

NB. Es könnte sein, effizienter einen Array mit den entsprechenden Zielen und die Eltern zuerst zu erzeugen, anstatt jedes Mal durch das gesamte Array zu iterieren:

var data; // parse the JSON into here 
var nodeTargets = []; 
var nodeParents = []; 
data.links.forEach(function(x) { 
    if (!nodeTargets[x.source]) { 
     nodeTargets[x.source] = [] 
    } 
    nodeTargets[x.source].push(x.target); 

    nodeParents[x.target] = x.source; 
}); 

Diese in der folgenden Anordnungsstruktur in nodeTargets führen:

[ 
    [1, 4], 
    [2, 3] 
] 

und folgend in nodeParents:

{ 
    1: 0, 
    4: 0, 
    2: 1, 
    3: 1 
} 

Dann wird die buildNode Funktion aussehen würde, wie folgt aus:

var buildNode = function(index) { 

    var children = nodeTargets[index].map(function(x) { 
     return buildNode(x); 
    }); 

    var parentIndex = nodeParents[index]; 
    var parentName; 
    if (parentIndex !== undefined) { 
     parentName = data.nodes[parentIndex].name; 
    } 

    return { 
     name: data.nodes[index].name, 
     parent: parentName, 
     children: children 
    }; 
}; 

Answer 2

Sie einen Baum durch Iterieren alle nodes und erzeugen ein Objekt mit Indizes als Schlüssel und nur den Namen, die dann von allen links und hängen Sie die Knoten mit Eltern und Kindern laufen, wo eine Baumstruktur aufbauen konnte wird generiert.

Dann müssen Sie die untergeordneten Elemente in einem Objekt kennzeichnen, wo es später nur nicht untergeordnete Knoten zurückgibt.

var data = { nodes: [{ name: "Top Level", group: 1 }, { name: "Level 2: A", group: 1 }, { name: "Son of A", group: 1 }, { name: "Daughter of A", group: 1 }, { name: "Level 2: B", group: 1 }], links: [{ source: 0, target: 1, value: 1 }, { source: 0, target: 4, value: 1 }, { source: 1, target: 2, value: 1 }, { source: 1, target: 3, value: 1 }] }, 
 
    tree = function (object) { 
 
     var o = {}, children = {}; 
 

 
     object.nodes.forEach(function (a, i) { 
 
      o[i] = { name: a.name }; 
 
     }); 
 

 
     object.links.forEach(function (a) { 
 
      o[a.target].parent = o[a.source].name; 
 
      o[a.source].children = o[a.source].children || []; 
 
      o[a.source].children.push(o[a.target]); 
 
      children[a.target] = true; 
 
     }); 
 

 
     return Object.keys(o).filter(function (k) { 
 
      return !children[k]; 
 
     }).map(function (k) { 
 
      return o[k]; 
 
     }); 
 
    }(data); 
 

 
console.log(tree);

.as-console-wrapper { max-height: 100% !important; top: 0; }