JS手写Promise以及promise.all方法

Promise是处理异步的一种方式，解决了回调地狱的问题。

Promise有三种状态：

1.pending（待定）：初始状态。

2.fulfilled（已兑现）：表示异步操作成功，返回一个返回值。

3.rejected（已拒绝）：表示异步操作失败，返回一个错误原因。

状态转换：可以从pending转换到fulfiied，从pending转换到rejected。一旦转换成功，状态就不可再发生改变。

常用方法：

1.Promise.resolve():将给定的一个值转换为Promise。如果本身就是Promise，那么直接返回，如果该值是一个thenable对象，那么将调用其then方法及其两个回调函数；

2.Promise.reject():返回一个已拒绝（rejected） 的Promise对象，拒绝原因为给定的参数。

3.Promise.all():接受一个Promise可迭代对象作为输入，并返回一个Promise。当所有的Promise都被兑现时，返回的Promise也将被兑现，并返回一个包含所有兑现值的数组。输入的任何被拒绝，返回的也将被拒绝。

接下来就是基本结构：

class myPromise{
    constructor(executer) {
        this.state = 'pending' //初始状态为pending
        this.value = undefined  //成功的值
        this.reason = undefined  //失败原因
        this.onFulfilledCallbacks = []; //成功回调函数数组
        this.onRejectedCallbacks = []  //失败回调函数数组

        const resolve = value => {  //resolve函数，用于改变状态，从pending到fulfilled，并记录成功的值
            if(this.state === 'pending') {  //只有在pending状态下才能进行状态转变
                this.state = 'fulfilled'
                this.value = value
                this.onFulfilledCallbacks.forEach(fn => fn())  //执行每一个回调函数
            }
        }

        const reject = reason => {  //reject函数，用于改变状态
            if(this.state = 'pending') {  //严谨一点
                this.state = 'rejected'
                this.reason = reason
                this.onRejectedCallbacks.forEach(fn => fn())  //执行每一个失败回调函数
            }
        };
    try {
        executor(resolve,reject);
    } catch (err){
        reject(err)
    }
    }
}

.then方法

myPromise.prototype.then = function(onFulfilled, onRejected) {
            onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value  //设置默认回调函数，确保函数类型，如果没有则使用默认处理函数
            onRejected = typeof onRejected === 'function' ? onRejected : reason => {throw reason}

            let promise2 = new myPromise((resolve,reject) => {  //创建新的promise用于链式调用
                if(this.state === 'fulfilled' || this.state === 'rejected') {   //判断状态，如果为fulfilled,执行成功回调，反之则执行失败回调
                    setTimeout(() => {
                        try {  //获取成功回调的返回值
                            let result = this.state ==='fulfilled' ? onFulfilled(this.value) :onRejected(this.reason)
                            resolvePromise(promise2, result, resolve, reject) //处理返回值确定promise2的状态
                        } catch (e) {
                            reject(e) //如果执行过程出错就reject
                        }
                    }, 0)
                }

                if(this.state === 'pending') {   //如果状态为pending，把回调函数存储起来
                    this.onFulfilledCallbacks.push(()=> {
                        setTimeout(() => {
                            try {
                                let x = onFulfilled(this.value)
                                resolvePromise(promise2, x, resolve, reject)
                            } catch (e) {
                                reject(e)
                            }
                        },0)
                    })
                    this.onRejectedCallbacks.push(() => {
                        setTimeout(() => {
                            try {
                                let x = onRejected(this.reason)
                                resolvePromise(promise2, x, resolve, reject)
                            } catch (e) {
                                reject(e)
                            }
                        },0)
                    })
                }

                return promise2
            })
        }

resolvePromise方法，用于处理then方法中返回的结果，以界定新的promise状态

function resolvePromise(promise2, x, resolve, reject) {
            if(promise2 === x) {  //如果一样，抛出TypeError防止自循环
                return reject(new TypeError('changing cycle detected from promise'))
            }
​
            let called  //如果X是对象或者数组
            if(x != null && (typeof x === 'object' || typeof x === 'function')) {
                try {
                    let then = x.then  //取出x的then方法
                    if(typeof then === 'function') {  //如果then是函数，调用，传入resolvePromise和reject函数
                        then.call(x,y => {
                            if(called) return
                            called = true
                            resolvePromise(promise2, y, resolve, reject)
                        }, r=> {
                            if(called) return
                            called = true
                            reject(r)
                        })
                    } else {
                        reslove(x) //如果x不是，以x为值fulfill promise2
                    }
                } catch(e) {
                    if(called) return 
                    called = true
                    reject(e)
                }
            } else {
                resolve(x)
            }
        }

resolve,reject方法用于快速生成一个promise对象

 myPromise.prototype.resolve = function(value) {
            return new myPromise((resolve,reject) => {
                resolve(value)
            })
        }
​
 myPromise.prototype.reject = function(reason) {
            return new myPromise((resolve,reject) => {
                reject(reason)
            })
        }
​

.all()方法，传入数组promise，将多个promise包装成一个新的promise，且只有多个全部成功，新实例才会成功

myPromise.prototype.all = function(promises) {
            return new myPromise((resolve, reject) => {  //返回一个新的promise
                let result = []  //存储每一个promise的结果
                let count = 0  //记录完成的数量
​
                function processresult(index, data) {  //处理单个promise
                    result[index] = data
                    count++
                    if(count === promises.length) {  //如果所有promise全部完成，resolve一个新的promise
                    resolve(result)
                    }
                }
​
                for(let i=0;i<promises.length;i++) {  //遍历数组，处理结果
                    promises[i].then(data => {
                       processresult(i,data)
                    }, reject)
                }
            })
        }