两个异步函数和第三个函数在前两个函数执行后执行

Question

说，我有三个 javascript 函数

function1和function2异步执行
function2在前两个执行完后执行

如何解决？

Answer 1

您可以使用 Promise.all() (see here)

来自 MDN 的示例：

var promise1 = Promise.resolve(3);
var promise2 = 42;
var promise3 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3]).then(function(values) {
  console.log(values);
});
// expected output: Array [3, 42, "foo"]

Answer 2

const promise1 = fn1();
const promise2 = fn2();

Promise.all([promise1, promise2])
  .then(values => {
    // Your code
});

对于 async/await，您必须将 fn1 和 fn2 声明为异步，然后：

const promise1 = await fn1();
const promise2 = await fn2();

// Now the two vars contain resolved promises

async/await 可能更具可读性，但它会花费更多时间，因为 fn2() 在 fn1() 的承诺完成之前不会执行。在 Promise.all 的第一个示例中，两个函数是并行调用的，因此性能会稍微好一些。

如果您想了解更多信息，请查看 Jake Archibald 关于 async/await 的这篇精彩文章：https://developers.google.com/web/fundamentals/primers/async-functions

Answer 3

承诺链或异步等待关键字的想法应该适合您。请参阅下面的承诺链接示例。

新承诺（函数（解决，拒绝）{

}).then(函数(结果){

});

Answer 4

您可以像这样链接承诺：

function f1() {
            return new Promise(function(resolve) {
                setTimeout(() => resolve('f1'), 1000);
            });
        }
        function f2() {
            return new Promise(function(resolve) {
                setTimeout(() => resolve('f2'), 1000);
            });
        }
        function f3() {
            return new Promise(function(resolve) {
                setTimeout(() => resolve('f3'), 1000);
            });
        }

// Chain promises
        f1()
          .then((res) => {
            console.log(res + ' done!')
            return f2()
          })
          .then((res) => {
            console.log(res + ' done!')
            return f3()
          })
          .then((res) => {
            console.log(res + ' done!')
          })

或者您可以对承诺进行分组：

        function f1() {
            return new Promise(function(resolve) {
                setTimeout(() => resolve('f1'), 1000);
            });
        }
        function f2() {
            return new Promise(function(resolve) {
                setTimeout(() => resolve('f2'), 1000);
            });
        }
        function f3() {
            return new Promise(function(resolve) {
                setTimeout(() => resolve('f3'), 1000);
            });
        }
        
// Group promises
        Promise.all([f1(), f2()])  
          .then((responses) => {
            console.log(responses.join(', ') + ' done!')
            return f3()
          })
          .then((res) => {
            console.log(res + ' done!')
          })

Answer 5

谢谢大家。我尝试了你所有的解决方案。不太奏效。尝试了一段时间后，我自己创建了一个解决方案。这是：

let promise1 = new Promise(function(resolve, reject) {
  setTimeout(() => resolve("promise1"), 1000);
});

let promise2 = new Promise(function(resolve, reject) {
  setTimeout(() => resolve("promise2"), 4000);
});

Promise.all([promise1, promise2])
.then(result => {
  console.log(result);
});

它创建了两个函数，运行将这两个函数作为 resolve。然后在数组中传给Promise.all，第三个函数可以在Promise.all.

的then块中运行

两个异步函数和第三个函数在前两个函数执行后执行

Two asynchronous functions and third function to be executed after first two is executed

javascript

function

promise

ecmascript-6

es6-promise