有关Promise的面试题

1、Promise是什么？说说你对Promise的理解？

Promise是一种异步解决方案，从语法上，它是一个对象，可以获取异步操作的结果。从字面意思上来说，是一种承诺，承诺等一会给你结果。Promise有中状态： pending（进行中）、fulfiled（已完成）、rejected（已失败），状态一旦改变就不会在改变，这也是它和事件的区别。

2、Promise是用来解决什么问题的？

用来解决两个问题：

（1）回调地狱，代码难以维护。

（2）Promise支持多个异步，同时可以得到异步请求的数据。

3、Promise.all和Promise.race方法有什么区别？

Promise.all 谁跑的慢，以谁为准执行回调。

Promise.race 谁跑的快，以谁为准执行回调。

4、Promise的实现？

第一步：创建一个MyPromise构造函数，同时在原型上实现一个then方法。

function MyPromise(fn) {
    let self = this;     //缓存this
    self.value = null;  //成功时的值
    self.error = null;  //失败时的原因
    self.onFulfilled = null; //成功的回调函数
    self.onRejected = null;  //失败的回调函数
    function resolve(value) {
        //异步
        self.value = value;
        self.onFulfilled(self.value); //resolve时执行成功回调
    }
    function reject(error) {
        self.error = error;
        self.onRejected(self.error); //reject时执行失败的回调
    }
    fn(resolve,reject);
}

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

第二步：在构造函数内部定义resolve和reject方法。

function resolve(value) {
    self.value = value;
    self.onFulfilled(self.value); //resolve时执行成功回调
}

function reject(error) {
    self.error = error;
    self.onRejected(self.error); //reject时执行失败的回调
}

第三步：支持同步任务、支持三种状态、支持链式调用。

function resolve(value) {
    if(self.status === PENDING) {
        setTimeout(()=>{
            self.status = FULFILLED;
            self.value = value;
            self.onFulfilledCallbacks.forEach((callback) => callback(self.value));
        })
    }
}

function reject(error) {
    if(self.status === PENDING) {
        setTimeout(()=>{
            self.status = REJECTED;
            self.error = error;
            self.onRejectedCallbacks.forEach((callback) => callback(self.error));
        })
    }
}

MyPromise.prototype.then = function(onFulfilled,onRejected) {
    if(this.status === PENDING) {
        this.onFulfilledCallbacks.push(onFulfilled);
        this.onRejectedCallbacks.push(onRejected);
    }else if(this.status = FULFILLED) {
        onFulfilled(this.value);
    }else {
        onRejected(this.error);
    }
    return this;
}

第四步：达到Promises/A+规范

首先来可以了解一下Promises/A+规范：

Promises/A+规范原版

Promises/A+规范中文版

Promises/A+规范主要是在其他情况下给予一定的判断。

if(x !== null && ((typeof x === 'object') || (typeof x === 'function'))) {
    try {
        //是否是thenable对象（具有then方法的对象/函数）
        //2.3.3.1 将then赋为x.then
        //2.3.3.3 如果 then 是一个函数，以x为this调用then函数，
        //且第一个参数是resolvePromise，第二个参数是rejectPromise
        let then = x.then;
        if(typeof then === "function") {
            then.call(x,y => {
                if(called) return;
                called = true;
                resolvePromise(bridgePromise,x,resolve,reject);
            },error => {
                if(called) true;
                called = true;
                reject(error);
            });
        }else {
            //2.3.3.4 如果 then不是一个函数，则 以x为值fulfill promise。
            resolve(x);
        }
    } catch(e) {
        //2.3.3.2 如果在取x.then值时抛出了异常，则以这个异常做为原因将promise拒绝
        if (called) return;
        called = true;
        reject(e);
    }
}else {
    resolve(x);
}