最近我遇到了几次一个特定的情况，我不知道如何正确地解决。假设以下代码：
somethingAsync()
.then( afterSomething )
.then( afterSomethingElse )
function afterSomething( amazingData ) {
return processAsync( amazingData );
}
function afterSomethingElse( processedData ) {
}
现在可能会出现这样一种情况，我希望在afterSomethingElse中访问amazingData。
一个显而易见的解决方案是从afterSomething返回一个数组或哈希表，因为你只能从函数中返回一个值。但我想知道是否有一种方法可以使afterSomethingElse接受两个参数并以相同的方式调用它，因为这似乎更容易记录和理解。
我只是想知道这种可能性是否存在，因为有Q.spread，它做了我想要的类似的事情。
你不能像从函数中返回多个值一样，使用多个属性来解决一个 Promise。Promise 的概念在概念上代表了一个随时间变化的值，因此虽然你可以表示复合值，但你不能将多个值放入一个 Promise 中。
一个 Promise 本质上是解析为单个值 - 这是 Q 的工作方式的一部分，Promises/A+ 规范的工作方式以及 这种抽象 的工作方式。
你可以通过使用 Q.spread 并返回数组或者使用 ES6 解构（如果支持）或者使用类似 BabelJS 这样的转译工具来实现最接近的效果。
至于如何将上下文传递到 Promise 链，请参考 Bergi 的优秀指南。
.spread() 方法，就像这个相关的回答中所展示的：https://dev59.com/TmEh5IYBdhLWcg3wIgYX#22776850 - Kevin GhadyaniPromise.all([a, b, c]).then(function(x, y, z) {...})可以正确工作，其中x、y和z将评估为a、b和c的解析值。因此更准确地说，语言不允许您轻松（或理智地）从用户代码中执行此操作（因为您可以直接从then子句返回一个Promise，您可以将您的值包装在promises中，然后再使用Promise.all()包装这些值以获得所需的行为，尽管方式有些复杂）。 - Austin HemmelgarnPromise.all会用一个数组来完成fulfillment。在 Promise.all([a,b]).then((a, b) => 中，b 是 undefined。这就是为什么需要使用解构赋值 .then(([a, b]) =>。 - Benjamin Gruenbaum你只能传递一个值，但这个值可以是内含多个值的数组，例如：
function step1(){
let server = "myserver.com";
let data = "so much data, very impresive";
return Promise.resolve([server, data]);
}
另一方面，您可以使用 ES2015 中的解构表达式来获取单个值。
function step2([server, data]){
console.log(server); // print "myserver.com"
console.log(data); // print "so much data, very impresive"
return Promise.resolve("done");
}
同时调用两个 Promise 并链式调用它们：
step1()
.then(step2)
.then((msg)=>{
console.log(msg); // print "done"
})
function step2([server, data]) { … - 这样你也避免了对隐式全局变量的赋值。而且在你的示例中，你真的应该使用 return 或 Promise.resolve，而不是 new Promise 构造函数。 - Bergi你可以返回一个包含这两个值的对象——这样做没有任何问题。
另一种策略是通过闭包保留该值，而不是将其传递：
somethingAsync().then(afterSomething);
function afterSomething(amazingData) {
return processAsync(amazingData).then(function (processedData) {
// both amazingData and processedData are in scope here
});
}
完全内联形式（等效，可以说更加一致）：
somethingAsync().then(function (amazingData) {
return processAsync(amazingData).then(function (processedData) {
// both amazingData and processedData are in scope here
});
}
then 语句中返回一个 then 结果是否可行？这不是一种反模式吗？ - robe007只需创建一个对象并从该对象中提取参数即可。
let checkIfNumbersAddToTen = function (a, b) {
return new Promise(function (resolve, reject) {
let c = parseInt(a)+parseInt(b);
let promiseResolution = {
c:c,
d : c+c,
x : 'RandomString'
};
if(c===10){
resolve(promiseResolution);
}else {
reject('Not 10');
}
});
};
checkIfNumbersAddToTen(5,5).then(function (arguments) {
console.log('c:'+arguments.c);
console.log('d:'+arguments.d);
console.log('x:'+arguments.x);
},function (failure) {
console.log(failure);
});
无论你从一个 Promise 返回什么，它都会被包装成一个 Promise，在下一个 .then() 阶段解封。
当你需要返回一个或多个 Promise 以及一个或多个同步值时，情况变得有趣，例如：
Promise.resolve([Promise.resolve(1), Promise.resolve(2), 3, 4])
.then(([p1,p2,n1,n2]) => /* p1 and p2 are still promises */);
在这些情况下，使用Promise.all()来获取p1和p2的承诺并在下一个.then()阶段展开是非常重要的。
Promise.resolve(Promise.all([Promise.resolve(1), Promise.resolve(2), 3, 4]))
.then(([p1,p2,n1,n2]) => /* p1 is 1, p2 is 2, n1 is 3 and n2 is 4 */);
你可以做两件事，返回一个对象。
somethingAsync()
.then( afterSomething )
.then( afterSomethingElse );
function processAsync (amazingData) {
//processSomething
return {
amazingData: amazingData,
processedData: processedData
};
}
function afterSomething( amazingData ) {
return processAsync( amazingData );
}
function afterSomethingElse( dataObj ) {
let amazingData = dataObj.amazingData,
processedData = dataObj.proccessedData;
}
var amazingData;
somethingAsync()
.then( afterSomething )
.then( afterSomethingElse )
function afterSomething( returnedAmazingData ) {
amazingData = returnedAmazingData;
return processAsync( amazingData );
}
function afterSomethingElse( processedData ) {
//use amazingData here
}
这是我认为你应该做的方式。
因为两个函数都将使用 amazingData，所以有一个专门的函数来处理它是有意义的。 每当我想要重复使用一些数据时，我通常会这样做，以便它始终作为函数参数存在。
由于您的示例正在运行一些代码，因此我假设所有内容都在一个函数中声明。我将其称为 toto()。 然后我们将有另一个函数，它将运行 afterSomething() 和 afterSomethingElse()。
function toto() {
return somethingAsync()
.then( tata );
}
function tata( amazingData ) {
var processed = afterSomething( amazingData );
return afterSomethingElse( amazingData, processed );
}
function afterSomething( amazingData ) {
return processAsync( amazingData );
}
function afterSomethingElse( amazingData, processedData ) {
}
function tata( amazingData ) {
return afterSomething()
.then( afterSomethingElse );
function afterSomething( /* no args */ ) {
return processAsync( amazingData );
}
function afterSomethingElse( processedData ) {
/* amazingData can be accessed here */
}
}
afterSomethingElse()与之前相同。它可以是异步的，也可以不是。将返回一个promise，或将值包装为已解决的promise。
function goingThroughTheEatingProcess(plenty, of, args, to, match, real, life) {
return iAmAsync()
.then(chew)
.then(swallow);
function chew(result) {
return carefullyChewThis(plenty, of, args, "water", "piece of tooth", result);
}
function swallow(wine) {
return nowIsTimeToSwallow(match, real, life, wine);
}
}
function iAmAsync() {
return Promise.resolve("mooooore");
}
function carefullyChewThis(plenty, of, args, and, some, more) {
return true;
}
function nowIsTimeToSwallow(match, real, life, bobool) {
}
function tata( amazingData ) {
return afterSomething( amazingData )
.then( afterSomethingElse.bind(null, amazingData) );
}
function afterSomething( amazingData ) {
return processAsync( amazingData );
}
function afterSomethingElse( amazingData, processedData ) {
}
function tata( amazingData ) {
return Promise.all( [ amazingData, afterSomething( amazingData ) ] )
.then( afterSomethingElse );
}
function afterSomething( amazingData ) {
return processAsync( amazingData );
}
function afterSomethingElse( args ) {
var amazingData = args[0];
var processedData = args[1];
}
只需返回一个元组：
async add(dto: TDto): Promise<TDto> {
console.log(`${this.storeName}.add(${dto})`);
return firebase.firestore().collection(this.dtoName)
.withConverter<TDto>(this.converter)
.add(dto)
.then(d => [d.update(this.id, d.id), d.id] as [any, string])
.then(x => this.get(x[1]));
}