catch 不会中断 promise ，可以继续向后传。

  1. function resolvePromise(promise2, x, resolve, reject) {
  2.   if (promise2 === x) {
  3.     return reject(new TypeError('循环引用'));
  4.   }
  5.   if (x !== null && (typeof x === 'object' || typeof x === 'function')) {
  6.     let called; // 防止被多次调用 resolve  reject
  7.     try { // 防止取then是出现异常 Object.defineProperty
  8.       let then = x.then; // 取x的then方法 {then:{}}
  9.       if (typeof then === 'function') { // 如果then是函数我就认为 x 是个promise
  10.         // call 第一个参数是 this ，后面的是成功的回调和失败的回调
  11.         then.call(x, y => { // 如果y是promise就继续递归解析promise
  12.           if (called) return;
  13.           called = true;
  14.           /*
  15.           p.then(()=>{
  16.             return new Promise((resolve,reject)=>{
  17.               resolve(new Promise())
  18.             })
  19.           })
  20.           */
  21.           resolvePromise(promise2, y, resolve, reject);
  22.         }, r => { // 只要失败了就失败了
  23.           if (called) return;
  24.           called = true;
  25.           reject(r);
  26.         });
  27.       } else { // then是一个普通对象，就直接成功即可1
  28.         resolve(x);
  29.       }
  30.     } catch (e) {
  31.       if (called) return;
  32.       called = true;
  33.       reject(e);
  34.     }
  35.   } else { // x = 123
  36.     resolve(x); // x就是一个普通值
  37.   }
  38. }
  40. class Promise {
  41.   constructor(executor) {
  42.     this.status = 'pending';
  43.     this.value = undefined;
  44.     this.reason = undefined;
  45.     this.onResolvedCallbacks = [];
  46.     this.onRejectedCallbacks = [];
  47.     let resolve, reject
  48.     resolve = (data) => {
  49.       // 如果 resolve 里面是一个 Promise ，注册then里面的方法。
  50.       if(value instanceof Promise){
  51.         return value.then(resolve,reject)
  52.       }
  53.       if (this.status === 'pending') {
  54.         this.value = data;
  55.         this.status = 'resolved';
  56.         this.onResolvedCallbacks.forEach(fn => fn());
  57.       }
  58.     }
  59.     reject = (reason) => {
  60.       if (this.status === 'pending') {
  61.         this.reason = reason;
  62.         this.status = 'rejected';
  63.         this.onRejectedCallbacks.forEach(fn => fn());
  64.       }
  65.     }
  66.     try {
  67.       executor(resolve, reject);
  68.     } catch (e) {
  69.       reject(e);
  70.     }
  71.   }
  73.   then(onFulFilled, onRejected) {
  74.     // 值的穿透 p.then().then().then(data=>{console.log(data)})
  75.     onFulFilled = typeof onFulFilled === 'function' ? onFulFilled : y => y;
  76.     onRejected = typeof onRejected === 'function' ? onRejected : err => { throw err; };
  77.     let promise2;
  79.     if (this.status === 'resolved') {
  80.       promise2 = new Promise((resolve, reject) => {
  81.         setTimeout(() => {
  82.           try {
  83.             let x = onFulFilled(this.value);
  84.             resolvePromise(promise2, x, resolve, reject);
  85.           } catch (e) {
  86.             reject(e);
  87.           }
  88.         }, 0);
  89.       });
  90.     }
  92.     if (this.status === 'rejected') {
  93.       promise2 = new Promise((resolve, reject) => {
  94.         setTimeout(() => {
  95.           try {
  96.             let x = onRejected(this.reason);
  97.             resolvePromise(promise2, x, resolve, reject)
  98.           } catch (e) {
  99.             reject(e);
  100.           }
  101.         }, 0);
  102.       });
  103.     }
  105.     if (this.status === 'pending') {
  106.       promise2 = new Promise((resolve, reject) => {
  107.         this.onResolvedCallbacks.push(() => {
  108.           setTimeout(() => {
  109.             try {
  110.               let x = onFulFilled(this.value);
  111.               resolvePromise(promise2, x, resolve, reject)
  112.             } catch (e) {
  113.               reject(e);
  114.             }
  115.           }, 0)
  116.         });
  117.         // 存放失败的回调
  118.         this.onRejectedCallbacks.push(() => {
  119.           setTimeout(() => {
  120.             try {
  121.               let x = onRejected(this.reason);
  122.               resolvePromise(promise2, x, resolve, reject);
  123.             } catch (e) {
  124.               reject(e);
  125.             }
  126.           }, 0);
  127.         });
  128.       })
  129.     }
  130.     return promise2; // 调用then后返回一个新的promise
  131.   }
  134.     // catch接收的参数 只用错误
  135.     catch(onRejected) {
  136.     // catch就是then的没有成功的简写
  137.     return this.then(null, onRejected);
  138.   }
  139. }
  141. Promise.resolve = function (val) {
  142.   return new Promise((resolve, reject) => resolve(val))
  143. }
  145. Promise.reject = function (reason) {
  146.   return new Promise((resolve, reject) => reject(reason));
  147. }
  149. // 有一个失败就失败，有一个成功就成功
  150. Promise.race = function (promises) {
  151.   return new Promise((resolve, reject) => {
  152.     for (let i = 0; i < promises.length; i++) {
  153.       // 判断下是否是 promise
  154.       let current = promises[i]
  155.       if((typeof current === 'object' && current !== null) || typeof current === 'function'){
  156.         if(typeof current.then === 'function'){
  157.           current.then(resolve,reject)
  158.         }else{
  159.             resolve(current);
  160.         }
  161.        }else{
  162.          resolve(current);
  163.        }
  164.     }
  165.   });
  166. }
  168. // 有一个失败直接失败，全部成功才成功
  169. Promise.all = function (promises) {
  170.   return new Promise((resolve,reject)=>{
  171.     let result = [];
  172.     let i = 0; // i的目的是为了保证获取全部成功，来设置的索引
  173.     function processData(index,data) {
  174.       result[index] = data;
  175.       i++;
  176.       if (i === promises.length){
  177.         resolve(result);
  178.       }
  179.     }
  180.     for(let i = 0;i<promises.length;i++){
  181.       // 判断下是否是 promise
  182.       let current = promises[i]
  183.       if((typeof current === 'object' && current !== null) || typeof current === 'function'){
  184.         if(typeof current.then === 'function'){
  185.           current.then(data=>{
  186.               processData(i,data);
  187.           },reject)
  188.         }else{
  189.             processData(i,current);
  190.         }
  191.        }else{
  192.          processData(i,current);
  193.        }
  194.     }
  195.   })
  196. }
  198. // 使用 promise A+ 测试
  199. // 延迟对象 deferred
  200. Promise.deferred = Promise.defer = function () {
  201.   let dfd = {};
  202.   dfd.promise = new Promise((resolve, reject) => {
  203.     dfd.resolve = resolve;
  204.     dfd.reject = reject;
  205.   })
  206.   return dfd;
  207. }
  209. module.exports = Promise;

上面暴露的 Promise.deferred 延迟对象使用：

  1. function read(url){
  2.   let dfd = Promise.defer()
  3.   fs.readFile(url,'utf8',(err,data)=>{
  4.       if(err) dfd.reject(err)
  5.     dfd.resolve(data)
  6.   })
  7.   return dfd.promise
  8. }
  10. read('1.txt').then(data=>{
  11.     console.log(data)
  12. })

看下面代码，输出什么？

  1. const p = Promise.resolve();
  3. (async () => {
  4.   await p;
  5.   console.log("after:await");
  6. })();
  8. p.then(() => {
  9.   console.log("tick:a");
  10. }).then(() => {
  11.   console.log("tick:b");
  12. });

在新版本的浏览器跟node 版本中都是下面的输出：

  1. tick:a
  2. tick:b
  3. after:await

那为什么 tick a 会比 after:await 快呢？我们把 async 函数转成 promise 就容易理解了：

  1. const p = Promise.resolve();
  3. (() => {
  4.   const implicit_promise = new Promise(resolve => {
  5.     const promise = new Promise(res => res(p));
  7.     promise.then(() => {
  8.       console.log("after:await");
  9.       resolve();
  10.     });
  11.   });
  12.   return implicit_promise;
  13. })();
  15. p.then(() => {
  16.   console.log("tick:a");
  17. }).then(() => {
  18.   console.log("tick:b");
  19. });

上面的输出就是： tick:a tick:b after:await

那如果在 p 后面再加一个 then 呢？如下：

  1. const p = Promise.resolve()
  2. ;(() => {
  3.   const implicit_promise = new Promise(resolve => {
  4.     const promise = new Promise(res => res(p))
  5.     promise.then(() => {
  6.       console.log('after:await')
  7.       resolve()
  8.     })
  9.   })
  10.   return implicit_promise
  11. })()
  13. p.then(() => {
  14.   console.log('tick:a')
  15. }).then(() => {
  16.   console.log('tick:b')
  17. }).then(()=>{
  18.   console.log('tick:c')
  19. })

上面的输出就是： tick:a tick:b after:await tick:c

分析：
new Promise(res => res(p)) 中 res(p) 这个 p = Promise.resolve() 是立即成功的，就会立马调用 p.then 的 tick:a ，由于这个 then 没有返回值，立即往微任务队列放入 tick:b ，相当于 x = p.then(()=>{console.log(‘tick:a’)})；x.then(()=>{console.log(“tick:b”)})；在调用了 tick:a 这个 then 后， promise 这个 Promise 就执行成功了，所以 after:await 这个 promise.then 会跟在 tick:b 之后放入微任务队列。最后才是 tick:c。

推荐阅读：

v8是怎么实现更快的 await ？深入理解 await 的运行机制