我非常喜欢使用Array.prototype.map，filter和reduce来定义数据转换。 不幸的是，在最近涉及大型日志文件的项目中，我不能再多次循环遍历我的数据...
我的目标：
我想创建一个函数，通过链接.filter和.map方法，而不是立即映射到数组上，组成一次循环访问数据的函数。 也就是说：
const DataTransformation = () => ({
map: fn => (/* ... */),
filter: fn => (/* ... */),
run: arr => (/* ... */)
});
const someTransformation = DataTransformation()
.map(x => x + 1)
.filter(x => x > 3)
.map(x => x / 2);
// returns [ 2, 2.5 ] without creating [ 2, 3, 4, 5] and [4, 5] in between
const myData = someTransformation.run([ 1, 2, 3, 4]);
我的尝试:
受这个答案和这篇博客文章的启发，我开始编写一个Transduce函数，用于将对象映射为对象数组。
const filterer = pred => reducer => (acc, x) =>
pred(x) ? reducer(acc, x) : acc;
const mapper = map => reducer => (acc, x) =>
reducer(acc, map(x));
const Transduce = (reducer = (acc, x) => (acc.push(x), acc)) => ({
map: map => Transduce(mapper(map)(reducer)),
filter: pred => Transduce(filterer(pred)(reducer)),
run: arr => arr.reduce(reducer, [])
});
问题:
Transduce代码片段的问题在于它是“反向”运行的...我链式调用的最后一个方法是首先被执行的:
const someTransformation = Transduce()
.map(x => x + 1)
.filter(x => x > 3)
.map(x => x / 2);
// Instead of [ 2, 2.5 ] this returns []
// starts with (x / 2) -> [0.5, 1, 1.5, 2]
// then filters (x < 3) -> []
const myData = someTransformation.run([ 1, 2, 3, 4]);
或者更抽象地说：
我想我知道为什么会发生这种情况，但是我无法在不改变函数“接口”的情况下解决它。Go from:
Transducer(concat).map(f).map(g) == (acc, x) => concat(acc, f(g(x)))To:
Transducer(concat).map(f).map(g) == (acc, x) => concat(acc, g(f(x)))Which is similar to:
mapper(f) (mapper(g) (concat))
问题：
如何使我的Transduce方法按正确的顺序链接filter和map操作？
注释：
- 我刚开始学习一些我尝试做的事情的命名。如果我错误地使用了Transduce术语或有更好的描述问题的方法，请告诉我。 - 我知道可以使用嵌套的for循环来完成相同的操作：
const push = (acc, x) => (acc.push(x), acc);
const ActionChain = (actions = []) => {
const run = arr =>
arr.reduce((acc, x) => {
for (let i = 0, action; i < actions.length; i += 1) {
action = actions[i];
if (action.type === "FILTER") {
if (action.fn(x)) {
continue;
}
return acc;
} else if (action.type === "MAP") {
x = action.fn(x);
}
}
acc.push(x);
return acc;
}, []);
const addAction = type => fn =>
ActionChain(push(actions, { type, fn }));
return {
map: addAction("MAP"),
filter: addAction("FILTER"),
run
};
};
// Compare to regular chain to check if
// there's a performance gain
// Admittedly, in this example, it's quite small...
const naiveApproach = {
run: arr =>
arr
.map(x => x + 3)
.filter(x => x % 3 === 0)
.map(x => x / 3)
.filter(x => x < 40)
};
const actionChain = ActionChain()
.map(x => x + 3)
.filter(x => x % 3 === 0)
.map(x => x / 3)
.filter(x => x < 40)
const testData = Array.from(Array(100000), (x, i) => i);
console.time("naive");
const result1 = naiveApproach.run(testData);
console.timeEnd("naive");
console.time("chain");
const result2 = actionChain.run(testData);
console.timeEnd("chain");
console.log("equal:", JSON.stringify(result1) === JSON.stringify(result2));- 这是我的尝试代码：
const filterer = pred => reducer => (acc, x) =>
pred(x) ? reducer(acc, x) : acc;
const mapper = map => reducer => (acc, x) => reducer(acc, map(x));
const Transduce = (reducer = (acc, x) => (acc.push(x), acc)) => ({
map: map => Transduce(mapper(map)(reducer)),
filter: pred => Transduce(filterer(pred)(reducer)),
run: arr => arr.reduce(reducer, [])
});
const sameDataTransformation = Transduce()
.map(x => x + 5)
.filter(x => x % 2 === 0)
.map(x => x / 2)
.filter(x => x < 4);
// It's backwards:
// [-1, 0, 1, 2, 3]
// [-0.5, 0, 0.5, 1, 1.5]
// [0]
// [5]
console.log(sameDataTransformation.run([-1, 0, 1, 2, 3, 4, 5]));
arr => arr.reduceRight(reducer, [])- user6445533run中的reducer成为之前传递的所有map和filter方法的组合。我认为问题不在于用数据减少我的arr的顺序，而是我未能正确返回新的reducer方法。例如：mapper(f) (mapper(g) (concat));返回类似于(acc, x) => concat(acc, g(f(x)))的 reducer，而我的Transduce(concat).map(f).map(g)返回(acc, x) => concat(acc, f(g(x)))。 - user3297291