如何在异步/等待情况下正确实现错误处理

Question

我使用 async/await ecma6 标准，没有任何自定义库。

我目前不知道如何正确捕获和抛出错误。 我有多个 async/await 函数，如果发生严重错误以下的某个地方，我想将错误抛出到所有异步函数的顶部并停止执行该函数。

我试图从 async/await 函数中抛出异常并在目标函数中捕获它，但在 node.js 中出现错误：

    this.basicAuthLogin= async function(user)
{
    "use strict";
    const login = new Login(this.host, this.url, user, user.pw);

    //getSessionID throws error
    this.sessionID = getSessionID(result.request.response);
}

(node:13964) UnhandledPromiseRejectionWarning: 未处理的承诺 拒绝（拒绝 id：1）：错误：getSessionID 响应未定义 （节点：13964）[DEP0018] 弃用警告：未处理的承诺 拒绝被弃用。在未来，承诺拒绝是 未处理将以非零退出终止 Node.js 进程 代码。已附加调试器。

所以看来我不允许从异步函数中抛出异常，甚至在 node.js 中的 promise 的 catch 块中重新抛出异常？

那么我该如何让它工作呢？ 我是否应该在异步函数中捕获错误并在承诺中返回错误并重新抛出异步函数？

   this.basicAuthLogin= async function(user)
{
    "use strict";
    const login = new Login(this.host, this.url, user, user.pw);
   try{
    //getSessionID throws error
    this.sessionID = getSessionID(result.request.response);
   } catch(err) { return err;}
}

但这意味着在我的第一个异步函数的调用堆栈中，每个函数都需要异步，即使我并不真正需要它，我也必须等待它。

希望有人能赐教。

问候 鲁维

编辑基本调用堆栈伪代码：

   async startTest[arr]{

    for (var i = 0; i < arr.length; i++)
    {
      try {
          await runStep(arr[i];
        } catch(err) { 
            console.log(err);
            break; 
        }
      }
    }

  async runStep(step)
  {
     try {
     var userIsValid = await validateUser(step.user);
     var req = buildRequest(step.request);
     var result = await sendRequest(req);
     var verify = verifyResult();
     } catch(err){ throw err;}
  }

  async validateUser(user)
  {
     //make checks
     //
     var result = await this.authenticate(parameter).catch(err => {throw err});
     userFound = true;
   }

  function authenticate(parameter) {
  //can throw async function
   basicAuthLogin(parameter).catch(err => {throw err};

   }

  function async basicAuthLogin(parameter()
  {
   try {
    //can throw  async function
      var result = await request(parameter);
      //can throw sync function
      this.sessionID = getSessionID(response);
      //can throw   sync function
      } catch(err) { throw err; }
   }

Answer 1

async/await 的一大优点是它们使 try/catch 能够处理您的异步代码。

您的第一个basicAuthLogin 函数绝对没问题（前提是getSessionID 是一个同步 函数；如果不是，则您缺少await [你现在说是]）。 使用 basicAuthLogin 的代码必须处理它抛出的可能性（通过处理错误或允许它传播给负责处理它的调用者）。所以要么：

// In an `async` function
try {
    await this.basicAuthLogin(/*...*/);
} catch (e) {
    // Handle the fact something failed
}

或

// NOT in an `async` function:
this.basicAuthLogin(/*...*/)
    .catch(e => { /* Handle the fact something failed */ });

如果使用它的代码执行这两件事之一（或让错误传播到执行这两件事之一的代码），您将不会收到“未处理的拒绝”错误。

在回复我询问getSessionID 是否异步的评论时，您写道：

不，它不是异步的，它是一个简单的函数，它抛出一个异常，我想在调用堆栈上捕获 5 或 6 层，但似乎我不允许这样做。

这是一个活生生的例子（在我的例子中，我已经让basicAuthLogin 在getSessionID 之前使用了一些异步的东西，但这并不重要）：

const getSessionID = () => {
  throw new Error("Failed");
};
const somethingAsync = () => new Promise(resolve => {
  setTimeout(resolve, 100);
});
const basicAuthLogin = async function(user)
{
    "use strict";
    await somethingAsync();
    /*
    const login = new Login(this.host, this.url, user, user.pw);
    */

    //getSessionID throws error
    getSessionID();
};

const wrapper1 = async () => {
  await basicAuthLogin();
};
const wrapper2 = async () => {
  await wrapper1();
};
const wrapper3 = async () => {
  await wrapper2();
};

// Top-level caller
(async () => {
  try {
    await wrapper3();
  } catch (e) {
    console.log("Caught error: " + e.message);
  }
})();

规则就像它有例外一样（因为理论上这些是例外）：

1. 要么处理它（例如，try/catch），要么让它传播给调用者（通常不做任何事情），并且

2. 顶层必须处理它

规则#2 意味着当您从非async 代码转换到async 代码（通常位于堆栈顶部）时，您需要一个包装器。要么：

(async () => {
  try {
    await theFirstAsyncFunction();
    await theNextAsyncFunction();
    await aThirdAsyncFunction();
  } catch (e) {
    // handle the error
  }
})();

或

(async () => {
  await theFirstAsyncFunction();
  await theNextAsyncFunction();
  await aThirdAsyncFunction();
})().catch(e => { /* handle the error */});

当然也可以：

theFirstAsyncFunction()
.then(() => theNextAsyncFunction())
.then(() => aThirdAsyncFunction())
.catch(e => { /* handle the error */});

有一个共同点：顶层总是处理错误。