js-Promise基础（第三周）
Promise含义
promise意思为允诺、许诺、承诺
在js中为了解决编写代码中的地狱回调，而封装的一个类，实现了同步编程风格来实现异步功能，其本质还是各种回调，它先有社区提出和实现，现在ES6也将promise吸进了，提供了原生的Promise了
Promise简单描述
promise表示一个异步操作的状态，和返回结果，promise有三种状态分别为pending（进行中）、resolved（已完成，又称fulfilled）、rejected（失败）；
当promise状态由pending转变为resolved或者rejected时，会相应的执行各自的方法，并且状态一点改变，就不会再次改变，这个可能就是Promise（承诺）这个名字的由来；
生成Promise对象
一般使用两种方法：
- 第一，直接new一个promise对象
let promise = new Promise(function(resolve,reject){ //异步操作的代码 if(){ //判断是否成功 resolve(value)//成功后执行代码，值可以再promise.then(value)取出 }else{ reject(err)//捕获错误 } })
- 第二，在函数中用return 返回promise对象，可以传参
function promise(abc){
return new Promise(function(resolve,reject){ //异步操作的代码 if(){ //判断是否成功 resolve(value)//成功后执行代码，值可以再promise.then(value)取出 }else{ reject(err)//捕获错误 } }) }
- promise三种状态
function promise (abc){
return new Promise(function(resolve,reject){ if(abc){ setTimeout(() => { resolve("resolve"); //延时100ms后执行resolve }, 100); }else{ setTimeout(() => { reject("reject"); //延时100ms后执行reject }, 100); } }) } let promise1 = promise(true);//能够执行resolve的promise对象 let promise2 = promise(false);//能够执行reject的promise对象 console.log(promise1); // 初始状态promise1 console.log(promise2); // 初始状态promise2 setTimeout(() => { console.log(promise1); //延时200ms后的promise1 }, 200); setTimeout(() => { console.log(promise2); //延时200ms后的promise2 }, 200); <p data-line="67" class="sync-line" style="margin:0;"></p>
结果：
then()和catch()
then方法是promise对象的方法，可以分别指定resolved状态和rejected状态的回调函数。then方法可以接收两个回调函数作为参数。以一个参数是promise对象状态为resolved是调用的，第二个参数是promise对象状态为rejected时调用，第二个可数是可以选参数。
catch方法在作用是捕获Promise的错误，与then方法的rejected回调作用几乎一致，但是由于Promise的抛错具有冒泡性质，能够不断传递，这样就能够在下一个catch()中统一处理这些错误。同时catch()也能够捕获then()中抛出的错误，所以建议不要使用then()的rejected回调，而是统一使用catch()来处理错误
function promise(abc){
return new Promise(function(resolve,reject){ if(abc){ resolve("这是resolve方法"); }else{ throw err= new Error("reject方法执行")//自定义错误 reject(err) } }) } promise(true).then(function(data){ console.log(data); //输出 这是resolve方法 },function(err){ console.log(err); //不执行 }) promise(false).then(function(data){ console.log(data); //不执行 },function(err){ console.log(err); //输出 Error：reject方法执行 }) promise(true).then(function(data){//建议写法 console.log(data); //输出 这是resolve方法 }).catch(function(err){ console.log(err); //不执行 }) promise(false).then(function(data){//建议写法 console.log(data); //不执行 }).catch(function(err){ console.log(err); //输出 这是resolve方法 })
结果：
使用
场景回顾看原帖
我今年18岁，准备找个女朋友，有三个人选（姑娘A、B、C），我表白之后姑娘都会过一段时间给我回复；我最喜欢A姑娘，不过我不知A姑娘是不是也喜欢我，表白成功率为0.4，我次之喜欢B姑娘，表白成功率为0.5，我知道姑娘C很喜欢我，表白成率为1，那么问题来了，谁会成为我最终的女票呢？
新场景：最终姑娘A答应我的表白请求，准备登记结婚，结婚领证是需要各自的身份证号，才能领取
场景模拟：用一个数组来收集两个人的身份证号，收集到两个身份证号是将这个数组通过一个方法装换成结婚证
普通回调：
let info = []
function myId(fn){ fn(1024) } function amieId(fn){ fn(1314520) } function writeId(id,callback){ info.push(id) console.log(info) if(callback){ callback() } } // 开始调用 如果比这再多几层，就不容易看懂了 myId(function(my_Id){ console.log(`我的身份证号：${my_Id}`) writeId(my_Id, function(){ amieId(function(amie_Id){ console.log(`姑娘A的身份证号：${amie_Id}`) writeId(amie_Id,function(){ console.log(`生成了结婚证，结婚证号为：${info}`) }); }) }) })
promise方式实现：
let info = []
function myId(id){ return new Promise(function(resolve,reject){ if(id){ resolve(id); }else{ reject(Error); } }) } function amieId(id){ return new Promise(function(resolve,reject){ if(id){ resolve(id); }else{ reject(Error); } }) } function writeId(id){ return new Promise(function(resolve,reject){ if(id){ info.push(id); console.log(info); resolve(id); return; }else{ reject(Error); } }) } myId(1024).then(function(data){ console.log(`我的身份证号：${data}`); return writeId(data); }) .then(function(){ return amieId(1314520) }) .then(function(data){ console.log(`姑娘A的身份证号：${data}`); return writeId(data); }) .then(function(){ console.log(`生成了结婚证，结婚证号为：${info}`) })
两种方式结果都是这样的：
两个在机构上显然promise的这种.then().then().then()……
比会回调function（function（function（）{}）{}）{}……
便于阅读和管理；
之所以Promise对象可以实现链式用法，是因为promise.then()会返回一个新的Promise对象，让前一个Promise对象的终值在then方法中生成一个新的Promise对象，以此类推……
Promise其他方法
Promise.resolve()和Promise.reject()
用来将一个现有的对象包装成Promise对象：
Promise.resolve()包装不同的对象返回的Promise对象会不同：
let a = Promise.resolve(); let b = Promise.resolve("常量"); let c = Promise.resolve({ name:"发挥不广泛", age:18 }) let d = Promise.resolve(b); let e = Promise.resolve({ name:"发挥不广泛", age:18, then:function(resolve,reject){ console.log(this); resolve(this.age); } }); console.log(b===d); //true console.log(a); //不带参数的 console.log(b); //带一个常量参数 console.log(c); //带一个没有then方法的对象为参数 console.log(d); //带一个Promise对象为参数 console.log(e); //带一个有then方法的对象为参数 setTimeout(() => { //1000ms后看e状态 console.log(e); }, 1000);
结果：
没有参数：resolved状态的Promise对象
参数是Promise：原样返回
参数带有then方法：转换为Promise后立即执行then方法
参数不带then方法、不是对象或没有参数：返回resolved状态的
Promise.reject()会直接返回rejected状态的Promise
Promise.all()
参数为Promise对象数组，如果有不是Promise的对象，将会先通过上面的Promise.resolve()方法转换
let promise = Promise.all( [p1, p2, p3] ) promise.then( ... ).catch( ... )
当p1、p2、p3的状态都变成resolved时，promise才会变成resolved，并调用then()的已完成回调，但只要有一个变成rejected状态，promise就会立刻变成rejected状态
Promise.race()
let promise = Promise.race( [p1, p2, p3] ) promise.then( ... ).catch( ... )
“竞速”方法，参数与Promise.all()相同，不同的是，参数中的p1、p2、p3只要有一个改变状态，promise就会立刻变成相同的状态并执行对于的回调
Promise.done() 和 Promise. finally()
Promise.done方法的用法类似 then方法，可以提供resolved和rejected方法，也可以不提供任何参数，它的主要作用是在回调链的尾端捕捉前面没有被 catch方法 捕捉到的错误
Promise. finally() 接受一个方法作为参数，这个方法不管promise最终的状态是怎样，都一定会被执行，不用他相当于在resolve方法和reject方法中都写一遍
<完>
20180810
发挥不广泛