等待多个异步函数的promise链等效是什么？

Question

我正在研究promsies和async/await的用法。

我编写了以下代码，它执行以下操作：

1. 它获取一些数据库数据（使用Knex.js），
2. 处理该数据，
3. 将处理的数据分配到指定的属性中

这3个步骤执行了多次（在下面的代码中，执行了两次），并且始终等待执行：

async function run() {
   return await getData();
}
async function getData() {
    let handledData = {};
    handledData.res1 = await knex.select('column1').from('table1').where('column1', '1')
                                 .then(data => handleData(data))
                                 .catch(handleError);
    handledData.res2 = await knex.select('column1').from('table1').where('column1', '2')
                                 .then(data => handleData(data, handledData))
                                 .catch(handleError);
    return handledData;
}
async function handleData(data) {
    let res = [];
    data.forEach(item => {
        res.push(item.column1);
    });
    return res; 
}
function handleError (error) {
    console.log(error);
}

现在，我正在尝试编写与getData等效的promise链，这就是我想到的：

async function getData() {
    let handledData = {};
    let promise = new Promise(function(resolve, error){ resolve(); });
    promise
    .then(function () {
        return knex.select('column1').from('table1').where('column1', '1')
                    .then(data => handleData(data))
                    .catch(handleError);
    })
    .then(function(handled){
        handledData.res1 = handled;
        return knex.select('column1').from('table1').where('column1', '2')
                    .then(data => handleData(data))
                    .catch(handleError);
    })
    .then(function(handled){
        handledData.res2 = handled;
        return handledData;
    })
    .catch(handleError);
    return promise;
}

但这不太管用。发生的是，在第一个然后返回之后，run中的wait结束了它的等待，这导致run返回-并且只有在第二个然后被执行。

如何使promise链接版本像多重等待版本那样工作？

（请随时指出我对promise/异步等待的任何误解）

Answer 1

knex.select（）。然后（）返回一个promise，所以你不需要用另一个promise包装它，你只需要设置然后（）s的链并返回整个东西。结果将是getData返回上次的promise。您可以从该然后（）返回您想要的值，这将使它对调用方可用。例如：

function run() {
    getData()
    .then(handledData => console.log(handledData) /* do something with data */)
}

function getData() {
    let handledData = {};
    // need to return this promise to callers can access it
    return knex.select('column1').from('table1').where('column1', '1')
    .then(data => handledData.res1 = handleData(data))
    .then(() => knex.select('column1').from('table1').where('column1', '2'))
    .then(data => {
        handledData.res2 = handleData(data)
        return handledData
    })
    .catch(handleError);
}

您还可以将其设置为将handledData对象传递给链，但在这种情况下不需要这样做。

函数handleData（）是同步的，因此不需要将其设为异步函数。

Answer 2

如果可能的话，我建议使用Promise.all，这将使您的脚本运行得更快，并且使逻辑更清晰：

const getData = Promise.all([
  knex.select('column1').from('table1').where('column1', '1')
    // Simply pass the function name as a parameter to the `.then`:
    .then(handleData)
    .catch(handleError),
  knex.select('column1').from('table1').where('column1', '2')
    .then(handleData)
    .catch(handleError)
])
  .then(([res1, res1]) => ({ res1, res2 }));