• 35648

    文章

  • 23

    评论

  • 20

    友链

  • 最近新加了很多技术文章,大家多来逛逛吧~~~~
  • 喜欢这个网站的朋友可以加一下QQ群,我们一起交流技术。

ES6 Promise

欢迎来到阿八个人博客网站。本 阿八个人博客 网站提供最新的站长新闻,各种互联网资讯。 喜欢本站的朋友可以收藏本站,或者加QQ:我们大家一起来交流技术! URL链接:https://www.abboke.com/jsh/2019/0715/8223.html 1190000019754884

参考
https://pouchdb.com/2015/05/1...
https://developer.mozilla.org...
http://es6.ruanyifeng.com/#do...

Promises

是一种编写异步代码的方法。

Promise 对象

用于表示一个异步操作的最终状态(完成或失败),以及该异步操作的结果值。

Promise 使用

Promise适用于这样的场景,后面的操作必须根据前面的操作的结果做出相应的反应。 那么后面的操作必须等前面的操作完成并且获得前面操作的结果。

假设我们现在有三个操作doSomethingFirst,doSomethingSecond 和finalHandler。
doSomethingSecond 需要根据 doSomethingFirst 的结果做出反应
finalHandler 需要根据 doSomethingSecond 的结果做出反应
流程如下:

//resOfDoSomethingFirst 是 DoSomethingFirst的结果
  doSomethingFirst
|-----------------|
                  doSomethingSecond(resOfDoSomethingFirst)
                  |------------------|
                                     finalHandler(doSomethingSecond的结果)
                                     |------------------|
实现这个场景需要解决以下两个问题:
    后面的操作 如何知道 前面的操作 完成了
    后面的操作 如何知道 前面的操作 的执行结果是什么

//包装第一个操作在 doSomethingFirst 中
const doSomethingFirst = new Promise(function(resolve, reject) {
  // ... some code

  if (/*操作成功 */){
    resolve(doSomethingFirstValue);     //将doSomethingFirst对象的状态从“pending”变为“resolved”
  } else {
    reject(doSomethingFirstError);
  }
});

//包装第二个操作在 
doSdoSomethingSecond(resOfDoSomethingFirst) {
      // ... some code
    return somePromise(); //返回一个promise 对象
});

//整个操作流程如下:
doSomethingFirst()
    .then(doSdoSomethingSecond)
    .then(finalHandler)
    .catch(function (err) {
      console.log(err);
    })
    .finally(() => {···});
    
通过new Promise创建的Promise 实例doSomethingFirst 有以下方法:
    Promise.all(iterable)
    Promise.race(iterable)
    Promise.reject(reason)
    Promise.resolve(value)
    Promise.prototype.catch(onRejected)
    Promise.prototype.then(onFulfilled, onRejected)
    Promise.prototype.finally(onFinally)

1. doSomethingSecond 如何知道 doSomethingFirst 操作完成了
    通过doSomethingFirst状态的变更通知。

    一个 Promise有以下几种状态:
        pending: 操作未完成。
        fulfilled: 操作完成,并且成功。
        rejected: 操作完成,但是失败。

    resolve()函数:
        在异步操作成功时调用
        作用是:将Promise对象的状态从 pending 变为 fulfilled,并将异步操作的结果,作为参数传递出去;
    reject()函数:
        在异步操作失败时调用
        作用是:将Promise对象的状态从 pending 变为 rejected, 并将异步操作的错误,作为参数传递出去。

    当操作完成时(Promise对象的状态变为fulfilled 或 rejected时),doSomethingFirst 就会通过then()函数调用doSomethingSecond,doSomethingSecond就知道doSomethingFirst已经完成了。
2. doSomethingSecond 如何知道 doSomethingFirst 的执行结果是什么
    doSomethingFirst通过给then()函数调用doSomethingSecond(resOfDoSomethingFirst)并把执行结果resOfDoSomethingFirst作为参数传递给doSomethingSecond

Promise.prototype.then(onFulfilled, onRejected)

用于为 Promise 实例添加状态改变时的回调函数
返回值:一个新的 Promise,所可以采用链式写法,then()函数后面再调用then()函数
参数:
    onFulfilled 
        是一个函数,有一个参数,用来记录变成fulfilled状态返回的结果
        当doSomethingFirst这个Promise的状态变成fulfilled 时,onFulfilled作为回调函数被调用
    onRejected
        是一个函数,有一个参数,用来记录变成rejected状态返回的原因
        当doSomethingFirst这个Promise的状态变成rejected 时,onRejected作为回调函数被调用

    在当前的例子里参数onFulfilled就是doSomethingSecond(resOfDoSomethingFirst),resOfDoSomethingFirst 记录了doSomethingFirst 变成fulfilled状态返回的结果。

注意事项:
    当给then()传入的参数不是函数时,它实际上将其解释为then(null),将使先前的Promise的结果落空
        Promise.resolve('foo').then(Promise.resolve('bar')).then(function (result) {
          console.log(result); // foo
        });    
            等价于
        Promise.resolve('foo').then(null).then(function (result) {
            console.log(result);// foo 
        });
    
        上面的代码并没有按照我们期望的打印"bar", 而是打印"foo"
        正确的写法是:
        Promise.resolve('foo').then(function () {
          return Promise.resolve('bar');
        }).then(function (result) {
          console.log(result); // bar
        });


给then()传入的参数是函数时,函数的内部我们可以做以下三件事:
    1. 返回另外一个promise
    2. 返回一个同步值
    3. 抛出一个同步错误

    示例:返回另外一个promise
        doSomethingFirst()
            .then(doSdoSomethingSecond)
            .then(finalHandler)
    
        //somePromise() 返回promise对象
        function doSomethingSecond(resOfDoSomethingFirst) {
            return somePromise(); //有return, finalHandler接受到的是resOfDoSomethingSecond
            //somePromise();// 没有return, finalHandler接受到的是undefined
        }
        function finalHandler(resOfDoSomethingSecond) {
            // handle resOfDoSomethingSecond
        }

    示例:返回同步值 && 抛出一个同步错误
        返回同步值实际上是将同步代码转换为Promisey代码的一种很棒的方法。例如,假设我们有一个用户的内存缓存。我们可以做到:
        
            //getUserByName  和 getUserAccountById 都返回promise对象
            getUserByName('nolan').then(function (user) {
              if (user.isLoggedOut()) { //如果用户注销
                throw new Error('user logged out!'); // 抛出一个同步错误
              }
              if (inMemoryCache[user.id]) {
                return inMemoryCache[user.id];       //  返回一个同步值!
              }
              return getUserAccountById(user.id);    // 返回一个promise!
            }).then(function (userAccount) {
              // I got a user account!
            }).catch(function (err) {
              // Boo, I got an error!
            });
            
        如果用户注销,catch()将收到一个同步错误;通过callbacks,这个错误会被忽略
        如果任何promise被拒绝,catch()将收到一个异步错误。

通常情况下,一个promise 依赖于另一个promise ,但当我们需要两个promises的输出。我们该怎么做
    getUserByName('nolan').then(function (user) {
      return getUserAccountById(user.id);
    }).then(function (userAccount) {
      // 在这里我们已经获取到了用户账号userAccount,
      // 但是我们也需要user对象时该怎么做?
    });    

    解决方案:
    function onGetUserAndUserAccount(user, userAccount) {
      return doSomething(user, userAccount);
    }
    
    function onGetUser(user) {
      return getUserAccountById(user.id).then(function (userAccount) {
        return onGetUserAndUserAccount(user, userAccount);
      });
    }
    
    getUserByName('nolan')
      .then(onGetUser)
      .then(function () {
      // at this point, doSomething() is done, and we are back to indentation 0
    });

Promise.prototype.catch(onRejected)

用于指定发生错误时的回调函数。catch 可以捕获
返回值:返回一个Promise,处理状态变为rejected的情况
参数:
    onRejected
        是一个函数,有一个参数,用来记录变成rejected状态返回的原因。
        当promise 状态变为rejected时被调用。

注意事项:
catch(rejectHandler) 
    等同于
.then(null, rejectHandler)或.then(undefined, rejectHandler)

但是 then(resolveHandler).catch(rejectHandler) 和then(resolveHandler, rejectHandler)
不是完全相同的。
区别在于:当使用then(resolveHandler, rejectHandler)格式时,如果resolveHandler本身抛出了错误,那么rejecthandler实际上不会捕获错误。所以更建议使用catch 而不是then的第二个参数。

示例:
    var p1 = new Promise((resolve, reject) => {
        resolve('one');
    });
    
    // catch函数中可以捕捉到resolveHandler 中的error并打印
    p1.then(function () {
        throw new Error('oh noes');
    }).catch(function (err) {
        console.log('err=', err); // Error: oh noes
    });
    
    // reject函数不能捕捉到resolveHandler中的error
    p1.then(function () {
        throw new Error('oh noes');
    }, function (err) {
        console.log('err=', err); 
    });

Promise.prototype.finally(onFinally)

用于指定不管 Promise 对象最后状态如何,都会执行的操作

finally本质上是then方法的特例
promise
.finally(() => {
  // 语句
});

// 等同于
promise
.then(
  result => {
    // 语句
    return result;
  },
  error => {
    // 语句
    throw error;
  }
);
返回值:返回一个Promise,这个Promise对象设置了 finally 回调函数
参数:Promise 结束后调用的函数,onFinally 这个函数不接收任何参数,它仅用于无论最终结果如何都要执行的情况。所以finally方法里面的操作,不应依赖于 Promise 的执行结果。
示例:
    promise
    .then(result => {···})
    .catch(error => {···})
    .finally(() => {···});

Promise.resolve(value)

用于将现有对象转为 Promise 对象
    new Promise(function (resolve, reject) {
      resolve(someSynchronousValue);
    }).then(/* ... */);
    等价于
    Promise.resolve(someSynchronousValue).then(/* ... */);

返回值:返回一个Promise 对象,这个Promise对象是被给定的值解析过的。
参数:
    value
        将被Promise对象解析的参数
        参数类型:
            Promise对象
            具有then方法的对象
            没有then方法的对象
            不带有任何参数

示例1:参数是一个Promise对象
    Promise.resolve将不做任何修改、原封不动地返回这个Promise对象

    var p = Promise.resolve([1,2,3]);
    console.log("p=", p); //"p=" [object Promise]
    console.log('p type= ', typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" Array [1, 2, 3]
      console.log("v type=",typeof(v)); //"v type=" "object"
    });
    
    var p2 =  Promise.resolve(p);
    console.log("p2=", p2); //"p2=" [object Promise]
    console.log('p2 type= ', typeof(p2)); //"p2 type= " "object"
    p2.then(function(v) {
      console.log("p2 v=",v); //"p2 v=" Array [1, 2, 3]
      console.log("p2 v type=",typeof(v)); //"p2 v type=" "object"
    });

    p2 == p
示例2:参数是一个具有then方法的对象
    返回的promise会采用这个thenable的对象的最终状态。

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

    Promise.resolve方法会将thenable对象转为 Promise 对象,然后就立即执行thenable对象的then方法,thenable对象的then方法执行后,对象p的状态就变为resolved,从而立即执行最后那个then方法指定的回调函数,输出 42

示例3:参数是一个没有then方法的对象
    var p = Promise.resolve([1,2,3]);
    console.log("p=", p); //"p=" [object Promise]
    console.log('p type= ', typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" Array [1, 2, 3]
      console.log("v type=",typeof(v)); //"v type=" "object"
    });
    
    var p = Promise.resolve(123);
    console.log("p=", p); //"p=" [object Promise]
    console.log('p type= ', typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" 123
      console.log("v type=",typeof(v)); //"v type=" "number"
    });
    
    var p = Promise.resolve("123");
    console.log("p=", p); //"p=" [object Promise]
    console.log('p type= ', typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" "123"
      console.log("v type=",typeof(v)); //"v type=" "string"
    });

示例4:不带有任何参数
    var p = Promise.resolve();
    console.log("p=", p); //"p=" [object Promise]
    console.log('p type= ', typeof(p)); // "p type= " "object"
    p.then(function(v) {
      console.log("v=",v); //"v=" undefined
      console.log("v type=",typeof(v)); //"v type=" "undefined"
    });

注意事项:
    立即resolve()的 Promise 对象,是在本轮“事件循环”(event loop)的结束时执行,而不是在下一轮“事件循环”的开始时
        //在下一轮“事件循环”开始时执行
        setTimeout(function () { 
          console.log('three');
        }, 0);
        //在本轮“事件循环”结束时执行
        Promise.resolve().then(function () {
          console.log('two');
        });
        //立即执行
        console.log('one');
    结果:
        "one"
        "two"
        "three"        
            

Promise.reject(reason)

返回值:返回一个Promise 对象,这个Promise 对象 带有状态是rejected的原因
参数:
    reason
        表示Promise被拒绝的原因
    new Promise(function (resolve, reject) {
      reject(someSynchronousReson);
    }).then(null,function(reason){
       //...
    });

等价于
    Promise.reject(someSynchronousReson)
    .then(null, function(reason) {
      //...
    });

    
示例:
    new Promise(function (resolve, reject) {
      reject("reject reason");
    }).then(null,function(reason){
            console.log(reason);//"reject reason"
    });
    
    Promise.reject("reject reason").then(null, function(reason) {
      console.log(reason); // "reject reason"
    });
    
    Promise.reject(new Error("reject reason")).then(null, function(error) {
      console.log(error); // Error: reject reason
    });

注意事项:与Promise.resolve不同的是Promise.reject()方法的参数,会原封不动地作为reject的理由,变成后续方法的参数。
    const thenable = {
      then(resolve, reject) {
        reject('出错了');
      }
    };
    
    Promise.reject(thenable)
    .catch(e => { //e不是reject抛出的“出错了”这个字符串,而是thenable对象。
      console.log(e === thenable) // true
    })

Promise.all(iterable)

用于将多个 Promise 实例,包装成一个新的 Promise 实例
返回值:返回一个新的promise对象,iterable中所有的promise都变成resolved状态时返回的 promise才会变为resolved状态; iterable中有一个promise变成rejected状态,promise就会变为rejected状态。
参数:
    iterable
    一个可迭代对象,eg Array 或 String

示例: iterable中所有的promise都变成resolved状态时返回的 promise才会变为resolved状态
    var p1 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 1000, 'one'); 
    }); 
    var p2 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 2000, 'two'); 
    });
    var p3 = new Promise((resolve, reject) => {
      setTimeout(resolve, 3000, 'three');
    });
    const p = Promise.all([p1, p2, p3]).then(values => { 
      console.log(values); //["one", "two", "three"]
    }).catch(reason => {
      console.log(reason); //没执行
    });

    流程:p创建时为pending状态,当p1, p2, p3的状态都变成resolved时触发p变成resolved状态。
    p1    1s
    |----------|resolved                      
    p2    2s 
    |--------------------|resolved
    p3    3s 
    |------------------------------|resolved
                                   p resolved
                                   

示例:iterable中有一个promise变成rejected状态,promise就会变为rejected状态
    var p1 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 1000, 'one'); 
    }); 
    var p2 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 2000, 'two'); 
    });
    var p3 = new Promise((resolve, reject) => {
      reject('reject');
    });
    const p = Promise.all([p1, p2, p3]).then(values => { 
      console.log(values); //没执行
    }).catch(reason => {
      console.log(reason); //"reject"
    });    

    流程:p创建时为pending状态,p3先执行完,p3的状态变成rejected时触发p变成rejected状态。
    p1    1s
    |----------|resolved                      
    p2    2s 
    |--------------------|resolved
    p3
    |-|rejected
      p rejected
      

示例:如果作为参数的 Promise 实例,自己定义了catch方法,那么它一旦被rejected,并不会触发Promise.all()的catch方法
    var p1 = new Promise((resolve, reject) => { 
          setTimeout(resolve, 1000, 'one'); 
        }); 
        var p2 = new Promise((resolve, reject) => { 
          setTimeout(resolve, 2000, 'two'); 
        });
        var p3 = new Promise((resolve, reject) => {
          reject('reject');
        }).catch(reason => {
          console.log(reason); //reject
        });
        const p = Promise.all([p1, p2, p3]).then(values => { 
          console.log(values); // ["one", "two", undefined]
        }).catch(reason => {
          console.log(reason); //没执行
        });    


    流程:p创建时为pending状态,p3先执行完,p3的状态变成rejected时,调用自己定义的catch函数抛出错误,不会触发p变成rejected状态。当p1 和 p2 也执行完时,触发p变成resolved状态
    p1    1s
    |----------|resolved                      
    p2    2s 
    |--------------------|resolved
    p3
    |-|rejected
                           |p resolved

示例:如果传入的参数是一个空的可迭代对象,则返回一个resolved状态的 Promise 
    const p = Promise.all([]).then(values => { //p创建时状态就为resolved
      console.log(values); // []
    });

Promise.race(iterable)

同样是将多个 Promise 实例,包装成一个新的 Promise 实例
返回值:返回一个新的promise对象,一旦iterable中的某个promise变为resolved或rejected状态,返回的 promise就会变为resolved或rejected状态。谁最先执行完就返回谁的状态
参数:
    iterable
    一个可迭代对象,eg Array 或 String

示例: 一旦iterable中的某个promise变为resolved状态,返回的 promise就会变为resolved状态。
    var p1 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 1000, 'one'); 
    }); 
    var p2 = new Promise((resolve, reject) => { 
      setTimeout(resolve, 2000, 'two'); 
    });
    var p3 = new Promise((resolve, reject) => {
      setTimeout(resolve, 3000, 'three');
    });
    const p = Promise.race([p1, p2, p3]).then(values => { 
      console.log(values); //["one", "two", "three"]
    }).catch(reason => {
      console.log(reason); //没执行
    });

流程:p创建时为pending状态,p1先执行完,p1的状态都变成resolved时触发p变成resolved状态。
p1    1s
|----------|resolved
           p resolved                      
p2    2s 
|--------------------|resolved
p3    3s 
|------------------------------|resolved
                               
                                   
示例:一旦iterable中的某个promise变为rejected状态,返回的 promise就会变为rejected状态。
var p1 = new Promise((resolve, reject) => { 
  setTimeout(resolve, 1000, 'one'); 
}); 
var p2 = new Promise((resolve, reject) => { 
  setTimeout(resolve, 2000, 'two'); 
});
var p3 = new Promise((resolve, reject) => {
  reject('reject');
});
const p = Promise.all([p1, p2, p3]).then(values => { 
  console.log(values); //没执行
}).catch(reason => {
  console.log(reason); //"reject"
});    

流程:p创建时为pending状态,p3先执行完,p3的状态变成rejected时触发p变成rejected状态。
p1    1s
|----------|resolved                      
p2    2s 
|--------------------|resolved
p3
|-|rejected
  p rejected

相关文章

暂住......别动,不想说点什么吗?
  • 全部评论(0
    还没有评论,快来抢沙发吧!