【问题标题】:Mapping a function on a generator in JavaScript在 JavaScript 中将函数映射到生成器
【发布时间】:2018-02-09 13:16:51
【问题描述】:

我在 JavaScript 中有一个名为 generateNumbers 的生成器,另一个生成器 generateLargerNumbers 获取由 generateNumbers 生成的每个值并将函数 addOne 应用于它,如下所示:

function addOne(value) {
  return value + 1
}

function* generateNumbers() {
  yield 1
  yield 2
  yield 3
}

function* generateLargerNumbers() {
  for (const number of generateNumbers()) {
    yield addOne(number)
  }
}

有没有更简洁的方法可以做到这一点,而无需从生成的值中构建一个数组?我在想这样的事情:

function* generateLargerNumbers() {
  yield* generateNumbers().map(addOne) // obviously doesn't work
}

【问题讨论】:

标签: javascript functional-programming generator


【解决方案1】:

高阶生成器

您可以选择自己操作生成器函数

const Generator =
  {
    map: (f,g) => function* (...args)
      {
        for (const x of g (...args))
          yield f (x)
      },
    filter: (f,g) => function* (...args)
      {
        for (const x of g (...args))
          if (f (x))
            yield x
      }
  }

// some functions !
const square = x =>
  x * x

const isEven = x =>
  (x & 1) === 0
  
// a generator !
const range = function* (x = 0, y = 1)
  {
    while (x < y)
      yield x++
  }

// higher order generator !
for (const x of Generator.map (square, Generator.filter (isEven, range)) (0,10))
  console.log('evens squared', x)

高阶迭代器

或者你可以选择操作迭代器

const Iterator =
  {
    map: (f, it) => function* ()
      {
        for (const x of it)
          yield f (x)
      } (),
    filter: (f, it) => function* ()
      {
        for (const x of it)
          if (f (x))
            yield x
      } ()
  }

// some functions !
const square = x =>
  x * x
  
const isEven = x =>
  (x & 1) === 0

// a generator !
const range = function* (x = 0, y = 1)
  {
    while (x < y)
      yield x++
  }
  
// higher-order iterators !
for (const x of Iterator.map (square, Iterator.filter (isEven, range (0, 10))))
  console.log('evens squared', x)

推荐

在大多数情况下,我认为操作迭代器更实用,因为它的接口定义明确(尽管很笨拙)。它允许你做类似的事情

Iterator.map (square, Iterator.filter (isEven, [10,11,12,13]))

而另一种方法是

Generator.map (square, Generator.filter (isEven, Array.from)) ([10,11,12,13])

两者都有用例,但我发现前者比后者好得多


持久迭代器

JavaScript 的有状态迭代器让我很恼火 - 每次对 .next 的后续调用都会不可逆地改变内部状态。

但是!没有什么能阻止你创建自己的迭代器,然后创建一个适配器来插入 JavaScript 的堆栈安全生成器机制

如果您对此感兴趣,您可能会喜欢此处提供的其他一些示例:Loop to a filesystem structure in my object to get all the files

唯一的好处不是我们可以重用一个持久迭代器,而是通过这种实现,由于记忆化,后续读取甚至比第一次读取更快更快 – 分数: JavaScript 0,持久迭代器2

// -------------------------------------------------------------------
const Memo = (f, memo) => () =>
  memo === undefined
    ? (memo = f (), memo)
    : memo

// -------------------------------------------------------------------
const Yield = (value, next = Return) =>
  ({ done: false, value, next: Memo (next) })
  
const Return = value =>
  ({ done: true, value })
  
// -------------------------------------------------------------------
const MappedIterator = (f, it = Return ()) =>
  it.done
    ? Return ()
    : Yield (f (it.value), () => MappedIterator (f, it.next ()))
    
const FilteredIterator = (f, it = Return ()) =>
  it.done
    ? Return ()
    : f (it.value)
      ? Yield (it.value, () => FilteredIterator (f, it.next ()))
      : FilteredIterator (f, it.next ())

// -------------------------------------------------------------------
const Generator = function* (it = Return ())
  {
    while (it.done === false)
      (yield it.value, it = it.next ())
    return it.value
  }

// -------------------------------------------------------------------  
const Range = (x = 0, y = 1) =>
  x < y
    ? Yield (x, () => Range (x + 1, y))
    : Return ()

const square = x =>
  x * x

const isEven = x =>
  (x & 1) === 0

// -------------------------------------------------------------------
for (const x of Generator (MappedIterator (square, FilteredIterator (isEven, Range (0,10)))))
  console.log ('evens squared', x)

【讨论】:

  • 您的“高阶”迭代器和持久迭代器(顺便说一句非常好)都表明了命令式迭代器概念的缺点。迭代器不是函数,因此您必须使用函数包装器来使其可组合。但是迭代器也不是数据类型,因此您必须记住 getter 计算才能重用它。因此,迭代器是一个有状态的 getter 对象,与它的数据源紧密耦合。或者正如我所表达的那样:对于迭代算法来说,这是可以想象的最糟糕的起点。换能器/短路是更好的选择。
  • @ftor 一个迭代器可以是一个函数;这完全取决于它是如何实现的;功能组合不是唯一的组合方式——而且,记忆是一种优化,而不是一种要求;在 javascript 中,只需要一个 thunk 来延迟评估——迭代器/流在所有情况下都不能与传感器互换;例如,传感器不能用于像 listOfPrimeNumbers 这样的无限集合
  • ... 见this recent answer - 它是用方案编写的,但显示了以两种不同方式编写的相同程序:一次使用流(迭代器),再次使用传感器 - only i> 这里的不同之处在于,scheme 允许您为流构造函数创建一个特殊形式,其中第二个参数自动包装在一个 thunk 中;在 js 中,我们必须显式地包裹在一个 thunk 中——注意在运行转换器程序之前需要知道列表的内容,但启动流程序只需要起始编号 (2)
  • ...Loop to a filesystem structure in my object to get all the files 表明迭代器 可以 以有意义的方式组合 - 特别重要的是,ConcatIterator 将迭代器与其自身连接,证明相同的迭代器可以多次使用——MyTreeIterator 展示了一种自然的递归遍历,它分叉成多个迭代器,然后变平
  • 我认为这些例子表明迭代器和转换器之间存在权衡,但它们并不相互排斥;两者都有令人信服的用例,都可以用来表达纯函数式程序——一如既往,感谢您的讨论^_^
【解决方案2】:

没有内置的方法来映射Generator 对象,但您可以滚动自己的函数:

const Generator = Object.getPrototypeOf(function* () {});
Generator.prototype.map = function* (mapper, thisArg) {
  for (const val of this) {
    yield mapper.call(thisArg, val);
  }
};

现在你可以这样做了:

function generateLargerNumbers() {
  return generateNumbers().map(addOne);
}

const Generator = Object.getPrototypeOf(function* () {});
Generator.prototype.map = function* (mapper, thisArg) {
  for (const val of this) {
    yield mapper.call(thisArg, val);
  }
};

function addOne(value) {
  return value + 1
}

function* generateNumbers() {
  yield 1
  yield 2
  yield 3
}

function generateLargerNumbers() {
  return generateNumbers().map(addOne)
}

console.log(...generateLargerNumbers())

【讨论】:

  • 另外,您可以使用传感器,它们本质上是可组合的,而且是无状态的。
  • 目标生成器函数本身似乎不切实际 - 请参阅我的答案以获得更多推理
【解决方案3】:

如何组合一个迭代器对象,而不是使用嵌套的生成器?

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

function generateGreaterNumbers(){
 return { next(){ var r = this.gen.next(); r.value+=1; return r; }, gen: generateNumbers() };`
}

【讨论】:

  • 有趣的解决方案,但不一定比替代方案更简洁或可读:)
  • 这会将返回值从undefined 转换为NaN,这可能是不需要的
【解决方案4】:

如果你需要真正将值传递给你的生成器,那么你不能用 for...of 来做,你必须传递每个值

  const mapGenerator = (generatorFunc, mapper) =>
    function*(...args) {
      let gen = generatorFunc(...args),
        i = 0,
        value;
      while (true) {
        const it = gen.next(value);
        if (it.done) return mapper(it.value, i);
        value = yield mapper(it.value, i);
        i++;
      }
    };

function* generator() {
  console.log('generator received', yield 1);
  console.log('generator received', yield 2);
  console.log('generator received', yield 3);
  return 4;
}

const mapGenerator = (generatorFunc, mapper) =>
  function*(...args) {
    let gen = generatorFunc(...args),
      i = 0,
      value;
    while (true) {
      const it = gen.next(value);
      if (it.done) return mapper(it.value, i);
      value = yield mapper(it.value, i);
      i++;
    }
  };

const otherGenerator = mapGenerator(generator, x => x + 1)

const it = otherGenerator();
console.log(
  it.next().value,
  it.next('a').value, 
  it.next('b').value,
  it.next('c').value
);

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 2021-09-15
    • 2017-05-01
    • 2016-06-17
    • 2012-07-24
    • 1970-01-01
    • 2011-08-04
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多