Две асинхронные функции и третья функция, которая будет выполнена после выполнения первых двух

Question

Скажем, у меня есть три функции javascript

1. function1 и function2 выполняются асинхронно
2. function2 выполняется после того, как первые две выполнены полностью

Как это можно решить?

Answer 1

Спасибо всем. Я перепробовал все ваши решения. Не совсем сработало. Я создал решение сам после попытки на некоторое время. Вот оно:

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);
});

Создает две функции, которые запускают две функции как разрешение. Затем он передается в Promise.all в виде массива, а третья функция может быть запущена в тогдашнем блоке Promise.all.

Answer 2

Вы можете связать обещания следующим образом:

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 3

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 две функции вызываются параллельно, и поэтому он будет немного более производительным.

Посмотрите эту замечательную статью Джейка Арчибальда о async/await, если хотите узнать больше: https://developers.google.com/web/fundamentals/primers/async-functions

Answer 4

Идея создания цепочки обещаний или асинхронных ожиданий должна работать на вас. Ниже приведен пример цепочки обещаний.

new Promise (функция (решите, отклоните) {

}). Then (функция (результат) {

}). Then (функция (результат) {

}). затем (функция (результат) {

});

Answer 5

Вы можете сделать это с Promise.all () ( см. Здесь )

Пример из 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"]