JavaScript承诺-拒绝与抛出

我已经阅读了几篇有关该主题的文章，但是我仍然不清楚Promise.reject与抛出错误之间是否存在区别。例如，

使用Promise.reject

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            return Promise.reject(new PermissionDenied());
        }
    });

使用抛出

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            throw new PermissionDenied();
        }
    });

我倾向于仅使用throw它，因为它更短，但我想知道一个相对于另一个是否有任何优势。

使用一个相对于另一个没有优势，但是，在特定情况下throw无法使用。但是，这些情况可以解决。

每当您进入promise回调时，都可以使用throw。但是，如果您在任何其他异步回调中，则必须使用reject。

例如，这不会触发捕获：

new Promise(function() {
  setTimeout(function() {
    throw 'or nah';
    // return Promise.reject('or nah'); also won't work
  }, 1000);
}).catch(function(e) {
  console.log(e); // doesn't happen
});

相反，您将面临未解决的承诺和未捕获的异常。在这种情况下，您可能会改为使用reject。但是，您可以通过两种方式解决此问题。

1. 通过使用超时内的原始Promise拒绝功能：

new Promise(function(resolve, reject) {
  setTimeout(function() {
    reject('or nah');
  }, 1000);
}).catch(function(e) {
  console.log(e); // works!
});

2. 通过通知超时：

function timeout(duration) { // Thanks joews
  return new Promise(function(resolve) {
    setTimeout(resolve, duration);
  });
}

timeout(1000).then(function() {
  throw 'worky!';
  // return Promise.reject('worky'); also works
}).catch(function(e) {
  console.log(e); // 'worky!'
});

另一个重要的事实是，reject() 并不像一个终止控制流return语句一样。相反，throw确实终止了控制流。

例：

new Promise((resolve, reject) => {
  throw "err";
  console.log("NEVER REACHED");
})
.then(() => console.log("RESOLVED"))
.catch(() => console.log("REJECTED"));

与

new Promise((resolve, reject) => {
  reject(); // resolve() behaves similarly
  console.log("ALWAYS REACHED"); // "REJECTED" will print AFTER this
})
.then(() => console.log("RESOLVED"))
.catch(() => console.log("REJECTED"));

是的，最大的不同是拒绝是一个在承诺被拒绝后执行的回调函数，而throw不能异步使用。如果您选择使用拒绝，您的代码将继续以异步方式正常运行，而throw将优先完成解析器功能（此功能将立即运行）。

我见过的一个可以帮助我弄清楚问题的示例是，您可以设置带有拒绝的Timeout函数，例如：

new Promise(_, reject) {
 setTimeout(reject, 3000);
});

上面不可能用throw编写。

在您的小示例中，两者之间的区别难以区分，但是当处理更复杂的异步概念时，两者之间的区别可能会非常大。

TLDR： 当函数有时返回一个 Promise 并抛出异常时，它很难使用。编写异步函数时，最好通过返回被拒绝的承诺来表示失败

您的特定示例混淆了它们之间的一些重要区别：

因为您是在 promise链中处理错误，所以抛出的异常会自动转换为拒绝的promise。这可以解释为什么它们似乎可以互换-不能互换。

考虑以下情况：

checkCredentials = () => {
    let idToken = localStorage.getItem('some token');
    if ( idToken ) {
      return fetch(`https://someValidateEndpoint`, {
        headers: {
          Authorization: `Bearer ${idToken}`
        }
      })
    } else {
      throw new Error('No Token Found In Local Storage')
    }
  }

这将是一种反模式，因为您将需要同时支持异步和同步错误情况。它可能看起来像：

try {
  function onFulfilled() { ... do the rest of your logic }
  function onRejected() { // handle async failure - like network timeout }
  checkCredentials(x).then(onFulfilled, onRejected);
} catch (e) {
  // Error('No Token Found In Local Storage')
  // handle synchronous failure
} 

不好，这正是Promise.reject救援（在全球范围内可用）并有效地与救援区别开的地方throw。重构现在变为：

checkCredentials = () => {
  let idToken = localStorage.getItem('some_token');
  if (!idToken) {
    return Promise.reject('No Token Found In Local Storage')
  }
  return fetch(`https://someValidateEndpoint`, {
    headers: {
      Authorization: `Bearer ${idToken}`
    }
  })
}

现在，您可以仅使用一种catch()来解决网络故障，并使用同步错误检查来缺少令牌：

checkCredentials()
      .catch((error) => if ( error == 'No Token' ) {
      // do no token modal
      } else if ( error === 400 ) {
      // do not authorized modal. etc.
      }

一个例子来尝试。只需将isVersionThrow更改为false即可使用拒绝而不是引发。

const isVersionThrow = true

class TestClass {
  async testFunction () {
    if (isVersionThrow) {
      console.log('Throw version')
      throw new Error('Fail!')
    } else {
      console.log('Reject version')
      return new Promise((resolve, reject) => {
        reject(new Error('Fail!'))
      })
    }
  }
}

const test = async () => {
  const test = new TestClass()
  try {
    var response = await test.testFunction()
    return response 
  } catch (error) {
    console.log('ERROR RETURNED')
    throw error 
  }  
}

test()
.then(result => {
  console.log('result: ' + result)
})
.catch(error => {
  console.log('error: ' + error)
})