Como o JavaScript processa a adição, exclusão, modificação e consulta de dados estruturados em árvore?

Descrição do problema: JS lida com adição, exclusão, modificação e consulta de estruturas de árvore

Recentemente, tenho desenvolvido um módulo de gerenciamento de permissão para um sistema de gerenciamento de backend, que envolve lógica de processamento de dados de várias estruturas de árvore, como: adição, exclusão. , modificação , consulta, etc.; em comparação com dados de estrutura de array comuns, o processamento da estrutura de árvore não é tão intuitivo quanto o de array, mas não é tão complicado. aqui, o blogueiro também resumirá o processo de desenvolvimento. Compartilharei o método que criei. Este artigo fornecerá uma compreensão completa do processamento de dados da estrutura em árvore JS:

Exemplo de estrutura de dados,

deixe data = [{
        identificação: 1,
        rótulo: 'Nível 1',
        crianças: [{
          identificação: 4,
          rótulo: 'Nível 1-1',
          crianças: [{
            identificação: 9,
            rótulo: 'Nível 3 1-1-1'
          }, {
            identificação: 10,
            rótulo: 'Nível 3 1-1-2'
          }]
        }]
      }, {
        identificação: 2,
        rótulo: 'Nível 2',
        crianças: [{
          identificação: 5,
          rótulo: 'Nível 2-1'
        }, {
          identificação: 6,
          rótulo: 'Nível 2-2'
        }]
      }, {
        identificação: 3,
        rótulo: 'Nível 3',
        crianças: [{
          identificação: 7,
          rótulo: 'Nível 2 3-1'
        }, {
          identificação: 8,
          rótulo: 'Nível 3-2'
        }]
      }];

Solução:

1. Adicione um novo nó

para encontrar o nó especificado na estrutura da árvore e adicione um novo nó filho. O código é o seguinte:

const appendNodeInTree = (id, tree, obj) => {.
  árvore.forEach(ele=> {
    if (ele.id === id) {
      ele.crianças?ele.crianças.push(obj): ele.crianças = [obj]
    } outro {
      if (ele.filhos) {
        anexarNodeInTree(id, ele.filhos, obj)
      }
    }
  })
  árvore de retorno
}

2. Exclua o nó.

Encontre o nó especificado na estrutura em árvore e exclua o nó. O código é o seguinte

const removeNodeInTree=(treeList, id)=> { // Remove elementos da matriz (estrutura em árvore) por id if. (!treeList || ! treeList.length) {
    retornar
  }
  for (seja i = 0; i < treeList.length; i++) {
    if (treeList[i].id === id) {
      treeList.splice(i, 1);
      quebrar;
    }
    removeNodeInTree(treeList[i].filhos, id)
  }
}

3. Modifique o nó

para pesquisar e modificar recursivamente o status de um nó. O código é o seguinte:

const updateNodeInTree=(treeList,id, obj)=> {.
      if (!treeList || !treeList.length) {
        retornar;
      }
      for (seja i = 0; i < treeList.length; i++) {
        if (treeList[i].id == id) {
          listaárvore[i]= obj;
          quebrar;
        }
        updateNodeInTree(treeList[i].filhos,id,obj);
      }
    }

4. Encontre um nó

recursivamente para encontrar um nó no nó da árvore, código:

const findNodeInTree = (dados, chave, retorno de chamada) => {
      for (seja i = 0; i < data.length; i++) {
        if (dados[i].chave == chave) {
          retornar retorno de chamada (dados[i], i, dados)
        }
        if (dados[i].filhos) {
          findNodeInTree (dados[i].filhos, chave, retorno de chamada)
        }
      }
    }

    //O método para armazenar o nó encontrado let Obj={}
    findNodeInTree(dados, chave, (item, índice, arr) => {
      Obj = item
    })

    // Este é o nó a ser encontrado correspondente ao Obj console.log(Obj)