重复一个承诺，直到它没有被拒绝或达到超时[重复]

Question

我仍然是一个 Promise 菜鸟，并且正在尝试弄清楚如何让我的 Promise 重演。

有一个 ES6 承诺，如果没有设置一些全局标志，则拒绝。我需要它每 500 毫秒重试一次，直到：

• 承诺返回一个解决方案，
• 或达到最大尝试次数（比如说 10 次）。

由于 Promise 是异步的，我真的不想使用 setInterval() 检查，因为我认为异步代码不能正常工作。一旦承诺成功解决（或超时），我需要立即终止检查。

我正在使用 ES6 + React + ES6 Promises（请不要使用 Q 或 Bluebird 特定的答案！）

http://jsfiddle.net/2k2kz9r9/8/

// CLASS
class Test extends React.Component {
    constructor() {
      this.state = {
        status: 'setting up..',
      }
    }
    componentDidMount() {
      // TODO: how do I get this to loop with a timeout?
      this.createSlot()
        .then((slot) => {
          this.setState({
            status: slot
          });
        })
        .catch((e) => {
          this.setState({
            status: e.message
          });
        })
    }
    createSlot() {
      return new Promise((resolve, reject) => {
        if (!this.checkIsReady()) {
          reject(new Error('Global isnt ready yet'));
        }
        // more stuff here but going to resolve a string for simplicity sake
        resolve('successful!');
      });
    }
    checkIsReady() {
      return window.globalThing && window.globalThing === true;
    }
    render() {
        return ( <div>{this.state.status}</div> );
    }
}





    // RENDER OUT
    React.render(< Test/> , document.getElementById('container'));

编辑：基于当前反馈的函数：

  createSlot(tries) {
    const _this = this;
    return new Promise(function cb(resolve, reject) {
      console.log(`${tries} remaining`);
      if (--tries > 0) {
        setTimeout(() => {
          cb(resolve, reject);
        }, 500);
      } else {
        const { divId, adUnitPath } = _this;
        const { sizes } = _this.props;

        // if it's not, reject
        if (!_this.isPubadsReady()) {
          reject(new Error('pubads not ready'));
        }
        // if it's there resolve
        window.googletag.cmd.push(() => {
          const slot = window.googletag
            .defineSlot(adUnitPath, sizes, divId)
            .addService(window.googletag.pubads());
          resolve(slot);
        });
      }
    });
  }

Answer 1

正如 Mike McCaughan 所说，您可以使用 setTimeout 在尝试之间创建延迟。一旦您的承诺成功或尝试次数不多，请解决或拒绝您的承诺。

function createPromise(tries, willFail) {
  return new Promise(function cb(resolve, reject) {
    console.log(tries + ' remaining');
    if (--tries > 0) {
      setTimeout(function() {
        cb(resolve, reject);
      }, 500);
    } else {
      if (willFail) {
        reject('Failure');
      } else {
        resolve('Success');
      }
    }
  });
}

// This one will fail after 3 attempts
createPromise(3, true)
  .then(msg => console.log('should not run'))
  .catch(msg => {
    console.log(msg);
    
    // This one will succeed after 5 attempts
    return createPromise(5, false);
  })
  .then(msg => console.log(msg))
  .catch(msg => console.log('should not run'));

Answer 2

你可以尝试链接调用，就像 promise 应该的那样，这有点做作，但我希望你明白我的意思：

PS 将全局对象附加到 windows 是一个坏主意，如果可能的话，不应该这样做，这只是展示了一个使用您的流程的快速示例...

window.attempts = 0;
window.maxAttempts = 10;
window.globalThing = true;
function createSlot() {

return new Promise((resolve, reject) => {
    if (!this.checkIsReady()) {
      reject(new Error('Global isnt ready yet'));
    }
    // more stuff here but going to resolve a string for simplicity sake
    resolve('successful!');
}).then((pass) => {
    return pass;
  }, (fail) => {
    window.attempts ++;
    //If within attempts, try again
    if(window.attempts < window.maxAttempts){
      //Chain a new promise to resolve with a timeout of 500ms
      return new Promise((resolve, reject) => {
         setTimeout(() => {
            resolve()
         }, 500);
      }).then(() => {
         //Then try again
         return createSlot();
      })
    }
    else {
      //else fail out with reason
      return fail;
    }
  });
}