¿Cómo procesa JavaScript la adición, eliminación, modificación y consulta de datos estructurados en árbol?

Descripción del problema: JS maneja la adición, eliminación, modificación y consulta de estructuras de árbol.

Recientemente, he estado desarrollando un módulo de gestión de permisos para un sistema de gestión de backend, que implica la lógica de procesamiento de datos de varias estructuras de árbol, como: adición, eliminación. , modificación, consulta, etc.; en comparación con los datos de la estructura de matriz ordinaria, el procesamiento de la estructura de árbol no es tan intuitivo como el de la matriz, pero no es tan complicado. Requiere un paso más: la búsqueda recursiva para realizar un recorrido profundo de los datos. Aquí, el blogger también resumirá el proceso de desarrollo. Compartiré el método que se me ocurrió. Este artículo le brindará una comprensión profunda del procesamiento de datos de la estructura de árbol JS:

Ejemplo de estructura de datos

let data = [{
        identificación: 1,
        etiqueta: 'Nivel 1',
        niños: [{
          identificación: 4,
          etiqueta: 'Nivel 1-1',
          niños: [{
            identificación: 9,
            etiqueta: 'Nivel 3 1-1-1'
          }, {
            identificación: 10,
            etiqueta: 'Nivel 3 1-1-2'
          }]
        }]
      }, {
        identificación: 2,
        etiqueta: 'Nivel 2',
        niños: [{
          identificación: 5,
          etiqueta: 'Nivel 2-1'
        }, {
          identificación: 6,
          etiqueta: 'Nivel 2-2'
        }]
      }, {
        identificación: 3,
        etiqueta: 'Nivel 3',
        niños: [{
          identificación: 7,
          etiqueta: 'Nivel 2 3-1'
        }, {
          identificación: 8,
          etiqueta: 'Nivel 3-2'
        }]
      }];

Solución:

1. Agregue un nuevo nodo

para encontrar el nodo especificado en la estructura de árbol y agregue un nuevo nodo secundario. El código es el siguiente:

const appendNodeInTree = (id, tree, obj) => {.
  árbol.forEach(ele=> {
    si (ele.id === identificación) {
      ele.niños? ele.niños.push(obj): ele.niños = [obj]
    } demás {
      si (ele.niños) {
        appendNodeInTree(id, ele.children, obj)
      }
    }
  })
  árbol de retorno
}

2. Elimine el nodo.

Busque el nodo especificado en la estructura de árbol y elimine el nodo. El código es el siguiente

const removeNodeInTree=(treeList, id)=> { // Elimina elementos de la matriz (estructura de árbol) por id. (!listadeárboles || !listadeárboles.longitud) {
    devolver
  }
  for (sea i = 0; i < treeList.length; i++) {
    si (lista de árboles[i].id === id) {
      lista de árboles.splice(i, 1);
      romper;
    }
    removeNodeInTree(treeList[i].niños, id)
  }
}

3. Modifique el nodo

para buscar y modificar de forma recursiva el estado de un nodo. El código es el siguiente:

const updateNodeInTree=(treeList,id, obj)=> {.
      if (!treeList || !treeList.length) {
        devolver;
      }
      for (sea i = 0; i < treeList.length; i++) {
        si (lista de árboles[i].id == id) {
          lista de árboles[i]= obj;
          romper;
        }
        updateNodeInTree(treeList[i].children,id,obj);
      }
    }

4. Busque un nodo

de forma recursiva para encontrar un nodo en el nodo del árbol, código:

const findNodeInTree = (datos, clave, devolución de llamada) => {
      for (sea i = 0; i < data.length; i++) {
        si (datos[i].clave == clave) {
          devolver devolución de llamada(datos[i], i, datos)
        }
        si (datos[i].niños) {
          findNodeInTree (datos[i].niños, clave, devolución de llamada)
        }
      }
    }

    //El método para almacenar el nodo encontrado let Obj={}
    findNodeInTree(datos, clave, (elemento, índice, arreglo) => {
      Objeto = elemento
    })

    // Este es el nodo que se encontrará correspondiente a Obj console.log(Obj)