Sugeriría reestructurar para que siempre se acceda a los subordinados con la misma clave y, por lo tanto, se puedan visitar de manera muy simple. También lo hice para que cada nodo sea una persona, no hay ningún objeto en la parte superior que no sea una persona. Dejé el nombre de la variable, pero ahora se refiere directamente a Dumbledore.

 let hogwartsHeirarchy = { name: "Professor Dumbledore", role: "Headmaster", key: 1, subordinates: [ { name: "Minerva McGonagall", role: "Headmistress", key: 2, subordinates: [ { name: "Rubeus Hagrid", role: "StandByProfessor", subject: "Potions Master", key: 3, subordinates: [ { name: "Horace Slughorn", key: 4, role: "Professor" }, { name: "Severus Snape", key: 4, role: "Professor" }, ], }, { name: "Alastor Moody", role: "StandByProfessor", subject: "Defense Against the Dark Arts", key: 3, subordinates: [ { name: "Remus Lupin", key: 4, role: "Professor" }, { name: "Gilderoy Lockhart", key: 4, role: "Professor" }, ], }, ], }, ], }; function visitStaff(staffMember) { if (staffMember.subordinates) { for (const subordinate of staffMember.subordinates) { visitStaff(subordinate); } } console.log("Staff member:", staffMember); } visitStaff(hogwartsHeirarchy);

Al configurar una estructura de datos, es importante pensar en cómo se accederá y cuáles son sus partes definitorias. En este caso, hay personas, que son los nodos, y relaciones (subordinadas), que son los bordes del grafo.

En su código original, tenía un objeto { Headmaster: [...] } , ¿qué representa? es una persona? no; es una relacion? tipo de, pero no. Define algo sobre Dumbledoor, que él es el director, pero no de quién o de qué es el director. Entonces, en realidad solo describe el rol/título del trabajo de Dumbledoor, por lo que tiene más sentido como una propiedad de la persona. Es redundante como objeto.

Ayuda a alinear sus objetos para que todos representen algo. Debería poder describir qué es cada objeto y matriz.

Puede eliminar las claves conocidas del objeto y obtener la jerarquía de tipos, luego iterar la propiedad y devolver la tupel de tipo, nombre, asunto y clave solo si el tipo existe.

 const getValues = (object, type) => [ ...(type ? [`${type} - name : ${object.name}, ${object.subject ? `subject : ${object.subject}, ` : ''}key : ${object.key}`] : []), ...Object .keys(object) .filter(k => !['name', 'subject', 'key'].includes(k)) .flatMap(k => object[k].flatMap(o => getValues(o, k))) ], hogwartsHierarchy = { Headmaster: [{ name: "Professor Dumbledore", key: 1, Headmistress: [{ name: "Minerva McGonagall", key: 2, StandByProfessor: [{ name: "Rubeus Hagrid", subject: "Potions Master", key: 3, Professor: [{ name: "Horace Slughorn", key: 4 }, { name: "Severus Snape", key: 4 }] }, { name: "Alastor Moody", subject: "Defense Against the Dark Arts", key: 3, Professor: [{ name: "Remus Lupin", key: 4 }, { name: "Gilderoy Lockhart", key: 4 }] }] }] }] }; console.log(getValues(hogwartsHierarchy));

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

Dada la estructura de datos:

a) Supongo que solo habrá una matriz en cada tipo de "título", y
b) esa matriz contendrá una lista de objetos de una estructura similar a la de su padre

Es posible ...

1. para usar for..of con el fin de
2. iterar a través de cada clave en un objeto y agregarlos a una cadena. Debido a que hay arreglos que contienen objetos,
3. Puedo recorrerlos, y
4. hacer un bucle recursivo, haciendo que el método se llame a sí mismo.

 const hogwartsHierarchy = { Headmaster: [{ name: "Professor Dumbledore", key: 1, Headmistress: [{ name: "Minerva McGonagall", key: 2, StandByProfessor: [{ name: "Rubeus Hagrid", subject: "Potions Master", key: 3, Professor: [{ name: "Horace Slughorn", key: 4 }, { name: "Severus Snape", key: 4 }] }, { name: "Alastor Moody", subject: "Defense Against the Dark Arts", key: 3, Professor: [{ name: "Remus Lupin", key: 4 }, { name: "Gilderoy Lockhart", key: 4 }] }] }] }] }; function printAllWithChilds(obj, prevProp) { let listItem = (prevProp) ? ' -- ' + prevProp : ''; for (const property in obj) { // 1 if (obj[property] instanceof Array) { obj[property].forEach((child_obj) => { // 3 listItem += printAllWithChilds(child_obj, property); // 4 }); } else { listItem += `, ${property}: ${obj[property]}`; // 2 } } return listItem; } let listStr = printAllWithChilds(hogwartsHierarchy); console.log(listStr);

Honestamente, dividiría la jerarquía de hogwartsHierarchy en partes más pequeñas, siguiendo una especie de estructura de base de datos, donde primary_key es única para cada individuo. Estas matrices no tienen mucho sentido, hasta que miras la variable professors y cómo su respectiva tecla belongs_to corresponde a los profesores en standbyprofessors , donde puedes ver que "Horace Slughorn" pertenece a "Rubeus Hagrid".

 const headermaster = { name: "Professor Dumbledore", primary_key: 1 }; const headmistress = { name: "Minerva McGonagall", primary_key: 2, belongs_to: 1 }; const standbyprofessors = [{ name: "Rubeus Hagrid", subject: "Potions Master", primary_key: 3, belongs_to: 2 }, { name: "Alastor Moody", subject: "Defense Against the Dark Arts", primary_key: 4, belongs_to: 2 } ]; const professors = [{ name: "Horace Slughorn", primary_key: 5, belongs_to: 3 }, { name: "Severus Snape", primary_key: 6, belongs_to: 3 }, { name: "Remus Lupin", primary_key: 7, belongs_to: 4 }, { name: "Gilderoy Lockhart", primary_key: 8, belongs_to: 4 }, ];