image.png

    1. const PENDING = "pending";
    2. const FULFILLED = "fulfilled";
    3. const REJECTED = "rejected";
    5. function Promise (executor) {
    6.     const self = this;
    7.     self.status = PENDING;
    8.     self.value = undefined;
    9.     self.reason = undefined;
    11.     self.onFulfilledCbs = [];//成功的回调
    12.     self.onRejectedCbs = []; //失败的回调
    14.     /* 
    15.     PromiseA+
    16.         2.1 Promise States
    17.             A promise must be in one of three states: pending, fulfilled, or rejected.
    19.             2.1.1 When pending, a promise:
    20.                 2.1.1.1 may transition to either the fulfilled or rejected state.
    22.             2.1.2 When fulfilled, a promise:
    23.                 2.1.2.1 must not transition to any other state.
    24.                 2.1.2.2 must have a value, which must not change.
    26.             2.1.3 When rejected, a promise:
    27.                 2.1.3.1 must not transition to any other state.
    28.                 2.1.3.2 must have a reason, which must not change.
    30.     */
    31.     function resolve (value) {
    32.         if (self.status === PENDING) {
    33.             self.status = FULFILLED;
    34.             self.value = value;
    36.             /*
    37.             PromiseA+ 2.2.6
    38.                 2.2.6 then may be called multiple times on the same promise.
    39.                     2.2.6.1 If/when promise is fulfilled, all respective onFulfilled callbacks must execute in the order of their originating calls to then.
    40.             */
    41.             self.onFulfilledCbs.forEach(fn => fn());
    42.         }
    43.     }
    45.     function reject (reason) {
    46.         if (self.status === PENDING) {
    47.             self.status = REJECTED;
    48.             self.reason = reason;
    50.             /*
    51.             PromiseA+ 2.2.6
    52.                 2.2.6 then may be called multiple times on the same promise.
    53.                     2.2.6.2 If/when promise is rejected, all respective onRejected callbacks must execute in the order of their originating calls to then.
    54.             */
    55.             self.onRejectedCbs.forEach(fn => fn());
    56.         }
    57.     }
    59.     try {
    60.         executor(resolve, reject);
    61.     } catch (e) {
    62.         reject(e);
    63.     }
    64. }
    66. Promise.prototype.then = function (onFulfilled, onRejected) {
    67.     /*
    68.     PromiseA+ 2.2.1
    69.         2.2.1 Both onFulfilled and onRejected are optional arguments:
    70.             2.2.1.1 If onFulfilled is not a function, it must be ignored.
    71.             2.2.1.2 If onRejected is not a function, it must be ignored.
    73.     PromiseA+ 2.2.5
    74.         2.2.5 onFulfilled and onRejected must be called as functions (i.e. with no this value). [3.2]
    76.     PromiseA+ 2.2.7.3
    77.             2.2.7.3 If onFulfilled is not a function and promise1 is fulfilled, promise2 must be fulfilled with the same value as promise1.
    79.     PromiseA+ 2.2.7.4
    80.             2.2.7.4 If onRejected is not a function and promise1 is rejected, promise2 must be rejected with the same reason as promise1.
    81.     */
    82.     onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
    83.     onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };
    85.     const self = this;
    87.     /*
    88.     PromiseA+ 2.2.7
    89.         2.2.7 then must return a promise [3.3].
    90.         promise2 = promise1.then(onFulfilled, onRejected);
    91.     */
    92.     let promise2 = new Promise((resolve, reject) => {
    93.         if (self.status === FULFILLED) {
    96.             /*
    97.             PromiseA+ 2.2.2
    98.                 2.2.2 If onFulfilled is a function:
    99.                     2.2.2.1 it must be called after promise is fulfilled, with promise’s value as its first argument.
    100.                     2.2.2.2 it must not be called before promise is fulfilled.
    101.                     2.2.2.3 it must not be called more than once.
    103.             PromiseA+ 2.2.4 --- setTimeout
    104.                 2.2.4 onFulfilled or onRejected must not be called until the execution context stack contains only platform code. [3.1].
    105.             */
    106.             setTimeout(() => {
    107.                 try {
    108.                     /*
    109.                     PromiseA+ 2.2.7.1
    110.                         2.2.7.1 If either onFulfilled or onRejected returns a value x, run the Promise Resolution Procedure [[Resolve]](promise2, x).
    111.                     */
    112.                     let x = onFulfilled(self.value);
    113.                     resolvePromise(promise2, x, resolve, reject);
    114.                 } catch (e) {
    115.                     /* 
    116.                     PromiseA+ 2.2.7.2
    117.                         2.2.7.2 If either onFulfilled or onRejected throws an exception e, promise2 must be rejected with e as the reason.
    118.                     */
    119.                     reject(e);
    120.                 }
    121.             });
    122.         }
    124.         /*
    125.         PromiseA+ 2.2.3
    126.             2.2.3 If onRejected is a function,
    127.                 2.2.3.1 it must be called after promise is rejected, with promise’s reason as its first argument.
    128.                 2.2.3.2 it must not be called before promise is rejected.
    129.                 2.2.3.3 it must not be called more than once.
    130.         */
    131.         if (self.status === REJECTED) {
    132.             setTimeout(() => {
    133.                 try {
    134.                     let x = onRejected(self.reason);
    135.                     resolvePromise(promise2, x, resolve, reject);
    136.                 } catch (e) {
    137.                     reject(e);
    138.                 }
    139.             });
    140.         }
    143.         if (self.status === PENDING) {
    144.             self.onFulfilledCbs.push(() => {
    145.                 setTimeout(() => {
    146.                     try {
    147.                         let x = onFulfilled(self.value);
    148.                         resolvePromise(promise2, x, resolve, reject);
    149.                     } catch (e) {
    150.                         reject(e);
    151.                     }
    152.                 });
    153.             });
    154.             self.onRejectedCbs.push(() => {
    155.                 setTimeout(() => {
    156.                     try {
    157.                         let x = onRejected(self.reason);
    158.                         resolvePromise(promise2, x, resolve, reject);
    159.                     } catch (e) {
    160.                         reject(e);
    161.                     }
    162.                 });
    163.             });
    164.         }
    165.     });
    166.     return promise2;
    167. }
    169. function resolvePromise (promise2, x, resolve, reject) {
    171.     /*
    172.     PromiseA+ 2.3.1
    173.         2.3.1 If promise and x refer to the same object, reject promise with a TypeError as the reason.
    174.     */
    175.     if (promise2 === x) {
    176.         reject(new TypeError('Chaining cycle'));
    177.     }
    179.     const self = this;
    181.     /*
    182.     PromiseA+ 2.3.2
    183.         2.3.2 If x is a promise, adopt its state [3.4]:
    184.             2.3.2.1 If x is pending, promise must remain pending until x is fulfilled or rejected.
    185.             2.3.2.2 If/when x is fulfilled, fulfill promise with the same value.
    186.             2.3.2.3 If/when x is rejected, reject promise with the same reason.
    188.     PromiseA+ 2.3.3
    189.         2.3.3 Otherwise, if x is an object or function,
    190.     */
    191.     if (x && typeof x === 'object' || typeof x === 'function') {
    193.         /*
    194.         PromiseA+ 2.3.3.3.3 只能调用一次
    195.             2.3.3.3.3 If both resolvePromise and rejectPromise are called, or multiple calls to the same argument are made, the first call takes precedence, and any further calls are ignored.
    196.         */
    197.         let used;
    198.         try {
    199.             /*
    200.             PromiseA+ 2.3.3.1
    201.                 2.3.3.1 Let then be x.then. [3.5]
    202.             */
    203.             let then = x.then;
    205.             if (typeof then === 'function') {
    206.                 /*
    207.                 PromiseA+ 2.3.3.3
    208.                     2.3.3.3 If then is a function, call it with x as this, first argument resolvePromise, and second argument rejectPromise, where:
    209.                         2.3.3.3.1 If/when resolvePromise is called with a value y, run [[Resolve]](promise, y).
    210.                         2.3.3.3.2 If/when rejectPromise is called with a reason r, reject promise with r.
    211.                         2.3.3.3.3 If both resolvePromise and rejectPromise are called, or multiple calls to the same argument are made, the first call takes precedence, and any further calls are ignored.
    212.                 */
    213.                 then.call(x, (y) => {
    214.                     if (used) return;
    215.                     used = true;
    216.                     resolvePromise(promise2, y, resolve, reject);
    217.                 }, (r) => {
    218.                     if (used) return;
    219.                     used = true;
    220.                     reject(r);
    221.                 });
    223.             } else {
    224.                 /*
    225.                 PromiseA+ 2.3.3.4
    226.                     2.3.3.4 If then is not a function, fulfill promise with x.
    227.                 */
    228.                 if (used) return;
    229.                 used = true;
    230.                 resolve(x);
    231.             }
    232.         } catch (e) {
    234.             /*
    235.             PromiseA+ 2.3.3.2
    236.                 2.3.3.2 If retrieving the property x.then results in a thrown exception e, reject promise with e as the reason.
    238.                 2.3.3.3.4 If calling then throws an exception e,
    239.                     2.3.3.3.4.1 If resolvePromise or rejectPromise have been called, ignore it.
    240.                     2.3.3.3.4.2 Otherwise, reject promise with e as the reason.
    241.             */
    242.             if (used) return;
    243.             used = true;
    244.             reject(e);
    245.         }
    246.     } else {
    247.         /*
    248.         PromiseA+ 2.3.3.4
    249.             2.3.3.4 If x is not an object or function, fulfill promise with x.
    250.         */
    251.         resolve(x);
    252.     }
    253. }
    255. /*
    256.     用于指定出错时的回调，是特殊的then方法，catch之后，可以继续 .then
    257. */
    258. Promise.prototype.catch = function (onRejected) {
    259.     return this.then(null, onRejected);
    260. }
    262. /*
    263.     不管成功还是失败，都会走到finally中,并且finally之后，还可以继续then。并且会将值原封不动的传递给后面的then.
    264. */
    265. Promise.prototype.finally = function (callback) {
    266.     return this.then((value) => {
    267.         return Promise.resolve(callback()).then(() => {
    268.             return value;
    269.         });
    270.     }, (err) => {
    271.         return Promise.resolve(callback()).then(() => {
    272.             throw err;
    273.         });
    274.     });
    275. }
    277. Promise.defer = Promise.deferred = function () {
    278.     let dfd = {};
    279.     dfd.promise = new Promise((resolve, reject) => {
    280.         dfd.resolve = resolve;
    281.         dfd.reject = reject;
    282.     });
    283.     return dfd;
    284. }
    286. /**
    287.     1 参数是一个 Promise 实例
    288.         将不做任何修改、原封不动地返回这个实例。
    289.     2 参数是一个thenable对象
    290.         方法会将这个对象转为 Promise 对象，然后就立即执行thenable对象的then()方法,(thenable对象指的是具有then方法的对象)
    291.     3 参数不是具有then()方法的对象，或根本就不是对象，或者不带有任何参数
    292.         返回一个新的 Promise 对象，value 为传入参数，状态为resolved
    293. */
    294. Promise.resolve = function (param) {
    295.     if (param instanceof Promise) {
    296.         return param;
    297.     }
    298.     return new Promise((resolve, reject) => {
    299.         if (param && param.then && typeof param.then === 'function') {
    300.             setTimeout(() => {
    301.                 param.then(resolve, reject);
    302.             });
    303.         } else {
    304.             resolve(param);
    305.         }
    306.     });
    307. }
    309. /*
    310.     Promise.reject(reason)方法也会返回一个新的 Promise 实例，该实例的状态为rejected。
    311.     Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。
    312. */
    313. Promise.reject = function (reason) {
    314.     return new Promise((resolve, reject) => {
    315.         reject(reason);
    316.     });
    317. }
    319. /*
    320.     返回一个promise对象
    321.     1 promise 中所有的 promise都“完成”时或参数中不包含 promise 时回调完成。
    322.     2 如果参数中有一个promise失败，那么Promise.all返回的promise对象失败
    323.     3 在任何情况下，Promise.all 返回的 promise 的完成状态的结果都是一个数组
    324. */
    325. Promise.all = function (promises) {
    326.     return new Promise((resolve, reject) => {
    327.         let index = 0;
    328.         let result = [];
    329.         if (promises.length === 0) {
    330.             resolve(result);
    331.         } else {
    332.             function processValue (i, data) {
    333.                 result[i] = data;
    334.                 if (++index === promises.length) {
    335.                     resolve(result);
    336.                 }
    337.             }
    339.             for (let i = 0; i < promises.length; i++) {
    340.                 //promises[i] 不一定是promise,可能是普通值
    341.                 Promise.resolve(promises[i])
    342.                     .then((data) => {
    343.                         processValue(i, data);
    344.                     }, (err) => {
    345.                         reject(err);
    346.                         return;
    347.                     });
    348.             }
    349.         }
    350.     });
    351. }
    354. /*
    355.     Promise.race函数返回一个 Promise，它将与第一个传递的 promise 相同的完成方式被完成。它可以是完成（ resolves），也可以是失败（rejects），这要取决于第一个完成的方式是两个中的哪个。
    357.     1 如果传的参数数组是空，则返回的 promise 将永远等待。
    358.     2 如果迭代包含一个或多个非承诺值和/或已解决/拒绝的承诺，则 Promise.race 将解析为迭代中找到的第一个值。
    359. */
    360. Promise.race = function (promises) {
    361.     return new Promise((resolve, reject) => {
    362.         if (promises.length === 0) {
    363.             return;
    364.         } else {
    365.             for (let i = 0; i < promises.length; i++) {
    366.                 Promise.resolve(promises[i]).then((data) => {
    367.                     resolve(data);
    368.                     return;
    369.                 }, (err) => {
    370.                     reject(err);
    371.                     return;
    372.                 });
    373.             }
    374.         }
    375.     });
    376. }
    378. module.exports = Promise;