如何获取 JavaScript 生成器的第 n 个值？

Question

如何获得生成器的第n个值？

function *index() {
  let x = 0;
  while(true)
    yield x++;
}

// the 1st value
let a = index();
console.log(a.next().value); // 0

// the 3rd value
let b = index();
b.next();
b.next();
console.log(b.next().value); // 2

// the nth value?
let c = index();
let n = 10;
console.log(...); // 9

Answer 1

你可以像python中的一样定义一个枚举方法:

function *enumerate(it, start) {
   start = start || 0;
   for(let x of it)
     yield [start++, x];
}

然后：

for(let [n, x] of enumerate(index()))
  if(n == 6) {
    console.log(x);
    break;
  }

http://www.es6fiddle.net/ia0rkxut/

同样，我们也可以重新实现 pythonic

range

和

islice

：

function *range(start, stop, step) {
  while(start < stop) {
    yield start;
    start += step;
  }
}

function *islice(it, start, stop, step) {
  let r = range(start || 0, stop || Number.MAX_SAFE_INTEGER, step || 1);
  let i = r.next().value;
  for(var [n, x] of enumerate(it)) {
    if(n === i) {
      yield x;
      i = r.next().value;
    }
  }
}

然后：

console.log(islice(index(), 6, 7).next().value);

http://www.es6fiddle.net/ia0s6amd/

现实世界的实施需要更多的工作，但你明白了。

Answer 2

作为 T.J. Crowder 指出，无法直接获取第

n

个元素，因为值是根据需要生成的，并且只能使用

next

函数检索即时值。因此，我们需要明确跟踪消耗的物品数量。

唯一的解决方案是使用循环，我更喜欢用

for..of

进行迭代。

我们可以创建一个这样的函数

function elementAt(generator, n) {
    "use strict";

    let i = 0;

    if (n < 0) {
        throw new Error("Invalid index");
    }

    for (let value of generator) {
        if (i++ == n) {
            return value;
        }
    }

    throw new Error("Generator has fewer than " + n + " elements");
}

然后像这样调用它

console.log(elementAt(index(), 10));
// 10

---

另一个有用的函数可能是

take

，它允许您从生成器中获取第一个

n

元素，就像这样

function take(generator, n) {
    "use strict";

    let i = 1,
        result = [];

    if (n <= 0) {
        throw new Error("Invalid index");
    }

    for (let value of generator) {
        result.push(value);
        if (i++ == n) {
            return result;
        }
    }

    throw new Error("Generator has fewer than " + n + " elements");
}

console.log(take(index(), 10))
// [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Answer 3

一个简单的循环就可以了：

let n = 10,
    iter = index();
while (--n > 0) iter.next();
console.log(iter.next().value); // 9

Answer 4

ECMAScript 2025 更新：我们现在有了迭代器辅助方法

drop

，所以我们现在可以这样做：

const iter = gen(); // Generators return iterator helper objects
const value = iter.drop(n - 1).next().value

drop

返回一个迭代器，当其第一个值被消耗时，消耗原始迭代器的前 n-1 个值，忽略它们，然后生成下一个值。

未创建数组。如果您想获得所有第一个 𝑛 值，请使用

take(n)

方法。

---

之前的回答：

您可以创建一个大小为 n 的数组，并使用

Array.from

及其第二个参数来获取所需的值。所以假设

iter

是生成器

gen

的迭代器：

var iter = gen();

然后可以按如下方式获取前 n 值：

var values = Array.from(Array(n), iter.next, iter).map(o => o.value)

...当您只对第 n^th 值感兴趣时，您可以跳过

map

部分，然后执行以下操作：

var value = Array.from(Array(n), iter.next, iter).pop().value

或者：

var value = [...Array(n)].reduce(iter.next.bind(iter), 1).value

缺点是您仍然（暂时）分配一个大小为 n 的数组。

Answer 5

我想避免不必要地创建数组或其他中间值。这就是我的

nth

的实现结果 -

function nth (iter, n)
{ for (const v of iter)
    if (--n < 0)
      return v
}

按照原始问题中的示例 -

// the 1st value
console.log(nth(index(), 0))

// the 3rd value
console.log(nth(index(), 2))

// the 10th value
console.log(nth(index(), 9))

0
2
9

对于有限生成器，如果索引越界，结果将是

undefined

-

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

console.log(nth(foo(), 99))

undefined

展开下面的代码片段以验证浏览器中的结果 -

function *index ()
{ let x = 0
  while (true)
    yield x++
}

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

function nth (iter, n) {
  for (const v of iter)
    if (--n < 0)
      return v
}

// the 1st value
console.log(nth(index(), 0))

// the 3rd value
console.log(nth(index(), 2))

// the 10th value?
console.log(nth(index(), 9))

// out-of-bounds?
console.log(nth(foo(), 99))