Javascript 承诺不使用setTimeOut从递归函数解析

我想在循环中经过一定的延迟后执行一些代码。一旦所有的迭代都完成了，我想做一些其他的任务。这些取决于从task1获得的结果。为此，我使用generator、async/await和promise编写了以下代码段：

function* iter() {
 for (var i = 0; i < 10; i++) yield i
}

async function start() {
    var myIter = iter();
    var p = await cb1(myIter);
    console.log('after await');
        p.then((value) => {
        console.log('-----------here-------------');
    });
}

start();

function cb1(myIter) {
    console.log("Started : " + new Date());
    var obj;
    return new Promise((resolve, reject) => {
        setTimeout(function(){
        if(myIter.next().done === true) {
            console.log("End : " + new Date());
            resolve('done');
        }else {
            console.log("---in else---");
            cb1(myIter);
        }
    }, 3000);
    });
}

函数*iter（）{
对于（var i=0；i<10；i++）收益率i
}
异步函数start（）{
var myIter=iter（）；
var p=等待cb1（myIter）；
console.log（'after wait'）；
p、 然后（（值）=>{
console.log（'--------------此处----------------'）；
});
}
start（）；
功能cb1（myIter）{
log（“开始：+new Date（））；
var-obj；
返回新承诺（（解决、拒绝）=>{
setTimeout（函数（）{
if（myIter.next（）.done==true）{
日志（“结束：+newdate（））；
决议（“完成”）；
}否则{
console.log（“--in-else--”；
cb1（myIter）；
}
}, 3000);
});
}

问题是，p.then（）中的控制台永远不会被打印出来。这意味着承诺永远无法得到解决，程序终止。迭代按预期执行，但承诺永远无法解决。这里可能出了什么问题？我使用递归触发迭代器.next（），只想在最后一次迭代中解析承诺，即当done=true时

在这个问题上我一直在挠头。谢谢你的帮助。以下是该程序的输出

---

还需要1个功能才能正常工作：

   function* iter() {
 for (var i = 0; i < 10; i++) yield i
}

async function start() {
    var myIter = iter();
    var p = await cb1(myIter);
    console.log('after await');
    console.log("here is p:" + p.done + "," + p.value);
}

start();

function repeat(myIter,resolver,previous){
    var temp;
    if((temp = myIter.next()).done === true) {
        console.log("End : " + new Date());
        resolver(previous);
    }else {
        console.log("---in else---");
        setTimeout(function(){repeat(myIter,resolver,temp)},3000);
    }
}

function cb1(myIter) {
    console.log("Started : " + new Date());
    var obj;
    return new Promise((resolve, reject) => {
       repeat(myIter,resolve);
    });
}

函数*iter（）{
对于（var i=0；i<10；i++）收益率i
}
异步函数start（）{
var myIter=iter（）；
var p=等待cb1（myIter）；
console.log（'after wait'）；
log（“这里是p:+p.done+”，“+p.value”）；
}
start（）；
函数重复（myIter、resolver、previous）{
无功温度；
if（（temp=myIter.next（））.done==true）{
日志（“结束：+newdate（））；
分解器（先前）；
}否则{
console.log（“--in-else--”；
setTimeout（函数（）{repeat（myIter，resolver，temp）}，3000）；
}
}
功能cb1（myIter）{
log（“开始：+new Date（））；
var-obj；
返回新承诺（（解决、拒绝）=>{
重复（myIter，resolve）；
});
}

---

还修复了p，wait将其取出，您需要获取上一个值

还需要1个函数才能工作：

   function* iter() {
 for (var i = 0; i < 10; i++) yield i
}

async function start() {
    var myIter = iter();
    var p = await cb1(myIter);
    console.log('after await');
    console.log("here is p:" + p.done + "," + p.value);
}

start();

function repeat(myIter,resolver,previous){
    var temp;
    if((temp = myIter.next()).done === true) {
        console.log("End : " + new Date());
        resolver(previous);
    }else {
        console.log("---in else---");
        setTimeout(function(){repeat(myIter,resolver,temp)},3000);
    }
}

function cb1(myIter) {
    console.log("Started : " + new Date());
    var obj;
    return new Promise((resolve, reject) => {
       repeat(myIter,resolve);
    });
}

函数*iter（）{
对于（var i=0；i<10；i++）收益率i
}
异步函数start（）{
var myIter=iter（）；
var p=等待cb1（myIter）；
console.log（'after wait'）；
log（“这里是p:+p.done+”，“+p.value”）；
}
start（）；
函数重复（myIter、resolver、previous）{
无功温度；
if（（temp=myIter.next（））.done==true）{
日志（“结束：+newdate（））；
分解器（先前）；
}否则{
console.log（“--in-else--”；
setTimeout（函数（）{repeat（myIter，resolver，temp）}，3000）；
}
}
功能cb1（myIter）{
log（“开始：+new Date（））；
var-obj；
返回新承诺（（解决、拒绝）=>{
重复（myIter，resolve）；
});
}

---

还修复了p，wait将其取出，您需要获取上一个值

有几个问题：

等待的结果永远不会是承诺；

wait

的目的是等待承诺解决，并为您提供解决值。因此，代码中的

p

不是承诺，也不会有

then

方法。但你不会因为#2而在这方面出错

每次调用

cb1

都会创建一个新的承诺，并使用一个新的

resolve

函数。您的上一次

setTimeout

回调正在解析最后一个承诺，但没有任何东西能够解析第一个承诺，因此您永远无法通过该

var p=await cb1（myIter）行

您可能需要一个用于计时器回调的内部函数，然后由

cb1

调用解析返回承诺

大致如下：

function* iter() {
    for (var i = 0; i < 10; i++) {
        yield i;
    }
}

async function start() {
    var myIter = iter();
    var p = await cb1(myIter);
    console.log("p = ", p);
}

start();
function cb1(myIter) {
    console.log("Started : " + new Date());
    return new Promise((resolve, reject) => {
        iteration();
        function iteration() {
            setTimeout(function() {
                if (myIter.next().done) { // `=== done` is pointless here
                    console.log("End : " + new Date());
                    resolve('done');
                } else {
                    console.log("---in else---");
                    iteration();
                }
            }, 3000);
        }
    });
}

函数*iter（）{
对于（变量i=0；i<10；i++）{
产量一；
}
}
异步函数start（）{
var myIter=iter（）；
var p=等待cb1（myIter）；
console.log（“p=”，p）；
}
start（）；
功能cb1（myIter）{
log（“开始：+new Date（））；
返回新承诺（（解决、拒绝）=>{
迭代（）；
函数迭代（）{
setTimeout（函数（）{
如果（myIter.next（）.done）{/`==done`在这里没有意义
日志（“结束：+newdate（））；
决议（“完成”）；
}否则{
console.log（“--in-else--”；
迭代（）；
}
}, 3000);
}
});
}

有几个问题：

等待的结果永远不会是承诺；

wait

的目的是等待承诺解决，并为您提供解决值。因此，代码中的

p

不是承诺，也不会有

then

方法。但你不会因为#2而在这方面出错

每次调用

cb1

都会创建一个新的承诺，并使用一个新的

resolve

函数。您的上一次

setTimeout

回调正在解析最后一个承诺，但没有任何东西能够解析第一个承诺，因此您永远无法通过该

var p=await cb1（myIter）行

您可能需要一个用于计时器回调的内部函数，然后由

cb1

调用解析返回承诺

大致如下：

function* iter() {
    for (var i = 0; i < 10; i++) {
        yield i;
    }
}

async function start() {
    var myIter = iter();
    var p = await cb1(myIter);
    console.log("p = ", p);
}

start();
function cb1(myIter) {
    console.log("Started : " + new Date());
    return new Promise((resolve, reject) => {
        iteration();
        function iteration() {
            setTimeout(function() {
                if (myIter.next().done) { // `=== done` is pointless here
                    console.log("End : " + new Date());
                    resolve('done');
                } else {
                    console.log("---in else---");
                    iteration();
                }
            }, 3000);
        }
    });
}

函数*iter（）{
对于（变量i=0；i<10；i++）{
产量一；
}
}
异步函数start（）{
var myIter=iter（）；
var p=等待cb1（myIter）；
console.log（“p=”，p）；
}
start（）；
功能cb1（myIter）{
log（“开始：+new Date（））；
返回新承诺（（解决、拒绝）=>{
迭代（）；
乐趣
  } else {
    console.log("---in else---");
    cb1(myIter).then(resolve);
  }