Javascript 承诺与超时

我正在尝试确定一种方法来“暂停”我的代码，直到条件为真，可能是通过使用递归的

setTimeout（）

。对于我的简单示例，我手动设置

waitValue

我需要等待片刻，如果

waitValue

仍然为false，则继续等待。当然，当

waitValue

变为true时，继续处理。以下是我到目前为止拼凑的内容：

var counter=0;
function promiseTest() { 
    return new Promise(  (resolve, reject) => {
        if  ( waitValue )  {
            console.log('waitValue is now true');
            resolve('FIRST PROMISE');
        } else  {                      // we need to wait again
            if  ( counter > 1000 ) {   // dont wait forever.
                reject('waited too long');
            } else {
                console.log('WAIT MESSAGE: ' + counter++ );
                setTimeout( promiseTest, 3000);
            }
        }
    })
    .then(   result => {
        return(`SECOND PROMISE:  the result is: ${result}`);
    });
}

使用它：

promiseTest().then( (result)=>{ console.log('LOCAL MESSAGE: ' + result); });

以下工作很好：

var waitValue = true;
promiseTest().then( (result)=>{ console.log('LOCAL MESSAGE: ' + result); });
// waitValue is now true
// LOCAL MESSAGE: SECOND PROMISE:  the result is: FIRST PROMISE

但是，以下内容似乎没有如我所愿完成：

var waitValue = false;
promiseTest().then( (result)=>{ console.log('LOCAL MESSAGE: ' + result); });
// waiting messages appear as expected
waitValue = true;
// waitValue is now true
// no other messages

我一直找不到一个可以临时执行的例子。普通javaScript示例可能如下所示：

var waitValue = false;
var counter = 0;
(function tester() {
   if  ( waitValue ) {
      console.log('finally true');
   } else {
       if  ( counter > 1000 ) {
           console.log('waited too long');
           process.exit;
       } else {
           console.log('still waiting, counter = ' + counter++);
           setTimeout(tester, 1000);
       }
   }
})();
// wait a few seconds and enter this into the console:
var waitValue = false;

暂时暂停执行的承诺脚本是什么样子的？或者承诺根本就不应该这样使用

非常感谢。

代码>设置超时（promiseTest，3000）将不起作用，这可能会再次调用

promiseTest

函数，但不会解析在最外层调用中创建的承诺

您正在使用的异步原语，

setTimeout

，而不是在回调中乱搞：

function wait(t) {
    return new Promise(resolve => {
        setTimeout(resolve, t);
    });
}

然后在您的轮询功能中使用：

function promiseTest(counter = 1000) {
    if (waitValue) {
        console.log('waitValue is now true');
        return Promise.resolve('FIRST PROMISE');
    } else if (counter <= 0) { // dont wait forever.
        return Promise.reject(new Error('waited too long'));
    } else {
        console.log('WAIT MESSAGE: ' + counter );
        return wait(3000).then(() => {
            return promiseTest(counter-1);
        });
    }
}

功能承诺测试（计数器=1000）{
如果（等待值）{
log（'waitValue现在为true'）；
返回承诺。解决（“第一个承诺”）；
}否则（柜台）{
返还承诺测试（柜台1）；
});
}
}

这个想法的方向是正确的。当递归调用函数时，您只需解析当前承诺，否则当前承诺将永远无法实现

但是请注意，如果等待时间很长，则会创建一堆承诺

功能承诺测试（计数器=1000）{
返回新承诺（（解决、拒绝）=>{
如果（等待值）{
log（'waitValue现在为true'）；
决议（“第一承诺”）；
}else if（计数器{//确保在嵌套承诺解析后调用'resolve'：
承诺测试（计数器1）。然后（解决）；
}, 3000);
}
})
。然后（结果=>{
return`secondpromise:结果是：${result}`；
});
}
var-waitValue=false；
promiseTest（）。然后（结果=>{
console.log（'done:'，result）；
});
//安排waitValue的更改：
setTimeout（=>waitValue=true，4000）避免错误！您没有转发最终的错误。我相信我在第二个版本中避免了反模式。不过，我将明确提到反模式。是的，第二个版本中递归
循环
，效果很好（但我认为它缺乏承诺的优点）“这个想法是在正确的方向上。”-这是我以前第一次听到这样的说法。谢谢你的夸奖。你的解决方案很棒，尤其是“loop.bind”。您精心设计的算法将在我们的deepstream sql接口项目中广泛使用。非常感谢。不客气；-）而且。。。我知道你的意思。人们经常发现的傲慢有时是难以忍受的。但这并不是唯一的声音：-）很高兴我的贡献对你有用。“也许承诺根本不应该这样使用？”-是的，你永远不应该使用投票。相反，在设置
waitValue
的地方做出一个承诺