Блог

Я пытаюсь объединить два значения функции (от a() и b() ), но код не ожидает оператора await в функции test , как ожидалось. Вместо этого значение результата выводит непосредственно неправильный результат.

 function resData(status, message) {
  return { ok: status, message: message };
}

function a() { 
  return resData(true, 'A'); 
}

async function b() {
  // simulate some long async task (e.g. db call) and then return the boolean result
  function sleep(ms) {
    return new Promise((resolve) => {
      setTimeout(resolve, ms);
  }); }
  await sleep(2500);
  return resData(true, 'B');
}

async function isValid() {
  const promises = [a, b].map(async (fnc) => { return await fnc().ok; });
  const results = await Promise.all(promises);
  // combine the results to one boolean value
  return results.every(Boolean);
}

async function test() {
  // not waiting here
  const res = await isValid();
  // prints directly - wrong result false
  console.log('result', res);
}

test(); 

После вывода неправильного результата он ждет 2,5 секунды. Я думаю , что это связано с вызовом функции resData , но я не мог понять сам, где мое непонимание асинхронности / ожидания. Заранее спасибо.

Вместо того, чтобы ждать разрешения функции, вы ожидаете возврата значения функцией.

 async function isValid() {
  const promises = [a, b].map(async (fnc) => {

    //return await fnc().ok;
    // You have to await first function then call `.ok` value
     return (await fnc()).ok;
  });
  const results = await Promise.all(promises);
  // combine the results to one boolean value
  return results.every(Boolean);
}
 

Просто чтобы упростить проблему, пожалуйста, проверьте приведенный ниже код.

 async function test() {
  return { ok: true };
}
async function main() {
  // trying to await on undefined.. test().ok == undefined
  console.log(await test().ok); // undefined
  // first await function.. then return ok
  console.log((await test()).ok); // true
}
main();
 

Я бы сказал, что есть 2 1 проблема с вашим кодом

1. a не возвращал обещание, так что вы не можете относиться к нему как к одному — игнорировать, оказывается, можно, кто же знал!
2. Вы не можете дождаться логического значения, поэтому await fnc().ok в этом нет смысла.

Я бы предложил вам

1. a Дайте обещание вернуть, даже если это всего лишь решенное обещание
2. Выполните только методы в map
3. Прочитайте значение ok в every вызове, чтобы определить, разрешены ли все обещания с этим значением, равным true

С этими изменениями все работает так, как я подозреваю, вы ожидали, с 2,5-секундным ожиданием перед записью на консоль.

 function resData(status, message) {
  return { ok: status, message: message };
}

function a() { 
  return resData(true, 'A'); 
}

async function b() {
  // simulate some long async task (e.g. db call) and then return the boolean result
  function sleep(ms) {
    return new Promise((resolve) => {
      setTimeout(resolve, ms);
  }); }
  await sleep(2500);
  return resData(true, 'B');
}

async function isValid() {
  const promises = [a, b].map(fnc => fnc());
  const results = await Promise.all(promises);
  // combine the results to one boolean value
  return results.every(x => x.ok);
}

async function test() {
  // not waiting here
  const res = await isValid();
  // prints directly - wrong result false
  console.log('result', res);
}

test(); 

Асинхронные функции неявно возвращают обещание, которое в конечном итоге будет разрешено до конечного значения, возвращаемого по окончании выполнения функции.

Таким образом, вам просто нужно вызвать свои функции внутри map обратного вызова, чтобы собрать обещания. Массив результатов будет представлять собой массив resData объектов. Итак, вы, наконец, проверяете каждое ok свойство на соответствие вашим требованиям.

 function sleep(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

function resData(status, message) {
  return {ok: status, message: message};
}

function a() { 
  return resData(true, 'A'); 
}

async function b() {
  await sleep(2500);
  return resData(true, 'B');
}

async function isValid() {
  const promises = [a, b].map((fnc) => fnc());
  const results = await Promise.all(promises);
  return results.every((result) => result.ok);
}

async function test() {
  const res = await isValid();
  console.log('result', res);
}

test();