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

Question

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

我现在不知道如何正确地捕捉和抛出错误。我有多个async/await函数，如果下面某个地方发生了严重错误，我希望将错误抛出到所有async函数的顶部，并停止函数的执行。

我试图抛出异常的异步/等待函数，并抓住它在目标函数，但我得到一个错误，在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);
}

（节点：13964）未处理的PromisejectionWarning:未处理的promise拒绝（拒绝id:1）：错误：getSessionID响应未定义（节点：13964）[DEP0018]弃用警告：未处理的promise拒绝已弃用。将来，未处理的promise拒绝将终止节点。具有非零退出代码的js进程。调试器已附加。

因此，我似乎不允许将异常抛出异步函数，甚至不允许在节点中promise的catch块中重新抛出异常。js？

那我怎么才能让它工作呢？我是否应该捕获异步函数中的错误，并在promise中返回错误，然后从异步函数中重试？

   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;}
}

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

我希望有人能启发我。

问候鲁维

编辑基本调用栈伪代码：

   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是一个同步函数； 如果不是，您就缺少了一个 wait [您现在已经说过了]）。使用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之前使用异步的东西，但这并不重要）：

js prettyprint-override">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);
  }
})();