手写Promise

  本文通过实现一个简单的符合promise/A+规范的Promise类，从而深入理解ES6中的Promise类。Promise/A+规范可以通过该链接获得https://promisesaplus.com/。代码如下：

  

let promisesAplusTests = require('promises-aplus-tests')

const PENDING = 'pending';
const FULLFILLED = 'fullfiled';
const REJECTED = 'rejected';

function PromiseResolve(promise2, x, resolve, reject) {
    if (promise2 === x) {
        return reject(new TypeError('TypeError: Chaining cycle detected for promise #<Promise>'));
    }
    let called;
    if (typeof x === 'function' || (typeof x === 'object' && x != null)) {
        try {
            let then = x.then;  // then 可能是getter object.defineProperty
            if (typeof then === 'function') {  // {then:null}
                then.call(x, y => {
                    if (called) return; // 1)
                    called = true;
                    PromiseResolve(promise2, y, resolve, reject);
                }, r => {
                    if (called) return; // 2)
                    called = true;
                    reject(r);
                })
            } else {
                resolve(x);
            }
        } catch (e) {
            if (called) return; // 3) 为了辨别这个promise 不能调用多次
            called = true;
            reject(e);
        }
    } else {
        resolve(x);
    }
}

class Promise {
    constructor(executor) {
        this.value;
        this.status = PENDING;
        this.reason;
        this.onfullfilledcallback = [];
        this.onrejectedcallback = [];
        let resolved = (data) => {

            if (data instanceof Promise) {
                data.then(resolved, rejected);
            }

            if (this.status == PENDING) {
                this.value = data;
                this.status = FULLFILLED;
                this.onfullfilledcallback.forEach((item) => {
                    item();
                });
            }
        };
        let rejected = (reason) => {
            if (this.status == PENDING) {
                this.reason = reason;
                this.status = REJECTED;
                this.onrejectedcallback.forEach((item) => {
                    item();
                });
            }
        };

        try {
            executor(resolved, rejected);
        } catch (err) {
            rejected(err);
        }
    }

    then(onfullfilled, onrejected) {
        onfullfilled = typeof onfullfilled === 'function' ? onfullfilled : data => data;
        onrejected = typeof onrejected === 'function' ? onrejected : (reason) => { throw reason };

        let promise2;
        promise2 = new Promise((resolve, rejecte) => {
            if (this.status == FULLFILLED) {
                setTimeout(() => {
                    try {
                        let x = onfullfilled(this.value);
                        PromiseResolve(promise2, x, resolve, rejecte)
                    } catch (err) {
                        rejecte(err);
                    }
                });
            }

            if (this.status == REJECTED) {
                setTimeout(() => {
                    try {
                        let x = onrejected(this.reason);
                        PromiseResolve(promise2, x, resolve, rejecte)
                    } catch (err) {
                        rejecte(err);
                    }
                });
            }

            if (this.status == PENDING) {
                this.onfullfilledcallback.push(() => {
                    setTimeout(() => {
                        try {
                            let x = onfullfilled(this.value);
                            PromiseResolve(promise2, x, resolve, rejecte)
                        } catch (err) {
                            rejecte(err);
                        }
                    });
                });

                this.onrejectedcallback.push(() => {
                    setTimeout(() => {
                        try {
                            let x = onrejected(this.reason);
                            PromiseResolve(promise2, x, resolve, rejecte)
                        }
                        catch (err) {
                            rejecte(err);
                        }
                    });
                });
            }
        });
        return promise2;
    }

    catch(onrejected) {
        return this.then(null, onrejected);
    }

    finally(fun) {
        this.then((data) => {
            Promise.resolve(fun).then(() => data);
        },
            (reason) => {
                Promise.resolve(fun).then(() => { throw reason });
            })
    }

}

Promise.resolve = function (value) {
    return new Promise((resolve, rejected) => {
        resolve(value);
    });
}

Promise.reject = function (reason) {
    return new Promise((resolve, rejected) => {
        rejected(reason);
    })
}

Promise.all = function (values) {
    return new Promise((resolve, reject) => {
        let arr = []; // arr[3] = 2  arr.length = 4
        let i = 0;
        let processData = (key, value) => {
            arr[key] = value; // after函数
            if (++i === values.length) {
                resolve(arr);
            }
        }
        for (let i = 0; i < values.length; i++) {
            let current = values[i];
            if (isPromise(current)) {
                current.then(y => {
                    processData(i, y);
                }, reject);
            } else {
                processData(i, current);
            }
        }
    })
}
Promise.defer = Promise.deferred = function () {
    let dfd = {};
    dfd.promise = new Promise((resolve, reject) => {
        dfd.resolve = resolve;
        dfd.reject = reject;
    });
    return dfd;
}




promisesAplusTests(Promise);

  通过调用promises-aplus-tests来检验我们的代码是否符合promise A+规范。