Promise链式调用(es6异步调用then结构)

promise俗称链式调用，它是es6中最重要的特性之一
简单的说可以不停的then调用嵌套在调用（异步之后，链式调用方式执行回调），这种操作方式称为promise
 
1.  Promise
    包含两个参数：resolve，reject；
    Resolve：将promise的状态设置为完成状态（resolved），此时then方法捕捉变化，执行成功的回调
    Reject：将promise状态设置为无效，（rejected），此时then方法执行失败回调
 
    ⑴． resolved（全部置为完成状态）
       ①.初始化：比如说以国家，省份，县市（china ，jiangshu ，xian）三个方法来演示下链式调用关系（采用setTimeout模拟异步操作）
 
           function  china(){
                    console.log('china中国')
                    var p =new Promise(
                    function( resolve,reject ) {
                             setTimeout(function(){
                             console.log('中国  国家')
                             resolve('教育大省份')
                         },1000)
                    }
               )
               return  p;
           }
 
           function  jiangshu(data){
                    console.log('江苏'+data);
                    var p=new Promise(function(resolve,reject){
                         setTimeout(function (){
                         console.log('江苏 省份')
                         resolve('地级市');
                    },2000)
               })
               return p;
           }
 
           function  xian(data){
                   console.log('盱眙县'+data)
                    var p=new Promise(function(resolve,reject){
                         setTimeout(function(){
                         console.log('盱眙县');
                         resolve ('淮河镇')
                    },2000)
               })
               return p;
            }
②. 函数写完之后，就开始结合then来链式调用了
china()
.then(function(data){returnjiangshu(data)})
.then(function(data){returnxian(data)})

.then(function(data){console.log(data)})

简化写法：
china ().then(jiangshu).then(xian).then(function(data){
    console.log(data)
})
 
③. 查看控制台输出：

2． rejected（部分置为无效状态）
    ①.初始化：同样的以上述的函数为例
                 function  china(){
                    console.log('china中国')
                    var p =new Promise(
                    function( resolve,reject ) {
                             setTimeout(function(){
                             console.log('中国  国家')
                             reject('教育大省份')
                         },1000)
                    }
               )
               return  p;
                 }
              
                 function jiangshu(data){
                       console.log('江苏是'+data);
                       varp=new Promise(function(resolve,reject){
                            setTimeout(function(){
                            console.log('江苏 省份')
                            resolve('地级市');
                       },2000)
                   })
                   returnp;
              }
    ②. 函数写完之后，就开始结合then来链式调用了
          china()
         .then(jiangshu,function(data){ console.log(data)})
        
         等同于（null不执行）
         china()
         .then(null,function(data){ console.log(data)})
 
         等同于（直接执行catch回调，抛出异常，页面也不会卡死，直接走catch）
         china()
         .then(jiangshu).catch(function(data){console.log(data)})
 
    (备注：为reject的时候，执行then的第二个参数回调，不会执行jiangshu)
    ③. 查看控制台输出：

 
3.  Promise之All，等执行所有异步，完事之后执行then回调返回出数组数据类型
    ①.初始化两个同级函数
          function  jiangshu1(){
                    console.log('江苏1');
                    var p=newPromise(function(resolve,reject){
                         setTimeout(function (){
                         console.log('江苏 省份1')
                         resolve('地级市1');
                    },1000)
               })
               return p;
           }
 
 
           function  jiangshu2(){
                    console.log('江苏2');
                    var p=newPromise(function(resolve,reject){
                         setTimeout(function (){
                         console.log('江苏 省份2')
                         resolve('地级市2');
                    },2000)
               })
               return p;
              }
 
    ②. 函数写完之后，调用了
     Promise.all([jiangshu1(),jiangshu2()]).then(function(data){console.log(data)})
 
    ③. 查看控制台输出：

未完待续……