Javascript 如何正确设置间隔生成器？

目标： 我想创建一个正在

setInterval（）

和

console.log

1到10中调用的生成器函数

问题： 为了在最后执行

clearInterval（）

，我需要一个条件来检查

gen.next（）.done===true

。 但每次条件运行时，它实际上会调用另一个

.next（）

所以我得到的最终结果是：

1 3 5 7 9未定义

如何在不调用

.next（）

的情况下设置done==true条件

函数*myGen（）{
设计数器=0；
for（设i=0；i{
如果（下一代（）.done）{
清除间隔（开始）；
}否则{
console.log（gen.next（）.value）；
}
}, 1500)

记住变量中的对象，而不是第二次调用

：


函数*myGen（）{
设计数器=0；
for（设i=0；i{
var next=gen.next（）；//***保存在此处
如果（next.done）{/***请在此处使用它。。。
清除间隔（开始）；
}否则{
console.log（next.value）；//***…和此处
}
}，150）
只需存储
下一个值

function* myGen(){
    let counter = 0;
    for(let i = 0 ; i <= 10; i++){
        yield counter++;    
    }
}

const gen = myGen();
const start = setInterval(() => {
    let nextValue = gen.next();
    if(nextValue.done){
        clearInterval(start);
    } else {
        console.log(nextValue.value);  
    }
}, 1500)

函数*myGen（）{
设计数器=0；
for（设i=0；i{
设nextValue=gen.next（）；
if（nextValue.done）{
清除间隔（开始）；
}否则{
console.log（nextValue.value）；
}
}, 1500)
您也可以使用
for..of
循环、
setTimeout（）
、
async/wait
来避免检查
.done
属性值


函数*myGen（）{
设计数器=0；
for（设i=0；i{
for（让n代表gen）{
等待新的承诺（解决=>{
设置超时（（）=>{
控制台日志（n）；
解决（）
}, 1500)
})
}
})（）；
函数*myGen（）{
设计数器=0；
for（设i=0；i{
var genObj=gen.next（）；//将next结果保留为对象，以避免重复使用next方法
如果（genObj.done）{
清除间隔（开始）；
}否则{
console.log（genObj.value）；
}
}，1500）//我花了一个小时学习这个，虽然晚了，但还是学到了一些知识，所以，谢谢。
另一种方法是使用相对较新的AsyncGenerator功能


我认为它很好地抽象了这个问题（创建一个迭代器，在每次迭代之间休眠）

异步函数*sleepGenerator（numSleeps，sleepMillis）{
for（设i=0；isetTimeout（resolve，sleepMillis））；
}
（异步函数运行（）{
等待（休眠发生器（5500）的常数）{
console.log（iterMeta）；
}
})();

function* myGen(){
    let counter = 0;
    for(let i = 0 ; i <= 10; i++){
        yield counter++;    
    }
}

const gen = myGen();
const start = setInterval(() => {
    let nextValue = gen.next();
    if(nextValue.done){
        clearInterval(start);
    } else {
        console.log(nextValue.value);  
    }
}, 1500)

function* myGen(){
let counter = 0;
for(let i = 0 ; i <= 10; i++){
    yield counter++;    
}
}

const gen = myGen();
const start = setInterval(() => {
var genObj=gen.next();//keep next result as an object to avoid use next method twice

if(genObj.done){
    clearInterval(start);
} else {
    console.log(genObj.value);  
}
}, 1500)//I spent an hour learning this,late but get some konwledge,so,thanks.

async function* sleepGenerator(numSleeps, sleepMillis) {
    for (let i = 0; i < numSleeps; i++) {
        await sleep(sleepMillis);
        yield {i, numSleeps, sleepMillis};
    }
}

function sleep(sleepMillis) {
    return new Promise(resolve => setTimeout(resolve, sleepMillis));
}

(async function run() {
    for await (const iterMeta of sleepGenerator(5, 500)) {
        console.log(iterMeta);
    }
})();