javascript - 如何避免显式构造反模式并仍然保持缩进/回调较低

Question

假设我们有一个函数，它调用大量异步函数，如下所示:

downloadAndAssemble = () => 
  new Promise(async (resolve, reject) => {

    if (!(await checkAvailableDiskSpace())) {
      resolve(false);
      return;
    }

    try {
      // Download all
      let files  = await this.downloadAll();

      // Assemble File from downloaded snippets.
      const assembledFile = await buildFile(files).catch(error => reject(error));

      // Save assembled file.
      resolve(true);
    } catch (err) {
      reject(err);
    } finally {
      const dirExists = await fs.exists(tmpFolderPath);
      if (dirExists) await fs.unlink(tmpFolderPath);
    }
  });

我看到的第一个问题是 new Promise(async (resolve,reject) => { ，即 an anti pattern according to this SO article 。

我从那篇文章中得到的总体想法是重用 Promise(如果可用)，而不是创建新的 Promise。

如果我遵循suggestions in this SO answer我应该在函数的逻辑流程中使用 .then 和 .catch 来利用现有的 Promises。

但这会导致更多的缩进(即每个使用的 promise 一个)，我认为 promise 应该有助于消除这种情况。

正如您从 .catch(error =>reject(error)) 中看到的，该代码与处理其中包含的 Promise 抛出的错误不太一致。

Answer 1

  downloadAndAssemble = async () =>  {
    if (!(await checkAvailableDiskSpace())) {
      return false;
    }

     try {
       // Download all
       let files  = await this.downloadAll();

       // Assemble File from downloaded snippets.
       const assembledFile = await buildFile(files);

      // Save assembled file.
      return true;
    } finally {
       const dirExists = await fs.exists(tmpFolderPath);
       if (dirExists) await fs.unlink(tmpFolderPath);
    }
};

如果你调用一个async函数，它会在后台隐式地为你创建一个promise，如果你返回，它就会解析；如果你抛出<，它就会拒绝，因此无需“手动”创建和管理 Promise。

.catch(error =>reject(error)) 没有什么意义，因为 await 会自动让错误冒出来。在您的代码中，这会绕过可能不需要的 try { ... } catch { ... } 。

这同样适用于} catch (err) {reject(err); }，await 就是您所需要的。