什么是完全 ramda.js 等效于此代码？

Question

i need create function that updates item with certain id in list by merging payload object

in ramda.js way

export const updateItem = <T extends { id: I }, I>(items: T[], id: I, payload: Partial<T>) =>
  items.map(
    item => item.id === id
      ? ({ ...item, ...payload })
      : item
  )

Answer 1

We can certainly write a fairly readable version in Ramda:

 const updateItem = (id, payload) => map ( when (propEq ('id', id), mergeLeft (payload)) ) const items = [{foo: 'a', id: 1}, {foo: 'b', id: 2}, {foo: 'c', id: 1}, {foo: 'd', id: 4}] console.log (updateItem (1, {bar: 'x'}) (items)) // updates all with id of 1 console.log (updateItem (2, {bar: 'x'}) (items))

 .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 {map, when, propEq, mergeLeft} = R </script>

We can read this as map over our input a function that when the id property equals ( propEq ) the id supplied, perform a mergeLeft on the payload and the current value. when has an implicit understanding that if the condition doesn't match, it returns the value intact.

If you want an entirely point-free version of the initial approach, we could use the somewhat obscure useWith , like this:

const updateItems = compose (map, useWith (when, [propEq ('id'), mergeLeft]))

I would probably prefer to write that like this, though:

const updateItem = useWith (when, [propEq ('id'), mergeLeft])
const updateItems = compose (map, updateItem)

If you want to supply all arguments together, we could do this:

const updateItem = (id, payload, xs) => 
  map (when (propEq ('id', id), mergeLeft (payload)), xs)
// ...
updateItem (1, {bar: 'x'}, items)

All of these make the assumption that we are testing every element. It does not assume that the id is unique. If you want to do that, the answer from Chad S. would work, but I would prefer to do it slightly differently:

 const updateItems = (id, payload, xs) => adjust (findIndex (propEq ('id', id), xs), mergeLeft (payload), xs) const items = [{foo: 'a', id: 1}, {foo: 'b', id: 2}, {foo: 'c', id: 1}, {foo: 'd', id: 4}] console.log (updateItems (1, {bar: 'x'}, items)) // only the first one. console.log (updateItems (2, {bar: 'x'}, items))

 .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 {adjust, findIndex, propEq, mergeLeft} = R </script>

We could also move toward point-free on this version, but I think it would end up pretty ugly. We could make xs implicit trivially, but anything else would make it less readable to my mind.

Answer 2

So first we want to find the index of the item we want to change:

R.findIndex(R.propEq('id', id))

If that's -1 then we don't have to do anything (return the items). Otherwise we have to adjust the items by merging the payload into the item at that index.

R.pipe(
  R.findIndex(R.propEq('id', id)), 
  R.ifElse(
    R.equals(-1), 
    R.always(R.identity), 
    R.adjust(R.__, R.mergeLeft(payload))
  )
)

Finally we just apply items to that pipe, and then apply items again to the result of the pipe:

const updateItem = R.curry((id, payload, items) => {
  return R.converge(R.applyTo, [
    R.identity,
    R.pipe(
      R.findIndex(R.propEq('id', id)), 
      R.ifElse(
        R.equals(-1), 
        R.always(R.identity), 
        R.adjust(R.__, R.mergeLeft(payload))
      )
    )
  ])(items)
});