精华内容
下载资源
问答
  • Promise面试题汇总

    万次阅读 多人点赞 2020-08-24 23:18:40
    Promise回顾 Promise基础 Promise的catch、then、finally Promise的all和race Async、await 其他题目

    在这里插入图片描述

    关注微信公众号:前端充电宝,获取最新原创文章!

    下面题目主要和Promise以及JS的事件循环有关,题目均为代码输出问题(面试题从文章第二部分开始)。

    Promise回顾

    首先来回顾一下Promise是什么。

    Promise 是异步编程的一种解决方案,比传统的解决方案回调函数和事件更合理和更强大。

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

    (1)Promise的实例有三个状态:

    • Pending(进行中)
    • Resolved(已完成)
    • Rejected(已拒绝)

    当把一件事情交给promise时,它的状态就是Pending,任务完成了状态就变成了Resolved、没有完成失败了就变成了Rejected。

    (2)Promise的实例有两个过程

    • pending -> fulfilled : Resolved(已完成)
    • pending -> rejected:Rejected(已拒绝)

    需要注意:一旦从进行状态变成为其他状态就永远不能更改状态了。

    特点:

    • 将异步操作以同步操作的流程表达出来,避免了层层嵌套的回调函数。流程更加清晰,代码更加优雅。
    • Promise对象提供统一的接口,使得控制异步操作更加容易。

    缺点:

    • 无法取消Promise,一旦新建它就会立即执行,无法中途取消。
    • 如果不设置回调函数,Promise内部抛出的错误,不会反应到外部。
    • 当处于pending状态时,无法得知目前进展到哪一个阶段(刚刚开始还是即将完成)。

    实例:

    当我们在构造 Promise 的时候,构造函数内部的代码是立即执行的:

    new Promise((resolve, reject) => {
      console.log('new Promise')
      resolve('success')
    })
    console.log('finifsh')
    // new Promise -> finifsh
    

    Promise 实现了链式调用,也就是说每次调用 then 之后返回的都是一个 Promise,并且是一个全新的 Promise,原因也是因为状态不可变。如果你在 then 中 使用了 return,那么 return 的值会被 Promise.resolve() 包装

    Promise.resolve(1)
      .then(res => {
        console.log(res) // => 1
        return 2 // 包装成 Promise.resolve(2)
      })
      .then(res => {
        console.log(res) // => 2
      })
    

    当然了,Promise 也很好地解决了回调地狱的问题,可以把之前的回调地狱例子改写为如下代码:

    ajax(url)
      .then(res => {
          console.log(res)
          return ajax(url1)
      }).then(res => {
          console.log(res)
          return ajax(url2)
      }).then(res => console.log(res))
    

    前面都是在讲述 Promise 的一些优点和特点,其实它也是存在一些缺点的,比如无法取消 Promise,错误需要通过回调函数捕获。

    Promise基础

    1、下面代码的执行结果是

    const promise = new Promise((resolve, reject) => {
      console.log(1);
      console.log(2);
    });
    promise.then(() => {
      console.log(3);
    });
    console.log(4);
    

    最后应该输出1 2 4。这样最主要的就是3,要知道promise.then是微任务,会在所有的宏任务执行完之后才会执行,同时需要promise内部的状态发生变化,因为这里内部没有发生变化,所以不输出3。

    2、下面代码的执行结果是

    const promise1 = new Promise((resolve, reject) => {
      console.log('promise1')
      resolve('resolve1')
    })
    const promise2 = promise1.then(res => {
      console.log(res)
    })
    console.log('1', promise1);
    console.log('2', promise2);
    

    输出结果如下:

    'promise1'
    '1' Promise{<resolved>: 'resolve1'}
    '2' Promise{<pending>}
    'resolve1'
    

    需要注意的是,直接打印promise1,会打印出它的状态值和参数。

    这里说一下这道题的具体思路:

    • script是一个宏任务,按照顺序执行这些代码
    • 首先进入Promise,执行该构造函数中的代码,打印promise1
    • 碰到resolve函数, 将promise1的状态改变为resolved, 并将结果保存下来
    • 碰到promise1.then这个微任务,将它放入微任务队列
    • promise2是一个新的状态为pendingPromise
    • 执行同步代码1, 同时打印出promise1的状态是resolved
    • 执行同步代码2,同时打印出promise2的状态是pending
    • 宏任务执行完毕,查找微任务队列,发现promise1.then这个微任务且状态为resolved,执行它。

    这样,就执行完了所有的的代码。

    3、下面代码的执行结果是

    const promise = new Promise((resolve, reject) => {
      console.log(1);
      setTimeout(() => {
        console.log("timerStart");
        resolve("success");
        console.log("timerEnd");
      }, 0);
      console.log(2);
    });
    promise.then((res) => {
      console.log(res);
    });
    console.log(4);
    
    • 首先遇到Promise构造函数,会先执行里面的内容,打印1
    • 遇到steTimeout,它是一个宏任务,被推入宏任务队列
    • 接下继续执行,打印出2
    • 由于Promise的状态此时还是pending,所以promise.then先不执行
    • 继续执行下面的同步任务,打印出4
    • 微任务队列此时没有任务,继续执行下一轮宏任务,执行steTimeout
    • 首先执行timerStart,然后遇到了resolve,将promise的状态改为resolved且保存结果并将之前的promise.then推入微任务队列,再执行timerEnd
    • 执行完这个宏任务,就去执行微任务promise.then,打印出resolve的结果

    4、 下面代码的执行结果是

    Promise.resolve().then(() => {
      console.log('promise1');
      const timer2 = setTimeout(() => {
        console.log('timer2')
      }, 0)
    });
    const timer1 = setTimeout(() => {
      console.log('timer1')
      Promise.resolve().then(() => {
        console.log('promise2')
      })
    }, 0)
    console.log('start');
    

    这个题目就有点绕了,下面来梳理一下:

    • 首先,Promise.resolve().then是一个微任务,加入微任务队列
    • 执行timer1,它是一个宏任务,加入宏任务队列
    • 继续执行下面的同步代码,打印出start
    • 这样第一轮的宏任务就执行完了,开始执行微任务,打印出promise1
    • 遇到timer2,它是一个宏任务,将其加入宏任务队列
    • 这样第一轮的微任务就执行完了,开始执行第二轮宏任务,指执行定时器timer1,打印timer1
    • 遇到Promise,它是一个微任务,加入微任务队列
    • 开始执行微任务队列中的任务,打印promise2
    • 最后执行宏任务timer2定时器,打印出timer2

    这个题目还是比较复杂的,值得去认真理解一下。

    执行结果:

    'start'
    'promise1'
    'timer1'
    'promise2'
    'timer2'
    

    5、 下面代码的执行结果是

    const promise = new Promise((resolve, reject) => {
        resolve('success1');
        reject('error');
        resolve('success2');
    });
    promise.then((res) => {
        console.log('then:', res);
    }).catch((err) => {
        console.log('catch:', err);
    })
    

    执行结果为:then:success1

    这个题目考察的就是Promise的状态在发生变化之后,就不会再发生变化。开始状态由pending变为resolve,说明已经变为已完成状态,下面的两个状态的就不会再执行,同时下面的catch也不会捕获到错误。

    6、下面代码的执行结果是

    Promise.resolve(1)
      .then(2)
      .then(Promise.resolve(3))
      .then(console.log)
    

    执行结果为:

    1
    Promise {<fulfilled>: undefined}
    

    Promise.resolve方法的参数如果是一个原始值,或者是一个不具有then方法的对象,则Promise.resolve方法返回一个新的Promise对象,状态为resolved,Promise.resolve方法的参数,会同时传给回调函数。

    then方法接受的参数是函数,而如果传递的并非是一个函数,它实际上会将其解释为then(null),这就会导致前一个Promise的结果会传递下面。

    7、下面代码的执行结果是

    const promise1 = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve('success')
      }, 1000)
    })
    const promise2 = promise1.then(() => {
      throw new Error('error!!!')
    })
    console.log('promise1', promise1)
    console.log('promise2', promise2)
    setTimeout(() => {
      console.log('promise1', promise1)
      console.log('promise2', promise2)
    }, 2000)
    

    输出的结果如下:

    promise1 Promise {<pending>}
    promise2 Promise {<pending>}
    
    Uncaught (in promise) Error: error!!!
    promise1 Promise {<fulfilled>: "success"}
    promise2 Promise {<rejected>: Error: error!!}
    

    这个就比较好理解了,和上面的几个题目思路类似。

    Promise的catch、then、finally

    8、下面代码的执行结果是

    Promise.resolve(1)
      .then(res => {
        console.log(res);
        return 2;
      })
      .catch(err => {
        return 3;
      })
      .then(res => {
        console.log(res);
      });
    

    输出结果为:1 2

    Promise可以链式调用,因为每次调用 .then 或者 .catch 都会返回一个新的 promise,从而实现了链式调用, 它并不像一般我们任务的链式调用一样return this。

    上面的输出结果之所以依次打印出1和2,是因为resolve(1)之后走的是第一个then方法,并没有走catch里,所以第二个then中的res得到的实际上是第一个then的返回值。并且return 2会被包装成resolve(2),被最后的then打印输出2。

    9、下面代码的执行结果是

    Promise.resolve().then(() => {
      return new Error('error!!!')
    }).then(res => {
      console.log("then: ", res)
    }).catch(err => {
      console.log("catch: ", err)
    })
    

    返回任意一个非 promise 的值都会被包裹成 promise 对象,因此这里的return new Error('error!!!')也被包裹成了return Promise.resolve(new Error('error!!!'))

    因此它被then捕获而不是catch,输出结果为:

    "then: " "Error: error!!!"
    

    10、下面代码的执行结果是

    const promise = Promise.resolve().then(() => {
      return promise;
    })
    promise.catch(console.err)
    

    这里其实是一个坑,.then.catch 返回的值不能是 promise 本身,否则会造成死循环。所以这道题会报错:

    Uncaught (in promise) TypeError: Chaining cycle detected for promise #<Promise>
    

    11、下面代码的执行结果是

    Promise.resolve(1)
      .then(2)
      .then(Promise.resolve(3))
      .then(console.log)
    

    看到这个题目,好多的then,实际上我们只需要记住一个原则:.then.catch 的参数期望是函数,传入非函数则会发生值透传

    第一个then和第二个then中传入的都不是函数,一个是数字,一个是对象,因此发生了透传,将resolve(1) 的值直接传到最后一个then里。

    所以输出结果为:1

    12、下面代码的执行结果是

    Promise.reject('err!!!')
      .then((res) => {
        console.log('success', res)
      }, (err) => {
        console.log('error', err)
      }).catch(err => {
        console.log('catch', err)
      })
    

    .then函数中的两个参数:

    • 第一个参数是用来处理Promise成功的函数
    • 第二个则是处理失败的函数

    也就是说Promise.resolve('1')的值会进入成功的函数,Promise.reject('2')的值会进入失败的函数。

    在这道题中,错误直接被then的第二个参数捕获了,所以就不会被catch捕获了,输出结果为:'error' 'error!!!'

    但是,如果是像下面这样:

    Promise.resolve()
      .then(function success (res) {
        throw new Error('error!!!')
      }, function fail1 (err) {
        console.log('fail1', err)
      }).catch(function fail2 (err) {
        console.log('fail2', err)
      })
    

    then的第一参数中抛出了错误,那么他就不会被第二个参数不活了,而是被后面的catch捕获到,所以输出结果为:

    fail2 Error: error!!!
                  at success 
    

    13、下面代码的执行结果是

    Promise.resolve('1')
      .then(res => {
        console.log(res)
      })
      .finally(() => {
        console.log('finally')
      })
    Promise.resolve('2')
      .finally(() => {
        console.log('finally2')
      	return '我是finally2返回的值'
      })
      .then(res => {
        console.log('finally2后面的then函数', res)
      })
    

    .finally()一般用的很少,只要记住以下几点就可以了:

    • .finally()方法不管Promise对象最后的状态如何都会执行
    • .finally()方法的回调函数不接受任何的参数,也就是说你在.finally()函数中是无法知道Promise最终的状态是resolved还是rejected
    • 它最终返回的默认会是一个上一次的Promise对象值,不过如果抛出的是一个异常则返回异常的Promise对象。
    • finally本质上是then方法的特例

    上面的代码的输出结果为:

    1
    finally2
    finally
    finally2后面的then函数 2
    

    再开看一下.finally()的错误捕获:

    Promise.resolve('1')
      .finally(() => {
        console.log('finally1')
        throw new Error('我是finally中抛出的异常')
      })
      .then(res => {
        console.log('finally后面的then函数', res)
      })
      .catch(err => {
        console.log('捕获错误', err)
      })
    

    输出结果为:

    'finally1'
    '捕获错误' Error: 我是finally中抛出的异常
    

    Promise的all和race

    • .all()的作用是接收一组异步任务,然后并行执行异步任务,并且在所有异步操作执行完后才执行回调。

    • .race()的作用是接收一组异步任务,然后并行执行异步任务,只保留取第一个执行完成的异步操作的结果,其他的方法仍在执行,不过执行结果会被抛弃。

    14、下面代码的执行结果是

    function runAsync (x) {
        const p = new Promise(r => setTimeout(() => r(x, console.log(x)), 1000))
        return p
    }
    
    Promise.all([runAsync(1), runAsync(2), runAsync(3)]).then(res => console.log(res))
    

    首先,我们定义了一个Promise,来异步执行函数runAsync,该函数传入一个值x,然后间隔一秒后打印出这个x。

    之后再使用Promise.all来执行这个函数,结果如下:

    1
    2
    3
    [1, 2, 3]
    

    执行的时候,看到一秒之后输出了1,2,3,同时输出了数组[1, 2, 3],三个函数是同步执行的,并且在一个回调函数中返回了所有的结果。并且结果和函数的执行顺序是一致的。

    15、下面代码的执行结果是

    function runAsync (x) {
      const p = new Promise(r => setTimeout(() => r(x, console.log(x)), 1000))
      return p
    }
    function runReject (x) {
      const p = new Promise((res, rej) => setTimeout(() => rej(`Error: ${x}`, console.log(x)), 1000 * x))
      return p
    }
    Promise.all([runAsync(1), runReject(4), runAsync(3), runReject(2)])
           .then(res => console.log(res))
           .catch(err => console.log(err))
    

    输出结果:

    // 1s后输出
    1
    3
    // 2s后输出
    2
    Error: 2
    // 4s后输出
    4
    

    我们可以看到。catch捕获到了第一个错误,在这道题目中最先的错误就是runReject(2)的结果。

    如果一组异步操作中有一个异常都不会进入.then()的第一个回调函数参数中。会被.then()的第二个回调函数捕获。

    16、下面代码的执行结果是

    下面再来看一下race:

    function runAsync (x) {
      const p = new Promise(r => setTimeout(() => r(x, console.log(x)), 1000))
      return p
    }
    Promise.race([runAsync(1), runAsync(2), runAsync(3)])
      .then(res => console.log('result: ', res))
      .catch(err => console.log(err))
    

    执行结果:

    1
    'result: ' 1
    2
    3
    

    then只会捕获第一个成功的方法,其他的函数虽然还会继续执行,但是不是被then捕获了。

    17、下面代码的执行结果是

    function runAsync(x) {
      const p = new Promise(r =>
        setTimeout(() => r(x, console.log(x)), 1000)
      );
      return p;
    }
    function runReject(x) {
      const p = new Promise((res, rej) =>
        setTimeout(() => rej(`Error: ${x}`, console.log(x)), 1000 * x)
      );
      return p;
    }
    Promise.race([runReject(0), runAsync(1), runAsync(2), runAsync(3)])
      .then(res => console.log("result: ", res))
      .catch(err => console.log(err));
    

    输出结果为:

    0
    Error: 0
    1
    2
    3
    

    可以看到在catch捕获到第一个错误之后,后面的代码还不执行,不过不会再被捕获了。

    注意:allrace传入的数组中如果有会抛出异常的异步任务,那么只有最先抛出的错误会被捕获,并且是被then的第二个参数或者后面的catch捕获;但并不会影响数组中其它的异步任务的执行。

    Async、await

    说到Promise就不得不提以下async和await,他们同样是用来执行异步代码。

    18、下面代码的执行结果是

    async function async1() {
      console.log("async1 start");
      await async2();
      console.log("async1 end");
    }
    async function async2() {
      console.log("async2");
    }
    async1();
    console.log('start')
    

    输出结果为:

    async1 start
    async2
    start
    async1 end
    
    • 首先执行函数中的同步代码async1 start,之后碰到了await,它会阻塞async1后面代码的执行,因此会先去执行async2中的同步代码async2,然后跳出async1
    • 跳出async1函数后,执行同步代码start
    • 在一轮宏任务全部执行完之后,再来执行await后面的内容async1 end

    这里可以理解为await后面的语句相当于放到了new Promise中,下一行及之后的语句相当于放在Promise.then中。

    19、下面代码的执行结果是

    async function async1() {
      console.log("async1 start");
      await async2();
      console.log("async1 end");
      setTimeout(() => {
        console.log('timer1')
      }, 0)
    }
    async function async2() {
      setTimeout(() => {
        console.log('timer2')
      }, 0)
      console.log("async2");
    }
    async1();
    setTimeout(() => {
      console.log('timer3')
    }, 0)
    console.log("start")
    

    输出结果为:

    async1 start
    async2
    start
    async1 end
    timer2
    timer3
    timer1
    

    这个题目就稍微就有点麻烦了。看一下执行的步骤:

    • 首先进入async1,打印出async1 start,这个是毋庸置疑的
    • 之后遇到async2,进入async2,遇到定时器timer2,加入宏任务队列,之后打印async2
    • 由于async2阻塞了后面代码的执行,所以执行后面的定时器timer3,将其加入宏任务队列,之后打印start
    • 然后执行async2后面的代码,打印出async1 end,遇到定时器timer1,将其加入宏任务队列
    • 最后,宏任务队列有三个任务,先后顺序为timer2timer3timer1,没有微任务,所以直接所有的宏任务按照先进先出的原则执行。

    实际上也不是很难,只要理清事件循环机制,就很容易做出来啦!

    20、下面代码的执行结果是

    async function async1 () {
      console.log('async1 start');
      await new Promise(resolve => {
        console.log('promise1')
      })
      console.log('async1 success');
      return 'async1 end'
    }
    console.log('srcipt start')
    async1().then(res => console.log(res))
    console.log('srcipt end')
    

    输出结果:

    script start
    async1 start
    promise1
    script end
    

    这里需要注意的是在async1await后面的Promise是没有返回值的,也就是它的状态始终是pending状态,所以在await之后的内容是不会执行的,也包括async1后面的 .then

    21、下面代码的执行结果是

    async function async1 () {
      console.log('async1 start');
      await new Promise(resolve => {
        console.log('promise1')
        resolve('promise1 resolve')
      }).then(res => console.log(res))
      console.log('async1 success');
      return 'async1 end'
    }
    console.log('srcipt start')
    async1().then(res => console.log(res))
    console.log('srcipt end')
    

    这里对上面一题进行了改造,加上了resolve,来看看输出结果:

    script start
    async1 start
    promise1
    script end
    promise1 resolve
    async1 success
    async1 end
    

    这个就不难理解了,不多解释。

    22、下面代码的执行结果是

    来看一道字节跳动面试题:

    async function async1() {
      console.log("async1 start");
      await async2();
      console.log("async1 end");
    }
    
    async function async2() {
      console.log("async2");
    }
    
    console.log("script start");
    
    setTimeout(function() {
      console.log("setTimeout");
    }, 0);
    
    async1();
    
    new Promise(function(resolve) {
      console.log("promise1");
      resolve();
    }).then(function() {
      console.log("promise2");
    });
    console.log('script end')
    
    script start
    async1 start
    async2
    promise1
    script end
    async1 end
    promise2
    setTimeout
    

    也不多解释了,只是流程比较长,实际上难度并不是很大。

    23、下面代码的执行结果是

    async function async1 () {
      await async2();
      console.log('async1');
      return 'async1 success'
    }
    async function async2 () {
      return new Promise((resolve, reject) => {
        console.log('async2')
        reject('error')
      })
    }
    async1().then(res => console.log(res))
    

    输出结果为:

    async2
    Uncaught (in promise) error
    

    我们可以看到,如果async函数中抛出了错误,就会终止错误结果,不会继续向下执行。

    如果想要让错误不足之处后面的代码执行,可以使用catch来捕获:

    async function async1 () {
      await Promise.reject('error!!!').catch(e => console.log(e))
      console.log('async1');
      return Promise.resolve('async1 success')
    }
    async1().then(res => console.log(res))
    console.log('script start')
    

    这样的输出结果就是:

    script start
    error!!!
    async1
    async1 success
    

    其他题目

    24、下面代码的执行结果是

    const first = () => (new Promise((resolve, reject) => {
        console.log(3);
        let p = new Promise((resolve, reject) => {
            console.log(7);
            setTimeout(() => {
                console.log(5);
                resolve(6);
                console.log(p)
            }, 0)
            resolve(1);
        });
        resolve(2);
        p.then((arg) => {
            console.log(arg);
        });
    }));
    first().then((arg) => {
        console.log(arg);
    });
    console.log(4);
    

    这是一道比较综合的题目,看一下执行结果:

    3
    7
    4
    1
    2
    5
    Promise{<resolved>: 1}
    

    说一下执行的步骤吧:

    • 首先会进入Promise,打印出3,之后进入下面的Promise,打印出7
    • 遇到了定时器,将其加入宏任务队列
    • 执行Promise p中的resolve,状态变为resolved,返回值为1
    • 执行Promise first中的resolve,状态变为resolved,返回值为2
    • 遇到p.then,将其加入微任务队列,遇到first().then,将其加入任务队列
    • 执行外面的代码,打印出4
    • 这样第一轮宏任务就执行完了,开始执行微任务队列中的任务,先后打印出1和2
    • 这样微任务就执行完了,开始执行下一轮宏任务,宏任务队列中有一个定时器,执行它,打印出5,由于执行已经变为resolved状态,所以resolve(6)不会再执行
    • 最后console.log(p)打印出Promise{<resolved>: 1}

    25、下面代码的执行结果是

    const async1 = async () => {
      console.log('async1');
      setTimeout(() => {
        console.log('timer1')
      }, 2000)
      await new Promise(resolve => {
        console.log('promise1')
      })
      console.log('async1 end')
      return 'async1 success'
    } 
    console.log('script start');
    async1().then(res => console.log(res));
    console.log('script end');
    Promise.resolve(1)
      .then(2)
      .then(Promise.resolve(3))
      .catch(4)
      .then(res => console.log(res))
    setTimeout(() => {
      console.log('timer2')
    }, 1000)
    

    输出结果为:

    script start
    async1
    promise1
    script end
    1
    timer2
    timer1                     
    

    这道题比较简单,简单说一下执行的过程:

    • 首先执行同步带吗,打印出script start
    • 遇到定时器timer1将其加入宏任务队列
    • 之后是执行Promise,打印出promise1,由于Promise没有返回值,所以后面的代码不会执行
    • 然后执行同步代码,打印出script end
    • 继续执行下面的Promise,.then和.catch期望参数是一个函数,这里传入的是一个数字,因此就会发生值渗透,将resolve(1)的值传到最后一个then,直接打印出1
    • 遇到第二个定时器,将其加入到微任务队列,执行微任务队列,按顺序依次执行两个定时器,但是由于定时器时间的原因,会在两秒后先打印出timer2,在四秒后打印出timer1

    26、下面代码的执行结果是

    const p1 = new Promise((resolve) => {
      setTimeout(() => {
        resolve('resolve3');
        console.log('timer1')
      }, 0)
      resolve('resovle1');
      resolve('resolve2');
    }).then(res => {
      console.log(res)  // resolve1
      setTimeout(() => {
        console.log(p1)
      }, 1000)
    }).finally(res => {
      console.log('finally', res)
    })
    

    执行结果为:

    resolve1
    finally  undefined
    timer1
    Promise{<resolved>: undefined}
    

    需要注意的是最后一个定时器打印出的p1其实是.finally的返回值,我们知道.finally的返回值如果在没有抛出错误的情况下默认会是上一个Promise的返回值,而这道题中.finally上一个Promise是.then(),但是这个.then()并没有返回值,所以p1打印出来的Promise的值会是undefined,如果在定时器的下面加上一个return 1,则值就会变成1。

    最后

    关于Promise代码输出的问题就先说这些吧,实际上,代码输出问题往往和事件循环结合在一起,只要理解了事件循环的过程,做这些题目也就毫无压力了。其实,Promise的面试题还是有很多的,不止有代码输出题,还有手写代码,Promise原理,实现Promise A+等等,后面有时间再总结!

    展开全文
  • promise面试题

    2021-06-29 16:40:04
    // new Promise(function(resolve) { // console.log('promise1'); // resolve(); // }).then(function() { // console.log('promise2'); // }); // console.log('script end'); // let body = document.body; // ...
    
    // async function async1() {
    //     console.log('async1 start');
    //     await async2();
    //     // 下一行代码放到了微任务队列当中
    //     console.log('async1 end');
    // }
    // async function async2() {
    //     console.log('async2');
    // }
    // console.log('script start');
    // setTimeout(function() {
    //     console.log('setTimeout');
    // }, 0)
    // async1();
    // new Promise(function(resolve) {
    //     console.log('promise1');
    //     resolve();
    // }).then(function() {
    //     console.log('promise2');
    // });
    // console.log('script end');
    
    
    // let body = document.body;
    // body.addEventListener('click', function () {
    //     Promise.resolve().then(() => {
    //         console.log(1);
    //     });
    //     console.log(2);
    // });
    // body.addEventListener('click', function () {
    //     Promise.resolve().then(() => {
    //         console.log(3);
    //     });
    //     console.log(4);
    // });
    
    
    // console.log('start');
    // let intervalId;
    // Promise.resolve().then(() => {
    //     console.log('p1');
    // }).then(() => {
    //     console.log('p2');
    // });
    // setTimeout(() => {
    //     Promise.resolve().then(() => {
    //         console.log('p3');
    //     }).then(() => {
    //         console.log('p4');
    //     });
    //     intervalId = setInterval(() => {
    //         console.log('interval');
    //     }, 3000);
    //     console.log('timeout1');
    // }, 0);
    
    
    // setTimeout(() => {
    //     console.log('a');
    // });
    // Promise.resolve().then(() => {
    //     console.log('b');
    // }).then(() => {
    //     return Promise.resolve('c').then(data => {
    //         setTimeout(() => {
    //             console.log('d')
    //         });
    //         console.log('f');
    //         return data;
    //     });
    // }).then(data => {
    //     console.log(data);
    // });
    
    
    // function func1() {
    //     console.log('func1 start');
    //     return new Promise(resolve => {
    //         resolve('OK');
    //     });
    // }
    // function func2() {
    //     console.log('func2 start');
    //     return new Promise(resolve => {
    //         setTimeout(() => {
    //             resolve('OK');
    //         }, 10);
    //     });
    // }
    // console.log(1);
    // setTimeout(async () => {
    //     console.log(2);
    //     await func1();
    //     console.log(3);
    // }, 20);
    // for (let i = 0; i < 90000000; i++) {} //循环大约要进行80MS左右
    // console.log(4);
    // func1().then(result => {
    //     console.log(5);
    // });
    // func2().then(result => {
    //     console.log(6);
    // });
    // setTimeout(() => {
    //     console.log(7);
    // }, 0);
    // console.log(8);
    
    
    展开全文
  • 常见Promise面试题

    千次阅读 2019-01-16 20:34:41
    常见Promise面试题 题目一 const promise = new Promise((resolve, reject) => { console.log(1); resolve(); console.log(2); }) promise.then(() => { console.log(3...

    常见Promise面试题

    题目一

    const promise = new Promise((resolve, reject) => {
        console.log(1);
        resolve();
        console.log(2);
    })
    promise.then(() => {
        console.log(3);
    })
    console.log(4);

    解析
    首先Promise新建后立即执行,所以会先输出1,2,而Promise.then()内部的代码在当次事件循环的结尾立即执行,所以会先输出4,最后输出3.
    答案:1 2 4 3

    题目二

    const promise = new Promise((resolve, reject) => {
        resolve('success1');
        reject('error');
        resolve('success2');
    });
    promise.then((res) => {
        console.log('then:', res);
    }).catch((err) => {
        console.log('catch:', err);
    })

    解析
    resolve函数Promise对象的状态从“未完成”变为“成功”(即从pending变为resolved),在异步操作成功时调用,并将异步操作的结果,作为参数传递出去;
    reject函数将Promise对象的状态从“未完成”变为“失败”(即从pending变为rejected),在异步操作失败时调用,并将异步操作报出的错误,作为参数传递出去。
    而一旦状态改变,就不会有再变。
    所以代码中的reject('error');不会有作用。
    Promise只能resolve一次,剩下的调用都会被忽略。
    所以第二次resolve('success');也不会有作用。
    答案:then:success1

    题目三

    Promise.resolve(1)
      .then(2)
      .then(Promise.resolve(3))
      .then(console.log)

    解析
    Promise.resolve方法的参数如果是一个原始值,或者是一个不具有then方法的对象,则Promise.resolve方法返回一个新的Promise对象,状态为resolved,Promise.resolve方法的参数,会同时传给回调函数。
    then方法接受的参数是函数,而如果传递的并非是一个函数,它实际上会将其解释为then(null),这就会导致前一个Promise的结果会传递下面。
    答案 1

    题目四

    红灯3秒亮一次,绿灯1秒亮一次,黄灯2秒亮一次;如何让三个灯不断交替重复亮灯?(用Promise实现)三个亮灯函数已经存在:

    function red() {
        console.log('red');
    }
    function green() {
        console.log('green');
    }
    function yellow() {
        console.log('yellow');
    }

    解析
    红灯3秒亮一次,绿灯1秒亮一次 ,黄灯2秒亮一次,意思就是3秒执行一次red函数,2秒执行一次green函数,1秒执行一次yellow函数,不断交替重复亮灯,意思就是按照这个顺序一直执行这3个函数,这步可以利用递归来实现。
    答案:

    function red() {
        console.log('red');
    }
    function green() {
        console.log('green');
    }
    function yellow() {
        console.log('yellow');
    }
    
    var light = function (timmer, cb) {
        return new Promise(function (resolve, reject) {
            setTimeout(function () {
                cb();
                resolve();
            }, timmer);
        });
    };
    
    var step = function () {
        Promise.resolve().then(function () {
            return light(3000, red);
        }).then(function () {
            return light(2000, green);
        }).then(function () {
            return light(1000, yellow);
        }).then(function () {
            step();
        });
    }
    
    step();

    题目五

    实现mergePromise函数,把传进去的数组按顺序先后执行,并且把返回的数据先后放到数组data中。

    const timeout = ms => new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve();
        }, ms);
    });
    
    const ajax1 = () => timeout(2000).then(() => {
        console.log('1');
        return 1;
    });
    
    const ajax2 = () => timeout(1000).then(() => {
        console.log('2');
        return 2;
    });
    
    const ajax3 = () => timeout(2000).then(() => {
        console.log('3');
        return 3;
    });
    
    const mergePromise = ajaxArray => {
        // 在这里实现你的代码
    
    };
    
    mergePromise([ajax1, ajax2, ajax3]).then(data => {
        console.log('done');
        console.log(data); // data 为 [1, 2, 3]
    });
    
    // 要求分别输出
    // 1
    // 2
    // 3
    // done
    // [1, 2, 3]

    解析
    首先ajax1,ajax2,ajax3都是函数,只是这些函数执行后会返回一个Promise,按照题目要求只要顺序执行这三个函数就好了,然后把结果放到data中,但是这些函数都是异步操作,想要按顺序执行输出1,2,3并非那么容易,举例

    function A() {
        setTimeout(function () {
            console.log('a');
        }, 3000);
    }
    
    function B() {
        setTimeout(function () {
            console.log('b');
        }, 1000);
    }
    
    A();
    B();
    
    // b
    // a

    例子中按照顺序执行A,B但是输出的结果却是b,a。因为对于异步函数来说,并不会按顺序执行完一个,再执行后一个。
    这道题主要考察用Promise控制异步流程,让这些涵涵素,一个执行完,再执行下一个。
    答案

    // 保存数组中的函数执行后的结果
    var data = [];
    
    // Promise.resolve方法调用时不带参数,直接返回一个resolved状态的 Promise 对象。
    var sequence = Promise.resolve();
    
    ajaxArray.forEach(function (item) {
        // 第一次的 then 方法用来执行数组中的每个函数,
        // 第二次的 then 方法接受数组中的函数执行后返回的结果,
        // 并把结果添加到 data 中,然后把 data 返回。
        sequence = sequence.then(item).then(function (res) {
            data.push(res);
            return data;
        });
    })
    
    // 遍历结束后,返回一个 Promise,也就是 sequence, 他的 [[PromiseValue]] 值就是 data,
    // 而 data(保存数组中的函数执行后的结果) 也会作为参数,传入下次调用的 then 方法中。
    return sequence;

    题目六

    以下代码最后输出什么

    const first = () => (new Promise((resolve, reject) => {
        console.log(3);
        let p = new Promise((resolve, reject) => {
            console.log(7);
            setTimeout(() => {
                console.log(5);
                resolve(6);
            }, 0)
            resolve(1);
        });
        resolve(2);
        p.then((arg) => {
            console.log(arg);
        });
    
    }));
    
    first().then((arg) => {
        console.log(arg);
    });
    console.log(4);

    解析
    这道题主要理解js执行机制
    第一轮事件循环
    先执行宏任务,主script,new Promise立即执行,输出 3,
    执行p这个new Promise操作,输出 7,
    发现setTimeout,将回调函数放入下一轮任务队列(Event Quene),p的then,暂且命名为then1,放入微任务队列,且first也有then,命名为then2,放入微任务队列。执行console.log(4),输出 4,宏任务执行结束。
    再执行微任务,执行then1,输出 1,
    执行then2,输出 3.
    第一轮事件循环结束,开始执行第二轮。
    第二轮事件循环
    先执行宏任务里面的,也就是setTimeout的回调,输出 5.
    resolve(6)不会生效,因为p的Promise状态一旦改变就不会再变化了。
    答案 3 7 4 1 2 5

    题目七

    有8个图片资源的url,已经存储在数组urls中(即urls=['http://example.com/1.jpg',...,'http:''example.com/8.jpg']),而且已经有一个函数function loading,输入一个url链接,返回一个Promise,该Promise在图片下载完成的时候resolve,下载失败则reject。
    但有一个要求,任何时刻同时下载的链接数量不可以超过3个。
    请写一段代码实现这个需求,要求尽可能快速地将所有图片下载完成。

    var urls = ['https://www.kkkk1000.com/images/getImgData/getImgDatadata.jpg', 'https://www.kkkk1000.com/images/getImgData/gray.gif', 'https://www.kkkk1000.com/images/getImgData/Particle.gif', 'https://www.kkkk1000.com/images/getImgData/arithmetic.png', 'https://www.kkkk1000.com/images/getImgData/arithmetic2.gif', 'https://www.kkkk1000.com/images/getImgData/getImgDataError.jpg', 'https://www.kkkk1000.com/images/getImgData/arithmetic.gif', 'https://www.kkkk1000.com/images/wxQrCode2.png'];
    function loadImg(url) {
        return new Promise((resolve, reject) => {
            const img = new Image()
            img.onload = function () {
                console.log('一张图片加载完成');
                resolve();
            }
            img.onerror = reject
            img.src = url
        })
    };

    解析
    题目的意思是需要先并发请求3张图片,当一张图片加载完成后,又会继续发起一张图片的请求,让并发数保持在3个,直到需要加载的图片都全部发起请求。
    用Promise来实现就是,先并发请求3个图片资源,这样可以得到3个Promise,组成一个数组promises,然后不断调用Promise.race来返回最快改变状态的Promise,然后从数组promises中删掉这个Promise对象,再加入一个新的Promise,直到全部的url被取完,最后再使用Promise.all来处理一遍数组promises中没有改变状态的Promise
    答案

    var urls = ['https://www.kkkk1000.com/images/getImgData/getImgDatadata.jpg', 'https://www.kkkk1000.com/images/getImgData/gray.gif', 'https://www.kkkk1000.com/images/getImgData/Particle.gif', 'https://www.kkkk1000.com/images/getImgData/arithmetic.png', 'https://www.kkkk1000.com/images/getImgData/arithmetic2.gif', 'https://www.kkkk1000.com/images/getImgData/getImgDataError.jpg', 'https://www.kkkk1000.com/images/getImgData/arithmetic.gif', 'https://www.kkkk1000.com/images/wxQrCode2.png'];
    function loadImg(url) {
        return new Promise((resolve, reject) => {
            const img = new Image()
            img.onload = function () {
                console.log('一张图片加载完成');
                resolve();
            }
            img.onerror = reject
            img.src = url
        })
    };
    
    function limitLoad(urls, handler, limit) {
        // 对数组做一个拷贝
        const sequence = [].concat(urls)
        let promises = [];
    
        //并发请求到最大数
        promises = sequence.splice(0, limit).map((url, index) => {
            // 这里返回的 index 是任务在 promises 的脚标,用于在 Promise.race 之后找到完成的任务脚标
            return handler(url).then(() => {
                return index
            }); 
        });
    
        // 利用数组的 reduce 方法来以队列的形式执行
        return sequence.reduce((last, url, currentIndex) => {
            return last.then(() => {
                // 返回最快改变状态的 Promise
                return Promise.race(promises)
            }).catch(err => {
                // 这里的 catch 不仅用来捕获 前面 then 方法抛出的错误
                // 更重要的是防止中断整个链式调用
                console.error(err)
            }).then((res) => {
                // 用新的 Promise 替换掉最快改变状态的 Promise
                promises[res] = handler(sequence[currentIndex]).then(() => { return res });
            })
        }, Promise.resolve()).then(() => {
            return Promise.all(promises)
        })
    
    }
    limitLoad(urls, loadImg, 3)
    
    /*
    因为 limitLoad 函数也返回一个 Promise,所以当 所有图片加载完成后,可以继续链式调用
    
    limitLoad(urls, loadImg, 3).then(() => {
        console.log('所有图片加载完成');
    }).catch(err => {
        console.error(err);
    })
    */

    题目八

    封装一个异步加载图片的方法

    function loadImageAsync(url) {
        return new Promise(function(resolve,reject) {
            var image = new Image();
            image.onload = function() {
                resolve(image) 
            };
            image.onerror = function() {
                reject(new Error('Could not load image at' + url));
            };
            image.src = url;
         });
    }   

    欢迎关注

    展开全文
  • ,当天晚上夜黑风高夜深人静的时候,脑海里面依然轮播这道面试题,真的很想知道 Promise 内部到底是个什么逻辑,越想越睡不着~越睡不着越想~ 9150e4e5gy1fqisabwf6sg208a07pgnh.gif 无奈之下,决定参考 Promise A+ ...

    点击上方“蓝色字体”,选择“设为星标

    做积极向上的前端人!

    作者 ITEM 

    原文链接:https://juejin.cn/post/6945319439772434469

    先把罪魁祸首挂在这里给大家群殴 ????

    Promise.resolve().then(() => {
        console.log(0);
        return Promise.resolve(4);
    }).then((res) => {
        console.log(res)
    })
    
    Promise.resolve().then(() => {
        console.log(1);
    }).then(() => {
        console.log(2);
    }).then(() => {
        console.log(3);
    }).then(() => {
        console.log(5);
    }).then(() =>{
        console.log(6);
    })
    
    // 大家先思考一下
    
    

    这道面试题是无意间在微信群里看到的,据说是某厂的面试题。一般关于 Promise 的面试题无非是考察宏微任务、EventLoop 之类的,当我认真去分析这道题的时候,越看越不对劲,感觉有诈!这是要考察啥?

    不管了,先在浏览器输出一下看看 ????

    打印结果:0、1、2、3、4、5、6 ????

    这里 4 怎么跑到 3 后面去了,不讲武德?Why......

    在我看来,这道题有两个 Promise.resolve(),相当于创建两个状态为 fulfilled 的 Promise

    紧随他们后面的第一个 then 方法会交替将其执行函数送入微任务队列排队执行,所以这里的 0 和 1,大家都可以理解,但是接下来执行的不是 console.log(res) 而是 console.log(2)

    如果说需要等待 return Promise.resolve(4) 执行完并将其结果和状态同步给外部的 Promise,那么这里只需要创建一个微任务去处理就应该可以了,也就是 4 会在 2 后面才对,为啥需要创建两个微任务呢? ????

    想了很久,也找很多朋友讨论这个问题,都没有得到有说服力的结论,真是百思不得其解!这样死抠细节,感觉有点浪费时间,毕竟这种面试题在生产中并不会出现,谁会去写这么奇葩的 Promise 代码, 放弃了,不去想了。

    然而 ????,当天晚上夜黑风高夜深人静的时候,脑海里面依然轮播这道面试题,真的很想知道 Promise 内部到底是个什么逻辑,越想越睡不着~越睡不着越想~

    9150e4e5gy1fqisabwf6sg208a07pgnh.gif

    无奈之下,决定参考 Promise A+ 规范手写一版 Promise,看看能不能从实现细节中找到蛛丝马迹。为了方便大家理解,下面我会利用不同 ???? 来介绍手写的细节和思路。文章最后会依据实现细节来探讨这道面试题,有手写经验的可以直接跳过手写 Promise 实现过程,看最后的结论。

    手写前需要先了解这些

    如果感觉对 Promise 还不太熟悉的就先移步 Promise 入门[1],稍微做一下知识预习,了解一下 Promise 的常规用法。

    什么是宏任务与微任务?

    我们都知道 Js 是单线程都,但是一些高耗时操作就带来了进程阻塞问题。为了解决这个问题,Js 有两种任务的执行模式:同步模式(Synchronous)和异步模式(Asynchronous)

    在异步模式下,创建异步任务主要分为宏任务与微任务两种。ES6 规范中,宏任务(Macrotask) 称为 Task, 微任务(Microtask) 称为 Jobs。宏任务是由宿主(浏览器、Node)发起的,而微任务由 JS 自身发起。

    宏任务与微任务的几种创建方式 ????

    宏任务(Macrotask)微任务(Microtask)
    setTimeoutrequestAnimationFrame(有争议)
    setIntervalMutationObserver(浏览器环境)
    MessageChannelPromise.[ then/catch/finally ]
    I/O,事件队列process.nextTick(Node 环境)
    setImmediate(Node 环境)queueMicrotask
    script(整体代码块)

    如何理解 script(整体代码块)是个宏任务呢 ????

    实际上如果同时存在两个 script 代码块,会首先在执行第一个 script 代码块中的同步代码,如果这个过程中创建了微任务并进入了微任务队列,第一个 script 同步代码执行完之后,会首先去清空微任务队列,再去开启第二个 script 代码块的执行。所以这里应该就可以理解 script(整体代码块)为什么会是宏任务。

    什么是 EventLoop ?

    先来看个图

    EventLoop.png
    1. 判断宏任务队列是否为空

    • 不空 --> 执行最早进入队列的任务 --> 执行下一步

    • 空 --> 执行下一步

    • 判断微任务队列是否为空

      • 不空 --> 执行最早进入队列的任务 --> 继续检查微任务队列空不空

      • 空 --> 执行下一步

      因为首次执行宏队列中会有 script(整体代码块)任务,所以实际上就是 Js 解析完成后,在异步任务中,会先执行完所有的微任务,这里也是很多面试题喜欢考察的。需要注意的是,新创建的微任务会立即进入微任务队列排队执行,不需要等待下一次轮回。

      什么是 Promise A+ 规范?

      看到 A+ 肯定会想到是不是还有 A,事实上确实有。其实 Promise 有多种规范,除了前面的 Promise A、promise A+ 还有 Promise/B,Promise/D。目前我们使用的 Promise 是基于 Promise A+ 规范实现的,感兴趣的移步 Promise A+规范[2]了解一下,这里不赘述。

      检验一份手写 Promise 靠不靠谱,通过 Promise A+ 规范自然是基本要求,这里我们可以借助 promises-aplus-tests[3] 来检测我们的代码是否符合规范,后面我会讲到如何使用它。

      手写开始

      很多手写版本都是使用 setTimeout 去做异步处理,但是 setTimeout 属于宏任务,这与 Promise 是个微任务相矛盾,所以我打算选择一种创建微任务的方式去实现我们的手写代码。

      这里我们有几种选择,一种就是 Promise A+ 规范中也提到的,process.nextTick( Node 端 ) 与 MutationObserver( 浏览器端 ),考虑到利用这两种方式需要做环境判断,所以在这里我们就推荐另外一种创建微任务的方式 queueMicrotask,了解更多 --> 在 JavaScript 中通过 queueMicrotask() 使用微任务[4];

      一、Promise 核心逻辑实现

      我们先简单实现一下 Promise 的基础功能。先看原生 Promise 实现的 ????,第一步我们要完成相同的功能。

      原生 ???? ????

      const promise = new Promise((resolve, reject) => {
         resolve('success')
         reject('err')
      })
      
      promise.then(value => {
        console.log('resolve', value)
      }, reason => {
        console.log('reject', reason)
      })
      
      // 输出 resolve success
      

      我们来分析一下基本原理

      1. Promise 是一个类,在执行这个类的时候会传入一个执行器,这个执行器会立即执行

      2. Promise 会有三种状态

      • Pending 等待

      • Fulfilled 完成

      • Rejected 失败

      • 状态只能由 Pending --> Fulfilled 或者 Pending --> Rejected,且一但发生改变便不可二次修改;

      • Promise 中使用 resolve 和 reject 两个函数来更改状态;

      • then 方法内部做但事情就是状态判断

        • 如果状态是成功,调用成功回调函数

        • 如果状态是失败,调用失败回调函数

      下面开始实现

      1. 新建 MyPromise 类,传入执行器 executor

      // 新建 MyPromise.js
      
      // 新建 MyPromise 类
      class MyPromise {
        constructor(executor){
          // executor 是一个执行器,进入会立即执行
          executor()
        }
      }
      

      2. executor 传入 resolve 和 reject 方法

      // MyPromise.js
      
      // 新建 MyPromise 类
      class MyPromise {
        constructor(executor){
          // executor 是一个执行器,进入会立即执行
          // 并传入resolve和reject方法
          executor(this.resolve, this.reject)
        }
        // resolve和reject为什么要用箭头函数?
        // 如果直接调用的话,普通函数this指向的是window或者undefined
        // 用箭头函数就可以让this指向当前实例对象
        // 更改成功后的状态
        resolve = () => {}
        // 更改失败后的状态
        reject = () => {}
      }
      

      3. 状态与结果的管理

      // MyPromise.js
      
      // 先定义三个常量表示状态
      const PENDING = 'pending';
      const FULFILLED = 'fulfilled';
      const REJECTED = 'rejected';
      
      // 新建 MyPromise 类
      class MyPromise {
        constructor(executor){
          // executor 是一个执行器,进入会立即执行
          // 并传入resolve和reject方法
          executor(this.resolve, this.reject)
        }
      
        // 储存状态的变量,初始值是 pending
        status = PENDING;
      
        // resolve和reject为什么要用箭头函数?
        // 如果直接调用的话,普通函数this指向的是window或者undefined
        // 用箭头函数就可以让this指向当前实例对象
        // 成功之后的值
        value = null;
        // 失败之后的原因
        reason = null;
      
        // 更改成功后的状态
        resolve = (value) => {
          // 只有状态是等待,才执行状态修改
          if (this.status === PENDING) {
            // 状态修改为成功
            this.status = FULFILLED;
            // 保存成功之后的值
            this.value = value;
          }
        }
      
        // 更改失败后的状态
        reject = (reason) => {
          // 只有状态是等待,才执行状态修改
          if (this.status === PENDING) {
            // 状态成功为失败
            this.status = REJECTED;
            // 保存失败后的原因
            this.reason = reason;
          }
        }
      }
      
      

      4. then 的简单实现

      // MyPromise.js
      
      then(onFulfilled, onRejected) {
        // 判断状态
        if (this.status === FULFILLED) {
          // 调用成功回调,并且把值返回
          onFulfilled(this.value);
        } else if (this.status === REJECTED) {
          // 调用失败回调,并且把原因返回
          onRejected(this.reason);
        }
      }
      

      5. 使用 module.exports 对外暴露 MyPromise 类

      // MyPromise.js
      module.exports = MyPromise;
      

      看一下我们目前实现的完整代码????

      // MyPromise.js
      
      // 先定义三个常量表示状态
      const PENDING = 'pending';
      const FULFILLED = 'fulfilled';
      const REJECTED = 'rejected';
      
      // 新建 MyPromise 类
      class MyPromise {
        constructor(executor){
          // executor 是一个执行器,进入会立即执行
          // 并传入resolve和reject方法
          executor(this.resolve, this.reject)
        }
      
        // 储存状态的变量,初始值是 pending
        status = PENDING;
      
        // resolve和reject为什么要用箭头函数?
        // 如果直接调用的话,普通函数this指向的是window或者undefined
        // 用箭头函数就可以让this指向当前实例对象
        // 成功之后的值
        value = null;
        // 失败之后的原因
        reason = null;
      
        // 更改成功后的状态
        resolve = (value) => {
          // 只有状态是等待,才执行状态修改
          if (this.status === PENDING) {
            // 状态修改为成功
            this.status = FULFILLED;
            // 保存成功之后的值
            this.value = value;
          }
        }
      
        // 更改失败后的状态
        reject = (reason) => {
          // 只有状态是等待,才执行状态修改
          if (this.status === PENDING) {
            // 状态成功为失败
            this.status = REJECTED;
            // 保存失败后的原因
            this.reason = reason;
          }
        }
      
        then(onFulfilled, onRejected) {
          // 判断状态
          if (this.status === FULFILLED) {
            // 调用成功回调,并且把值返回
            onFulfilled(this.value);
          } else if (this.status === REJECTED) {
            // 调用失败回调,并且把原因返回
            onRejected(this.reason);
          }
        }
      }
      
      module.exports = MyPromise
      

      使用我的手写代码执行一下上面那个 ????

      // 新建 test.js
      
      // 引入我们的 MyPromise.js
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
         resolve('success')
         reject('err')
      })
      
      promise.then(value => {
        console.log('resolve', value)
      }, reason => {
        console.log('reject', reason)
      })
      
      // 执行结果:resolve success
      

      执行结果符合我们的预期,第一步完成了 ????????????

      二、在 Promise 类中加入异步逻辑

      上面还没有经过异步处理,如果有异步逻辑加如来会带来一些问题,例如:

      // test.js
      
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
        setTimeout(() => {
          resolve('success')
        }, 2000);
      })
      
      promise.then(value => {
        console.log('resolve', value)
      }, reason => {
        console.log('reject', reason)
      })
      
      // 没有打印信息!!!
      

      分析原因

      主线程代码立即执行,setTimeout 是异步代码,then 会马上执行,这个时候判断 Promise 状态,状态是 Pending,然而之前并没有判断等待这个状态

      这里就需要我们处理一下 Pending 状态,我们改造一下之前的代码 ????

      1. 缓存成功与失败回调

      // MyPromise.js
      
      // MyPromise 类中新增
      // 存储成功回调函数
      onFulfilledCallback = null;
      // 存储失败回调函数
      onRejectedCallback = null;
      

      2. then 方法中的 Pending 的处理

      // MyPromise.js
      
      then(onFulfilled, onRejected) {
        // 判断状态
        if (this.status === FULFILLED) {
          // 调用成功回调,并且把值返回
          onFulfilled(this.value);
        } else if (this.status === REJECTED) {
          // 调用失败回调,并且把原因返回
          onRejected(this.reason);
        } else if (this.status === PENDING) {
          // ==== 新增 ====
          // 因为不知道后面状态的变化情况,所以将成功回调和失败回调存储起来
          // 等到执行成功失败函数的时候再传递
          this.onFulfilledCallback = onFulfilled;
          this.onRejectedCallback = onRejected;
        }
      }
      

      3. resolve 与 reject 中调用回调函数

      // MyPromise.js
      
      // 更改成功后的状态
      resolve = (value) => {
        // 只有状态是等待,才执行状态修改
        if (this.status === PENDING) {
          // 状态修改为成功
          this.status = FULFILLED;
          // 保存成功之后的值
          this.value = value;
          // ==== 新增 ====
          // 判断成功回调是否存在,如果存在就调用
          this.onFulfilledCallback && this.onFulfilledCallback(value);
        }
      }
      
      // MyPromise.js
      // 更改失败后的状态
      reject = (reason) => {
        // 只有状态是等待,才执行状态修改
        if (this.status === PENDING) {
          // 状态成功为失败
          this.status = REJECTED;
          // 保存失败后的原因
          this.reason = reason;
          // ==== 新增 ====
          // 判断失败回调是否存在,如果存在就调用
          this.onRejectedCallback && this.onRejectedCallback(reason)
        }
      }
      

      我们再执行一下上面的 ????

      // test.js
      
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
        setTimeout(() => {
          resolve('success')
        }, 2000);
      })
      
      promise.then(value => {
        console.log('resolve', value)
      }, reason => {
        console.log('reject', reason)
      })
      
      // 等待 2s 输出 resolve success
      

      目前已经可以简单处理异步问题了 ✌️

      三、实现 then 方法多次调用添加多个处理函数

      Promise 的 then 方法是可以被多次调用的。这里如果有三个 then 的调用,如果是同步回调,那么直接返回当前的值就行;如果是异步回调,那么保存的成功失败的回调,需要用不同的值保存,因为都互不相同。之前的代码需要改进。

      同样的先看一个 ????

      // test.js
      
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
        setTimeout(() => {
          resolve('success')
        }, 2000);
      })
      
      promise.then(value => {
        console.log(1)
        console.log('resolve', value)
      })
      
      promise.then(value => {
        console.log(2)
        console.log('resolve', value)
      })
      
      promise.then(value => {
        console.log(3)
        console.log('resolve', value)
      })
      
      // 3
      // resolve success
      
      

      目前的代码只能输出:3 resolve success,怎么可以把 1、2 弄丢呢!

      我们应该一视同仁,保证所有 then 中的回调函数都可以执行 ???? 继续改造

      1. MyPromise 类中新增两个数组

      // MyPromise.js
      
      // 存储成功回调函数
      // onFulfilledCallback = null;
      onFulfilledCallbacks = [];
      // 存储失败回调函数
      // onRejectedCallback = null;
      onRejectedCallbacks = [];
      

      2. 回调函数存入数组中

      // MyPromise.js
      
      then(onFulfilled, onRejected) {
        // 判断状态
        if (this.status === FULFILLED) {
          // 调用成功回调,并且把值返回
          onFulfilled(this.value);
        } else if (this.status === REJECTED) {
          // 调用失败回调,并且把原因返回
          onRejected(this.reason);
        } else if (this.status === PENDING) {
          // ==== 新增 ====
          // 因为不知道后面状态的变化,这里先将成功回调和失败回调存储起来
          // 等待后续调用
          this.onFulfilledCallbacks.push(onFulfilled);
          this.onRejectedCallbacks.push(onRejected);
        }
      }
      

      3. 循环调用成功和失败回调

      // MyPromise.js
      
      // 更改成功后的状态
      resolve = (value) => {
        // 只有状态是等待,才执行状态修改
        if (this.status === PENDING) {
          // 状态修改为成功
          this.status = FULFILLED;
          // 保存成功之后的值
          this.value = value;
          // ==== 新增 ====
          // resolve里面将所有成功的回调拿出来执行
          while (this.onFulfilledCallbacks.length) {
            // Array.shift() 取出数组第一个元素,然后()调用,shift不是纯函数,取出后,数组将失去该元素,直到数组为空
            this.onFulfilledCallbacks.shift()(value)
          }
        }
      }
      
      // MyPromise.js
      
      // 更改失败后的状态
      reject = (reason) => {
        // 只有状态是等待,才执行状态修改
        if (this.status === PENDING) {
          // 状态成功为失败
          this.status = REJECTED;
          // 保存失败后的原因
          this.reason = reason;
          // ==== 新增 ====
          // resolve里面将所有失败的回调拿出来执行
          while (this.onRejectedCallbacks.length) {
            this.onRejectedCallbacks.shift()(reason)
          }
        }
      }
      

      再来运行一下,看看结果 ????

      1
      resolve success
      2
      resolve success
      3
      resolve success
      

      ???????????? 完美,继续

      四、实现 then 方法的链式调用

      then 方法要链式调用那么就需要返回一个 Promise 对象
      then 方法里面 return 一个返回值作为下一个 then 方法的参数,如果是 return 一个 Promise 对象,那么就需要判断它的状态

      举个栗子 ????

      // test.js
      
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
        // 目前这里只处理同步的问题
        resolve('success')
      })
      
      function other () {
        return new MyPromise((resolve, reject) =>{
          resolve('other')
        })
      }
      promise.then(value => {
        console.log(1)
        console.log('resolve', value)
        return other()
      }).then(value => {
        console.log(2)
        console.log('resolve', value)
      })
      

      用目前的手写代码运行的时候会报错 ???? 无法链式调用

      }).then(value => {
        ^
      
      TypeError: Cannot read property 'then' of undefined
      

      接着改 ????

      // MyPromise.js
      
      class MyPromise {
        ......
        then(onFulfilled, onRejected) {
          // ==== 新增 ====
          // 为了链式调用这里直接创建一个 MyPromise,并在后面 return 出去
          const promise2 = new MyPromise((resolve, reject) => {
            // 这里的内容在执行器中,会立即执行
            if (this.status === FULFILLED) {
              // 获取成功回调函数的执行结果
              const x = onFulfilled(this.value);
              // 传入 resolvePromise 集中处理
              resolvePromise(x, resolve, reject);
            } else if (this.status === REJECTED) {
              onRejected(this.reason);
            } else if (this.status === PENDING) {
              this.onFulfilledCallbacks.push(onFulfilled);
              this.onRejectedCallbacks.push(onRejected);
            }
          })
      
          return promise2;
        }
      }
      
      function resolvePromise(x, resolve, reject) {
        // 判断x是不是 MyPromise 实例对象
        if(x instanceof MyPromise) {
          // 执行 x,调用 then 方法,目的是将其状态变为 fulfilled 或者 rejected
          // x.then(value => resolve(value), reason => reject(reason))
          // 简化之后
          x.then(resolve, reject)
        } else{
          // 普通值
          resolve(x)
        }
      }
      

      执行一下,结果 ????

      1
      resolve success
      2
      resolve other
      

      em... 符合预期 ????

      五、then 方法链式调用识别 Promise 是否返回自己

      如果 then 方法返回的是自己的 Promise 对象,则会发生循环调用,这个时候程序会报错

      例如下面这种情况 ????

      // test.js
      
      const promise = new Promise((resolve, reject) => {
        resolve(100)
      })
      const p1 = promise.then(value => {
        console.log(value)
        return p1
      })
      

      使用原生 Promise 执行这个代码,会报类型错误

      100
      Uncaught (in promise) TypeError: Chaining cycle detected for promise #<Promise>
      

      我们在 MyPromise 实现一下

      // MyPromise.js
      
      class MyPromise {
        ......
        then(onFulfilled, onRejected) {
          const promise2 = new MyPromise((resolve, reject) => {
            if (this.status === FULFILLED) {
              const x = onFulfilled(this.value);
              // resolvePromise 集中处理,将 promise2 传入
              resolvePromise(promise2, x, resolve, reject);
            } else if (this.status === REJECTED) {
              onRejected(this.reason);
            } else if (this.status === PENDING) {
              this.onFulfilledCallbacks.push(onFulfilled);
              this.onRejectedCallbacks.push(onRejected);
            }
          })
      
          return promise2;
        }
      }
      
      function resolvePromise(promise2, x, resolve, reject) {
        // 如果相等了,说明return的是自己,抛出类型错误并返回
        if (promise2 === x) {
          return reject(new TypeError('Chaining cycle detected for promise #<Promise>'))
        }
        if(x instanceof MyPromise) {
          x.then(resolve, reject)
        } else{
          resolve(x)
        }
      }
      

      执行一下,竟然报错了 ????

              resolvePromise(promise2, x, resolve, reject);
                             ^
      
      ReferenceError: Cannot access 'promise2' before initialization
      

      为啥会报错呢?从错误提示可以看出,我们必须要等 promise2 完成初始化。这个时候我们就要用上宏微任务和事件循环的知识了,这里就需要创建一个异步函数去等待 promise2 完成初始化,前面我们已经确认了创建微任务的技术方案 --> queueMicrotask

      // MyPromise.js
      
      class MyPromise {
        ......
        then(onFulfilled, onRejected) {
          const promise2 = new MyPromise((resolve, reject) => {
            if (this.status === FULFILLED) {
              // ==== 新增 ====
              // 创建一个微任务等待 promise2 完成初始化
              queueMicrotask(() => {
                // 获取成功回调函数的执行结果
                const x = onFulfilled(this.value);
                // 传入 resolvePromise 集中处理
                resolvePromise(promise2, x, resolve, reject);
              })
            } else if (this.status === REJECTED) {
            ......
          })
      
          return promise2;
        }
      }
      

      执行一下

      // test.js
      
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
          resolve('success')
      })
      
      // 这个时候将promise定义一个p1,然后返回的时候返回p1这个promise
      const p1 = promise.then(value => {
         console.log(1)
         console.log('resolve', value)
         return p1
      })
      
      // 运行的时候会走reject
      p1.then(value => {
        console.log(2)
        console.log('resolve', value)
      }, reason => {
        console.log(3)
        console.log(reason.message)
      })
      

      这里得到我们的结果 ????

      1
      resolve success
      3
      Chaining cycle detected for promise #<Promise>
      

      哈哈,搞定 ???? 开始下一步

      六、捕获错误及 then 链式调用其他状态代码补充

      目前还缺少重要的一个环节,就是我们的错误捕获还没有处理

      1. 捕获执行器错误

      捕获执行器中的代码,如果执行器中有代码错误,那么 Promise 的状态要变为失败

      // MyPromise.js
      
      constructor(executor){
        // ==== 新增 ====
        // executor 是一个执行器,进入会立即执行
        // 并传入resolve和reject方法
        try {
          executor(this.resolve, this.reject)
        } catch (error) {
          // 如果有错误,就直接执行 reject
          this.reject(error)
        }
      }
      

      验证一下:

      // test.js
      
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
          // resolve('success')
          throw new Error('执行器错误')
      })
      
      promise.then(value => {
        console.log(1)
        console.log('resolve', value)
      }, reason => {
        console.log(2)
        console.log(reason.message)
      })
      

      执行结果 ????

      2
      执行器错误
      

      OK,通过 ????

      2. then 执行的时错误捕获

      // MyPromise.js
      
      then(onFulfilled, onRejected) {
        // 为了链式调用这里直接创建一个 MyPromise,并在后面 return 出去
        const promise2 = new MyPromise((resolve, reject) => {
          // 判断状态
          if (this.status === FULFILLED) {
            // 创建一个微任务等待 promise2 完成初始化
            queueMicrotask(() => {
              // ==== 新增 ====
              try {
                // 获取成功回调函数的执行结果
                const x = onFulfilled(this.value);
                // 传入 resolvePromise 集中处理
                resolvePromise(promise2, x, resolve, reject);
              } catch (error) {
                reject(error)
              }
            })
          } else if (this.status === REJECTED) {
            // 调用失败回调,并且把原因返回
            onRejected(this.reason);
          } else if (this.status === PENDING) {
            // 等待
            // 因为不知道后面状态的变化情况,所以将成功回调和失败回调存储起来
            // 等到执行成功失败函数的时候再传递
            this.onFulfilledCallbacks.push(onFulfilled);
            this.onRejectedCallbacks.push(onRejected);
          }
        })
      
        return promise2;
      }
      

      验证一下:

      // test.js
      
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
          resolve('success')
          // throw new Error('执行器错误')
       })
      
      // 第一个then方法中的错误要在第二个then方法中捕获到
      promise.then(value => {
        console.log(1)
        console.log('resolve', value)
        throw new Error('then error')
      }, reason => {
        console.log(2)
        console.log(reason.message)
      }).then(value => {
        console.log(3)
        console.log(value);
      }, reason => {
        console.log(4)
        console.log(reason.message)
      })
      

      执行结果 ????

      1
      resolve success
      4
      then error
      

      这里成功打印了 1 中抛出的错误 then error

      七、参考 fulfilled 状态下的处理方式,对 rejected 和 pending 状态进行改造

      改造内容包括:

      1. 增加异步状态下的链式调用

      2. 增加回调函数执行结果的判断

      3. 增加识别 Promise 是否返回自己

      4. 增加错误捕获

      // MyPromise.js
      
      then(onFulfilled, onRejected) {
        // 为了链式调用这里直接创建一个 MyPromise,并在后面 return 出去
        const promise2 = new MyPromise((resolve, reject) => {
          // 判断状态
          if (this.status === FULFILLED) {
            // 创建一个微任务等待 promise2 完成初始化
            queueMicrotask(() => {
              try {
                // 获取成功回调函数的执行结果
                const x = onFulfilled(this.value);
                // 传入 resolvePromise 集中处理
                resolvePromise(promise2, x, resolve, reject);
              } catch (error) {
                reject(error)
              }
            })
          } else if (this.status === REJECTED) {
            // ==== 新增 ====
            // 创建一个微任务等待 promise2 完成初始化
            queueMicrotask(() => {
              try {
                // 调用失败回调,并且把原因返回
                const x = onRejected(this.reason);
                // 传入 resolvePromise 集中处理
                resolvePromise(promise2, x, resolve, reject);
              } catch (error) {
                reject(error)
              }
            })
          } else if (this.status === PENDING) {
            // 等待
            // 因为不知道后面状态的变化情况,所以将成功回调和失败回调存储起来
            // 等到执行成功失败函数的时候再传递
            this.onFulfilledCallbacks.push(() => {
              // ==== 新增 ====
              queueMicrotask(() => {
                try {
                  // 获取成功回调函数的执行结果
                  const x = onFulfilled(this.value);
                  // 传入 resolvePromise 集中处理
                  resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                  reject(error)
                }
              })
            });
            this.onRejectedCallbacks.push(() => {
              // ==== 新增 ====
              queueMicrotask(() => {
                try {
                  // 调用失败回调,并且把原因返回
                  const x = onRejected(this.reason);
                  // 传入 resolvePromise 集中处理
                  resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                  reject(error)
                }
              })
            });
          }
        })
      
        return promise2;
      }
      

      八、then 中的参数变为可选

      上面我们处理 then 方法的时候都是默认传入 onFulfilled、onRejected 两个回调函数,但是实际上原生 Promise 是可以选择参数的单传或者不传,都不会影响执行。

      例如下面这种 ????

      // test.js
      
      const promise = new Promise((resolve, reject) => {
        resolve(100)
      })
      
      promise
        .then()
        .then()
        .then()
        .then(value => console.log(value))
      
      // 输出 100
      

      所以我们需要对 then 方法做一点小小的调整

      // MyPromise.js
      
      then(onFulfilled, onRejected) {
        // 如果不传,就使用默认函数
        onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
        onRejected = typeof onRejected === 'function' ? onRejected : reason => {throw reason};
      
        // 为了链式调用这里直接创建一个 MyPromise,并在后面 return 出去
        const promise2 = new MyPromise((resolve, reject) => {
        ......
      }
      
      

      改造完自然是需要验证一下的

      先看情况一:resolve 之后

      // test.js
      
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
        resolve('succ')
      })
      
      promise.then().then().then(value => console.log(value))
      
      // 打印 succ
      

      先看情况一:reject 之后

      // test.js
      
      const MyPromise = require('./MyPromise')
      const promise = new MyPromise((resolve, reject) => {
        reject('err')
      })
      
      promise.then().then().then(value => console.log(value), reason => console.log(reason))
      
      // 打印 err
      

      写到这里,麻雀版的 Promise 基本完成了,鼓掌 ????????????

      九、实现 resolve 与 reject 的静态调用

      就像开头挂的那道面试题使用 return Promise.resolve 来返回一个 Promise 对象,我们用现在的手写代码尝试一下

      const MyPromise = require('./MyPromise')
      
      MyPromise.resolve().then(() => {
          console.log(0);
          return MyPromise.resolve(4);
      }).then((res) => {
          console.log(res)
      })
      

      结果它报错了 ????

      MyPromise.resolve().then(() => {
                ^
      
      TypeError: MyPromise.resolve is not a function
      

      除了 Promise.resolve 还有 Promise.reject 的用法,我们都要去支持,接下来我们来实现一下

      // MyPromise.js
      
      MyPromise {
        ......
        // resolve 静态方法
        static resolve (parameter) {
          // 如果传入 MyPromise 就直接返回
          if (parameter instanceof MyPromise) {
            return parameter;
          }
      
          // 转成常规方式
          return new MyPromise(resolve =>  {
            resolve(parameter);
          });
        }
      
        // reject 静态方法
        static reject (reason) {
          return new MyPromise((resolve, reject) => {
            reject(reason);
          });
        }
      }
      

      这样我们再测试上面的 ???? 就不会有问题啦

      执行结果 ????

      0
      4
      

      到这里手写工作就基本完成了,前面主要为了方便理解,所以有一些冗余代码,我规整一下

      // MyPromise.js
      
      // 先定义三个常量表示状态
      const PENDING = 'pending';
      const FULFILLED = 'fulfilled';
      const REJECTED = 'rejected';
      
      // 新建 MyPromise 类
      class MyPromise {
        constructor(executor){
          // executor 是一个执行器,进入会立即执行
          // 并传入resolve和reject方法
          try {
            executor(this.resolve, this.reject)
          } catch (error) {
            this.reject(error)
          }
        }
      
        // 储存状态的变量,初始值是 pending
        status = PENDING;
        // 成功之后的值
        value = null;
        // 失败之后的原因
        reason = null;
      
        // 存储成功回调函数
        onFulfilledCallbacks = [];
        // 存储失败回调函数
        onRejectedCallbacks = [];
      
        // 更改成功后的状态
        resolve = (value) => {
          // 只有状态是等待,才执行状态修改
          if (this.status === PENDING) {
            // 状态修改为成功
            this.status = FULFILLED;
            // 保存成功之后的值
            this.value = value;
            // resolve里面将所有成功的回调拿出来执行
            while (this.onFulfilledCallbacks.length) {
              // Array.shift() 取出数组第一个元素,然后()调用,shift不是纯函数,取出后,数组将失去该元素,直到数组为空
              this.onFulfilledCallbacks.shift()(value)
            }
          }
        }
      
        // 更改失败后的状态
        reject = (reason) => {
          // 只有状态是等待,才执行状态修改
          if (this.status === PENDING) {
            // 状态成功为失败
            this.status = REJECTED;
            // 保存失败后的原因
            this.reason = reason;
            // resolve里面将所有失败的回调拿出来执行
            while (this.onRejectedCallbacks.length) {
              this.onRejectedCallbacks.shift()(reason)
            }
          }
        }
      
        then(onFulfilled, onRejected) {
          const realOnFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
          const realOnRejected = typeof onRejected === 'function' ? onRejected : reason => {throw reason};
      
          // 为了链式调用这里直接创建一个 MyPromise,并在后面 return 出去
          const promise2 = new MyPromise((resolve, reject) => {
            const fulfilledMicrotask = () =>  {
              // 创建一个微任务等待 promise2 完成初始化
              queueMicrotask(() => {
                try {
                  // 获取成功回调函数的执行结果
                  const x = realOnFulfilled(this.value);
                  // 传入 resolvePromise 集中处理
                  resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                  reject(error)
                }
              })
            }
      
            const rejectedMicrotask = () => {
              // 创建一个微任务等待 promise2 完成初始化
              queueMicrotask(() => {
                try {
                  // 调用失败回调,并且把原因返回
                  const x = realOnRejected(this.reason);
                  // 传入 resolvePromise 集中处理
                  resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                  reject(error)
                }
              })
            }
            // 判断状态
            if (this.status === FULFILLED) {
              fulfilledMicrotask()
            } else if (this.status === REJECTED) {
              rejectedMicrotask()
            } else if (this.status === PENDING) {
              // 等待
              // 因为不知道后面状态的变化情况,所以将成功回调和失败回调存储起来
              // 等到执行成功失败函数的时候再传递
              this.onFulfilledCallbacks.push(fulfilledMicrotask);
              this.onRejectedCallbacks.push(rejectedMicrotask);
            }
          })
      
          return promise2;
        }
      
        // resolve 静态方法
        static resolve (parameter) {
          // 如果传入 MyPromise 就直接返回
          if (parameter instanceof MyPromise) {
            return parameter;
          }
      
          // 转成常规方式
          return new MyPromise(resolve =>  {
            resolve(parameter);
          });
        }
      
        // reject 静态方法
        static reject (reason) {
          return new MyPromise((resolve, reject) => {
            reject(reason);
          });
        }
      }
      
      function resolvePromise(promise2, x, resolve, reject) {
        // 如果相等了,说明return的是自己,抛出类型错误并返回
        if (promise2 === x) {
          return reject(new TypeError('Chaining cycle detected for promise #<Promise>'))
        }
        // 判断x是不是 MyPromise 实例对象
        if(x instanceof MyPromise) {
          // 执行 x,调用 then 方法,目的是将其状态变为 fulfilled 或者 rejected
          // x.then(value => resolve(value), reason => reject(reason))
          // 简化之后
          x.then(resolve, reject)
        } else{
          // 普通值
          resolve(x)
        }
      }
      
      module.exports = MyPromise;
      

      到这一步手写部分基本大功告成 ????????????

      Promise A+ 测试

      上面介绍了 Promise A+ 规范,当然我们手写的版本也得符合了这个规范才有资格叫 Promise, 不然就只能是伪 Promise 了。

      上文讲到了 promises-aplus-tests,现在我们正式开箱使用

      1. 安装一下

      npm install promises-aplus-tests -D
      

      2. 手写代码中加入 deferred

      // MyPromise.js
      
      MyPromise {
        ......
      }
      
      MyPromise.deferred = function () {
        var result = {};
        result.promise = new MyPromise(function (resolve, reject) {
          result.resolve = resolve;
          result.reject = reject;
        });
      
        return result;
      }
      module.exports = MyPromise;
      

      3. 配置启动命令

      {
        "name": "promise",
        "version": "1.0.0",
        "description": "my promise",
        "main": "MyPromise.js",
        "scripts": {
          "test": "promises-aplus-tests MyPromise"
        },
        "author": "ITEM",
        "license": "ISC",
        "devDependencies": {
          "promises-aplus-tests": "^2.1.2"
        }
      }
      
      

      开启测试

      npm run test
      

      迫不及待了吧 ???? 看看我们的结果如何,走起 ????‍????

      fail.gif

      虽然功能上没啥问题,但是测试却失败了 ????

      针对提示信息,我翻看了一下 Promise A+ 规范,发现我们应该是在 2.3.x 上出现了问题,这里规范使用了不同的方式进行了 then 的返回值判断。

      image.png

      自红线向下的细节,我们都没有处理,这里要求判断 x 是否为 object 或者 function,满足则接着判断 x.then 是否存在,这里可以理解为判断 x 是否为 promise,这里都功能实际与我们手写版本中 x instanceof MyPromise 功能相似。

      我们还是按照规范改造一下 resolvePromise 方法吧

      // MyPromise.js
      
      function resolvePromise(promise, x, resolve, reject) {
        // 如果相等了,说明return的是自己,抛出类型错误并返回
        if (promise === x) {
          return reject(new TypeError('The promise and the return value are the same'));
        }
      
        if (typeof x === 'object' || typeof x === 'function') {
          // x 为 null 直接返回,走后面的逻辑会报错
          if (x === null) {
            return resolve(x);
          }
      
          let then;
          try {
            // 把 x.then 赋值给 then
            then = x.then;
          } catch (error) {
            // 如果取 x.then 的值时抛出错误 error ,则以 error 为据因拒绝 promise
            return reject(error);
          }
      
          // 如果 then 是函数
          if (typeof then === 'function') {
            let called = false;
            try {
              then.call(
                x, // this 指向 x
                // 如果 resolvePromise 以值 y 为参数被调用,则运行 [[Resolve]](promise, y "[Resolve]")
                y => {
                  // 如果 resolvePromise 和 rejectPromise 均被调用,
                  // 或者被同一参数调用了多次,则优先采用首次调用并忽略剩下的调用
                  // 实现这条需要前面加一个变量 called
                  if (called) return;
                  called = true;
                  resolvePromise(promise, y, resolve, reject);
                },
                // 如果 rejectPromise 以据因 r 为参数被调用,则以据因 r 拒绝 promise
                r => {
                  if (called) return;
                  called = true;
                  reject(r);
                });
            } catch (error) {
              // 如果调用 then 方法抛出了异常 error:
              // 如果 resolvePromise 或 rejectPromise 已经被调用,直接返回
              if (called) return;
      
              // 否则以 error 为据因拒绝 promise
              reject(error);
            }
          } else {
            // 如果 then 不是函数,以 x 为参数执行 promise
            resolve(x);
          }
        } else {
          // 如果 x 不为对象或者函数,以 x 为参数执行 promise
          resolve(x);
        }
      }
      

      改造后启动测试

      success.gif

      完美通过 ????????????

      最终时刻,如何解释那道面试题的执行结果

      先用我们自己的 Promise 运行一下那道面试题 ????

      // test.js
      
      const MyPromise = require('./MyPromise.js')
      
      MyPromise.resolve().then(() => {
        console.log(0);
        return MyPromise.resolve(4);
      }).then((res) => {
        console.log(res)
      })
      
      MyPromise.resolve().then(() => {
        console.log(1);
      }).then(() => {
        console.log(2);
      }).then(() => {
        console.log(3);
      }).then(() => {
        console.log(5);
      }).then(() =>{
        console.log(6);
      })
      

      执行结果:0、1、2、4、3、5、6 ????

      这里我们手写版本的 4 并没有和 原生 Promise 一样在 3 后面,而是在 2 后面

      其实从我们的手写代码上看,在判断 then 内部函数执行结果,也就是在这里 ????

      // MyPromise.js
      
      // 获取成功回调函数的执行结果
      const x = realOnFulfilled(this.value);
      // 传入 resolvePromise 集中处理
      resolvePromise(promise2, x, resolve, reject);
      

      面试题中 x 为 MyPromise.resolve(4) 的时候,在传入 resolvePromise 方法中会对 x 的类型进行判断时,会发现它是一个 Promise,并让其调用 then 方法完成状态转换。再看 resolvePromis 方法中这一块判断逻辑 ????

      if (typeof x === 'object' || typeof x === 'function') {
          // x 为 null 直接返回,走后面的逻辑会报错
          if (x === null) {
            return resolve(x);
          }
      
          let then;
          try {
            // 把 x.then 赋值给 then
            then = x.then;
          } catch (error) {
            // 如果取 x.then 的值时抛出错误 error ,则以 error 为据因拒绝 promise
            return reject(error);
          }
      
          // 如果 then 是函数
          if (typeof then === 'function') {
            let called = false;
            try {
              then.call(
                x, // this 指向 x
                // 如果 resolvePromise 以值 y 为参数被调用,则运行 [[Resolve]](promise, y "[Resolve]")
                y => {
                  // 如果 resolvePromise 和 rejectPromise 均被调用,
                  // 或者被同一参数调用了多次,则优先采用首次调用并忽略剩下的调用
                  // 实现这条需要前面加一个变量 called
                  if (called) return;
                  called = true;
                  resolvePromise(promise, y, resolve, reject);
                },
                // 如果 rejectPromise 以据因 r 为参数被调用,则以据因 r 拒绝 promise
                r => {
                  if (called) return;
                  called = true;
                  reject(r);
                });
            }
            ......
      

      那么问题来了

      • 为什么我们 Promise A+ 测试全部通过的手写代码,执行结果却与原生 Promise 不同?

      • 在我们手写代码使用创建一次微任务的方式,会带来什么问题吗?

      ES6 中的 Promise 虽然是遵循 Promise A+ 规范实现的,但实际上也 Promise A+ 上做了一些功能扩展,例如:Promise.all、Promise.race 等,所以即使都符合 Promise A+ ,执行结果也是可能存在差异的。我们这里更需要思考的是第二个问题,不这么做会带来什么问题,也就是加一次微任务的必要性。

      我尝试过很多例子,都没有找到相关例证,我们手写实现的 Promise 都很好的完成工作,拿到了结果。我不得不去翻看更多的相关文章,我发现有些人会为了让执行结果与原生相同,强行去再多加一次微任务,这种做法是很牵强的。

      毕竟实现 Promise 的目的是为了解决异步编程的问题,能够拿到正确的结果才是最重要的,强行为了符合面试题的输出顺序去多加一次微任务,只能让手写代码变的更加复杂,不好理解。

      在 stackoverflow 上,有一个类似的问题 What is the difference between returned Promise?[5]回答中有一个信息就是

      It only required the execution context stack contains only platform code. 也就相当于等待 execution context stack 清空。

      这个在掘金中的一篇文章 我以为我很懂 Promise,直到我开始实现 Promise/A+规范[6] 也有一段关于这道面试题的讨论

      return Promise.resolve(4),JS 引擎会安排一个 job(job 是 ECMA 中的概念,等同于微任务的概念),其回调目的是让其状态变为 fulfilled。

      实际上我们已经在 static resolve 创建了一个新的 MyPromsie,并调用其 then 方法,创建了一个微任务。

      所以,就目前的信息来说,两次微任务依旧不能证明其必要性,目前的 Promise 日常操作,一次微任务都是可以满足。

      大家对于这个道面试题有什么想法或者意见,赶紧在留言区告诉我吧,一起探讨一下到底是必然还是巧合 ????

      长文整理不易,记得 点赞 ???? 支持一下哦 ????

      参考资料

      [1]

      Promise 入门: https://es6.ruanyifeng.com/#docs/promise

      [2]

      Promise A+规范: https://promisesaplus.com/

      [3]

      promises-aplus-tests: https://www.npmjs.com/package/promises-aplus-tests

      [4]

      在 JavaScript 中通过 queueMicrotask() 使用微任务: https://developer.mozilla.org/zh-CN/docs/Web/API/HTML_DOM_API/Microtask_guide

      [5]

      What is the difference between returned Promise?: https://stackoverflow.com/questions/58217603/what-is-the-difference-between-returned-promise

      [6]

      我以为我很懂 Promise,直到我开始实现 Promise/A+规范: https://juejin.cn/post/6937076967283884040

      最后
      
      点击关注下方卡片关注我????????
      
      
      26岁离开谷歌,女朋友一个建议助他开发出10亿美元App
      很多人上来就删除的package-lock.json,还有这么多你不知道的(深度内容)下一代前端构建工具 ViteJS 技术解读,尤雨溪diss:Webpack!
      漫画 | 如何凭实力炒老板鱿鱼,并喜提N+1~为什么优秀的程序员都成了无能的领导?
      漫画 | 再见 Java,再见Java之父~面试官:Vue3.0的设计目标是什么?做了哪些优化?
      解读Promise原理,手动实现一个Promise~
      看完这几道 Promise 面试题,还被面试官问倒就活该~
      
      如果觉得这篇文章还不错,来个【分享、点赞、在看】三连吧,让更多的人也看到~
      
    展开全文
  • Promise面试题整理

    千次阅读 2021-02-14 23:07:36
    - 面试题一:写出下列代码的打印结果?? setTimeout(()=>{ console.log(1) },0) Promise.resolve().then(()=>{ console.log(2) }) Promise.resolve().then(()=>{ console.log(4) }) console.log...
  • 作者:HuberTRoyhttps://juejin.cn/post/6966857691381645325Promise 想必大家都十分熟悉,想想就那么几个 api,可是你真的了解 Pr...
  • 经典Promise面试题----手写Promise详细步骤(一)

    千次阅读 热门讨论 2021-02-16 22:15:08
    Promise的封装–手写一个Promise–实现基本结构以及resolve、reject结构功能实现! 1. 初始结构的搭建 步骤结构的简介: 1:在文件夹中新建两个文件,一个index.html作为入口,另外一个promise.js作为封装主体函数...
  • promise的理解以及promise面试题整理

    千次阅读 2019-03-21 02:56:54
    1. 了解 Promise 吗? promise是一种异步编程的解决方案。用于解决回调地狱的问题。 promise的写法 new Promise(请求1) .then(请求2(请求结果1)) .then(请求3(请求结果2)) .then(请求4(请求结果3)) .then(请求5...
  • Promise 面试题整理

    2021-07-19 17:40:50
    基础输出 题目1 const promise = new Promise((resolve, reject) => { console.log(1) resolve() console.log(2) }) promise.then(() => { console.log(3) }) console.log(4) // 1 2 4 3 记住 new ...
  • promise 面试题

    2021-08-11 10:42:07
    一、基础 题目1: const p = new Promise((resolve, reject) => { console.log(1) resolve(2) console.log(3) }) p.then(res => console.log(res)) console.log(4) 1.Promise 对象一旦创建会立即...
  • 关于 ES6 中 Promise面试题

    千次阅读 2018-10-29 13:12:45
    最近在复习 Promise 的知识,所以就做了一些,这里挑出几道,大家一起看看吧。 题目一 const promise = new Promise ( ( resolve , reject ) => { console . log ( 1 ) ; resolve ( ) ; ...
  • 一.Promise 1.是什么? Promise是一个对象,一般作为构造函数来使用(new Promise) ,它里面有3种状态,pending(处理中), fuilfiled(成功),rejected(失败)。 2.怎么用 拿到一个Promise实例后,具有then和catch...
  • Promise面试题

    2021-08-03 13:38:50
    1 setTimeout(()=>... Promise.resolve().then(()=>{ console.log(2) }) Promise.resolve().then(()=>{ console.log(4) }) console.log(3) 1结果: 2 setTimeout(() => { console.log(1)
  • 经典Promise面试题----手写Promise详细步骤(三)

    千次阅读 热门讨论 2021-02-19 12:17:27
    手写Promise封装继续行进----实现then方法的结构功能! 按照步骤进行,逻辑思路很简单易实现! 前文链接导航: 功能1:搭建Promise结构,实现关键resolve、reject功能 功能2:实现throw抛出异常以及Promise对象状态...
  • 前端Promise相关面试题以及知识点

    千次阅读 2020-06-21 21:39:35
    什么是PromisePromise 是异步编程的一种解决方案:从语法上讲,promise是一个对象,从它可以获取异步操作的消息;从本意上讲,它是承诺,承诺它过一段时间会给你一个结果。promise有三种状态:pending(等待态),...
  • 对于promise的常见面试题总结分析

    千次阅读 2019-07-05 08:04:27
    1、了解 Promise 吗? 1) 了解PromisePromise是一种异步编程的解决方案,有三种状态,pending(进行中)、resolved(已完成)、rejected(已失败)。当Promise的状态由pending转变为resolved或reject时,会执行...
  • js事件循环中的异步队列有两种:...常见的 micro-task 比如: process.nextTick、Promise、MutationObserver 等。 循环过程 我们先看一个完整的 Event Loop 过程。 初始状态:micro 队列空,macro 队列里有且只有
  • promise经典面试题汇总

    千次阅读 2019-03-06 14:13:46
    promise经典面试题汇总
  • Promise全家桶自己总结的 1、错误类型 Error:所有的错误的父类型 ReferenceError:引用类型不正确的错误 TypeError:数据类型不正确的错误 RangeError:数据值不在其所允许的范围内 SyntaxError:语法错误 2...
  • ES6之Promise常见面试题

    万次阅读 多人点赞 2018-07-07 13:33:12
    本文根据 Promise 的一些知识点总结了十道,看看你能做对几道。 以下 promise 均指代 Promise 实例,环境是Promise 想必大家都十分熟悉,想想就那么几个 api,可是你真的了解 Promise 吗?本文根据 Promise 的一些...
  • 文章目录一、Promise.all的使用二、Promise.race的使用 参考: https://blog.csdn.net/xyphf/article/details/77925571 https://blog.csdn.net/xyphf/article/details/88862011 一、Promise.all的使用 Promise.all...
  • 前端面试题-Promise

    2021-02-04 23:12:00
    之前写过vue相关的面试题(如果有需要可以查看历史博客),今天更新前端面试题promise相关的.希望大家可以多多支持!!! // 面试题1 setTimeout(()=>{ console.log(1) },0) Promise.resolve().then(()=>{ ...
  • Promise有三种状态,分别是pending、fulfilled 和 rejected; Promise的状态一旦改变,就不能再次改变; Promise中调用resolve或reject并不会终结 Promise 的参数函数的执行; 题目一 const promise = new Promise(...
  • 关于promise面试题

    千次阅读 2018-12-13 20:38:24
    关于promise面试题12 1 今天面试被问到了两个关于promise面试题,不外乎就是执行顺序相关的问题,话不多说,先上代码! 这道题相信大家都明白了,一道烂大街的题,输出结果不外乎就是Promise1,1,Promise2,...
  • 关于promise面试题

    2019-07-31 07:16:28
    今天面试被问到了两个关于promise面试题,不外乎就是执行顺序相关的问题,话不多说,先上代码! 这道题相信大家都明白了,一道烂大街的题,输出结果不外乎就是Promise1,1,Promise2,setTimeout 大致说一下原理,...
  • 手写实现Promise是一道经典的前端面试题。比如在美团,Promise几乎就是必考题,在其它互联网一线大厂也是高频题目。 Promise的实现相对比较复杂,考虑的逻辑也比较多,下面带着大家逐一分析,找到其关键点、以及...
  • } } //这个方法主要判断如果p是promise,那就在p的promise pending状态结束后执行resolve和reject方法 function resolvePromise(p, resolve, reject) { try { if (p instanceof SPromise) { p.then((res) => { ...
  • js面试题Promise

    2020-12-27 14:11:13
    面试题 面试题2 事件循环 基本输出题 1、new Promise 的参数函数是同步执行 const p = new Promise((resolve, reject) => { console.log(1) resolve() console.log(2) }) p.then(() => {

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,149
精华内容 5,259
关键字:

promise面试题