0
votes

JavaScript - supprimer récursivement les nœuds d'un certain type de l'arbre, mais réaménagent les enfants éligibles

J'écris une fonction récursive sur un arborescence JSON {nom, type, [enfants]} code> pour supprimer des nœuds d'un certain type. Cependant, les enfants du nœud supprimé doivent être rétablis au parent, s'ils ne sont pas du type à retirer.

Je connais la difficulté suivante: Disons que je veux retirer le type B sur l'arborescence suivante: P>

const removeType = (node, type) => {
    //if the node should not be removed    
    if (node.type !== type){
        //if the node has children, recursively call to prune children
        if (node.children && node.children.length > 0){
            node.children = [...node.children.map(child => removeType(child, type))
                                             .filter(child => child !== null)]
            return node
        }
        //if the node has no children, return the node
        else return node
    }
    //if the node should be removed
    else if (node.type === type){
        //if the node has children, recursively call, then reattach the children
        if (node.children && node.children.length > 0){
            node.children = [...node.children.map(child => removeType(child, type))
                                             .filter(child => child !== null)]
            return node.children
        }
        //
        else return null
    }
}

javascript json recursion tree

0 commentaires

3 Réponses :

1
votes

mis à jour strong>

Je pense que vous pouvez utiliser réduire pour cela, je n'ai pas mon ordinateur en ce moment pour le tester, mais ce sera quelque chose comme ça P>

const removeType = (node, type) => {
    if (!node) return;

    return node.reduce((acc, child) => {
        if(child["type"] === type) {
            const removedChild = removeType(child["children"], type);
            acc = [...acc, ...removedChild];
        } else {
            child.children = removeType(child["children"], type);
            acc.push(child);
        }
        return acc;
    }, []);

}

2 commentaires

Ce retour [enfant, [petit-enfant, petit-enfant], coeur] a toujours le tableau imbriqué.


                                                
                                                                                            
                                                    Merci beaucoup! J'aurais dû penser à utiliser réduire lol.


                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Voici un moyen de simplifier le programme à l'aide de  array.pototype.fraTmap  code>, d'une induction mathématique et d'une touche de récursivité mutuelle - 

  RemoveType  code> Accepte un  em> de  em> de  de noeuds  code> et d'un type de requête à supprimer,  q  code>  li>  li>
  removeType1  code> Accepte un  Single  em>  Node  code> et un type de requête pour supprimer,  q  code>  li>
 ul>   p> 


[
  {
    "name": "parent",
    "type": "a",
    "children": [
      {
        "name": "childA",
        "type": "a",
        "children": null
      },
      {
        "name": "grandChildA",
        "type": "a",
        "children": null
      },
      {
        "name": "grandChildB",
        "type": "a",
        "children": null
      },
      {
        "name": "childC",
        "type": "a",
        "children": null
      }
    ]
  }
]

                                

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Merci d'avoir répondu! C'est très utile!                                                
                                                
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Je pense que cette réponse est juste assez différente des autres fournies pour l'ajouter comme alternative. Il a la même structure récursive que la réponse de Merci, mais elle simplifie l'hypothèse que votre entrée est toujours une matrice, de même que tous les enfants  code> enfants  code> les nœuds  p> 

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

                                

                                                                    
                                    
                                    
                                        0 commentaires