脚本宝典收集整理的这篇文章主要介绍了

ES6中Promise 承诺对象封装异步操作解析

脚本宝典小编觉得挺不错的,现在分享给大家,也给大家做个参考,希望能帮助你少写一行代码,多一份安全和惬意。

Promise

是异步编程的一种解决方案,比传统的解决方案(回调函数和事件)更合理和更强大。它由社区最早
出和实现,ES6 将其写进了语言标准,统一了用法,原生提供了Promise对象。

所谓Promise,简单说就是一个容器,里面保存着某个未来才会结束的事件(通常是一个异步操作)的结果。从语法上说,Promise 是一个对象,从它可以获取异步操作的消息。Promise 提供统一的 API,各种异步操作都可以用同样的方法进行处理。
有了Promise对象,就可以将异步操作以同步操作的流程表达出来,避免了层层嵌套的回调函数。此外,Promise对象提供统一的接口,使得控制异步操作更加容易

异步的解决方案:

  • 1)传统ajax

        是一种异步的JavaScript的请求,能够在不影响当前进程的情况下和后台进行交互.
               1.发起请求
                   请求的返回时间难以确定,影响因素比较多,比如网络延迟
               2.监听(成功,失败)
                   通过判断状态码来决定执行那个回调函数
                   200 ok
                   404 not found
                   500 后台代码异常
                   403 无权访问
                   304 文档内容没有发生改变
               3.调用回调函数
                   完成请求后的处理
    
    
    
             $.getJSON('http://120.78.164.247:8080/grade',function(data){
               alert(data)
               });
               alert('end');
               //先执行end 在弹出data
    

出现的问题:在回调函数中嵌套如果比较多,就很容易出问题

  • 2)promise

       承诺
       存在三种状态:
           1.未知状态,
           2.成功状态,resolve() 未知状态---》成功状态
           3.失败状态,reject()    未知状态---》失败状态
       ajax中使用最多
       
       
       let promise = new Promise((resolve,reject)=>{
       $.ajaxSetup({
           error:function(){reject()};    //失败
          });
           $.get('',function(data){
           resolve(data);    //成功
          });
       promise.then(()={}).catch(()=>{});
    

在我的理解中promise是对ajax的一种封装,上述代码中,使用的是用JQuery封装的ajax代码分成了两部分。

对异步操作Ajax的封装

  • 1.先来看看我们自己封装一个Ajax
    let fetch = (method,url,successHandler,errorHandler)=>{
        let xhr = new XMLHttpRequest();
        xhr.open(method,url);
        xhr.responseType = 'json';
        xhr.setRequestHeader('Accept','application/json');//设置头部信息
        
        xhr.onreadystatechange = function(){
            if(this.readyState == 4){
                if(this.status == 200){
                    successHandler(this.response)
                }else{
                    errorHandler(this.response);
                };
            }
        };
        xhr.send();
    
    }

需要注意的是因为原生代码中需要http协议,所以这个代码在node中是无法使用的,

  • 2.下面来看看使用promise来封装

    简单的思路:

       let promise = new Promise((resolve,reject)=>{
       
           setTimeout(function(){//模拟异步请求
               if (Math.round(Math.random()*10)>5) {
                           resolve('success');//成功
                       }else{
                           reject('erro');//失败
                       }
       
           },3000);
       
       });
       
       promise.then((data)=>{
           console.log(data);
       }).catch((erro)=>{
           console.log(erro);
       });
    

    我们来看看promise如何封装Ajax

       let fetch = (method,url)=>{
           return new Promise((resolve,reject)=>{
               let xhr = new XMLHttpRequest();//声明一个请求
               xhr.open(method,url);
               xhr.responseType = 'json';
               xhr.setRequestHeader('Accept','application/json');
               xhr.onreadystatechange = function(){
                   if(this.readyState == 4){//判断状态
                   if(this.status == 200){
                       resolve(this.response)
                   }else{
                       reject(this.response);
                   };
               };
               };
                   xhr.send();//发送请求
           });
       };
       fetch('get','http://120.78.164.247:8080/grade/findAll').then(({code,msg,extend})=>{
           console.log(code);
           console.log(msg);
           console.log(extend);
       }).catch(()=>{});//调用自己封装的fetch
       
       

Promise常用方法

接着,我们来看看Promise中的一些基本用法

  • 1.Promise.prototype.then()

     .then(function(){//success},functions(){//error});
    

then方法是定义在原型对象Promise.prototype上的,也就是说,Promise 实例具有then方法。它的作用是为 Promise 实例添加状态改变时的回调函数。then方法的第一个参数是Resolved状态的回调函数,第二个参数(可选)是Rejected状态的回调函数。then方法返回的是一个新的Promise实例注意,不是原来那个Promise实例)。因此可以采用链式写法,即then方法后面再调用另一个then方法。如果使用两个then方法,第一个回调函数完成以后,会将返回结果作为参数,传入第二个回调函数。

getJSON("/post/1.json").then( 
    post => getJSON(post.commentURL)
 ).then( 
    comments => console.log("Resolved: ", comments), 
    err => console.log("Rejected: ", err) 
); 

上面代码中,第一个then方法指定的回调函数,返回的是另一个Promise对象。这时,第二个then方法指定的回调函数,就会等待这个新的Promise对象状态发生变化。如果变为resolved,就调用funcA,如果状态变为rejected,就调用funcB。

Promise.prototype.catch方法是.then(null, rejection)的别名,用于指定发生错误时的回调函数,一般来说,不要在then方法里面定义Reject状态的回调函数(即then的第二个参数)总是使用catch方法

var promise = new Promise(function(resolve, reject) { 
    reject(new Error('test')); 
});
 promise.catch(function(error) { 
    console.log(error);
 });

Promise 对象的错误具有“冒泡”性质,会一直向后传递,直到被捕获为止。也就是说,错误总是会被下一个catch语句捕获。

  • 3.Promise.all()

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

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

上面代码中,Promise.all方法接受一个数组作为参数,p1、p2、p3都是 Promise 实例,p的状态由p1、p2、p3决定,分成两种情况。
只有p1、p2、p3的状态都变成fulfilled,p的状态才会变成fulfilled,此时p1、p2、p3的返回值组成一个数组,传递给p的回调函数。
只要p1、p2、p3之中有一个被rejected,p的状态就变成rejected,此时第一个被reject的实例的返回值,会传递给p的回调函数。

  • 4.Promise.race()

Promise.race方法同样是将多个Promise实例,包装成一个新的Promise实例。下面代码中,只要p1、p2、p3之中有一个实例率先改变状态,p的状态就跟着改变。那个率先改变的 Promise 实例的返回值,就传递给p的回调函数。

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

上面代码中,Promise.all方法接受一个数组作为参数,p1、p2、p3都是 Promise 实例,p的状态由p1、p2、p3决定,分成两种情况。
只有p1、p2、p3的状态都变成fulfilled,p的状态才会变成fulfilled,此时p1、p2、p3的返回值组成一个数组,传递给p的回调函数。
只要p1、p2、p3之中有一个被rejected,p的状态就变成rejected,此时第一个被reject的实例的返回值,会传递给p的回调函数。

  • 5.Promise.resolve()

方法将现有对象转为Promise对象,例如:

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

根据参数的不同,方法的返回值也会发生变化:

1.参数是一个Promise实例
Promise.resolve将不做任何修改、原封不动地返回这个实例。
2.参数是一个thenable对象
thenable对象指的是具有then方法的对象,Promise.resolve方法会将这个对象转为Promise对象,然后就立即执行thenable对象的then方法。
3.参数不是具有then方法的对象,或根本就不是对象
如果参数是一个原始值,或者是一个不具有then方法的对象,则Promise.resolve方法返回一个新的Promise对象,状态为Resolved。
4.不带有任何参数
直接返回一个Resolved状态的Promise对象。需要注意的是,立即resolve的Promise对象,是在本轮“事件循环”(event loop)的结束时,而不是在下一轮“事件循环”的开始时。
  • 6.Promise. reject()

Promise.reject(reason)方法也会返回一个新的 Promise 实例,该实例的状态为rejected 。

var p = Promise.reject('出错了'); 
// 等同于 
var p = new Promise((resolve, reject) => reject('出错了')) ;

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

server.listen(0) .then(function () {
     // run test
 }) .finally(server.stop);    //关掉服务器

使用总结

Promise对象的使用大致分为如下几个步骤:

 1. 构建承诺对象
    let promise = new Promise((resolve,reject)=>{
      // resolve()    未知->成功
      // reject()     未知->失败
    });
 2. 执行
    promise.then(()=>{
      //成功后的回调
    }).catch(()=>{
      //失败后的回调
    });

 3. 企业级应用




总结

以上是脚本宝典为你收集整理的

ES6中Promise 承诺对象封装异步操作解析

全部内容,希望文章能够帮你解决

ES6中Promise 承诺对象封装异步操作解析

所遇到的程序开发问题,欢迎加入QQ群277859234一起讨论学习。如果觉得脚本宝典网站内容还不错,欢迎将脚本宝典网站推荐给程序员好友。 本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。如您有任何意见或建议可联系处理。小编QQ:384754419,请注明来意。

80%的人都看过