Promise 和 setTimeout

我正在尝试确定一种方法来“暂停”我的 Promises 代码，直到条件成立为止，也许可以使用递归setTimeout()。对于我的简单示例，我手动设置waitValue.

我需要等一下，如果waitValue仍然是错误的，那就只能继续等待了。当然，当waitValue为真，则继续处理。这是我到目前为止拼凑的内容：

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;

暂时暂停执行的 Promise 脚本会是什么样子？或者也许 Promise 根本不应该这样使用？

非常感谢。

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

但请注意，如果等待时间较长，您将创建一堆承诺。

function promiseTest(counter = 1000) { 
    return new Promise(  (resolve, reject) => {
        if ( waitValue )  {
            console.log('waitValue is now true');
            resolve('FIRST PROMISE');
        } else if  ( counter <= 0 ) {   // dont wait forever.
            reject('waited too long');
        } else {
            console.log('Count down: ' + counter);
            setTimeout( _ => { // make sure to call `resolve` after the nested promise resolved:
                promiseTest(counter-1).then(resolve);
            }, 3000);
        }
    })
    .then(   result => {
        return `SECOND PROMISE:  the result is: ${result}`;
    });
}

var waitValue = false;

promiseTest().then ( result => {
   console.log('done:', result);
});

// schedule the change of the waitValue:
setTimeout(_ => waitValue = true, 4000);

请注意输出如何包含每个已解析的嵌套链式 Promise 的一些痕迹。

选择

我发现对您定义的函数执行递归调用更直观within the Promise构造函数回调，而不是在创建该函数的函数上Promise。这样你就只创建一个承诺，并且避免了Promise 构造函数反模式 https://stackoverflow.com/q/23803743/5459839它存在于您的想法（及其上面的工作版本）中：

function promiseTest(counter = 1000) { 
    return new Promise(  (resolve, reject) => {
        (function loop(counter) {
            if ( waitValue )  {
                console.log('waitValue is now true');
                resolve('FIRST PROMISE');
            } else if  ( counter <= 0 ) {   // dont wait forever.
                reject('waited too long');
            } else {
                console.log('Count down: ' + counter);
                setTimeout( loop.bind(null, counter-1), 3000);
            }
        })(counter); // initial value of count-down
    })
    .then(   result => {
        return `SECOND PROMISE:  the result is: ${result}`;
    });
}

var waitValue = false;

promiseTest().then ( result => {
   console.log('done:', result);
});

// schedule the change of the waitValue:
setTimeout(_ => waitValue = true, 4000);

请注意输出与第一个版本略有不同，这反映出只有一个new涉及承诺

注意：这不是必需的，但我更喜欢从某个值（1000）开始倒数，并将其作为参数传递给执行循环的匿名函数。