另一个答案，使用babel节点版本<6

使用async - await

NPM install -g babel@5.6.14

example.js:

async function getExample(){

  let response = await returnPromise();

  let response2 = await returnPromise2();

  console.log(response, response2)

}

getExample()

然后，运行babel-node example.js，瞧!

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

ECMAScript和谐

当然，语言设计者也认识到了这个问题。他们做了大量的工作，异步函数提案最终得以通过

ECMAScript 8

您不再需要单个then调用或回调函数，就像在异步函数(在被调用时返回promise)中一样，您可以简单地等待promise直接解析。它还具有任意的控制结构，如条件，循环和try-catch子句，但为了方便起见，我们在这里不需要它们:

async function getExample() {
    var resultA = await promiseA(…);
    // some processing
    var resultB = await promiseB(…);
    // more processing
    return // something using both resultA and resultB
}

ECMAScript 6

当我们在等待ES8时，我们已经使用了非常类似的语法。ES6附带了生成器函数，允许在任意放置的yield关键字处将执行分开。这些切片可以彼此独立地、甚至异步地运行——当我们想要在运行下一步之前等待承诺解决时，我们就是这样做的。

有专门的库(如co或task.js)，但也有许多承诺库有辅助函数(Q, Bluebird, when，…)，当你给它们一个生成承诺的生成器函数时，它们会为你执行异步逐步执行。

var getExample = Promise.coroutine(function* () {
//               ^^^^^^^^^^^^^^^^^ Bluebird syntax
    var resultA = yield promiseA(…);
    // some processing
    var resultB = yield promiseB(…);
    // more processing
    return // something using both resultA and resultB
});

这在Node.js 4.0版本起就可以了，也有一些浏览器(或他们的开发版本)相对较早地支持生成器语法。

ECMAScript 5

然而，如果你想要/需要向后兼容，你就不能在没有转译器的情况下使用它们。当前工具支持生成器函数和异步函数，例如，请参阅关于生成器和异步函数的Babel文档。

此外，还有许多其他的编译到js语言 它们致力于简化异步编程。它们通常使用类似于await的语法(例如Iced CoffeeScript)，但也有其他一些具有类似haskell的do-notation(例如LatteJs, monadic, PureScript或LispyScript)。

显式直通

类似于嵌套回调，此技术依赖于闭包。然而，链保持不变——不是只传递最新的结果，而是为每一步传递某个状态对象。这些状态对象累积先前操作的结果，传递稍后将再次需要的所有值加上当前任务的结果。

function getExample() {
    return promiseA(…).then(function(resultA) {
        // some processing
        return promiseB(…).then(b => [resultA, b]); // function(b) { return [resultA, b] }
    }).then(function([resultA, resultB]) {
        // more processing
        return // something using both resultA and resultB
    });
}

这里，小箭头b => [resultA, b]是在resultA上关闭的函数，并将两个结果的数组传递给下一步。它使用参数解构语法将其再次分解为单个变量。

在ES6提供解构之前，许多承诺库(Q, Bluebird, when，…)提供了一个漂亮的助手方法，名为.spread()。它接受一个带有多个参数的函数——每个数组元素一个参数——作为.spread(function(resultA, resultB) {....

当然，这里需要的闭包可以通过一些辅助函数进一步简化，例如。

function addTo(x) {
    // imagine complex `arguments` fiddling or anything that helps usability
    // but you get the idea with this simple one:
    return res => [x, res];
}

…
return promiseB(…).then(addTo(resultA));

或者，您可以使用Promise。所有这些都是为了产生数组的承诺:

function getExample() {
    return promiseA(…).then(function(resultA) {
        // some processing
        return Promise.all([resultA, promiseB(…)]); // resultA will implicitly be wrapped
                                                    // as if passed to Promise.resolve()
    }).then(function([resultA, resultB]) {
        // more processing
        return // something using both resultA and resultB
    });
}

你不仅可以使用数组，还可以使用任意复杂的对象。例如，用_。扩展或对象。在不同的helper函数中赋值:

function augment(obj, name) {
    return function (res) { var r = Object.assign({}, obj); r[name] = res; return r; };
}

function getExample() {
    return promiseA(…).then(function(resultA) {
        // some processing
        return promiseB(…).then(augment({resultA}, "resultB"));
    }).then(function(obj) {
        // more processing
        return // something using both obj.resultA and obj.resultB
    });
}

While this pattern guarantees a flat chain and explicit state objects can improve clarity, it will become tedious for a long chain. Especially when you need the state only sporadically, you still have to pass it through every step. With this fixed interface, the single callbacks in the chain are rather tightly coupled and inflexible to change. It makes factoring out single steps harder, and callbacks cannot be supplied directly from other modules - they always need to be wrapped in boilerplate code that cares about the state. Abstract helper functions like the above can ease the pain a bit, but it will always be present.

嵌套(和)闭包

使用闭包来维护变量的作用域(在我们的例子中是成功回调函数参数)是自然的JavaScript解决方案。有了promises，我们可以任意嵌套和平化.then()回调函数——它们在语义上是等价的，除了内部的范围不同。

function getExample() {
    return promiseA(…).then(function(resultA) {
        // some processing
        return promiseB(…).then(function(resultB) {
            // more processing
            return // something using both resultA and resultB;
        });
    });
}

当然，这是在建造一个压痕金字塔。如果缩进变得太大，您仍然可以应用旧的工具来对抗厄运金字塔:模块化，使用额外的命名函数，并在您不再需要变量时将承诺链压平。 理论上，您总是可以避免超过两层嵌套(通过使所有闭包显式)，在实践中使用尽可能多的是合理的。

function getExample() {
    // preprocessing
    return promiseA(…).then(makeAhandler(…));
}
function makeAhandler(…)
    return function(resultA) {
        // some processing
        return promiseB(…).then(makeBhandler(resultA, …));
    };
}
function makeBhandler(resultA, …) {
    return function(resultB) {
        // more processing
        return // anything that uses the variables in scope
    };
}

对于这类局部应用程序，您还可以使用helper函数，如_。来自Underscore/lodash或本机.bind()方法的部分，以进一步减少缩进:

function getExample() {
    // preprocessing
    return promiseA(…).then(handlerA);
}
function handlerA(resultA) {
    // some processing
    return promiseB(…).then(handlerB.bind(null, resultA));
}
function handlerB(resultA, resultB) {
    // more processing
    return // anything that uses resultA and resultB
}

打破枷锁

When you need to access the intermediate values in your chain, you should split your chain apart in those single pieces that you need. Instead of attaching one callback and somehow trying to use its parameter multiple times, attach multiple callbacks to the same promise - wherever you need the result value. Don't forget, a promise just represents (proxies) a future value! Next to deriving one promise from the other in a linear chain, use the promise combinators that are given to you by your library to build the result value.

这将导致一个非常直接的控制流程，清晰的功能组合，因此易于模块化。

function getExample() {
    var a = promiseA(…);
    var b = a.then(function(resultA) {
        // some processing
        return promiseB(…);
    });
    return Promise.all([a, b]).then(function([resultA, resultB]) {
        // more processing
        return // something using both resultA and resultB
    });
}

而不是在Promise之后的回调中进行参数解构。在ES5中，then调用将被许多承诺库(Q, Bluebird, when，…)提供的一个漂亮的助手方法所取代:.spread(function(resultA, resultB) {....

Bluebird还提供了一个专用的连接功能来取代承诺。All +扩展组合，更简单(更有效)的结构:

…
return Promise.join(a, b, function(resultA, resultB) { … });