где вы получаете обещания, а затем отдельно ждите их; вместо этого используйтеPromise.all (по крайней мере на данный момент):

const [value1, value2] = await Promise.all([getValue1Async(), getValue2Async()]);

Пока ваше решениеделает запустить две операции параллельно, он не будет обрабатывать отклонение должным образом, если оба обещания отклоняют.

Ваше решение запускает их параллельно, но всегда ждет завершения первого, а затем ожидания второго.Если вы просто хотите запустить их, запустить их параллельно и получить оба результата, это нормально. (Нет, продолжайте читать ...) Обратите внимание, что если на выполнение первой (скажем) пяти секунд уходит, а во-вторых, происходит сбой в течение одной секунды, ваш код будет ждать полные пять секунд, а затем произойдет сбой.

К сожалению, в настоящее время нетawait синтаксис для параллельного ожидания, так что у вас есть неловкость, которую вы перечислили, илиPromise.all, (Там жебыло обсуждениеawait.all или похожие, хотя; возможно когда-нибудь.)

Promise.all версия:

const [value1, value2] = await Promise.all([getValue1Async(), getValue2Async()]);

... что более кратко, и также не ожидает завершения первой операции, если вторая не удалась быстро (например, в моем примере пять секунд / одна секунда выше, вышеприведенное будет отклонено через одну секунду, а не ждать пять) , Также обратите внимание, что в исходном коде, если второе обещание отклоняется до того, как первое обещание разрешается, вы вполне можете получить ошибку «необработанное отклонение» в консоли (в настоящее время вы используете Chrome v61), хотя эта ошибка может быть ложной (поскольку выделать, в конце концов, справиться с отказом). Но еслиобе отклонения обещаний, вы получите подлинную необработанную ошибку отклонения, потому что поток контроля никогда не достигаетconst value2 = await p2; и, таким образом, отклонение p2 никогда не обрабатывается.

Необработанные отклонения - это плохая вещь ™ (настолько, что скоро NodeJS прервет процесс на действительно необработанных отклонениях, точно так же, как необработанные исключения - потому что это то, чем они являются), поэтому лучше избегать «получите обещание»await это "образец в вашем вопросе.

Вот пример разницы во времени в случае сбоя (при использовании 500 мс и 100 мс, а не 5 секунд и 1 секунда), и, возможно, также, возможно, ложная необработанная ошибка отклонения (откройтереальный консоль браузера, чтобы увидеть это):

const getValue1Async = () => {
  return new Promise(resolve => {
    setTimeout(resolve, 500, "value1");
  });
};
const getValue2Async = () => {
  return new Promise((resolve, reject) => {
    setTimeout(reject, 100, "error");
  });
};

// This waits the full 500ms before failing, because it waits
// on p1, then on p2
(async () => {
  try {
    console.time("separate");
    const p1 = getValue1Async();
    const p2 = getValue2Async();
    const value1 = await p1;
    const value2 = await p2;
  } catch (e) {
    console.error(e);
  }
  console.timeEnd("separate");
})();

// This fails after just 100ms, because it doesn't wait for p1
// to finish first, it rejects as soon as p2 rejects
setTimeout(async () => {
  try {
    console.time("Promise.all");
    const [value1, value2] = await Promise.all([getValue1Async(), getValue2Async()]);
  } catch (e) {
    console.timeEnd("Promise.all", e);
  }
}, 1000);

Open the real browser console to see the unhandled rejection error.

И здесь мы отвергаем обаp1 а такжеp2, что приводит к не поддельной необработанной ошибке отклонения наp2:

const getValue1Async = () => {
  return new Promise((resolve, reject) => {
    setTimeout(reject, 500, "error1");
  });
};
const getValue2Async = () => {
  return new Promise((resolve, reject) => {
    setTimeout(reject, 100, "error2");
  });
};

// This waits the full 500ms before failing, because it waits
// on p1, then on p2
(async () => {
  try {
    console.time("separate");
    const p1 = getValue1Async();
    const p2 = getValue2Async();
    const value1 = await p1;
    const value2 = await p2;
  } catch (e) {
    console.error(e);
  }
  console.timeEnd("separate");
})();

// This fails after just 100ms, because it doesn't wait for p1
// to finish first, it rejects as soon as p2 rejects
setTimeout(async () => {
  try {
    console.time("Promise.all");
    const [value1, value2] = await Promise.all([getValue1Async(), getValue2Async()]);
  } catch (e) {
    console.timeEnd("Promise.all", e);
  }
}, 1000);

Open the real browser console to see the unhandled rejection error.

В комментарии вы спросили:

Дополнительный вопрос: будет ли следующая сила ждать обоих (и отбрасывать результаты)await p1 && await p2?

При отклонении обещания возникают те же проблемы, что и в исходном коде:p1 разрешается, даже еслиp2 отклоняет ранее; это может привести к ошибочной необоснованной ошибке отклонения, еслиp2 отвергает раньшеp1 решает; и он генерирует подлинную необработанную ошибку отклонения, если обаp1 а такжеp2 отклонить (потому чтоp2Отклонение никогда не обрабатывается).

Вот тот случай, когдаp1 решает иp2 отвергает:

const getValue1Async = () => {
  return new Promise(resolve => {
    setTimeout(resolve, 500, false);
  });
};
const getValue2Async = () => {
  return new Promise((resolve, reject) => {
    setTimeout(reject, 100, "error");
  });
};

(async () => {
  try {
    const p1 = getValue1Async();
    const p2 = getValue2Async();
    console.log("waiting");
    await p1 && await p2;
  } catch (e) {
    console.error(e);
  }
  console.log("done waiting");
})();

Look in the real console (for the unhandled rejection error).

... и где оба отвергают:

const getValue1Async = () => {
  return new Promise((resolve, reject) => {
    setTimeout(reject, 500, "error1");
  });
};
const getValue2Async = () => {
  return new Promise((resolve, reject) => {
    setTimeout(reject, 100, "error2");
  });
};

(async () => {
  try {
    const p1 = getValue1Async();
    const p2 = getValue2Async();
    console.log("waiting");
    await p1 && await p2;
  } catch (e) {
    console.error(e);
  }
  console.log("done waiting");
})();

Look in the real console (for the unhandled rejection error).