从可能是异步的回调中捕获并返回错误

Question

我有这样的功能：

const x = y(callback);
x();

可以通过同步或异步回调调用：

const a = y(() => 42);
const b = y(async () => Promise.resolve(42));

函数y 应该接受一个回调，它可以是同步的或异步的。是否可以从同步或异步回调中捕获抛出的错误？

我不能简单地将回调包装在 try/catch 中：

const y = (callback) => function () {
  try {
    return callback(...arguments);
  }
  catch (callbackError) {
    throw callbackError;
  }
};

因为它没有捕捉到 Promise 抛出的错误。我不能只将.catch 链接到回调，因为它可能不是一个承诺。

我读过在调用函数may not trivial/may not be possible之前检查函数是否是一个承诺。

在将catch 链接到它之前，我不能调用它来检查它是否返回一个承诺，因为如果它抛出，catch 将不会被链接到调用上

有没有办法从可能是也可能不是承诺的回调中捕获错误？

---

根据 cmets，我应该指定我不希望函数返回承诺。那就是：

const a = y(() => { throw new Error(); })();
console.log(a instanceof Error);

const b = y(async () => { throw new Error(); })();
console.log(b instanceof Error);

const c = y(() => 42)();
console.log(c === 42);

const d = y(async () => Promise.resolve(42))();
console.log(d instanceof Promise);

应该都是真的。简单来说就是想返回错误或者结果

Answer 1

一个异步函数也会发出一个promise，你可以考虑将异步包装在一个promise中，它在解析时会发出值

Answer 2

意识到没有必要立即链接catch！所以下面的可憎让我确定它是否是一个承诺并相应地处理错误：

const y = (error, callback) => function () {
  try {
    const returnValue = callback(...arguments);

    if (returnValue instanceof Promise) {
      return returnValue.catch((callbackError) => {
        return callbackError;
      });
    }
    else {
      return returnValue;
    }
  }
  catch (callbackError) {
    return callbackError;
  }
};

如果您想知道为什么这个函数很有用，这里有一个我使用它的例子。它会在返回之前修改错误（将其与另一个错误链接，请参阅VError）：

const y = (error, callback) => function () {
  try {
    const returnValue = callback(...arguments);

    if (returnValue instanceof Promise) {
      return returnValue.catch((callbackError) => {
        throw VError(error, callbackError);
      });
    }
    else {
      return returnValue;
    }
  }
  catch (callbackError) {
    throw VError(error, callbackError);
  }
};

请注意根据问题返回以下内容：

const a = y(() => 42)(); // returns '42'
const b = y(async () => Promise.resolve(42))(); // returns 'Promise {42}'
const c = y(() => { throw new Error('Base'); })(); // throws VError
const d = y(async () => { throw new Error('Base'); })(); // throws VError

Answer 3

您可以在此处使用async/await 表示法。 Await 将与同步和异步函数一起使用。

尝试做：

async function init() {
  const x = y( async () => await callback() );
  try {
    await x();
  }
  catch(error) {
    /.../
  }
}

您的功能现在可以简化为：

const y = (callback) => function (...argument) {
    return callback(...arguments); 
};

Answer 4

好吧，您可以通过使所有代码异步来做类似的事情...如果我解决了您的问题。

UPD：了解问题，这是我的方法

(async () => {

  // Run fn
  const fn = callback => {
    return new Promise(async (resolve, reject) => {
        const res = await callback().catch(err => reject(err));
        // Resolve
        resolve(res);
    });
  };

  const variousFNs = [
    // Function 1
    {
      fn: () => 2+2
    },
    // Function 2 with error
    {
      fn: () => {
        const x = 1;
        x = 2;
        return x;
      }
    },
    // Promise Function 3
    {
      fn: () => Promise.resolve(8)
    },
    // Promise function 4 with error
    {
      fn: () => new Promise(async (resolve, reject) => reject('some promise error'))
    }
  ];
  
  //
  //
  // Run all your fns
  for (let i = 0; i < variousFNs.length; i++) {
    try {
      const res = await variousFNs[i].fn();
      console.log(res);
    } catch(err) {
      console.log(`Error catched: ${err}`);
    }
  }

})();