Promise自定义封装，各种Promise方法的封装

//声明构造函数
function Promise(executor) {
    //添加属性
    this.PromiseState = 'pending';
    this.PromiseResult = null;
    //声明属性
    this.callback = [];
    //保存实例对象的 this 的值
    const self = this;
    //resolve函数
    function resolve(data) {
        if (self.PromiseState !== 'pending') return
        //1. 修改对象的状态 (promiseState)
        self.PromiseState = 'resolved';
        //2. 设置对象结果值 (promiseResult)
        self.PromiseResult = data
        //调用成功的回调函数
        setTimeout(() => {
            self.callbacks.forEach(item => {
                item.onResolved(data);
            });
        });
    }
    //reject函数
    function reject(data) {
        if (self.PromiseState !== 'pending') return
        //1. 修改对象的状态 (promiseState)
        self.PromiseState = 'rejected';
        //2. 设置对象结果值 (promiseResult)
        self.PromiseResult = data
        //调用失败的回调函数
        setTimeout(() => {
            self.callbacks.forEach(item => {
                item.onRejected(data);
            });
        });
    }
    try {
        //同步调用『执行器函数』
        executor(resolve, reject)
    } catch (e) {
        reject(e);
    }

}
//Promise.then方法用来指定处理程序，它最多接收两个参数，第一个参数是成功的回调函数，第二个参数是失败的回调函数，
//这里为了方便讲解给它们七个名字onResolved和onRejected它们可以在执行器函数里通过resolve()和reject()被调用。
//Promise.prototype.then()返回一个新的Promise实例，该实例基于onResolved或onReject处理程序的返回值构建,其返回值会被Promise.resolvePromise.reject包装。

//添加 then 方法
Promise.prototype.then = function (onResolved, onRejected) {
    const self = this;
    //判断回调函数参数
    if(typeof onRejected !== 'function'){
        onRejected = reason => {
            throw reason;
        }
    }
    if(typeof onResolved !== 'function'){
        onResolved = value => value;
        //value => { return value};
    }
    return new Promise((resolve, reject) => {
        //封装函数
        function callback(type){
            try{
                //获取回调函数的执行结果
                let result = type(self.PromiseResult);
                //判断
                if(result instanceof Promise){
                    //如果是 Promise 类型的对象
                    result.then(v => {
                        resolve(v);
                    }, r=>{
                        reject(r);
                    })
                }else{
                    //结果的对象状态为『成功』
                    resolve(result);
                }
            }catch(e){
                reject(e);
            }
        }
        //调用回调函数
        if (this.PromiseState === 'resolved') {
            setTimeout(() => {
                callback(onResolved);
            });
        }
        if (this.PromiseState === 'rejected') {
            setTimeout(() => {
                callback(onRejected);
            });
        }
        if (this.PromiseState === 'pending') {
            //保存回调函数
            this.callback.push({
                onResolve: function () {
                    callback(onResolved)
                },
                onReject: function () {
                    callback(onRejected)
                }
            });
        }
    })
}

//添加 catch 方法
Promise.prototype.catch = function(onRejected){
    return this.then(undefined, onRejected);
}

//添加 resolve 方法
Promise.resolve = function(value){
    //返回promise对象
    return new Promise((resolve, reject) => {
        if(value instanceof Promise){
            value.then(v=>{
                resolve(v);
            }, r=>{
                reject(r);
            })
        }else{
            //状态设置为成功
            resolve(value);
        }
    });
}

//添加 reject 方法
Promise.reject = function(reason){
    return new Promise((resolve, reject)=>{
        reject(reason);
    });
}


//添加 all 方法
Promise.all = function(promises){
    //返回结果为promise对象
    return new Promise((resolve, reject) => {
        //声明变量
        let count = 0;
        let arr = [];
        //遍历
        for(let i=0;i<promises.length;i++){
            //
            promises[i].then(v => {
                //得知对象的状态是成功
                //每个promise对象 都成功
                count++;
                //将当前promise对象成功的结果 存入到数组中
                arr[i] = v;
                //判断
                if(count === promises.length){
                    //修改状态
                    resolve(arr);
                }
            }, r => {
                reject(r);
            });
        }
    });
}

//添加 race 方法
Promise.race = function(promises){
    return new Promise((resolve, reject) => {
        for(let i=0;i<promises.length;i++){
            promises[i].then(v => {
                //修改返回对象的状态为 『成功』
                resolve(v);
            },r=>{
                //修改返回对象的状态为 『失败』
                reject(r);
            })
        }
    });
}

手写Promise以供参考学习