JS之什么是Promise 手写简易Promise、Promise.race、Promise.all

JS之什么是Promise 手写简易Promise、Promise.race、Promise.all

一.什么是promise：
①.Promise的出现其实是作为异步编程的一种解决方案
解决采用回调模式实现异步编程时，即在一个回调函数中嵌套多个回调函数，产生回调地狱的情况。

②.每个 Promise都会经历一个短暂的生命周期，初始为挂起态（ pending state），这表示异步操作尚未结束。一个挂起的 Promise 也被认为是未决的（ unsettled ）。
一旦异步操作结束， Promise就会被认为是已决的（ settled ），并进入两种可能状态之一：
1. 已完成（fulfilled ）： Promise 的异步操作已成功结束；
2. 已拒绝（rejected ）： Promise 的异步操作未成功结束，可能是一个错误，或由其他原因导致。

一旦状态改变，就「凝固」了，会一直保持这个状态，不会再发生变化。当状态发生变化，promise.then绑定的函数就会被调用。

注意：Promise一旦新建就会「立即执行」，无法取消。这是它的缺点

③.promise的then方法：

可以进行链式调用
我们默认在第一个then里返回一个promise，叫promise2，将它传递下一个then中

④.promise的catch方法：


二.什么是Promise.all：


三.什么是Promise.race

四.手写简易的Promise、Promise.race、Promise.all

①.Promise：

class Promsie {
    constructor(fn) {
        //三个状态
        this.status = 'pending',
        this.resolve = undefined;
        this.reject = undefined;
        let resolve = value => {
            if (this.status === 'pending') {
                this.status = 'resolved';
                this.resolve = value;
            }
        };
        let reject = value => {
            if (this.status === 'pending') {
                this.status = 'rejected';
                this.reject = value;
            }
        }
        try {
            fn(resolve, reject)
        } catch (e) {
            reject(e)
        }
    }
    then(onResolved, onRejected) {
        switch (this.status) {
            case 'resolved': onResolved(this.resolve); break;
            case 'rejected': onRejected(this.resolve); break;
            default:
        }
    }

}

②.Promise.all

   function promiseAll(promises) {
            if (!Array.isArray(promises)) {
                throw new Error("promises must be an array")
            }
            return new Promise(function (resolve, reject) {

                let promsieNum = promises.length;
                let resolvedCount = 0;
                let resolveValues = new Array(promsieNum);
                for (let i = 0; i < promsieNum; i++) {
                    Promise.resolve(promises[i].then(function (value) {
                        resolveValues[i] = value;
                        resolvedCount++;
                        if (resolvedCount === promsieNum) {
                            return resolve(resolveValues)
                        }
                    }, function (reason) {
                        return reject(reason);
                    }))

                }
            })
        }

③.Promise.race:

 function promiseRace(promises) {
            if (!Array.isArray(promises)) {
                throw new Error("promises must be an array")
            }
            return new Promise(function (resolve, reject) {
                promises.forEach(p =>
                    Promise.resolve(p).then(data => {
                        resolve(data)
                    }, err => {
                        reject(err)
                    })
                )
            })
        }