生成器的过滤器和映射函数

Question

在 JavaScript 中传递包含过滤 + 映射逻辑的生成器的推荐方法是什么？

不知何故，JavaScript 生成器缺少诸如 filter 和 map 操作数之类的基本内容，类似于数组，以便能够创建包含该逻辑的生成器，而无需先运行迭代。

我的正面方法是实现应用逻辑的自定义函数：

function * filter(g, cb) {
    let a;
    do {
        a = g.next();
        if (!a.done && cb(a.value)) {
            yield a.value;
        }
    } while (!a.done);
    return a.value;
}

function * map(g, cb) {
    let a;
    do {
        a = g.next();
        if (!a.done) {
            yield cb(a.value);
        }
    } while (!a.done);
    return a.value;
}

但这会造成回调地狱。我想简单地链接一个生成器，就像一个常规数组：

// create a filtered & re-mapped generator, without running it:
const gen = myGenerator().filter(a => a > 0).map(b => ({value: b})); 

// pass generator into a function that will run it:
processGenerator(gen);

有没有办法扩展生成器以自动访问这些基本功能？

另外，如果有人想强调为什么这些基本的东西不是生成器实现的一部分，那就太棒了！我认为过滤和映射是序列需要的两个最基本的东西。

Answer 1

您的解决方案的替代方法是使用for...of 循环而不是do...while。

我也更喜欢 filter 和 map 函数来使用和生成生成器函数，如下所示：

function filter(gen, predicate) {
  return function*() {
    for (let e of gen()) {
       if (predicate(e)) {
         yield e; 
       }
     }
  }
}

function map(gen, fn) {
  return function*() {
    for (let e of gen()) {
      yield fn(e);
    }
  }
}

function generatorWrapper(gen) {
  return {
    call: () => gen(),
    filter: predicate => generatorWrapper(filter(gen, predicate)),
    map: fn => generatorWrapper(map(gen, fn))
  };
}

function* generator() {
  yield 1;
  yield 2;
  yield 3;
}

const it = generatorWrapper(generator)
  .filter(x => x > 1)
  .map(x => x * 2)
  .call();

for (let e of it) {
  console.log(e);
}

Answer 2

通过管道装饰器获取原始可迭代和产生值的管道函数怎么样？

const pipe = function* (iterable, decorators) {
  // First build the pipeline by iterating over the decorators
  // and applying them in sequence.
  for(const decorator of decorators) {
    iterable = decorator(iterable)
  }

  // Then yield the values of the composed iterable.
  for(const value of iterable) {
    yield value;
  }
};

const filter = predicate =>
  function* (iterable) {
    for (const value of iterable) {
      if (predicate(value)) {
        yield value;
      }
    }
  };

const map = cb =>
  function* (iterable) {
    for (const value of iterable) {
      yield cb(value);
    }
  };

const mergeMap = cb =>
  function* (iterable) {
    for (const value of iterable) {
      for (const mapped of cb(value)) {
        yield mapped;
      }
    }
  };

const take = n =>
  function* (iterable) {
    for (const value of iterable) {
      if (!n--) {
        break;
      }
      yield value;
    }
  };

function* test(value1, value2) {
  yield value1;
  yield value2;
}

function* infinite() {
  for (;;) yield Math.random();
}

for (const value of pipe(test(111, 222), [
  filter(f => f > 0),
  map(m => ({ value: m }))
])) {
  console.log(value);
}

for (const value of pipe(infinite(), [
  take(5),
  mergeMap(v => [v, { timesTwo: v * 2 }])
])) {
  console.log(value);
}

.as-console-wrapper {
  max-height: 100% !important;
}

Answer 3

我可能已经找到了一个合适的解决方案......

我创建了 Iterable 类，它在 this answer 上扩展：

class Iterable {
    constructor(generator) {
        this[Symbol.iterator] = generator;
    }

    static extend(generator, cc) {
        // cc - optional calling context, when generator is a class method;
        return function () {
            return new Iterable(generator.bind(cc ?? this, ...arguments));
        }
    }
}

Iterable.prototype.filter = function (predicate) {
    let iterable = this;
    return new Iterable(function* () {
        for (let value of iterable)
            if (predicate(value)) {
                yield value;
            }
    });
};

Iterable.prototype.map = function (cb) {
    let iterable = this;
    return new Iterable(function* () {
        for (let value of iterable) {
            yield cb(value);
        }
    });
};

现在我们可以采用现有的生成器函数，如下所示：

function* test(value1, value2) {
    yield value1;
    yield value2;
}

并把它变成一个扩展的迭代器：

const extTest = Iterable.extend(test);

然后用它代替原来的生成器：

const i = extTest(111, 222).filter(f => f > 0).map(m => ({value: m}));

现在可以正常工作了：

const values = [...i];
//=> [ { value: 111 }, { value: 222 } ]

更新

经过更多研究，我确信RXJS / IXJS 是正确的选择。这些包装迭代器并提供开箱即用的扩展。