Actualmente estoy trabajando en un proyecto que ha insistido en definir explícitamente más de 1700 preguntas en un esquema de datos JSON para una API y se está saliendo de control. He estado sugiriendo una estructura más genérica para el esquema y dejo que los datos hablen para decirle cuál es el contexto.
Si bien hay debates sobre qué esquema usar, hemos decidido en nuestros sistemas internos seguir adelante y usar un modelo más genérico, incluso si el modelo externo es el explícito. Esto significa que necesitamos un adaptador para convertir de uno a otro, hasta el momento en que podamos usar el que queríamos en primer lugar.
El negocio es una tienda de Java, no sé si aconsejar construir el adaptador en Java o si podemos incorporar algún JavaScript ligero para hacer el trabajo, tal vez en forma de configuración.
Mi pregunta es: ¿Cómo abordaría la conversión del primer ejemplo de JSON en el segundo ejemplo de JSON? Se asigna desde objetos definidos explícitamente a objetos genéricos en matrices. Gracias por considerar mi pregunta.
Ejemplo uno
{ "nested_object" : { "department_one" : { "floor" : "4", "product_one" : { "quantity" : 10, "size" : "L" }, "product_two" : { "quantity" : 5, "size" : "S" } }, "department_two" : { "floor" : "2", "product_thirteen" : { "quantity" : 1, "size" : "M" }, "product_eleven" : { "quantity" : 8, "size" : "L" } } } }Ejemplo dos
{ "departments" : [ { "department_name" : "department_one", "floor" : "4", "products" : [ { "product_name" : "product_one", "quantity" : 10, "size" : "L" }, { "product_name" : "product_two", "quantity" : 5, "size" : "S" } ] }, { "department_name" : "department_two", "floor" : "2", "products" : [ { "product_name" : "product_thirteen", "quantity" : 1, "size" : "M" }, { "product_name" : "product_eleven", "quantity" : 8, "size" : "L" } ] } ] }Puede usar una combinación de Object.keys (to grab product and department names) . A continuación se muestra una implementación rápida.
const obj1 = { "nested_object" : { "department_one" : { "floor" : "4", "product_one" : { "quantity" : 10, "size" : "L" }, "product_two" : { "quantity" : 5, "size" : "S" } }, "department_two" : { "floor" : "2", "product_thirteen" : { "quantity" : 1, "size" : "M" }, "product_eleven" : { "quantity" : 8, "size" : "L" } } } } const transformedObj = { departments: [ ], }; //holds all department names const departmentKeys = Object.keys(obj1.nested_object) const departmentsArr = departmentKeys.map((key) => { const floor = obj1.nested_object[key].floor //remove floor reference, since we already stored the value above delete obj1.nested_object[key].floor //holds all product names const productsKeysArr = Object.keys(obj1.nested_object[key]) //holds all product objects for respective department const productsArr = productsKeysArr.map((product) => { const quantity = obj1.nested_object[key][product].quantity const size = obj1.nested_object[key][product].size return { product_name: product, quantity: quantity, size: size } }) return { department_name: key, floor: floor, products: productsArr } }) //assign departments array to transformed object transformedObj.departments = departmentsArr console.log(transformedObj)Esta sería mi opinión sobre esto. Me gusta la concisión y la expresividad en las implementaciones:
const data = { "nested_object": { ... }} Object.entries(data.nested_object).map(([department_name, {floor, ...ps}]) => ({ department_name, floor, products: Object.entries(ps).map(([product_name, p]) => ({product_name, ...p})) }))