当我在每个函数调用中创建一个新的生成器时，为什么此生成器函数包装器会消耗迭代器？]

Question

当直接从新制作的序列中减少序列时，我可以多次缩小同一序列，但是如果我尝试从.map创建的序列中反复减少序列，它只能在第一次使用吗？

似乎我正在使用原始的迭代器...但是我不知道如何/在哪里。据我所理解的这段代码，Sequence :: map构建了一个新的生成器以在每次调用时进行迭代，因此它应该能够每次都重复使用相同的seq。有人可以帮助我了解我所缺少的吗？

// A wrapper for a generatorFn
class Sequence {

  constructor(generatorFn) {
    if (typeof generatorFn === "function") {
      this[Symbol.iterator] = generatorFn;
    } else {
      throw new Error("Cannot create Sequence from provided argument");
    }
  }


  static of(obj) {
    //Create a generatorFn from an iterable object  
    function* genFn() {
        for (const x of obj) {
        yield x;
      }
    }
    return new Sequence(genFn);
  }

  map(fn) {
    //Make a generator from the generator function
    const gen = this[Symbol.iterator]();

    //Make a new generator function that applies fn to each value
    function* mapGenFn() {
      for (const x of gen) {
        yield fn(x);
      }
    }

    // Create a new sequence using the new generator function
    return new Sequence(mapGenFn);
  }

    reduce(fn, initial) {
    let acc;
    let first = true;
    // Make a new generator from the seq's generator fn
    const gen = this[Symbol.iterator]();
    if (initial) {
      acc = initial
      // iterate on the new generator
      for (const x of gen) {
        acc = fn(acc, x);
      }
    } else {
        acc = this.fold(fn);
    }
    return acc;
  }

  fold(fn) {
    const gen = this[Symbol.iterator]();
    let first = true;
    let acc;
    for (const x of gen) {
        if (first) {
            acc = x;
          first = false;
        } else {
          acc = fn(acc, x);
        }
    }
    return acc;
  }
}

const seqA = Sequence.of([1,2,3])
console.log("SeqA1 is: ", seqA.reduce((acc, x) => acc + x)); // 6
console.log("SeqA2 is: ", seqA.reduce((acc, x) => acc + x)); // 6
console.log("SeqA3 is: ", seqA.reduce((acc, x) => acc + x)); // 6

const seqB = Sequence.of([1,2,3]).map(x => x + 1);
console.log("SeqB1 is: ", seqB.reduce((acc, x) => acc + x)); // 9
console.log("SeqB2 is: ", seqB.reduce((acc, x) => acc + x)); // undefined
console.log("SeqB3 is: ", seqB.reduce((acc, x) => acc + x)); // undefined

证明问题的小提琴：https://jsfiddle.net/qsh9mupz/5/

当直接减少一个新创建的序列时，我可以多次缩小同一序列，但是如果我尝试重复减少从.map创建的序列，它仅在第一个...起作用吗？] >> < [

每次使用新序列时，都会创建

const gen = this[Symbol.iterator]()。

not

，但在调用.map(…)时仅创建一次。将该部分移到mapGenFn中：

map(fn) {
  const gen = this[Symbol.iterator]; // no call here!
  return new Sequence(function* mapGenFn() {
    for (const x of gen()) {
//                     ^^ create new iterator here every time the sequence uses mapGenFn
      yield fn(x);
    }
  });
}

Answer 1

not