Менее суровый поворот на «Mutable contextual state»

Использование объекта с локальным охватом для сбора промежуточных результатов в цепочке обещаний является разумным подходом к заданному вами вопросу. Рассмотрим следующий фрагмент:

function getExample(){
    //locally scoped
    const results = {};
    return promiseA(...).then(function(resultA){
        results.a = resultA;
        return promiseB(...);
    }).then(function(resultB){
        results.b = resultB;
        return promiseC(...);
    }).then(function(resultC){
        //Resolve with composite of all promises
        return Promise.resolve(results.a + results.b + resultC);
    }).catch(function(error){
        return Promise.reject(error);
    });
}

• Глобальные переменные являются плохими, поэтому в этом решении используется локально ограниченная переменная, которая не наносит вреда. Он доступен только внутри функции.
• Мутируемое состояние уродливое, но это не мутирует состояние уродливо. Уродливое изменчивое состояние традиционно относится к модификации состояния аргументов функции или глобальных переменных, но этот подход просто изменяет состояние переменной локального охвата, которая существует с единственной целью агрегирования результатов обещания ... переменная, которая умрет простой смертью
• Промежуточные обещания не препятствуют доступу к состоянию объекта результатов, но это не приводит к некоторому страшному сценарию, когда одно из обещаний в цепочке будет изгонять и саботировать ваши результаты. Ответственность за установку значений на каждом шаге обещания ограничивается этой функцией, и общий результат будет либо правильным, либо неправильным ... это не будет какой-то ошибкой, которая возникнет спустя годы в производстве (если вы не намерены ее !) [/ ​​g3]
• Это не приводит к сценарию условий гонки, который возникает из-за параллельного вызова, потому что для каждого вызова функции getExample создается новый экземпляр переменной результатов.

function getExample() {
    var retA, retB;
    return promiseA(…).then(function(resultA) {
        retA = resultA;
        // Some processing
        return promiseB(…);
    }).then(function(resultB) {
        // More processing
        //retA is value of promiseA
        return // How do I gain access to resultA here?
    });
}

простой способ: D

При использовании bluebird вы можете использовать метод .bind для обмена переменными в цепочке обещаний:

somethingAsync().bind({})
.spread(function (aValue, bValue) {
    this.aValue = aValue;
    this.bValue = bValue;
    return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) {
    return this.aValue + this.bValue + cValue;
});

, пожалуйста, проверьте эту ссылку для получения дополнительной информации:

http : //bluebirdjs.com/docs/api/promise.bind.html

Я думаю, вы можете использовать хэш из RSVP.

Что-то вроде ниже:

    const mainPromise = () => {
        const promise1 = new Promise((resolve, reject) => {
            setTimeout(() => {
                console.log('first promise is completed');
                resolve({data: '123'});
            }, 2000);
        });

        const promise2 = new Promise((resolve, reject) => {
            setTimeout(() => {
                console.log('second promise is completed');
                resolve({data: '456'});
            }, 2000);
        });

        return new RSVP.hash({
              prom1: promise1,
              prom2: promise2
          });

    };


   mainPromise()
    .then(data => {
        console.log(data.prom1);
        console.log(data.prom2);
    });

В эти дни я также встречаю такие вопросы, как вы. Наконец, я нашел хорошее решение с запросом, это просто и хорошо читать. Я надеюсь, что это может вам помочь.

Согласно how-to-chain-javascript-promises

ok, давайте посмотрим на код:

const firstPromise = () => {
    const promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('first promise is completed');
            resolve({data: '123'});
        }, 2000);
    });
};

const secondPromise = (someStuff) => {
    const promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('second promise is completed');
            resolve({newData: `${someStuff.data} some more data`});
        }, 2000);
    });
};

const thirdPromise = (someStuff) => {
    const promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('third promise is completed');
            resolve({result: someStuff});
        }, 2000);
    });
};

firstPromise()
    .then(seondPromise)
    .then(thirdPromise)
    .then(data => {
        console.log(data);
    });