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

我现在不知道如何才能正确捕获和抛出错误。 我有多个异步/等待函数，如果低于严重错误的某处发生我想将错误抛出到所有异步函数的顶部并停止执行该函数。

我试图从 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: Unhandled promise rejection (rejection id: 1): Error: getSessionID response is undefined (node:13964) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code. Debugger attached.

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

那么我该如何让它工作呢？ 我是否应该在异步函数中捕获错误并在 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; }
   }

最佳答案

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 是否异步的评论，您写道:

No it is not async it is a simple function that throws an exception that I want to catch 5 or 6 floors up the call stack but it seems I am not allowed to do that.

这是一个实际的例子(在我的例子中，我已经让 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);
  }
})();

规则就像异常(exception)一样(因为理论上这些是异常(exception)):

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 */});

共同点是:顶层总是处理错误。

关于javascript - 如何在异步/等待情况下正确实现错误处理，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48685872/