Цепочка обещаний в javascript с вызовами ajax

Question

У меня есть функция (f1), которую я хочу вызвать только после двух вызовов ajax (скажем, a1 и a2).a2 следует вызывать только после завершения a1.Ниже приведена последовательность операций =

$.when(a1 and a2) {
   f1
}

Я попробовал следующий фрагмент кода -

$.when(a1a2()).done(function(){
  f1();
}

var a1a2 = function(){
  return $.when(a1()).done(function() {
    if (<check for a few variables a1 sets>) {
      // another ajax call for which f1 should wait
      return a2();
    } else {
      // random function for which f1 shouldn't wait
      f2();
    }
  });
}

В приведенном выше коде f1 ожидает завершения a1, но не ожидаета2 до финиша.

Я также попробовал следующий фрагмент кода (но он также просто ждет завершения a1) -

var a1a2 = function(){
  var retVal = new Promise(function(){
    a1().then(function(){
      if (<check for a few variables a1 sets>) {
        return a2();
      } else {
        // random function for which f1 shouldn't wait
        f2();
      }
    });
  });
}

Я смотрел на другие подобные вопросы, но не смог найти решение,Может кто-нибудь помочь, пожалуйста?

Answer 1

Прежде всего, ваш код Promise неисправен, потому что вы не создаете Promise правильно

new Promise(function(resolve, reject) {
    // in here you call resolve or reject otherwise Promise is forever pending
});

Однако, поскольку a1 возвращает Promise (как и все функции, япри условии, что вам не нужно создавать обещание

Итак, ваш код будет

a1()
.then(function() {
    if (somecondition == true) {
        return a2();
    } else {
        f2(); // since there's no return here, there's no "wait" for the promise f2 returns
    }
})
.then(function() {
    return f1();
})

Чтобы проиллюстрировать вышесказанное, вот ваш код один раз с условием true, а затем с условием false

Обратите внимание на «временные метки» для вывода на консоль

// dummy code to set up some promises
const dummy = (x, d=1000) => {
    console.log(performance.now(), 'start', x);
    return new Promise(resolve => setTimeout(() => {
        console.log(performance.now(), 'end', x);
        resolve(x);
    }, d));
};

const a1 = () => dummy('a1');
const a2 = () => dummy('a2');
const f1 = () => dummy('f1');
const f2 = () => dummy('f2', 3000);

// end dummy code

console.log('wait for a2');
a1()
.then(function() {
    if (true) {
        return a2();
    } else {
        // random function for which f1 shouldn't wait
        f2();
    }
})
.then(function() {
    return f1();
})
.then(() => {
    console.log('dont wait for f2');
    a1()
    .then(function() {
        if (false) {
            return a2();
        } else {
            // random function for which f1 shouldn't wait
            f2();
        }
    })
    .then(function() {
        f1();
    });
});

Однако!Если f2 - функция, которая не имеет асинхронности, то нет способа ^* предотвратить вызов f1 после завершения f2 - потому что именно так работает javascript

^* - Полагаю, вы могли бы поместить его в setTimeout, тогда f2 будет выполняться после начала f1 (опять-таки, если f1 имеет некоторую асинхронность, иначе f2 начнется после окончания f1)

Answer 2

Позвоните a1, чтобы получить Обещание, затем позвоните Promise.all на a1 и a1, прикованным a2:

const a1Prom = a1();
Promise.all([
  a1Prom,
  a1Prom.then(a2)
])
  .then(f1);

console.log('script start');

const delay = ms => new Promise(res => setTimeout(res, ms));
const a1 = () => delay(1000).then(() => console.log('a1 done'));
const a2 = () => {
  console.log('a2 starting');
  return delay(1000).then(() => console.log('a2 done'));
};

const f1 = () => console.log('f1 starting');



const a1Prom = a1();
Promise.all([
  a1Prom,
  a1Prom.then(a2)
])
  .then(f1);

Answer 3

function a1() {
  return new Promise(resolve => { 
     resolve();
  });
}

function a2() {
  return new Promise(resolve => {
    resolve();
  });
}

function f1() {
  // this runs when the a1 and a2 is resolved.
}

// this is the call method. there are so many approach in your question first is chaining of promise.
function CallMethod(){
   a1().then(function () { // you can optionally pass data here via the resolve in the promise
      return a2();
   }).then(function () { // same here you can pass optional data here.
      // here the a1 and a2 is resolved you can call the f1() now.
      f1();
   });
}
// second one is called Promise.all()
function CallMethod() {
  Promise.all([a1(), a2()]).then(data => { // this is the optional data passed in the resolve base on the index of the function promises. 
     var firstResolve = data[0]; // resolved data of a1();
     var secondResolve = data[1]; // resolved data of a2();
  })
}

Answer 4

Я не знаком с синтаксисом when / done, но это исправление для вашего второго фрагмента.Большой совет, который я бы дал, заключается в том, что использование new Promise в 90% случаев является плохой идеей.

var a1a2 = function(){
  var retVal = a1().then(function(){
    if (<check for a few variables a1 sets>) {
      return a2();
    } else {
      // random function for which f1 shouldn't wait
      f2();
    }
  });
});