Node.js 如何在使用承诺时分别运行多个函数？

我试着按顺序一个接一个地运行4个函数，我试过下面的代码，但是在运行了第一个和第二个函数之后，有些函数是如何运行的

代码示例：

const Bluebird = require('bluebird');

///// also tried changing all Bluebird below to Promise -> didn't work

//const Promise = require('bluebird');

const promisesFunc = async (array) => {
    let interval = 1000;
    const delayPromise1 = (data, delayDuration) => {
      return new Promise((resolve) => {
        setTimeout(() => {
            /// do some code here requires .map function may take 10s or more
            resolve();
        }, delayDuration)
      });
    };

    const delayPromise2 = (data, delayDuration) => {
      return new Promise((resolve) => {
        setTimeout(() => {
            /// do some code here requires .map function may take 10s or more
            resolve();
        }, delayDuration)
      });
    };

    const delayPromise3 = (data, delayDuration) => {
      return new Promise((resolve) => {
        setTimeout(() => {
            /// do some code here requires .map function may take 10s or more
            resolve();
        }, delayDuration)
      });
    };

    const delayPromise4 = (data, delayDuration) => {
      return new Promise((resolve) => {
        setTimeout(() => {
            /// do some code here requires .map function may take 10s or more
            resolve();
        }, delayDuration)
      });
    };

    try {
    /////////////// first attempt //////////////
    await Bluebird.map(array, (data, index) => delayPromise1(data, index * interval))
    await Bluebird.map(array, (data, index) => delayPromise2(data, index * interval))
    await Bluebird.map(array, (data, index) => delayPromise3(data, index * interval))
    await Bluebird.map(array, (data, index) => delayPromise4(data, index * interval))
    console.log('done ***************************************************');
    setTimeout(() => {
      console.log('response was sent');
      res.status(200).json('done')
    }, 1000);

    /////////////// second attempt ////////////

    const promises = Bluebird.map(array, (data, index) => delayPromise1(data, index * interval))
      .then(() => Bluebird.map(array, (data, index) => delayPromise2(data, index * interval)))
      .then(() => Bluebird.map(array, (data, index) => delayPromise3(data, index * interval)))
      .then(() => Bluebird.map(array, (data, index) => delayPromise4(data, index * interval)))
      .then(() => {
        setTimeout(() => {
          console.log('response was sent');
          res.status(200).json('done')
        }, 1000);
      })
      .catch(err => console.error(err))

      await Promise.all([promises]);

      ///////////// third attempt ////////////////////

      const promises1 = array.map((data, index) => delayPromise1(data, index * interval));
      const promises2 = array.map((data, index) => delayPromise2(data, index * interval));
      const promises3 = array.map((data, index) => delayPromise3(data, index * interval));
      const promises4 = array.map((data, index) => delayPromise4(data, index * interval));
      await Promise.all([promises1, promises2, promises3, promises4]);
      setTimeout(function(){
        console.log('response was sent');
        res.status(200).json('done')
      }, 1000);


    } catch (e) {
      console.error(e);
    }
}
promisesFunc(array)

注意在第一次和第二次尝试中，delayPromise1和delayPromise2函数成功运行，但随后停止并不再继续，其他解决方案则分别不起作用

是否知道为什么会发生这种情况，是否有更好的解决方案来保证这些函数分别运行

PS功能结构需要是这样的。它们需要依次运行

---

在数据数组中进行映射，然后在delayPromise函数中对其进行一些处理，然后解析（）。在某些情况下，解决承诺不必等待代码执行完成。

您的第三次尝试就是成功之路。但您可以在

承诺时发送响应。所有
解析和所有异步操作都已完成

const promises1 = array.map((data, index) => delayPromise1(data, index * interval));
const promises2 = array.map((data, index) => delayPromise2(data, index * interval));
const promises3 = array.map((data, index) => delayPromise3(data, index * interval));
const promises4 = array.map((data, index) => delayPromise4(data, index * interval));

await Promise.all([promises1, promises2, promises3, promises4]).then(() => {
  console.log('response was sent');
  return res.status(200).json('done')
})

你的第三次尝试是正确的。但您可以在
承诺时发送响应。所有
解析和所有异步操作都已完成

const promises1 = array.map((data, index) => delayPromise1(data, index * interval));
const promises2 = array.map((data, index) => delayPromise2(data, index * interval));
const promises3 = array.map((data, index) => delayPromise3(data, index * interval));
const promises4 = array.map((data, index) => delayPromise4(data, index * interval));

await Promise.all([promises1, promises2, promises3, promises4]).then(() => {
  console.log('response was sent');
  return res.status(200).json('done')
})

我会像这样使用数组
.reduce
方法：

[delayPromise1, delayPromise2, ...]
    .reduce((m, delayPromise) => {

        /* here we chain the promises */
        return Promise.resolve(m).then(delayPromise)

    }, {/* any input data to be the argument of delayPromise1 */} )

    .then( res => {

        // do something when all is ready
    })

我会像这样使用数组
.reduce
方法：

[delayPromise1, delayPromise2, ...]
    .reduce((m, delayPromise) => {

        /* here we chain the promises */
        return Promise.resolve(m).then(delayPromise)

    }, {/* any input data to be the argument of delayPromise1 */} )

    .then( res => {

        // do something when all is ready
    })

如果要运行并行传递，则所有延迟函数都要在Promise.all内传递。如果您想按顺序运行，请使用下面的命令


const promisesFunc=async（数组）=>{
设间隔=1000；
const delayPromise1=（数据，延迟持续时间）=>{
返回新承诺（（解决）=>{
设置超时（（）=>{
///这里需要一些代码。映射函数可能需要10秒或更长时间
解决（）；
}，延迟时间）
});
};
const delayPromise2=（数据，延迟持续时间）=>{
返回新承诺（（解决）=>{
设置超时（（）=>{
///这里需要一些代码。映射函数可能需要10秒或更长时间
解决（）；
}，延迟时间）
});
};
const delayPromise3=（数据，延迟持续时间）=>{
返回新承诺（（解决）=>{
设置超时（（）=>{
///这里需要一些代码。映射函数可能需要10秒或更长时间
解决（）；
}，延迟时间）
});
};
const delayPromise4=（数据，延迟持续时间）=>{
返回新承诺（（解决）=>{
设置超时（（）=>{
///这里需要一些代码。映射函数可能需要10秒或更长时间
解决（）；
}，延迟时间）
});
};
试一试{
控制台日志（“启动”）；
wait promise1.all（array.map（（数据，索引）=>delayPromise1（数据，索引*间隔））；
控制台日志（“完成延迟承诺1”）；
等待承诺.all（（array.map（（数据，索引）=>delayPromise2（数据，索引*间隔））；
控制台日志（“完成延迟承诺2”）；
wait Promise.all（array.map（（数据，索引）=>delayPromise3（数据，索引*间隔））；
控制台日志（“完成延迟承诺3”）；
wait promise4.all（array.map（（数据，索引）=>delayPromise4（数据，索引*间隔））；
控制台日志（“完成延迟承诺4”）；
控制台日志（“完成”）；
}捕获（e）{
控制台错误（e）；
}
};
promisesFunc（[1,2,3]）
如果要运行并行传递，则所有延迟函数都在Promise.all内传递。如果您想按顺序运行，请使用下面的命令


const promisesFunc=async（数组）=>{
设间隔=1000；
const delayPromise1=（数据，延迟持续时间）=>{
返回新承诺（（解决）=>{
设置超时（（）=>{
///这里需要一些代码。映射函数可能需要10秒或更长时间
解决（）；
}，延迟时间）
});
};
const delayPromise2=（数据，延迟持续时间）=>{
返回新承诺（（解决）=>{
设置超时（（）=>{
///这里需要一些代码。映射函数可能需要10秒或更长时间
解决（）；
}，延迟时间）
});
};
const delayPromise3=（数据，延迟持续时间）=>{
返回新承诺（（解决）=>{
设置超时（（）=>{
///这里需要一些代码。映射函数可能需要10秒或更长时间
解决（）；
}，延迟时间）
});
};
const delayPromise4=（数据，延迟持续时间）=>{
返回新承诺（（解决）=>{
设置超时（（）=>{
///这里需要一些代码。映射函数可能需要10秒或更长时间
解决（）；
}，延迟时间）
});
};
试一试{
控制台日志（“启动”）；
wait promise1.all（array.map（（数据，索引）=>delayPromise1（数据，索引*间隔））；
控制台日志（“完成延迟承诺1”）；
等待承诺.all（（array.map（（数据，索引）=>delayPromise2（数据，索引*间隔））；
控制台日志（“完成延迟承诺2”）；
wait Promise.all（array.map（（数据，索引）=>delayPromise3（数据，索引*间隔））；
控制台日志（“完成延迟承诺3”）；
wait promise4.all（array.map（（数据，索引）=>delayPromise4（数据，索引*间隔））；
控制台日志（“完成延迟承诺4”）；
控制台日志（“完成”）；
}捕获（e）{
控制台错误（e）；
}
};
promisesFunc（[1,2,3]）
我尝试过这种方法，它不会等到代码执行完成。它不是分别运行它们，而是并行运行这些函数。我尝试过这种方法，它不会等到代码执行完成。我不懂你的例子，你能用上面的代码解释更多吗？我不懂你的例子，你能用上面的代码解释更多吗？这个解决方案很好，但是如果没有，如何设置delayPromise函数的超时