Promise的理解

作者: Kris_lee | 来源:发表于2017-06-06 11:34 被阅读278次

    如何解决异步

    在Promise没有出现之前,我们通过回调函数,进行解决异步操作

    function add(getX, getY,cd){
        var x,y;
        getX(function(xValue){
            x = xValue;
            if(y!=undefined){
                cb(x+y)
            }
        })
        
        getY(function(yValue){
            y = yValue;
            if(x!=undefined){
                cb(x+y)
            }
        })
    }
    

    利用Promise重写

    function add2(xPromise,yPromise){
        return Promise.all([xPromise,yPromise]).then(function(values){
            return values[0]+values[1];
        })
    }
    
    上面的代码是通过回调来解决异步,在ES6中出现Promise以及Generator函数来解决异步问题,在ES7中出现async/await 。那么探讨一下什么是Promise

    1、Promise是什么

    Promise是抽象异步处理对象,以及对其进行各种操作的组件,可以将复杂的异步处理轻松的进行模式化。

    2、Promise的特点

    对象的状态不受外界影响

    Promise的对象待变一个异步操作,有三种状态:Pending(进行中)、Resolved(已完成,又称Fulfilled)和Rejected(失败).


    一旦状态改变,就不会再变,任何时候都可以得到这个结果

    3、Promise的缺点

    Promise也有一些缺点。首先,无法取消Promise,一旦新建它就会立即执行,无法中途取消。其次,如果不设置回调函数,Promise内部抛出的错误,不会反应到外部。第三,当处于Pending状态时,无法得知目前进展到哪一个阶段(刚刚开始还是即将完成)。
    如果某些事件不断地反复发生,一般来说,使用 Stream 模式是比部署Promise更好的选择。

    4、基本用法

    ES6 规定,Promise对象是一个构造函数,用来生成Promise实例。

    var promise = new Promise(function(resolve, reject) {
      // ... some code
    
      if (/* 异步操作成功 */){
        resolve(value);//成功抛出value
      } else {
        reject(error);//失败抛出错误
      }
    });
    

    Promise实例生成以后,可以用then方法分别指定Resolved状态和Reject状态的回调函数。

    promise.then(function(value) {
      // success
    }, function(error) {
      // failure   --->可选
    });
    

    那么来写一个简单的Promise

    var ok = 1;
    var promise = new Promise((resolve,reject) =>{
        if(typeof ok === 'number'){
            resolve(ok)
        }else{
            reject(new TypeError("ok is not number"))
        }
    }).then((result) =>{
        console.log(result)
    }).then((result) =>{
        console.log(result)
    }).catch((error)=>{
        console.log(error)
    })
    

    可以发现第二个结果是undefined。现在我们需要让第二个结果是1。只需要这样修改。

        var ok = 1;
        var promise = new Promise((resolve,reject) =>{
            if(typeof ok === 'number'){
                resolve(ok)
            }else{
                reject(new TypeError("ok is not number"))
            }
        }).then((result) =>{
            console.log(result)
            return result
        }).then((result) =>{
            console.log(result)
        }).catch((error)=>{
            console.log(error)
        })
    

    5、依赖关系的Promise


    var task1 = new Promise((resolve, reject) => {
    resolve("task1")
    })

    var task2 = new Promise((resolve, reject) => {
        resolve("task2")
    })
    
    var mainTask = new Promise((resolve, reject) => {
        resolve("main task has done")
    }).then((result) => {
        console.log(result);
        return task1;
    }).then((result) => {
        console.log(result);
        return task2;
    }).then((result) => {
        console.log(result)
        console.log("mission complete")
    }).catch((error) => {
        console.error(error)
    })
    
    if(typeof mainTask.then === "function") {
        console.log("mainTask then is a function")
    }
    

    这样链式,同样流行也有函数式,增加程序的可读性。我们可以发现,
    打印的结果是

    屏幕快照 2017-06-06 上午10.12.52.png
    在这里先打印出来的是if。后将Promise结果打印出来,当出现异步的操作的时候,总是等本轮事件循环结束后打印异步结果,而不是在下一轮“事件循环”的开始。

    6、Promise.all

    Promise.all方法用于将多个Promise实例,包装成一个新的Promise实例
    eg:

     var p = Promise.all([p1,p2,p3])
    

    上面代码中,Promise.all方法接受一个数组作为参数,p1、p2、p3都是 Promise 实例,如果不是,就会先调用下面讲到的Promise.resolve方法,将参数转为 Promise 实例,再进一步处理。(Promise.all方法的参数可以不是数组,但必须具有 Iterator 接口,且返回的每个成员都是 Promise 实例。)

    而 p的状态由p1,p2,p3决定,分成两种情况。

    只有p1、p2、p3的状态都变成fulfilled,p的状态才会变成fulfilled,此时p1、p2、p3的返回值组成一个数组,传递给p的回调函数。


    只要p1、p2、p3之中有一个被rejected,p的状态就变成rejected,此时第一个被reject的实例的返回值,会传递给p的回调函数。

    7、Promise.race()

    Promise.race方法同样是将多个Promise实例,包装城一个新的Promise实例

    var p = Promise.all([p1,p2,p3])
    

    上面代码中,只要p1、p2、p3之中有一个实例率先改变状态,p的状态就跟着改变。那个率先改变的 Promise 实例的返回值,就传递给p的回调函数。
    和Promise.all的区别也就是,逻辑运算符 && 和 || 的区别。

    8、Promise.resolve()

    有时需要将现有对象转为Promise对象,Promise.resolve方法就起到这个作用

    var jsPromise = Promise.resolve($.ajax('/whatever.json'));
    

    上面代码将JQuery生成的deferred对象,转为一个新的Promise对象。

    Promise.resolve等价于下面的写法。

    Promise.resolve('foo')
    //等价于
    new Promise(resolve => resolve('foo'))
    

    Promise.resolve方法的参数分为四种情况。
    (1)参数是一个Promise实例
    如果参数是Promise实例,那么Promise.resolve将不做任何修改,原封不动地返回这个实例.
    (2)参数是一个thenable对象
    thenable对象指的是具有then方法的对象,比如下面这个对象。

    let thenable = {
      then: function(resolve, reject) {
        resolve(42);
      }
    };
    

    Promise.resolve方法会将这个对象转为Promise对象,然后立刻执行thenable的then方法。

        let thenable = {
      then: function(resolve, reject) {
        resolve(42);
      }
    };
    
    let p1 = Promise.resolve(thenable);
    p1.then(function(value) {
      console.log(value);  
    });
    

    打印出来的结果为:

    屏幕快照 2017-06-06 上午10.57.11.png
    thenable对象的then方法执行后,对象p1的状态就变为resolved,从而立即执行最后那个then方法指定的回调函数,输出42。

    (3)参数不是具有then方法的对象,或根本就不是对象
    如果参数是一个原始值,或者是一个不具有then方法的对象,则Promise.resolve方法返回一个新的Promise对象,状态为Resolved。

    var p = Promise.resolve('Hello');
    p.then(function (s){
        console.log(s)
    });
    //Hello
    

    **(4)不带有任何参数 **
    Promise.resolve方法允许调用时不带参数,直接返回一个Resolved状态的Promise对象。

    var task = () =>{
        console.log("task")
    }
    var p = Promise.resolve();
    p.then(task());
    console.log("next");
    

    打印的结果是


    在之前我们说过,Promise执行,是在本次 “事件循环”结束后的操作,而这里,打印出的结果则是先task 后next这里的resolve .then使得事件同步执行,而非异步。那么如何让结果异步执行呢

        var task = () =>{
        console.log("task")
    }
    var p = Promise.resolve();
    p.then(task);
    console.log("next");
    

    打印结果:


    去掉括号,则task 是一个方法,方法并没有执行。typeof task的时候,打印出的结果是function。而typeof task(),打印出的结果是undefined。执行了task()方法,返回值我们没有给入,所以返回的结果是undefined。

    9、Promise.reject()

    Promise.reject(reason)方法也会返回一个新的 Promise 实例,该实例的状态为rejected。
    方式方法同上。可以作为参考。

    10、Promise.try()

    实际开发中,经常遇到一种情况:不知道或者不想区分,函数f是同步函数还是异步操作,但是想用 Promise 来处理它。因为这样就可以不管f是否包含异步操作,都用then方法指定下一步流程,用catch方法处理f抛出的错误。一般就会采用下面的写法。

    Promise.resolve().then(f)
    

    上面的写法有一个缺点,就是如果f是同步函数,那么它会在本轮事件循环的末尾执行。

        const f = () => console.log('now');
        Promise.resolve().then(f);
        console.log('next');
        // next
        // now
    

    上面代码中,函数f是同步的,但是用 Promise 包装了以后,就变成异步执行了。

    那么有没有一种方法,让同步函数同步执行,异步函数异步执行,并且让它们具有统一的 API 呢?回答是可以的,并且还有两种写法。第一种写法是用async函数来写。

        const f = () => console.log('now');
        (async () => f())();
        console.log('next');
        // now
        // next
    

    上面代码中,第二行是一个立即执行的匿名函数,会立即执行里面的async函数,因此如果f是同步的,就会得到同步的结果;如果f是异步的,就可以用then指定下一步,就像下面的写法。

    (async () => f())()
    .then(...)
    

    第二种写法是使用new Promise()。

        const f = () => console.log('now');
    (
      () => new Promise(
        resolve => resolve(f())
      )
    )();
    console.log('next');
    // now
    // next
    

    上面所有的方式都可以用Promise.try来取代。

    const f = () => console.log('now');
    Promise.try(f);
    console.log('next');
    

    两个有用的附加方法

    done()

    Promise对象的回调链,不管以then方法或catch方法结尾,要是最后一个方法抛出错误,都有可能无法捕捉到(因为Promise内部的错误不会冒泡到全局)。因此,我们可以提供一个done方法,总是处于回调链的尾端,保证抛出任何可能出现的错误。

        asyncFunc()
      .then(f1)
      .catch(r1)
      .then(f2)
      .done();
    

    finally()

    finally方法用于指定不管Promise对象最后状态如何,都会执行的操作。它与done方法的最大区别,它接受一个普通的回调函数作为参数,该函数不管怎样都必须执行。
    服务器使用Promise处理请求,然后使用finally方法关掉服务器。

    server.listen(0)
      .then(function () {
        // run test
      })
      .finally(server.stop);
    

    应用

    将Promise和Generator函数应用

        function getFoo () {
      return new Promise(function (resolve, reject){
        resolve('foo');
      });
    }
    
    var g = function* () {
      try {
        var foo = yield getFoo();
        console.log(foo);
      } catch (e) {
        console.log(e);
      }
    };
    
    function run (generator) {
      var it = generator();
    
      function go(result) {
        if (result.done) return result.value;
    
        return result.value.then(function (value) {
          return go(it.next(value));
        }, function (error) {
          return go(it.throw(error));
        });
      }
    
      go(it.next());
    }
    
    run(g);
    

    上面代码的Generator函数g之中,有一个异步操作getFoo,它返回的就是一个Promise对象。函数run用来处理这个Promise对象,并调用下一个next方法。
    执行run(g)的代码,执行完成之后,输出的结果为:foo

    以上参考阮一峰老师关于ES6的入门的理解,如果有不正确的地方,请各位大神留言告知。

    相关文章

      网友评论

      • __________mo:大神问一下,为什么第二个then加了return,console出来就不是undefined的了呢?刚用很多不清楚
        __________mo:@Kris_lee 嗯嗯,谢谢了~已经解决了
        Kris_lee:下一个then调用的时候,会根据你上一个的返回值来进行操作。如果只是console.log出来,下一个then调用也是undefined。因此如果下一个then需要调用上一个数据的来进行操作的时候,需要上个进行return

      本文标题:Promise的理解

      本文链接:https://www.haomeiwen.com/subject/kmygfxtx.html