javascript - 在同一迭代中过滤和映射

Question

我有这种简单的情况，我想过滤并映射到相同的值，如下所示:

 const files = results.filter(function(r){
      return r.file;
    })
    .map(function(r){
       return r.file;
    });

为了节省代码行数并提高性能，我正在寻找:

const files = results.filterAndMap(function(r){
  return r.file;
});

这个存在吗，还是我应该自己写点什么？我在几个地方想要这样的功能，只是以前从来没有费心去研究它。

Answer 1

传感器

在最通用的形式中，您问题的答案在 transducers 中。 .但在我们过于抽象之前，让我们先看看一些基础知识——下面，我们实现了几个转换器 mapReduce、filterReduce 和 tapReduce；您可以根据需要添加任何其他内容。

const mapReduce = map => reduce =>
  (acc, x) => reduce (acc, map (x))
  
const filterReduce = filter => reduce =>
  (acc, x) => filter (x) ? reduce (acc, x) : acc
  
const tapReduce = tap => reduce =>
  (acc, x) => (tap (x), reduce (acc, x))

const tcomp = (f,g) =>
  k => f (g (k))

const concat = (xs,ys) =>
  xs.concat(ys)
  
const transduce = (...ts) => xs =>
  xs.reduce (ts.reduce (tcomp, k => k) (concat), [])

const main =
  transduce (
    tapReduce (x => console.log('with:', x)),
    filterReduce (x => x.file),
    tapReduce (x => console.log('has file:', x.file)),
    mapReduce (x => x.file),
    tapReduce (x => console.log('final:', x)))
      
const data =
  [{file: 1}, {file: undefined}, {}, {file: 2}]
  
console.log (main (data))
// with: { file: 1 }
// has file: 1
// final: 1
// with: { file: undefined }
// with: {}
// with: { file: 2 }
// has file: 2
// final: 2
// => [ 1, 2 ]

可链接的 API

也许您对代码的简单性感到满意，但对有点不合常规的 API 感到不满意。如果您想保留链接 .map、.filter、.whatever 调用而不添加不当迭代的能力，我们可以创建一个通用接口(interface)用于转换并在此基础上制作我们的可链接 API – 这个答案改编 self 上面分享的链接和 other answers I have about transducers

// Trans Monoid
const Trans = f => ({
  runTrans: f,
  concat: ({runTrans: g}) =>
    Trans (k => f (g (k)))
})

Trans.empty = () =>
  Trans(k => k)

// transducer "primitives"
const mapper = f =>
  Trans (k => (acc, x) => k (acc, f (x)))
  
const filterer = f =>
  Trans (k => (acc, x) => f (x) ? k (acc, x) : acc)
  
const tapper = f =>
  Trans (k => (acc, x) => (f (x), k (acc, x)))
  
// chainable API
const Transduce = (t = Trans.empty()) => ({
  map: f =>
    Transduce (t.concat (mapper (f))),
  filter: f =>
    Transduce (t.concat (filterer (f))),
  tap: f =>
    Transduce (t.concat (tapper (f))),
  run: xs =>
    xs.reduce (t.runTrans ((xs,ys) => xs.concat(ys)), [])
})

// demo
const main = data =>
  Transduce()
    .tap (x => console.log('with:', x))
    .filter (x => x.file)
    .tap (x => console.log('has file:', x.file))
    .map (x => x.file)
    .tap (x => console.log('final:', x))
    .run (data)
    
const data =
  [{file: 1}, {file: undefined}, {}, {file: 2}]

console.log (main (data))
// with: { file: 1 }
// has file: 1
// final: 1
// with: { file: undefined }
// with: {}
// with: { file: 2 }
// has file: 2
// final: 2
// => [ 1, 2 ]

可链接的 API，取 2

作为以尽可能少的依赖仪式实现链接 API 的练习，我在不依赖 Trans monoid 实现或原始转换器 mapper 的情况下重写了代码片段、filterer 等——感谢@ftor 的评论。

就整体可读性而言，这是一个明确的降级。我们失去了只看它并理解正在发生的事情的能力。我们还丢失了幺半群接口(interface)，这使我们很容易在其他表达式中推理我们的传感器。这里的一大收获是 Transduce 的定义包含在 10 行源代码中；与之前的 28 相比 – 因此虽然表达式更复杂，但您可能可以在大脑开始挣扎之前读完整个定义

// chainable API only (no external dependencies)
const Transduce = (t = k => k) => ({
  map: f =>
    Transduce (k => t ((acc, x) => k (acc, f (x)))),
  filter: f =>
    Transduce (k => t ((acc, x) => f (x) ? k (acc, x) : acc)),
  tap: f =>
    Transduce (k => t ((acc, x) => (f (x), k (acc, x)))),
  run: xs =>
    xs.reduce (t ((xs,ys) => xs.concat(ys)), [])
})

// demo (this stays the same)
const main = data =>
  Transduce()
    .tap (x => console.log('with:', x))
    .filter (x => x.file)
    .tap (x => console.log('has file:', x.file))
    .map (x => x.file)
    .tap (x => console.log('final:', x))
    .run (data)
    
const data =
  [{file: 1}, {file: undefined}, {}, {file: 2}]

console.log (main (data))
// with: { file: 1 }
// has file: 1
// final: 1
// with: { file: undefined }
// with: {}
// with: { file: 2 }
// has file: 2
// final: 2
// => [ 1, 2 ]

>谈论性能

就速度而言，它的任何功能变体都无法击败静态 for 循环，它将所有程序语句组合在一个循环体中。然而，上面的传感器确实有潜力比一系列.map/.filter/.whatever 调用，其中通过大型数据集进行多次迭代会很昂贵。

编码风格和实现

transducer 的本质在于mapReduce，这也是我选择先介绍它的原因。如果您能理解如何进行多个 mapReduce 调用并将它们排序在一起，您就会理解转换器。

当然，您可以通过多种方式实现传感器，但我发现了 Brian's approach最有用的，因为它将传感器编码为 monoid – 拥有一个幺半群允许我们对它做出各种方便的假设。一旦我们转换了一个数组(一种幺半群)，您可能想知道如何转换任何其他幺半群……在这种情况下，请阅读那篇文章!