Question

cons columnDefs = [
   {
     label: 'The_First_Name',
     value: getProp,
     args: ['firstName'] // different number of arguments depending on function
   },
   {
     label: 'City',
     value: getNestedProperty,
     args: ['location', 'city'] 
   }
]

const data = [
  {
     firstName: 'Joe',
     lastName: 'Smith',
     location: {
       city: 'London'
     }
  },
   {
     firstName: 'Anna',
     lastName: 'Andersson',
     location: {
       city: 'Stockholm'
     }
  }
]

const getProp = (object, key) => R.prop(key, object);

const getNestedProperty = (obj, args) => R.path(..args, obj);

Ramda管道映射数据：

const tableBuilder = R.pipe(R.map); // some ramda functions in here

const rows = tableBuilder(data, columnDefs);

所需的输出：

rows output:

[
   {
      The_First_Name: 'Joe',
      city: 'London'
   },
   {
      The_First_Name: 'Anna',
      city: 'Stockholm'
   }
]

每一行的键是label中的columnDefs属性。该值是从Ramda道具的value函数中获取的，以及args道具中定义的参数。

https://plnkr.co/edit/rOGh4zkyOEF24TLaCZ4e?p=preview

完全卡住。 Ramda甚至可能做到这一点吗？还是用普通的javascript更好？

Answer 1

您可以使用applySpec从另一个对象创建对象：

const obj = applySpec({
  The_First_Name: prop('firstName'),
  city: path(['location', 'city'])
})

obj({
  firstName: 'Joe',
  lastName: 'Smith',
  location: {
     city: 'London'
   }
});
//=> {"The_First_Name": "Joe", "city": "London"}

然后您可以使用该函数在数组上进行映射：

const data = [
  {
     firstName: 'Joe',
     lastName: 'Smith',
     location: {
       city: 'London'
     }
  },
   {
     firstName: 'Anna',
     lastName: 'Andersson',
     location: {
       city: 'Stockholm'
     }
  }
];

const obj = applySpec({
  The_First_Name: prop('firstName'),
  city: path(['location', 'city'])
})

console.log(

  map(obj, data)

);

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.min.js"></script>
<script>const {applySpec, prop, path, map} = R;</script>

这是将columnDefs转换为可与applySpec一起使用的对象的方式：

const spec = def => ({[def.label]: apply(def.value, def.args)});
const specs = compose(mergeAll, map(spec));

const columnDefs = [
   {
     label: 'The_First_Name',
     value: prop,
     args: ['firstName'] // different number of arguments depending on function
   },
   {
     label: 'City',
     value: path,
     args: [['location', 'city']]
   }
]

const data = [
  {
     firstName: 'Joe',
     lastName: 'Smith',
     location: {
       city: 'London'
     }
  },
   {
     firstName: 'Anna',
     lastName: 'Andersson',
     location: {
       city: 'Stockholm'
     }
  }
]

const spec = def => ({[def.label]: apply(def.value, def.args)});
const specs = compose(mergeAll, map(spec));

console.log(

  map(applySpec(specs(columnDefs)), data)

);

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.min.js"></script>
<script>const {apply, compose, mergeAll, map, prop, path, applySpec} = R;</script>

Answer 2

以下方法应该起作用：

const tableBuilder = (objs, spec) => objs .map (
  obj => Object .assign ( ...spec.map (
    ( {label, value, args} ) => ( { [label]: value (obj, args) } )
  ))
)

const getProp = (object, key) => R.prop (key, object);

const getNestedProperty = (obj, args) => R.path (args, obj);

const columnDefs = [
   {label: 'The_First_Name', value: getProp, args: ['firstName']},
   {label: 'City', value: getNestedProperty, args: ['location', 'city']}
]

const data = [
  {firstName: 'Joe', lastName: 'Smith', location: {city: 'London'}},
  {firstName: 'Anna', lastName: 'Andersson', location: {city: 'Stockholm'}}
]

console .log (
  tableBuilder (data, columnDefs)
)

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.js"></script> <script>
const {prop, path} = R                                                         </script>

但是它主要是偶然发生的。您可能需要重新考虑一下函数的定义方式。

这称为prop (['firstName'], obj)的等效项，恰好像prop ('firstName', obj)一样工作，但仅出于'foo' + ['bar']产生'foobar'的相同原因。这可能是您不应该依赖的巧合。

麻烦的是，您要统一对待带有单个参数的函数和带有参数数组的函数。这是个问题。您可能需要保持一致。

尽管您可以为此编写Ramda光泽，但我不确定它是否更具可读性。也许用Object .assign (...spec.map (代替mergeAll (spec.map (会更干净。而且，如果您不介意更改参数顺序，则可能需要进行更多清理。但这已经相当可读了。

更新

@customcommander的回答使我确信Ramda确实可以在这里增加一些价值。这要求您愿意为value函数交换参数顺序，并愿意将其作为完全咖喱函数（tableBuilder (columnDefs) (data)来调用），但这确实导致了一些不错的代码。

这主要是customcommander的工作，但我对其进行了一些调整以使功能更具可读性：

const spec = ({label, value, args}) => ({[label]: value(args)})

const tableBuilder = pipe(
  map(spec),
  mergeAll,
  applySpec,
  map
)

const columnDefs = [
   {label: 'The_First_Name', value: prop, args: ['firstName']},
   {label: 'City', value: path, args: ['location', 'city']}
]

const data = [
  {firstName: 'Joe', lastName: 'Smith', location: {city: 'London'}},
  {firstName: 'Anna', lastName: 'Andersson', location: {city: 'Stockholm'}}
]


console .log (
  tableBuilder (columnDefs) (data)
)

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.js"></script><script>
const {prop, path, pipe, map, mergeAll, applySpec} = R                        </script>

与prop的问题相同，但请注意，您可以在此处将其替换为path而不会造成损害。要点是，您所有的value函数都应具有相同的输入（值数组和要处理的对象。）如果它们相同，那么这对它们中的任何一个都应该起作用。

管道，带有动态参数的ramda

2 个答案:

更新