Soy nuevo en Ramda y trato de limitarme a no recurrir a métodos Vanilla JS para tareas como esta mientras me adapto. Estoy atascado en algo que se siente muy simple. Ramda pierde claridad para mí tan pronto como necesito encadenar algunas cosas como esta.
R.groupBy para agregar algunos otros datos en un objeto con algunas claves, tengo un objeto de destino con el que me gustaría fusionar esto; sin embargo, las claves del groupby están anidadas dentro de él.
Puedo crear una vista con una lente en la propiedad de destino para ver los datos transformados para que coincidan; no estoy muy seguro de cómo hacer lo contrario para aplicar los datos agrupados al objeto anidado.
let ungroupedData = [ {"tag":"foo","id":99}, {"tag":"bar","id":33}, {"tag":"foo","id":14}, {"tag":"bar","id":26}, {"tag":"baz","id":99}, {"tag":"qux","id":33}, {"tag":"foo","id":49}, {"tag":"bar","id":13} ]; let groupedData = R.map(R.pluck('id'), R.groupBy(R.prop('tag'),ungroupedData)); console.log({groupedData}); // groupedData: // { // "foo": [99, 14, 49], // "bar": [33, 26, 13], // "baz": [99], // "qux": [33] // } let nestedTargetObjectToMerge = { "foo": { //... "ids": [344, 121], //... }, "bar": { //... "ids": [103, 66], //... } } // a view of the target object using a lens which matches groupedData let view = R.map(R.view(R.lensProp("ids")), nestedTargetObjectToMerge); console.log({view}); // view: // { // "foo": [344, 121], // "bar": [103, 66] // } /* let merged = ?? // R.mergeDeepWithKey ? // R.over? */ <script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.min.js"></script> { "foo" : { "ids" : [344, 121, 99, 14, 49], }, "bar" : { "ids" : [103, 66, 33, 26, 13], }, "baz" : { "ids": [99], }, "qux" : { "ids" : [33], } }Después de agrupar, asigne los grupos y use R.applySpec con R.pluck para crear un objeto con ids . Ahora puede usar R.mergeDeepWith con R.concat combinar los ids de ambos objetos:
const { pipe, groupBy, prop, map, applySpec, pluck, mergeDeepWith, concat } = R; const groupData = pipe( groupBy(prop('tag')), map(applySpec({ ids: pluck('id') })) ) const ungroupedData = [{"tag":"foo","id":99},{"tag":"bar","id":33},{"tag":"foo","id":14},{"tag":"bar","id":26},{"tag":"baz","id":99},{"tag":"qux","id":33},{"tag":"foo","id":49},{"tag":"bar","id":13}]; const nestedTargetObjectToMerge = {"foo":{"ids":[344,121]},"bar":{"ids":[103,66]}}; const groupedData = groupData(ungroupedData); const result = mergeDeepWith( concat, nestedTargetObjectToMerge, groupedData ); console.log(result); <script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.min.js"></script>Mi respuesta es similar a la de Ori Drori, pero lo suficientemente diferente como para incluirla también:
const extractIds = compose (map (objOf ('ids')), map (pluck ('id')), groupBy (prop ('tag'))) const group = compose (flip (mergeDeepWith (concat)), extractIds) const nestedTargetObjectToMerge = {foo: {ids: [344, 121]}, bar: {ids: [103, 66]}} const ungroupedData = [{tag: "foo", id: 99}, {tag: "bar", id: 33}, {tag: "foo", id: 14}, {tag: "bar", id: 26}, {tag: "baz", id: 99}, {tag: "qux", id: 33}, {tag: "foo", id: 49}, {tag: "bar", id: 13}] console .log ( group (ungroupedData) (nestedTargetObjectToMerge) ) .as-console-wrapper {max-height: 100% !important; top: 0} <script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.28.0/ramda.min.js"></script> <script> const {compose, map, objOf, pluck, groupBy, prop, flip, mergeDeepWith, concat} = R </script> Aquí extractIds convierte sus datos desagrupados en el mismo formato que su objeto de destino, y luego el group lo usa para pasar eso a mergeDeepWith (concat) . extreactId podría integrarse fácilmente en group , pero lo encuentro más legible así.
Sin embargo, quiero comentar sobre esto:
Soy nuevo en Ramda y trato de limitarme a no recurrir a métodos Vanilla JS para tareas como esta mientras me adapto. Estoy atascado en algo que se siente muy simple. Ramda pierde claridad para mí tan pronto como necesito encadenar algunas cosas como esta.
Soy uno de los fundadores y principales mantenedores de Ramda. Soy un gran fan. Pero sería muy cauteloso con esta filosofía. Ramda es una herramienta; está destinado a facilitar el trabajo en un cierto estilo. Pero no se supone que se haga cargo de todo por ti. A menudo se puede usar para hacer que su código sea más limpio. Úsalo cuando lo haga. Cuando no sea así, no intente exprimirlo. Si se trata únicamente de un ejercicio de aprendizaje, entonces juegue con las soluciones de Ramda. Pero para su trabajo real, no trate de forzarlo.
Y, aunque estoy bastante contento con la solución anterior, y con la versión de Ori Drori, no descartaría una solución simple de JS usando un solo pliegue, como este:
const group = (xs) => (target) => xs .reduce ((a, {tag, id}) => ({ ...a, [tag]: {...(a [tag] ?? {}), ids: [... (a [tag] ?.ids ?? []), id]} }), target) const nestedTargetObjectToMerge = {foo: {ids: [344, 121]}, bar: {ids: [103, 66]}} const ungroupedData = [{tag: "foo", id: 99}, {tag: "bar", id: 33}, {tag: "foo", id: 14}, {tag: "bar", id: 26}, {tag: "baz", id: 99}, {tag: "qux", id: 33}, {tag: "foo", id: 49}, {tag: "bar", id: 13}] console .log ( group (ungroupedData) (nestedTargetObjectToMerge) ) .as-console-wrapper {max-height: 100% !important; top: 0}