手写Promise-面试必问！

什么是Promise?

所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。Promise提供统一的API，各种异步操作都可以用同样的方法进行处理。

Promise出现之前都是通过回调函数来实现，回调函数本身没有问题，但是嵌套层级过深，很容易掉进回调地狱。

const fs = require('fs');
fs.readFile('1.txt', (error,data) => {
    fs.readFile('2.txt', (error,data) => {
        fs.readFile('3.txt', (error,data) => {
            //你的代码
        });
    });
});

Promise的出现正是为了解决这个痛点，我们可以把上面的回调嵌套用Promise改写一下：

const readFile = function(fileName){
    return new Promise((resolve, reject)=>{
        fs.readFile(fileName, (error, data)=>{
            if(error){
                reject(error)
            } else {
                resolve(data)
            }
        })
    })
}
readFile('1.txt')
    .then(data => {
        return readFile('2.txt');
    }).then(data => {
        return readFile('3.txt');
    }).then(data => {
        //...
    });

Promise基本结构：
回顾一下，我们平常使用promise的方式：

var p = new Promise(function(resolve, reject){
    console.log('执行')
    setTimeout(function(){
        resolve(2)
    }, 1000)
})
//then方法返回的也是一个promise对象
p.then(function(res){
    console.log('res',res)
},function(err){
    console.log('err',err)
})

首先看出来，Promise是通过构造函数实例化一个对象，然后通过实例对象上的then方法，来处理异步返回的结果。同时，promise/A+规范规定了：

promise 是一个拥有 then 方法的对象或函数，其行为符合本规范；
一个 Promise 的当前状态必须为以下三种状态中的一种：等待态（Pending）、执行态（Fulfilled）和拒绝态（Rejected）。

const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

function Promise(executor) {
    var _this = this
    this.state = PENDING; //状态
    this.value = undefined; //成功结果
    this.reason = undefined; //失败原因
    function resolve(value) {} //成功时的回调
    function reject(reason) {} //失败时的回调
}

Promise.prototype.then = function (onFulfilled, onRejected) {
};

module.exports = Promise;

当我们实例化Promise时，构造函数会马上调用传入的执行函数executor，我们可以试一下：

let p = new Promise((resolve, reject) => {
    console.log('执行了');
});

因此在Promise中构造函数立马执行，同时将resolve函数和reject函数作为参数传入：

function Promise(executor) {
    var _this = this
    this.state = PENDING; //状态
    this.value = undefined; //成功结果
    this.reason = undefined; //失败原因
    function resolve(value) {}
    function reject(reason) {}
    executor(resolve, reject)

但是executor也会可能存在异常，因此通过try/catch来捕获一下异常情况：

try {
    executor(resolve, reject);
} catch (e) {
    reject(e);
}

不可变
promise/A+规范中规定，当Promise对象已经由等待态（Pending）改变为执行态（Fulfilled）或者拒绝态（Rejected）后，就不能再次更改状态，且终值也不可改变。因此我们在回调函数resolve和reject中判断，只能是pending状态的时候才能更改状态

function resolve (value) {
    if(_this.state === PENDING) {
        _this.state = FULFILLED;
        _this.value = value;
    }
}
//失败时的回调
function reject (reason) {
    if(_this.state === PENDING) {
        _this.state = REJECTED;
        _this.reason = reason;
    }
}

then实现
当Promise的状态改变之后，不管成功还是失败，都会触发then回调函数。因此，then的实现也很简单，就是根据状态的不同，来调用不同处理终值的函数。

Promise.prototype.then = function (onFulfilled, onRejected) {
    if(this.state === FULFILLED){
        typeof onFulfilled === 'function' && onFulfilled(this.value)
    }
    if(this.state === REJECTED){
         typeof onRejected === 'function' && onRejected(this.reason)
    }
};

在规范中也说了，onFulfilled和onRejected是可选的，因此我们对两个值进行一下类型的判断：

onFulfilled 和 onRejected 都是可选参数。如果 onFulfilled 不是函数，其必须被忽略。如果 onRejected 不是函数，其必须被忽略
代码写到这里，貌似该有的实现方式都有了，我们来写个demo测试一下：

var myP = new Promise(function(resolve, reject){
    console.log('执行')
    setTimeout(function(){
        reject(3)
    }, 1000)
});
myP.then(function(res){
    console.log(res)
},function(err){
    console.log(err)
});

很遗憾，运行起来我们发现只打印了构造函数中的执行，下面的then函数根本都没有执行。我们整理一下代码的运行流程：

当then里面函数运行时，resolve由于是异步执行的，还没有来得及修改state，此时还是PENDING状态；因此我们需要对异步的情况做一下处理。
支持异步
参考发布订阅模式，如果当前是PENDING状态，就把回调函数寄存到一个数组中，当状态发生改变时，去数组中取出回调函数，因此先定义下变量

function Promise(executor) {
	this.onFulfilled = [];//存成功的回调
	this.onRejected = [];//存失败的回调
}

这样，当then方法执行时，如果还是PENDING状态时，不立马执行回调函数，而是先存到数组中

Promise.prototype.then = function (onFulfilled, onRejected) {
    if (this.state === 'FULFILLED') {
        typeof onFulfilled === 'function' && onFulfilled(this.value)
    }
    if (this.state === 'REJECTED') {
        typeof onRejected === 'function' && onRejected(this.reason)
    }
    if (this.state === PENDING) {
        typeof onFulfilled === 'function' && this.onFulfilled.push(onFulfilled)
        typeof onRejected === 'function' && this.onRejected.push(onRejected)
    }
}

存储起来后，当resolve或者reject异步执行的时候就可以来调用了：

function resolve(value) {
    if(_this.state === PENDING){
        _this.state = FULFILLED
        _this.value = value
        _this.onFulfilled.forEach(fn => fn(value))
    }
}
function reject(reason) {
    if(_this.state === PENDING){
        _this.state = REJECTED
        _this.reason = reason
        _this.onRejected.forEach(fn => fn(reason))
    }
}

有童鞋可能会提出疑问了，为什么这边onFulfilled和onRejected要存在数组中，直接用一个变量接收不是也可以么？下面看一个例子：

var p = new Promise((resolve, reject)=>{
    setTimeout(()=>{
        resolve(4)
    }, 0)
})
p.then((res)=>{
    //4 res
    console.log(res, 'res')
})
p.then((res1)=>{
    //4 res1
    console.log(res1, 'res1')
})

我们分别调用了两次then，如果是一个变量的话，最后肯定只会运行后一个then，把之前的覆盖了，如果是数组的话，两个then都能正常运行。

至此，我们运行demo，就能如愿以偿的看到运行结果了；一个四十行左右的简单Promise垫片就此完成了。这里贴一下完整的代码：

const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected';
export function MyPromise(executor) {
    let that = this;
    this.state = PENDING;  //状态
    this.value = undefined; //成功返回的结果
    this.reason = undefined; //失败的原因
    
    this.onFulfilledCallback = []; //存成功时需要执行的回调函数
    this.onRejectedCallback = []; //存失败时需要执行的回调函数

    //成功时的回调
    function resolve (value) {
        if (that.state === PENDING) {
            that.state = FULFILLED; //状态改变
            that.value = value;
            
            //异步执行，同步任务执行完以后才执行，在这里执行由于state值没来得及修改而没有执行的回调函数
            setTimeout(() => {
                that.onFulfilledCallback.forEach(callback => callback(value));
            });
        }
    }

    //失败时的回调
    function reject (reason) {
        if (that.state === PENDING) {
            that.state = REJECTED;
            that.reason = reason;
         
            //异步执行，同步任务执行完以后才执行，在这里执行由于state值没来得及修改而没有执行的回调函数
            setTimeout(() => {
                that.onRejectedCallback.forEach(callback => callback(reason))；
            });
        }
    }

    try { 
        executor(resolve, reject);
    } catch (err) {
        reject(err);
    }

    MyPromise.prototype.then = function (onFulfilled, onRejected) {
          //判断回调函数参数，如果不是函数设置默认值
          if(typeof onFulfilled !== 'function') {
               onFulfilled = value => value;
          }
          if(typeof onRejected !== 'function') {
               onRejected = reason => {
                   throw reason; 
             }
          }
          //如果 onFulfilled 或者 onRejected 抛出一个异常 e ，则 promise2 必须拒绝执行，并返回拒因 e。
        if (this.state === FULFILLED) {
            let promise1 = new MyPromise(function (resolve, reject) {
                try {
                    onFulfilled(this.value);
                } catch (error) {
                    reject(error);
                }
            });
            return promise;
        }

        if (this.state === REJECTED) {
            let promise2 = new MyPromise(function (resolve, reject) {
                try {
                    onRejected(this.reason);
                } catch (error) {
                    reject(error);
                }
            });
            return promise2;
        }
        
        //当走到then时，如果状态为PENDING，先不执行回调，将它们存起来，在异步回调中去调用
        if (_this.state === PENDING) {
            typeof onFulfilled === 'function' && this.onFulfilledCallback.push(onFulfilled);
            typeof onRejected === 'function' && this.onRejectedCallback.push(onRejected);
        }
    };
    
    MyPromise.prototype.catch = function (onRejected) {
        //catch函数为then函数的特例，第一个参数为undefined或者null
        return this.then(undefined, onRejected);
    };

    //传入promise数组，
    //1.每当遍历结果是成功时，用计数器记录，当计数器当值等于数组长度，则全部成功，返回成功状态
    //2.如果当数组中任意一个promise的执行结果是rejected时，直接返回失败的状态
     MyPromise.all = (promises) => {
        return new Promise((resolve, reject) => {
            //计数器
            let count = 0;
            //存放结果
            let arr = [];
            for (let i = 0; i < promises.length; i++) {
                promises[i].then(v => {
                    count++;
                    arr[i] = v;
                    if (count === promises.length) {
                        resolve(arr);
                     }
                }, r => reject(r));
            }
        });
    };
     //谁先执行完就返回谁的结果和状态，参数也是promise组成的数组
    MyPromise.race = (promises) => {
        return new Promise((resolve, reject) => {
            for (let i = 0; i < promises; i++) {
                promises[i].then(v => {
                   //谁的回调先执行就先返回谁
                    resolve(v);
                }, r => reject(r));
            }
        });
    };
} 

本文抄写自网络文章，抄写此文章仅为个人收藏，分享知识，如有侵权，请联系博主进行删除。
原文作者：谢小飞
原文地址：https://zhuanlan.zhihu.com/p/144058361