Как разрешить рекурсивные асинхронные промисы?

Ошибка в том, что вы передаете функцию, которая возвращает обещание setTimeout. Это обещание теряется в эфире. Временное исправление может заключаться в рекурсии функции-исполнителя:

var checkIsFinished = function (athlete) {
  return new Promise(function executor(resolve) {
    if (athlete.distanceTravelled >= 100) {
      clearInterval(intervalID);
      console.log("finished");
      resolve(athlete);
    } else {
      console.log("not finished yet, check again in a bit");
      setTimeout(executor.bind(null, resolve), 1000);
    }    
  });
};

Но мех. Я думаю, что это отличный пример того, почему следует избегать анти-шаблона промис-конструктора (потому что смешивание кода обещания и не -promise-код неизбежно приводит к таким ошибкам).

Лучшие практики, которым я следую, чтобы избежать таких ошибок:

1. Работайте только с асинхронными функциями, которые возвращают промисы.
2. Если обещание не возвращается, оберните его конструктором обещания.
3. Оберните его как можно более узко (с минимальным количеством кода).
4. Не используйте конструктор промисов ни для чего другого.

После этого я нахожу, что код становится легче анализировать и его труднее запутать, потому что все следует одному и тому же шаблону.

Применение этого к вашему примеру привело меня сюда (для краткости я использую функции стрелок es6. Они работают в Firefox и Chrome 45):

var console = { log: msg => div.innerHTML += msg + "<br>",
                error: e => console.log(e +", "+ e.lineNumber) };

var wait = ms => new Promise(resolve => setTimeout(resolve, ms));

var startRunning = () => {
  var athlete = {
    timeTaken: 0,
    distanceTravelled: 0,
    intervalID: setInterval(() => {
      athlete.distanceTravelled += 25;
      athlete.timeTaken += 2.5;
      console.log("updated athlete ");
    }, 2500)
  };
  return wait(2000).then(() => athlete);
};

var checkIsFinished = athlete => {
  if (athlete.distanceTravelled < 100) {
    console.log("not finished yet, check again in a bit");
    return wait(1000).then(() => checkIsFinished(athlete));
  }
  clearInterval(athlete.intervalID);
  console.log("finished");
  return athlete;
};

startRunning()
  .then(checkIsFinished)
  .then(athlete => console.log('printing time: ' + athlete.timeTaken))
  .catch(console.error);

<div id="div"></div>

Обратите внимание, что checkIsFinished возвращает либо спортсмена, либо обещание. Здесь это нормально, потому что .then функции автоматически продвигают возвращаемые значения из функций, которые вы передаете в промисы. Если вы будете вызывать checkIsFinished в других контекстах, вы можете сделать повышение самостоятельно, используя return Promise.resolve(athlete); вместо return athlete;.

Редактировать в ответ на комментарии Амита:

Для нерекурсивного ответа замените всю функцию checkIsFinished этим помощником:

var waitUntil = (func, ms) => new Promise((resolve, reject) => {
  var interval = setInterval(() => {
    try { func() && resolve(clearInterval(interval)); } catch (e) { reject(e); }
  }, ms);
});

а затем сделайте это:

var athlete;
startRunning()
  .then(result => (athlete = result))
  .then(() => waitUntil(() => athlete.distanceTravelled >= 100, 1000))
  .then(() => {
    console.log('finished. printing time: ' + athlete.timeTaken);
    clearInterval(athlete.intervalID);
  })
  .catch(console.error);

var console = { log: msg => div.innerHTML += msg + "<br>",
                error: e => console.log(e +", "+ e.lineNumber) };

var wait = ms => new Promise(resolve => setTimeout(resolve, ms));

var waitUntil = (func, ms) => new Promise((resolve, reject) => {
  var interval = setInterval(() => {
    try { func() && resolve(clearInterval(interval)); } catch (e) { reject(e); }
  }, ms);
});

var startRunning = () => {
  var athlete = {
    timeTaken: 0,
    distanceTravelled: 0,
    intervalID: setInterval(() => {
      athlete.distanceTravelled += 25;
      athlete.timeTaken += 2.5;
      console.log("updated athlete ");
    }, 2500)
  };
  return wait(2000).then(() => athlete);
};

var athlete;
startRunning()
  .then(result => (athlete = result))
  .then(() => waitUntil(() => athlete.distanceTravelled >= 100, 1000))
  .then(() => {
    console.log('finished. printing time: ' + athlete.timeTaken);
    clearInterval(athlete.intervalID);
  })
  .catch(console.error);

<div id="div"></div>

Использование setTimeout / setInterval — это один из сценариев, который плохо сочетается с промисами и заставляет вас использовать антишаблон хмурого промиса.

Сказав это, если вы реконструируете свою функцию, сделаете ее функцией типа «ожидание завершения» (и назовите ее соответствующим образом), вы сможете решить свою проблему. Функция waitForFinish вызывается только один раз и возвращает один промис (хотя и новый, поверх исходного промиса, созданного в startRunning). Обработка повторения через setTimeout выполняется во внутренней функции опроса, где используется надлежащий try/catch для обеспечения распространения исключений на промис.

var intervalID;
var startRunning = function () {
  var athlete = {
    timeTaken: 0,
    distanceTravelled: 0
  };
  var updateAthlete = function () {
    athlete.distanceTravelled += 25;
    athlete.timeTaken += 2.5;
    console.log("updated athlete", athlete)
  }

  intervalID = setInterval(updateAthlete, 2500);

  return new Promise(function (resolve, reject) {
    setTimeout(resolve.bind(null, athlete), 2000);
  })
};

var waitForFinish = function (athlete) {
  return new Promise(function(resolve, reject) {
    (function pollFinished() {
      try{
        if (athlete.distanceTravelled >= 100) {
          clearInterval(intervalID);
          console.log("finished");
          resolve(athlete);
        } else {
          if(Date.now()%1000 < 250) { // This is here to show errors are cought
            throw new Error('some error');
          }
          console.log("not finished yet, check again in a bit");
          setTimeout(pollFinished, 1000);
        }
      }
      catch(e) { // When an error is cought, the promise is properly rejected
        // (Athlete will keep running though)
        reject(e);
      }
    })();
  });
};

var printTime = function (athlete) {
  console.log('printing time', athlete.timeTaken);
};

var handleError = function (e) { console.log('Handling error:', e); };

startRunning()
  .then(waitForFinish)
  .then(printTime)
  .catch(handleError);

Хотя весь этот код работает правильно, решение для опроса никогда не рекомендуется в асинхронной среде, и его следует по возможности избегать. В вашем случае, поскольку этот образец имитирует связь с сервером, я бы по возможности рассмотрел возможность использования веб-сокетов.

Поскольку вы используете промисы довольно неуместно, немного сложно точно сказать, что вы пытаетесь сделать или какая реализация лучше всего подходит, но вот рекомендация.

Обещания — это однократная конечная машина. Таким образом, вы возвращаете обещание, и ровно один раз в будущем обещание может быть либо отклонено с указанием причины, либо разрешено со значением. Учитывая такой дизайн промисов, я думаю, что имеет смысл использовать что-то вроде этого:

startRunning(100).then(printTime, handleError);

Вы можете реализовать это с помощью такого кода:

function startRunning(limit) {
    return new Promise(function (resolve, reject) {
        var timeStart = Date.now();
        var athlete = {
            timeTaken: 0,
            distanceTravelled: 0
        };
        function updateAthlete() {
            athlete.distanceTravelled += 25;
            console.log("updated athlete", athlete)
            if (athlete.distanceTravelled >= limit) {
                clearInterval(intervalID);
                athlete.timeTaken = Date.now() - timeStart;
                resolve(athlete);
            }
        }
        var intervalID = setInterval(updateAthlete, 2500);
    });
}

function printTime(athlete) {
    console.log('printing time', athlete.timeTaken);
}

function handleError(e) { 
    console.log(e); 
}

startRunning(100).then(printTime, handleError);

Рабочая демонстрация: http://jsfiddle.net/jfriend00/fbmbrc8s/

К вашему сведению, мое предпочтение в дизайне, вероятно, состояло бы в том, чтобы иметь общедоступный объект спортсмена, а затем методы для этого объекта, чтобы начать работу, остановить работу и т. д.

Вот некоторые из фундаментальных вещей, которые вы допустили неправильно при использовании промисов:

1. Это одноразовые объекты. Они решаются или отклоняются только один раз.
2. Структура startRunning().then(checkIsFinished) просто не имеет логического смысла. Чтобы первая часть этого работала, startRunning() должен вернуть обещание, и он должен разрешить или отклонить это обещание, когда произойдет что-то полезное. Вы просто разрешаете это через две секунды, что, похоже, не приносит ничего полезного.
3. Слова вашего описания звучат так, как будто вы хотите, чтобы `checkIsFinished() продолжала работать, а не выполняла свое обещание, пока спортсмен не закончит. Это можно сделать, постоянно связывая промисы, но это кажется очень сложным способом делать что-то и, конечно, здесь не нужно. Кроме того, это совсем не то, что пытается сделать ваш код. Ваш код просто возвращает новое обещание, которое никогда не разрешается, если спортсмен уже не преодолел желаемое расстояние. Если нет, он возвращает обещание, которое никогда не разрешается и не отклоняется. Это фундаментальное нарушение концепций обещаний. Функция, которая возвращает обещание, отвечает за его окончательное разрешение или отклонение, если только вызывающий код не ожидает просто отказаться от обещания, и в этом случае это, вероятно, неправильный инструмент проектирования.

Вот еще один подход, который создает общедоступный объект Athlete(), который имеет некоторые методы и позволяет нескольким людям наблюдать за ходом выполнения:

var EventEmitter = require('events');

function Athlete() {
    // private instance variables
    var runInterval, startTime; 
    var watcher = new EventEmitter();

    // public instance variables
    this.timeTaken = 0;
    this.distanceTravelled = 0;
    this.startRunning = function() {
        startTime = Date.now();
        var self = this;
        if (runInterval) {clearInterval(runInterval);}
        runInterval = setInterval(function() {
            self.distanceTravelled += 25;
            self.timeTaken = Date.now() - startTime;
            console.log("distance = ", self.distanceTravelled);
            // notify watchers
            watcher.emit("distanceUpdate");
        },2500);
    }
    this.notify = function(limit) {
        var self = this;
        return new Promise(function(resolve, reject) {
            function update() {
                if (self.distanceTravelled >= limit) {
                    watcher.removeListener("distanceUpdate", update);
                    resolve(self);
                    // if no more watchers, then stop the running timer
                    if (watcher.listeners("distanceUpdate").length === 0) {
                        clearInterval(runInterval);
                    }
                }
            }
            watcher.on("distanceUpdate", update);
        });
    }
}

var a = new Athlete();
a.startRunning();
a.notify(100).then(function() {
    console.log("done");
});