Promise.prototype.catch()

Promise.prototype.catch()方法是.then(null, rejection)或.then(undefined, rejection)的别名，用于指定发生错误时的回调函数。

  1. getJSON('/posts.json').then(function(posts) {
  2.   // ...
  3. }).catch(function(error) {
  4.   // 处理 getJSON 和 前一个回调函数运行时发生的错误
  5.   console.log('发生错误！', error);
  6. });

上面代码中，getJSON()方法返回一个 Promise 对象，如果该对象状态变为resolved，则会调用then()方法指定的回调函数；如果异步操作抛出错误，状态就会变为rejected，就会调用catch()方法指定的回调函数，处理这个错误。另外，then()方法指定的回调函数，如果运行中抛出错误，也会被catch()方法捕获。

  1. p.then((val) => console.log('fulfilled:', val))
  2.   .catch((err) => console.log('rejected', err));
  4. // 等同于
  5. p.then((val) => console.log('fulfilled:', val))
  6.   .then(null, (err) => console.log("rejected:", err));

下面是一个例子。

  1. const promise = new Promise(function(resolve, reject) {
  2.   throw new Error('test');
  3. });
  4. promise.catch(function(error) {
  5.   console.log(error);
  6. });
  7. // Error: test

上面代码中，promise抛出一个错误，就被catch()方法指定的回调函数捕获。注意，上面的写法与下面两种写法是等价的。

  1. // 写法一
  2. const promise = new Promise(function(resolve, reject) {
  3.   try {
  4.     throw new Error('test');
  5.   } catch(e) {
  6.     reject(e);
  7.   }
  8. });
  9. promise.catch(function(error) {
  10.   console.log(error);
  11. });
  13. // 写法二
  14. const promise = new Promise(function(resolve, reject) {
  15.   reject(new Error('test'));
  16. });
  17. promise.catch(function(error) {
  18.   console.log(error);
  19. });

比较上面两种写法，可以发现reject()方法的作用，等同于抛出错误。

如果 Promise 状态已经变成resolved，再抛出错误是无效的。

  1. const promise = new Promise(function(resolve, reject) {
  2.   resolve('ok');
  3.   throw new Error('test');
  4. });
  5. promise
  6.   .then(function(value) { console.log(value) })
  7.   .catch(function(error) { console.log(error) });
  8. // ok

上面代码中，Promise 在resolve语句后面，再抛出错误，不会被捕获，等于没有抛出。因为 Promise 的状态一旦改变，就永久保持该状态，不会再变了。

Promise 对象的错误具有“冒泡”性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个catch语句捕获。

  1. getJSON('/post/1.json').then(function(post) {
  2.   return getJSON(post.commentURL);
  3. }).then(function(comments) {
  4.   // some code
  5. }).catch(function(error) {
  6.   // 处理前面三个Promise产生的错误
  7. });

上面代码中，一共有三个 Promise 对象：一个由getJSON()产生，两个由then()产生。它们之中任何一个抛出的错误，都会被最后一个catch()捕获。

一般来说，不要在then()方法里面定义 Reject 状态的回调函数（即then的第二个参数），总是使用catch方法。

  1. // bad
  2. promise
  3.   .then(function(data) {
  4.     // success
  5.   }, function(err) {
  6.     // error
  7.   });
  9. // good
  10. promise
  11.   .then(function(data) { //cb
  12.     // success
  13.   })
  14.   .catch(function(err) {
  15.     // error
  16.   });

上面代码中，第二种写法要好于第一种写法，理由是第二种写法可以捕获前面then方法执行中的错误，也更接近同步的写法（try/catch）。因此，建议总是使用catch()方法，而不使用then()方法的第二个参数。

跟传统的try/catch代码块不同的是，如果没有使用catch()方法指定错误处理的回调函数，Promise 对象抛出的错误不会传递到外层代码，即不会有任何反应。

  1. const someAsyncThing = function() {
  2.   return new Promise(function(resolve, reject) {
  3.     // 下面一行会报错，因为x没有声明
  4.     resolve(x + 2);
  5.   });
  6. };
  8. someAsyncThing().then(function() {
  9.   console.log('everything is great');
  10. });
  12. setTimeout(() => { console.log(123) }, 2000);
  13. // Uncaught (in promise) ReferenceError: x is not defined
  14. // 123

上面代码中，someAsyncThing()函数产生的 Promise 对象，内部有语法错误。浏览器运行到这一行，会打印出错误提示ReferenceError: x is not defined，但是不会退出进程、终止脚本执行，2 秒之后还是会输出123。这就是说，Promise 内部的错误不会影响到 Promise 外部的代码，通俗的说法就是“Promise 会吃掉错误”。

这个脚本放在服务器执行，退出码就是0（即表示执行成功）。不过，Node.js 有一个unhandledRejection事件，专门监听未捕获的reject错误，上面的脚本会触发这个事件的监听函数，可以在监听函数里面抛出错误。

  1. process.on('unhandledRejection', function (err, p) {
  2.   throw err;
  3. });

上面代码中，unhandledRejection事件的监听函数有两个参数，第一个是错误对象，第二个是报错的 Promise 实例，它可以用来了解发生错误的环境信息。

注意，Node 有计划在未来废除unhandledRejection事件。如果 Promise 内部有未捕获的错误，会直接终止进程，并且进程的退出码不为 0。

再看下面的例子。

  1. const promise = new Promise(function (resolve, reject) {
  2.   resolve('ok');
  3.   setTimeout(function () { throw new Error('test') }, 0)
  4. });
  5. promise.then(function (value) { console.log(value) });
  6. // ok
  7. // Uncaught Error: test

上面代码中，Promise 指定在下一轮“事件循环”再抛出错误。到了那个时候，Promise 的运行已经结束了，所以这个错误是在 Promise 函数体外抛出的，会冒泡到最外层，成了未捕获的错误。

一般总是建议，Promise 对象后面要跟catch()方法，这样可以处理 Promise 内部发生的错误。catch()方法返回的还是一个 Promise 对象，因此后面还可以接着调用then()方法。

  1. const someAsyncThing = function() {
  2.   return new Promise(function(resolve, reject) {
  3.     // 下面一行会报错，因为x没有声明
  4.     resolve(x + 2);
  5.   });
  6. };
  8. someAsyncThing()
  9. .catch(function(error) {
  10.   console.log('oh no', error);
  11. })
  12. .then(function() {
  13.   console.log('carry on');
  14. });
  15. // oh no [ReferenceError: x is not defined]
  16. // carry on

上面代码运行完catch()方法指定的回调函数，会接着运行后面那个then()方法指定的回调函数。如果没有报错，则会跳过catch()方法。

  1. Promise.resolve()
  2. .catch(function(error) {
  3.   console.log('oh no', error);
  4. })
  5. .then(function() {
  6.   console.log('carry on');
  7. });
  8. // carry on

上面的代码因为没有报错，跳过了catch()方法，直接执行后面的then()方法。此时，要是then()方法里面报错，就与前面的catch()无关了。

catch()方法之中，还能再抛出错误。

  1. const someAsyncThing = function() {
  2.   return new Promise(function(resolve, reject) {
  3.     // 下面一行会报错，因为x没有声明
  4.     resolve(x + 2);
  5.   });
  6. };
  8. someAsyncThing().then(function() {
  9.   return someOtherAsyncThing();
  10. }).catch(function(error) {
  11.   console.log('oh no', error);
  12.   // 下面一行会报错，因为 y 没有声明
  13.   y + 2;
  14. }).then(function() {
  15.   console.log('carry on');
  16. });
  17. // oh no [ReferenceError: x is not defined]

上面代码中，catch()方法抛出一个错误，因为后面没有别的catch()方法了，导致这个错误不会被捕获，也不会传递到外层。如果改写一下，结果就不一样了。

  1. someAsyncThing().then(function() {
  2.   return someOtherAsyncThing();
  3. }).catch(function(error) {
  4.   console.log('oh no', error);
  5.   // 下面一行会报错，因为y没有声明
  6.   y + 2;
  7. }).catch(function(error) {
  8.   console.log('carry on', error);
  9. });
  10. // oh no [ReferenceError: x is not defined]
  11. // carry on [ReferenceError: y is not defined]

上面代码中，第二个catch()方法用来捕获前一个catch()方法抛出的错误。