¿Por qué mi recursividad regresa indefinida? Estoy tratando de "decodificar" datos de niños anidados de mongo que se devuelven como ID como:
{ "_id": "613fd030f374cb62f8f91557", "children": [ "613fd035f374cb62f8f9155b", "613fd136f374cb62f8f91564", "613fd1a5f374cb62f8f91571", "613fd20bf374cb62f8f9157c" ], ...more data } Mi objetivo es profundizar y convertir cada ID de niño en el Objeto que representa la ID y convertir sus ID de niños en objetos y luego continuar hasta que el child === [] (sin niños). Estoy tratando de que el padre inicial ( 613fd030f374cb62f8f91557 ) tenga acceso a todos los objetos secundarios anidados de varios niveles.
Este es mi código:
const get_documents = (documents) => { // Loop through each document documents.map((document) => { if (document.parent === null) { //convert children ids (_id) to array of objects let dbData = []; document.children.map((id) => { let dbChildren = documents.find((x) => x._id === id); dbData.push(dbChildren); }); let formattedData = []; dbData.map((child) => { let formattedObject = { id: child._id, name: child.name, depth: 0, parent: child.parent, closed: true, children: child_recursion(child.children), }; formattedData.push(formattedObject) }); } }); }; const child_recursion = (arr) => { let dbData = []; arr.map((id) => { let dbChildren = documents.find((x) => x._id === id); dbData.push(dbChildren); }); let formattedData = []; dbData.map((child) => { let newChild = []; if (child.children.length > 1) { newChild = child_recursion(child.children); } let formattedObject = { id: child._id, name: child.name, depth: 0, parent: child.parent, closed: true, children: newChild, }; formattedData.push(formattedObject); if (newChild === []) { return formattedData } }); };¿Qué estoy haciendo mal en mi recursividad? ¡Gracias por la ayuda!
Lo que te trae aquí es mezclar mutación con recursividad, lo que tiende a complicar mucho más las cosas.
Lo que esta línea me está diciendo:
children: child_recursion(child.children), es que siempre está esperando que child_recursion devuelva una matriz de niños formateados.
Sin embargo, en child_recursion no siempre devuelves algo. A veces estás mutando a veces en su lugar. Personalmente, creo que tiende a ser más fácil entender que no se usa la mutación.
El proceso, por lo tanto, debería ser algo como esto:
De esta forma podemos convertir cada hijo en un objeto con sus hijos convertidos y así sucesivamente.
También es algo extraño que esté intentando convertir todos los documentos a la vez. En cambio, como dio en su pregunta, debe concentrarse en el objeto que está tratando de convertir y trabajar hacia abajo desde allí. Si es el caso en el que los objetos pueden ser tanto padres como hijos, entonces tiene un gráfico, no un árbol, y la recursividad tendría que manejarse de manera diferente a lo que espera.
Realmente no necesitamos dos funciones para hacer esto, solo una y en el caso de que ya tenga los objetos que está buscando, también puede pasarlos (si no solo elimina los documentos y los obtiene de la base de datos o algún servicio en su lugar). También podemos usar lo que se llama un acumulador para establecer valores iniciales antes de nuestra recursión y rastrearlos a medida que recurrimos.
const convert_children = (obj, documents) => { const convert_children_acc = (obj, documents, parent, depth) => { let partial_format = { id: obj._id, name: obj.name, depth: depth, parent: parent, close: true } if (obj.children && obj.children.length === 0) { return { ...partial_format, children: [] } } else { return { ...partial_format, children: obj.children.map(child => { child = documents.find(x => child === x._id); return convert_children_acc(child, documents, obj._id, depth+1) }) } } } return convert_children_acc(obj, documents, null, 0); };