comment encoder ces données à la structure parent / children dans JSON

Je suis en train de travailler avec d3.js pour visualiser les familles d'animaux (organismes) (jusqu'à 4000 à la fois) comme un arbre graphique, même si la source de données pourrait tout aussi bien être un listing de répertoire ou à la liste des espaces de objets. mon apparence des données:

json = {
    organisms:[
        {name: 'Hemiptera.Miridae.Kanakamiris'},
        {name: 'Hemiptera.Miridae.Neophloeobia.incisa'},
        {name: 'Lepidoptera.Nymphalidae.Ephinephile.rawnsleyi'},
        ... etc ...
    ]
}

ma question est la suivante: je suis en train d'essayer de trouver le meilleur moyen de convertir les données ci-dessus à la hiérarchie parent /enfants la structure de données utilisée par un certain nombre de d3 visualisations comme treemap (pour les données d'exemple, voir le les reflets.json dans le d3/exemples/données/répertoire).
Voici un exemple, de la structure de données:

{"name": "ROOT",
 "children": [
        {"name": "Hemiptera",
         "children": [
             {"name": "Miridae",
              "children": [
                  {"name": "Kanakamiris", "children":[]},
                  {"name": "Neophloeobia",
                   "children": [
                       {"name": "incisa", "children":[] }
                   ]}
              ]}
         ]},
        {"name": "Lepidoptera",
         "children": [
             {"name": "Nymphalidae",
              "children": [
                  {"name": "Ephinephile",
                   "children": [
                       {"name": "rawnsleyi", "children":[] }
                   ]}
              ]}
         ]}
    ]}
}

EDIT: ci-joint l'original de tous les données de votre choix de la structure à l'intérieur d'un ROOT nœud, de sorte à se conformer à la structure de la d3 exemples, qui n'ont qu'un seul maître nœud parent.

Je cherche à comprendre générale modèle de conception, et comme un bonus, je serais ravi de voir quelques solutions en javascript, php, (ou même de python). javascript est ma préférence.
En ce qui concerne php: les données, j'utilise provient d'un appel à une base de données à un script php qui encode les résultats sous forme de json.
résultats de base de données dans le script php est un ensemble ordonné (voir ci-dessous), si c'est tout l'utilisation de php en fonction des réponses.

Array
(
    [0] => Array
        (
            ['Rank_Order'] => 'Hemiptera'
            ['Rank_Family'] => 'Miridae'
            ['Rank_Genus'] => 'Kanakamiris'
            ['Rank_Species'] => ''
        ) ........

où:
'Rank_Order' isParentOf 'Rank_Family' isParentOf 'Rank_Genus' isParentOf 'Rank_Species'

J'ai posé une question similaire axé sur une solution php icimais la seule réponse ne fonctionne pas sur mon serveur, et je n'ai pas tout à fait comprendre ce qui se passe, donc je veux vous poser cette question à partir d'un modèle de conception de point de vue, et d'inclure une référence à mon utilisation réelle qui est en javascript et d3.js.

source d'informationauteur johowie

Suivantes sont spécifiques à la structure que vous avez fournis, il pourrait être plus générique assez facilement. Je suis sûr que le addChild fonction peut être simplifiée. Nous espérons que les commentaires sont utiles.

function toHeirarchy(obj) {

  //Get the organisms array
  var orgName, orgNames = obj.organisms;

  //Make root object
  var root = {name:'ROOT', children:[]};

  //For each organism, get the name parts
  for (var i=0, iLen=orgNames.length; i<iLen; i++) {
    orgName = orgNames[i].name.split('.');

    //Start from root.children
    children = root.children;

    //For each part of name, get child if already have it
    //or add new object and child if not
    for (var j=0, jLen=orgName.length; j<jLen; j++) {
      children = addChild(children, orgName[j]);      
    }
  }
  return root;

  //Helper function, iterates over children looking for 
  //name. If found, returns its child array, otherwise adds a new
  //child object and child array and returns it.
  function addChild(children, name) {

    //Look for name in children
    for (var i=0, iLen=children.length; i<iLen; i++) {

      //If find name, return its child array
      if (children[i].name == name) {
        return children[i].children;        
      }
    }
    //If didn't find name, add a new object and 
    //return its child array
    children.push({'name': name, 'children':[]});
    return children[children.length - 1].children;
  }
}

Donné votre départ de l'entrée, je crois, quelque chose comme le code suivant va produire de la sortie souhaitée. Je n'ai pas imaginer que c'est la plus belle façon de le faire, mais c'est ce qui m'est venu à l'esprit à l'époque.

Il semblait plus facile à pré-traiter les données de première division, le premier tableau de chaînes de caractères dans un tableau de tableaux comme ceci:

[
   ["Hemiptera","Miridae","Kanakamiris" ],
   ["Hemiptera","Miridae","Neophloeobia","incisa" ],
   //etc
]

...et puis processus pour obtenir un objet dans une forme à quelque chose comme ceci:

  working = {
       Hemiptera : {
           Miridae : {
              Kanakamiris : {},
              Neophloeobia : {
                  incisa : {}
              }
           }
       },
       Lepidoptera : {
           Nymphalidae : {
              Ephinephile : {
                  rawnsleyi : {}
              }
           }
       }
    }

...parce que travailler avec des objets plutôt que des tableaux de fait, il est plus facile de tester si l'enfant existent déjà. La création de la structure au-dessus je les traiter ensuite une dernière fois pour obtenir votre dernière sortie souhaitée. Donc:

//start by remapping the data to an array of arrays
var organisms = data.organisms.map(function(v) {
        return v.name.split(".");
    });

//this function recursively processes the above array of arrays
//to create an object whose properties are also objects
function addToHeirarchy(val, level, heirarchy) {
    if (val[level]) {
        if (!heirarchy.hasOwnProperty(val[level]))
            heirarchy[val[level]] = {};
        addToHeirarchy(val, level + 1, heirarchy[val[level]]);
    }
}
var working = {};    
for (var i = 0; i < organisms.length; i++)
    addToHeirarchy(organisms[i], 0, working);

//this function recursively processes the object created above
//to create the desired final structure
function remapHeirarchy(item) {
    var children = [];
    for (var k in item) {
        children.push({
            "name" : k,
            "children" : remapHeirarchy(item[k])
        });
    }
    return children;
}

var heirarchy = {
    "name" : "ROOT",
    "children" : remapHeirarchy(working)
};

Démo: http://jsfiddle.net/a669F/1/

2

Une alternative de réponse à ma propre question....Dans le passé jour j'ai à apprendre pas beaucoup plus sur d3.js et par rapport à cette question d3.nid() avec .key() et .entrées() est mon ami (toutes d3 fonctions).
Cette réponse implique de modifier les données initiales, de sorte qu'il ne peut pas être qualifié comme une bonne réponse à la question précise que j'ai demandé. Toutefois, si quelqu'un a une question similaire, et peut changer des choses sur le serveur puis c'est une jolie solution simple:

renvoyer les données de la base de données dans ce format:
```
json = {'Organisms': [
    { 'Rank_Order': 'Hemiptera',
      'Rank_Family': 'Miridae',
      'Rank_Genus': 'Kanakamiris',
      'Rank_Species': '' },
    {}, ...
]}
```
Puis à l'aide de d3.nid()
```
organismNest = d3.nest()
    .key(function(d){return d.Rank_Order;})
    .key(function(d){return d.Rank_Family;})
    .key(function(d){return d.Rank_Genus;})
    .key(function(d){return d.Rank_Species;})
    .entries(json.Organism);
```
ce retourne:
```
{
key: "Hemiptera"
  values: [
    {
      key: "Cicadidae"
      values: [
        {
          key: "Pauropsalta "
          values: [
            {
              key: "siccanus"
              values: [
                       Rank_Family: "Cicadidae"
                       Rank_Genus: "Pauropsalta "
                       Rank_Order: "Hemiptera"
                       Rank_Species: "siccanus"
                       AnotherOriginalDataKey: "original data value"

etc etc, nested and lovely
```
Cela renvoie à quelque chose de très semblable à elles de tableau que j'ai décrit comme mon format de votre choix ci-dessus dans la question, avec quelques différences. En particulier, Il n'est pas tout joignant la RACINE de l'élément et également attendu que les touches a l'origine je voulais étaient "nom" et "enfants" .nid() renvoie les touches "clé" et "valeurs", respectivement.
Ces alternatives touches sont assez faciles à utiliser dans d3.js par juste la définition appropriée de données fonctions d'accesseur (base d3 concept) ... mais que c'est au-delà de la portée de la question ... j'espère que l'aide à quelqu'un trop

Vous devez vous connecter pour publier un commentaire.