如何拒绝异步/等待语法？

我知道这是一个古老的问题，但是我偶然发现了该线程，并且错误和拒绝之间似乎存在混淆，这与经常重复使用的建议（至少在许多情况下）不使用异常处理处理预期的案件。举例说明：如果异步方法正在尝试对用户进行身份验证而身份验证失败，则表示拒绝（两种预期情况之一），而不是错误（例如，如果身份验证API不可用）。

为了确保我不仅仅是在分裂头发，我使用以下代码对三种不同的方法进行了性能测试：

const iterations = 100000;

function getSwitch() {
  return Math.round(Math.random()) === 1;
}

function doSomething(value) {
  return 'something done to ' + value.toString();
}

let processWithThrow = function () {
  if (getSwitch()) {
    throw new Error('foo');
  }
};

let processWithReturn = function () {
  if (getSwitch()) {
    return new Error('bar');
  } else {
    return {}
  }
};

let processWithCustomObject = function () {
  if (getSwitch()) {
    return {type: 'rejection', message: 'quux'};
  } else {
    return {type: 'usable response', value: 'fnord'};
  }
};

function testTryCatch(limit) {
  for (let i = 0; i < limit; i++) {
    try {
      processWithThrow();
    } catch (e) {
      const dummyValue = doSomething(e);
    }
  }
}

function testReturnError(limit) {
  for (let i = 0; i < limit; i++) {
    const returnValue = processWithReturn();
    if (returnValue instanceof Error) {
      const dummyValue = doSomething(returnValue);
    }
  }
}

function testCustomObject(limit) {
  for (let i = 0; i < limit; i++) {
    const returnValue = processWithCustomObject();
    if (returnValue.type === 'rejection') {
      const dummyValue = doSomething(returnValue);
    }
  }
}

let start, end;
start = new Date();
testTryCatch(iterations);
end = new Date();
const interval_1 = end - start;
start = new Date();
testReturnError(iterations);
end = new Date();
const interval_2 = end - start;
start = new Date();
testCustomObject(iterations);
end = new Date();
const interval_3 = end - start;

console.log(`with try/catch: ${interval_1}ms; with returned Error: ${interval_2}ms; with custom object: ${interval_3}ms`);

由于我对Javascript解释器的不确定性，其中包含了其中的一些内容（我只喜欢一次钻一个兔子洞）。例如，我包含了该doSomething函数并为其分配了返回值，dummyValue以确保不会对条件块进行优化。

我的结果是：

with try/catch: 507ms; with returned Error: 260ms; with custom object: 5ms

我知道在很多情况下寻找小小的优化是不值得的，但是在大型系统中，这些事情会产生很大的累加差异，这是一个非常鲜明的比较。

如此…虽然我认为在您期望必须处理异步功能内不可预测的错误的情况下，可以接受的答案的方法是合理的，但在拒绝仅意味着“您将必须使用计划B（或C或D…）“，我想我的首选是拒绝使用自定义响应对象。