更新（2019-02-12）

Question

我正在努力将Ramda和函数式编程作为一个整体，看看对我而言是否有意义。

下面是我需要解决的典型问题：

以下为输入数据：

const values = [
 { a: 1,   b: 2,   c: 3 },
 { a: 10,  b: 20,  c: 30 },
 ...
 { a: 100, b: 200, c: 300 }
]

以下功能应用于数据：

const eFn = x => x.a + x.b
const fFn = ? // cumulative add: Sum of the e keys from first to current index, first iteration f = 3, then 3 + 30, then 3 + 30 +300
const gFN = x => x.f > x.e

按此给定顺序：

eFn（）
fFn（）
gFn（）

结果如下：

const results = [
 { a: 1,   b: 2,   c: 3,   e: 3,   f: 3,  g: true },
 { a: 10,  b: 20,  c: 30,  e: 30,  f: 33, g: true  },
 ...
 { a: 100, b: 200, c: 300, e: 300, f: 333, g: false }
]

问题：

对于此类问题，

使用ramda有意义吗？
这是否简化了问题，并且我知道fFn取决于前一行的数据并且必须在fFn之后应用gFn吗？我可以避免在数据上循环多次吗？

我发现使用Ramda很难很好地解决此问题。

任何帮助将不胜感激。

更新（2019-02-12）

基于@ scott-sauyet的答案，我确实尝试对Ramda vs Rambda进行基准测试。由于我不愿意重复100％的测试，因此我对其进行了修改以更改fFn的行为，并手动设置应用每个功能的次数。

    const {floor, random} = Math

    const demo = counts => {

      const eFns = R.curry((n, x) => R.assoc(`e${n}`, x.a + x.b, x))
      const fFns = R.curry((n, x) => R.assoc(`f${n}`,  x.d * x.b, x))
      const gFns = R.curry((n, x) => R.assoc(`g${n}`,  x.f > x.e, x))

      const transform = R.pipe(
        R.map(eFns(1)),
        R.map(eFns(2)),
        R.map(eFns(3)),
        R.map(eFns(4)),
        R.map(eFns(5)),
        R.map(eFns(6)),
        R.map(eFns(7)),
        R.map(eFns(8)),
        R.map(eFns(9)),
        R.map(eFns(10)),
        R.map(eFns(12)),
        R.map(eFns(13)),
        R.map(eFns(14)),
        R.map(eFns(15)),
        R.map(eFns(16)),
        R.map(eFns(17)),
        R.map(eFns(18)),
        R.map(eFns(19)),
        R.map(eFns(20)),
        R.map(eFns(21)),
        R.map(eFns(22)),
        R.map(eFns(23)),
        R.map(eFns(24)),
        R.map(eFns(25)),
        R.map(eFns(26)),
        R.map(eFns(27)),
        R.map(eFns(28)),
        R.map(eFns(29)),
        R.map(eFns(30)),
        R.map(eFns(31)),
        R.map(eFns(32)),
        R.map(eFns(33)),
        R.map(eFns(34)),
        R.map(eFns(35)),
        R.map(eFns(36)),
        R.map(eFns(37)),
        R.map(eFns(38)),
        R.map(eFns(39)),
        R.map(eFns(40)),
        R.map(fFns(1)),
        R.map(fFns(2)),
        R.map(fFns(3)),
        R.map(fFns(4)),
        R.map(fFns(5)),
        R.map(fFns(6)),
        R.map(fFns(7)),
        R.map(fFns(8)),
        R.map(fFns(9)),
        R.map(fFns(10)),
        R.map(gFns(1)),
        R.map(gFns(2)),
        R.map(gFns(3)),
        R.map(gFns(4)),
        R.map(gFns(5)),
        R.map(gFns(6)),
        R.map(gFns(7)),
        R.map(gFns(8)),
        R.map(gFns(9)),
        R.map(gFns(10))
      )


      const vals = R.times(n => ({
        a: floor(random() * 1000),
        b: floor(random() * 1000),
        c: floor(random() * 1000),
        d: floor(random() * 1000)
      }), counts)

      const now = new Date()
      transform(vals)
      const time = new Date() - now

      console.log(`Ran ${counts} records through ${eFns.length} e's, ${fFns.length} f's, and ${gFns.length} g's in ${time} ms`)
    }

    console.clear()
    demo(10)
    demo(100)
    demo(1000)
    demo(10000)
    demo(100000)

现在，我将此代码成功粘贴到Ramda REPL，然后粘贴到Rambda REPL。我在Windows 7，带有Chrome 66的核心i7-6820HQ和Node.js v8.11.1中进行了测试。

令我惊讶的是，Rambda的速度比Ramda慢。请注意，这是一个快速而肮脏的测试，我可能错过了为Rambda设置测试的正确方法（我只是想将代码复制并粘贴到每个REPL中，然后通过修改import语句在节点中运行）。 / p>

这是我的结果：（请注意，该图形为对数-对数比例）

Record Number             [-] :  10 | 10 | 1000 | 10000  | 10000
Ramda Chrome 66  [time in ms] :  5  | 39 | 329  | 3673   | 38910  
Rambda Chrome 66 [time in ms] :  6  | 85 | 530  | 5306   | 53777  
Ramda Node.js    [time in ms] :  8  | 38 | 396  | 4219   | 45621
Rambda Node.js   [time in ms] :  7  | 62 | 537  | 5468   | 57540

Answer 1

使用Ramda可能有意义。请注意，Ramda的最佳结合点是一系列pipe或compose进行的简单转换，以创建一个更复杂的转换。因此，使用Ramda的最直接方法无法满足您仅循环一次的目标。在某些情况下，换能器可能对此有所帮助，但是许多Ramda功能尚未准备好换能器，因此您必须先看看能用什么。

但是我认为，编码这样的问题的正确方法是从简单的代码开始，并且仅在实际遇到性能问题时才能解决它们。编写简单的代码，如果发现它是应用程序中的瓶颈，请解决它。（并且只有在解决了更严重的瓶颈之后才这样做。）令人惊讶的是，经常发现原来您认为有问题的代码根本不是一个代码。

所以我可能会这样做：

const {assoc, curry, tail, scan, pipe, map} = R

const eFn = x => assoc('e', x.a + x.b, x)
const fFn = (a, x) => assoc('f', a.f + x.e, x)
const gFn = x => assoc('g', x.f > x.e, x)

// scan includes initial value -- should this be fixed?
const myScan = curry((fn, init, xs) => tail(scan(fn, init, xs)))

const transform = pipe(
  map(eFn),
  myScan(fFn, {f: 0}),
  map(gFn)  
)

const values = [
 { a: 1,   b: 2,   c: 3 },
 { a: 10,  b: 20,  c: 30 },
 { a: 100, b: 200, c: 300 }
]

console.log(transform(values))

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.js"></script>

这显示了scan中的缺陷（类似于mapAccum，但界面更简单）。 scan(add, 0, [1, 2, 3, 4]) //=> [0, 1, 3, 6, 10]。尽管我没有去查看历史记录以查看是否遗漏了重要内容，但我看不出有充分的理由将结果包括该初始0。我通过将其包装在tail之后的函数中来解决此问题。但是我们可以轻松地将tail添加到管道中：

const transform = pipe(
  map(eFn),
  scan(fFn, {f: 0}), 
  tail,
  map(gFn)  
)

更新

有一条评论询问了性能。这是一个针对给定数量的记录测试许多e，f和g样式函数的版本：

const {curry, tail, scan, map, assoc, range, apply, pipe, addIndex, times} = R
const {floor, random} = Math
const myScan = curry((fn, init, xs) => tail(scan(fn, init, xs)))

const demo = (es, fs, gs, counts) => {

  const eFns = map(n => (x) => assoc(`e${n}`, x.a + x.b, x), range(1, es + 1))
  const fFns = map(n => (a, x) => assoc(`f${n}`, a[`f${n}`] + x[`e${n}`], x), range(1, fs + 1))
  const gFns = map(n => (x) => assoc(`g${n}`, x[`f${n}`] > x[`e${n}`], x), range(1, gs + 1))

  const transform = apply(pipe)([...map(map, eFns), ...addIndex(map)((f, i) => myScan(f, {[`f${i + 1}`]: 0}), fFns), ...map(map, gFns)])

  const vals = times(n => ({
    a: floor(random() * 1000),
    b: floor(random() * 1000),
    c: floor(random() * 1000),
  }), counts)

  const now = new Date()
  transform(vals)
  const time = new Date() - now

  console.log(`Ran ${counts} records through ${eFns.length} e's, ${fFns.length} f's, and ${gFns.length} g's in ${time} ms`)
}

console.clear()
demo(40, 10, 10, 100)
demo(40, 10, 10, 1000)
demo(40, 10, 10, 10000)

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.js"></script>

对于带有40 e，10 f和10 g的10000条记录，在更新的MacBook Pro上使用Chrome可以获得大约2.5秒的时间。我不知道这对您的应用程序是否合理。（您也可以在 Ramda REPL 上进行操作。）

Answer 2

我认为使用Ramda很有意义：

Ramda不会变异数据
Ramda确实有很多功能可以帮助您处理列表和对象

这会改变原始对象：

const add_ab = obj => { obj.e = obj.a + obj.b; return obj };

这不会：

const add_ab = obj => assoc('e', obj.a + obj.b, obj);

您可以将迭代的和值与mapAccum结合使用，这在您的情况下可能会有用：

mapAccum函数的行为类似于map和reduce的组合；它将函数应用于列表的每个元素，从左到右传递一个累加参数，并返回该累加器的最终值以及新列表。

迭代器函数接收两个参数acc和value，并应返回一个元组[acc，value]。

const {assoc, compose, last, mapAccum} = R;

const data = [
 { a: 1,   b: 2,   c: 3 },
 { a: 10,  b: 20,  c: 30 },
 { a: 100, b: 200, c: 300 }
];


const set_e = obj => assoc('e', obj.a + obj.b, obj);
const set_f = (acc, obj) =>  assoc('f', acc.f + obj.e, obj);
const set_g = obj => assoc('g', obj.f > obj.e, obj);

const execute = compose(last, mapAccum((acc, cur) => [
  set_f(acc, set_e(cur)),
  set_g(set_f(acc, set_e(cur)))
], {f: 0}));

console.log(
 execute(data)
);

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.min.js"></script>

使用ramdajs进行迭代计算

更新（2019-02-12）

2 个答案:

更新