对于promise的常见面试题总结分析

栏目: JavaScript · 发布时间: 5年前

内容简介:1)了解Promise,2)1)回调地狱,代码难以维护, 常常第一个的函数的输出是第二个函数的输入这种现象,是为解决异步操作函数里的嵌套回调

1)了解Promise, Promise是一种异步编程的解决方案,有三种状态,pending(进行中)、resolved(已完成)、rejected(已失败) 。当Promise的状态由pending转变为resolved或reject时,会执行相应的方法

2) Promised的特点是只有异步操作的结果,可以决定当前是哪一种状态,任务其他操作都无法改变这个状态 ,也是“Promise”的名称的由来,同时,状态一旦改变,就无法再次改变状态

2、Promise 解决的痛点是什么?

Promise解决的痛点:

1)回调地狱,代码难以维护, 常常第一个的函数的输出是第二个函数的输入这种现象,是为解决异步操作函数里的嵌套回调 (callback hell) 问题,代码臃肿,可读性差,只能在回调里处理异常

2)promise可以支持多个并发的请求,获取并发请求中的数据

3)promise可以解决可读性的问题,异步的嵌套带来的可读性的问题,它是由 异步的运行机制引起的 ,这样的代码读起来会非常吃力

4)promise可以解决信任问题,对于回调过早、回调过晚或没有调用和回调次数太少或太多,由于promise只能决议一次,决议值只能有一个,决议之后无法改变,任何then中的回调也只会被调用一次,所以这就保证了Promise可以解决信任问题

3、Promise 解决的痛点还有其他方法可以解决吗?如果有,请列举。

1)Promise 解决的痛点还有其他方法可以解决,比如setTimeout、事件监听、回调函数、Generator函数,async/await

2)setTimeout:缺点不精确,只是确保在一定时间后加入到任务队列,并不保证立马执行。只有执行引擎栈中的代码执行完毕,主线程才会去读取任务队列

3)事件监听:任务的执行不取决于代码的顺序,而取决于某个事件是否发生

4)Generator函数虽然将异步操作表示得很简洁,但是流程管理却不方便(即何时执行第一阶段、何时执行第二阶段)。即如何实现自动化的流程管理

5)async/await

4、Promise 如何使用?

1)创造一个Promise实例

2)Promise实例生成以后,可以用 then方法分别指定resolved状态和rejected状态的回调函数

3)可用Promise的try和catch方法预防异常

5、Promise 常用的方法有哪些?它们的作用是什么?

1)Promise.resolve(value)

类方法,该方法返回一个以 value 值解析后的 Promise 对象 如果这个值是个 thenable(即带有 then 方法),返回的 Promise 对象会“跟随”这个 thenable 的对象,采用它的最终状态(指 resolved/rejected/pending/settled ) 如果传入的 value 本身就是 Promise 对象,则该对象作为 Promise.resolve 方法的返回值返回 其他情况以该值为成功状态返回一个 Promise 对象

2)Promise.reject

类方法,且与 resolve 唯一的不同是,返回的 promise 对象的状态为 rejected

3)Promise.prototype.then

实例方法,为 Promise 注册回调函数,函数形式: fn(vlaue){},value 是上一个任务的返回结果,then 中的函数一定要 return 一个结果或者一个新的 Promise 对象,才可以让之后的then 回调接收

4)Promise.prototype.catch

实例方法,捕获异常,函数形式: fn(err){} , err 是 catch 注册 之前的回调抛出的异常信息

5)Promise.race

类方法,多个 Promise 任务同时执行,返回最先执行结束的 Promise 任务的结果,不管这个 Promise 结果是成功还是失败

6)Promise.all

类方法,多个 Promise 任务同时执行 如果全部成功执行,则以数组的方式返回所有 Promise 任务的执行结果。 如果有一个 Promise 任务 rejected,则只返回 rejected 任务的结果

6、Promise 在事件循环中的执行过程是怎样的?

1)事件循环

从代码执行顺序的角度来看,程序最开始是按代码顺序执行代码的,遇到同步任务,立刻执行;遇到异步任务,则只是调用异步函数发起异步请求。此时,异步任务开始执行异步操作,执行完成后到消息队列中排队。程序按照代码顺序执行完毕后,查询消息队列中是否有等待的消息。如果有,则按照次序从消息队列中把消息放到执行栈中执行。执行完毕后,再从消息队列中获取消息,再执行,不断重复。由于主线程不断的重复获得消息、执行消息、再取消息、再执行

2)promise的事件循环

Promise在初始化时,传入的函数是同步执行的,然后注册 then 回调。注册完之后,继续往下执行同步代码,在这之前,then 中回调不会执行。同步代码块执行完毕后,才会在事件循环中检测是否有可用的 promise 回调,如果有,那么执行,如果没有,继续下一个事件循环

7、Promise 的业界实现都有哪些?

1) promise可以支持多个并发的请求,获取并发请求中的数据

2)promise可以解决可读性的问题,异步的嵌套带来的可读性的问题,它是由异步的运行机制引起的,这样的代码读起来会非常吃力

8、能不能手写一个 Promise 的 polyfill?

1)Promsie的 polyfill 的源码实现

实例代码:

function Promise(fn){
        //  说明 Promise必须以构造函数形式被调用
        if(!(this instanceof  Promise))
            throw  new TypeError('Promises must be constructed via new');
        // 说明 Promise的唯一参数fn必须是函数类型
        if(typeof fn !== "function")
            throw new TypeError('not a function');
        // _state属性定义了Promise的状态
        // Promise有pending、fulfilled、rejected三种状态,分别对应_state值为0、1、2
        this._state = 0;
        // _handled属性的类型为Boolean,初始值为false,其代表Promise是否被处理
        this._handled = false;
        //  _value属性的类型为Promise或undefined,初始值为undefined
        this._value = undefined;
        // _deferreds属性的类型为Array,初始值为空数组,数组中存放的值为Function
        this._deferreds = [];
        // 将Promise的参数fn与代表当前对象的this作为参数,deResolve函数进行调用
        doResolve(fn,this);
    }

function doResolve(fn, self) {
        // done变量的作用就是为了防止resolve()和reject()被同时调用
        //  Promise的状态只能从pending->fulfilled或pending->rejected
        var done = false;
        try {
            //  fn的构造函数的参数,new Promise传入的回调函数  fn(resolve,reject);
            fn(
                    function(value) {
                        if (done) return;
                        // done变量为true则直接退出函数
                        done = true;
                        resolve(self, value);
                    },
                    function(reason) {
                        if (done) return;
                        done = true;
                        reject(self, reason);
                    }
            );
        } catch (ex) {
            // 调用Promsie构造函数如果抛出异常,则Promise就会变为rejected状态
            if (done) return;
            done = true;
            reject(self, ex);
        }
    }
复制代码

2) Promise 的 polyfill的实现

实例代码:

const promiseStatusSymbol = Symbol("PromiseStatus");
    const promiseValueSymbol = Symbol("PromiseValue");
    // pending、fulfilled、rejected
    const status = {
        pending:"pending",
        fulfilled:"fulfilled",
        rejected:"rejected"
    };
    const transition = function(status){
    /*    var self = this;
        return function(value){
            this[promiseStatusSymbol] = status;
            this[promiseValueSymbol] = value;
        }*/

       return (value) => {
            this[promiseValueSymbol] = value;
            setStatus.call(this,status);
        }
    };

    // 对于状态的改变进行控制
    // 如果状态从 pending 到 fulfilled, 那么调用链式的下一个fulfilled函数
    // 如果状态从 pending 到 rejected, 那么调用链式的下一个rejected函数
    const setStatus = function(status){
       this[promiseStatusSymbol] = status;
       if(status === status.fulfilled){
           this.deps.resolver && this.deps.resolver();
       }else if( status === status.rejected){
           this.deps.rejector && this.deps.rejector();
       }
    };

    // 当开始异步操作的时候,还没有结果的时候,处于pending状态,然后再改变为成功或者是失败的状态
    const promise = function(resolver){
      if(typeof  resolver !== "function"){
          throw new TypeError("parameter 1 must be a function");
      }
        this[promiseStatusSymbol] = status.pending;
        this[promiseValueSymbol] = [];
        this.deps = [];
        resolver(
            //  返回函数resolve和reject
            //  这两个函数会分别对当期的Promise的状态和值进行修改,修改成功或者失败
            transition.call(this,status.fulfilled),
            transition.call(this.status.rejected)
        );
    };

    // promise的链式调用主要是一个对于依赖进行依次收集的过程,then方法是添加依赖,不是执行回调函数
    promise.prototype.then = function(fulfilled,rejected){
        const self = this;
        return promise(function(resolve,reject){
           const callback = function () {
               // 回调函数执行的返回值需要保存下来
               // 在链式调用的时候,参数应该传递给链式调用的下一个
               const resoleValue = fulfilled(self[promiseValueSymbol]);
              // resolve(resoleValue);
              // 返回值相当于是一个thenable对象,改变直接调用then方法,获取一个返回值
              if(resoleValue && typeof resoleValue.then === "function"){
                  // 内嵌promise,将得到的值绑定在promise的依赖中
                  resoleValue.then(function(data){
                      resolve(data);
                  },function(err){
                      reject(err);
                  });
              }else{
                  // then 方法链式调用的连接点
                  // 在初始化状态或者上一次promise的状态发生改变的时候,调用当前promise成功的方法
                  //  对当前promise的状态进行改变,以及进行调用链式的下一个promise的回调
                  resolve(resoleValue);
              }
           };
           const errCallback = function(){
               const rejectValue = rejected(self[promiseValueSymbol]);
               reject(rejectValue);
           };

           // 对于promise的状态处理
           // 如果上一个promise在执行then方法之前就已经完成了,那么下一个promise对应的回调应该立即执行
           // 如果当前的状态为pending,说明promise的异步操作还没有决议,成功和失败的回调应该保存在之前的promise的依赖之中
            if(self[promiseStatusSymbol] === status.fulfilled){
               return callback();
           }else if(self[promiseStatusSymbol] === status.rejected){
               return errCallback();
           }else if(self[promiseStatusSymbol] === status.pending){
               self.deps.resolver = callback;
               self.deps.rejector = errCallback;
           }
        });
    };
复制代码

9、 Promise的问题?解决办法?

promise的问题为:

  • promise一旦执行,无法中途取消

  • promise的错误无法在外部被捕捉到,只能在内部进行预判处理

  • promise的内如何执行,监测起来很难

解决办法

  • 正是因为这些原因,ES7引入了更加灵活多变的async,await来处理异步

10、手写Promise与ajax的结合?

实例代码:

function promiseGet (url) {
  return new Promise((resolve, reject) => {
    let xhr = new XMLHttpRequest()
    xhr.open('GET', url, true)
    xhr.onreadystatechange = function () {
      if (this.readyState === 4) {
        if (this.status === 200) {
          resolve(this.responseText,this)
        } else {
          let resJson = {
            code: this.status,
            response: this.response
          }
          reject(resJson, this)
        }
      }
    }
  })
复制代码

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

分布式机器学习:算法、理论与实践

分布式机器学习:算法、理论与实践

刘铁岩、陈薇、王太峰、高飞 / 机械工业出版社 / 2018-10-20 / 89.00

人工智能和大数据时代,解决最有挑战性问题的主流方案是分布式机器学习!本书旨在全面介绍分布式机器学习的现状,深入分析其中的核心技术问题,并且讨论该领域未来的发展方向。 由微软亚洲研究院机器学习核心团队潜心力作!鄂维南院士、周志华教授倾心撰写推荐序! 本书旨在全面介绍分布式机器学习的现状,深入分析其中的核心技术问题,并且讨论该领域未来的发展方向。 全书共12章。第1章是绪论,向大家展......一起来看看 《分布式机器学习:算法、理论与实践》 这本书的介绍吧!

SHA 加密
SHA 加密

SHA 加密工具

正则表达式在线测试
正则表达式在线测试

正则表达式在线测试

HEX HSV 转换工具
HEX HSV 转换工具

HEX HSV 互换工具