promise.pptx

    1. /*
    2.  *  基于Promise/A+规范实现 Promise https://promisesaplus.com/
    3.  */
    4. const PENDING = "pending";
    5. const FULFILLED = "fulfilled";
    6. const REJECTED = "rejected";
    8. class MyPromise {
    9.   constructor(fn) {
    10.     this.status = PENDING;
    11.     this.value = "";
    12.     this.onResolvedCallbacks = [];
    13.     this.onRejectedCallbacks = [];
    15.     try {
    16.       fn(this.resolve.bind(this), this.reject.bind(this));
    17.     } catch (e) {
    18.       this.reject.bind(this, e);
    19.     }
    20.   }
    21.   resolve(value) {
    22.     if (value instanceof Promise) {
    23.       return value.then(this.resolve.bind(this), this.reject.bind(this));
    24.     }
    25.     setTimeout(() => {
    26.       if (this.status === PENDING) {
    27.         this.status = FULFILLED;
    28.         this.value = value;
    29.         this.onResolvedCallbacks.map(fn => fn(this.value));
    30.       }
    31.     });
    32.   }
    33.   reject(err) {
    34.     setTimeout(() => {
    35.       if (this.status === PENDING) {
    36.         this.status = REJECTED;
    37.         this.value = err;
    38.         this.onRejectedCallbacks.map(fn => fn(this.value));
    39.       }
    40.     });
    41.   }
    42.   then(onFulfilled, onRejected) {
    43.     let that = this;
    44.     onFulfilled =
    45.       typeof onFulfilled === "function" ? onFulfilled : value => value;
    46.     onRejected =
    47.       typeof onRejected === "function"
    48.         ? onRejected
    49.         : err => {
    50.             throw err;
    51.           };
    53.     let promise2;
    55.     if (this.status === FULFILLED) {
    56.       promise2 = new MyPromise(function(resolve, reject) {
    57.         setTimeout(() => {
    58.           try {
    59.             let x = onFulfilled(that.value);
    60.             resolvePromise(promise2, x, resolve, reject);
    61.           } catch (e) {
    62.             reject(e);
    63.           }
    64.         });
    65.       });
    66.     }
    67.     if (this.status === REJECTED) {
    68.       return new MyPromise(function(resolve, reject) {
    69.         setTimeout(() => {
    70.           try {
    71.             let x = onRejected(that.value);
    72.             resolvePromise(promise2, x, resolve, reject);
    73.           } catch (e) {
    74.             reject(e);
    75.           }
    76.         });
    77.       });
    78.     }
    79.     if (this.status === PENDING) {
    80.       promise2 = new MyPromise(function(resolve, reject) {
    81.         that.onResolvedCallbacks.push(function(value) {
    82.           try {
    83.             let x = onFulfilled(value);
    84.             resolvePromise(promise2, x, resolve, reject);
    85.           } catch (e) {
    86.             reject(e);
    87.           }
    88.         });
    89.         that.onRejectedCallbacks.push(function(value) {
    90.           try {
    91.             let x = onRejected(value);
    92.             resolvePromise(promise2, x, resolve, reject);
    93.           } catch (e) {
    94.             reject(e);
    95.           }
    96.         });
    97.       });
    98.     }
    100.     return promise2;
    101.   }
    103.   catch(obRejected) {
    104.     return this.then(null, onRejected);
    105.   }
    106. }
    107. function resolvePromise(promise2, x, resolve, reject) {
    108.   let then, called;
    110.   if (x !== null && (typeof x === "object" || typeof x === "function")) {
    111.     try {
    112.       then = x.then;
    113.       if (typeof then === "function") {
    114.         then.call(
    115.           x,
    116.           function(y) {
    117.             if (called) return;
    118.             called = true;
    119.             resolvePromise(promise2, y, resolve, reject);
    120.           },
    121.           function(r) {
    122.             if (called) return;
    123.             called = true;
    124.             reject(r);
    125.           }
    126.         );
    127.       } else {
    128.         resolve(x);
    129.       }
    130.     } catch (e) {
    131.       if (called) return;
    132.       called = true;
    133.       reject(e);
    134.     }
    135.   } else {
    136.     resolve(x);
    137.   }
    138. }
    140. module.exports = MyPromise;