根据在第一个异步函数之前收集的数据，对第二个异步函数进行条件调用

Question

我在数组中有一些数据。

let data = ['firstData', 'secondData'];

第一个对象（firstData）始终存在，secondData 可以为空。所以我总是用它来调用我的异步函数，比如：

myAsyncFunction(data[0]).then(result => {
    //do something here
});

如果data[1] 存在，我想用data[1] 调用myAsyncFunction。

我目前的解决方案是嵌套承诺。像这样：

myAsyncFunction(data[0]).then(result => {
    return result;
}).then(result => {
    if(data[1] !== null){
        myAsyncFunction(data[1].then(resultTwo => {
        //dostuff with data
      });
    }
});

我不是很喜欢这个解决方案，但它确实有效。这一定是一个更好的方法。 result 始终是一个对象。我试过Promise.all，但它不起作用。我认为这是某种“竞争条件”的问题（我在这里如履薄冰）。

我目前的解决方案是唯一的吗？

这是 myAsuncFunction 的样子：

myAsyncFunction(personData){
    return new Promise<any> ((resolve, reject) => {

        //Assingen private variables

    secondAsyncFunction(somePersonData).then(result =>
     {

                    //Do some sync stuff

          return someNewData; //not a promise
     })
         .then(thirdAsyncFunction)
         .then(data => {
              resolve(data);
         })
         .catch(error => {
          reject(error);
     });
});

Answer 1

Promise.all 设计用于在数组中有动态数量的 Promise 时使用，并且您希望将它们组合成一个 Promise，该 Promise 在数组中的所有 Promise 都已解析时解析。

根据你的用例，你应该可以这样使用它：

data = data.filter(x => x !== null);

Promise.all(data.map(myAsyncFunction)).then((results) => {
    const [resultOne, resultTwo] = results;
    if (resultTwo) {
        // handle resultTwo
    }
    // handle resultOne
});

Answer 2

鉴于data 在承诺结果之前是静态已知的，您不需要将条件放在then 回调中 - 您可以使整个链接成为条件：

var promise = myAsyncFunction(data[0]);
if(data[1] !== null){
    promise.then(result =>
        myAsyncFunction(data[1])
    ).then(resultTwo => {
        //dostuff with data
    });
}

一般来说，注意嵌套并不是一件坏事，当你想要分支控制流时需要它。只是不要忘记始终 return 您对所有（回调）函数的承诺。

Answer 3

你可以这样做：

const stuffOnlyRelatedToSecondData = result2 => /*do something*/

myAsyncFunction(data[0]).then(result => {
    if (data[1] === null) {return null}
    return myAsyncFunction(data[1]).then(stuffOnlyRelatedToSecondData) 
}).then(/*Anything to do after [1] or [1,2]*/)

这样你可以使用相同的链，两种可能的情况如下：

myAsyncFunction(data[0]) --> END
myAsyncFunction(data[0]) --> myAsyncFunction(data[1]) --> END

编辑：

似乎myAsyncFunction 可能存在承诺泄漏，请尝试使用类似的东西：

const myAsyncFunction = personData => {
    //Assigning private variables
    return secondAsyncFunction(somePersonData).then(result => {
        //Do some sync stuff
        return someNewData; //not a promise
    })
    .then(thirdAsyncFunction)
}

我们可以这样写，因为secondAsyncFunction 启动了一个新的 Promise，因此我们不需要另一个 Promise 包装器。并且可以将 catch 放入执行 myAsyncFunction 的父 Promise 链本身中