ES6-Promise

一、简介
Promise是ES6引入的一种异步编程解决方案，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上说，Promise是一个构造函数，从它可以获取异步操作的消息。
使用promise的优点：支持链式调用，可以解决回调地狱问题。ES6之前，通常使用回调函数来实现异步操作，这种方法带来了阅读不便，错误处理困难等问题。

promise两个特点：
1、对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：

pending-进行中
fulfilled-已成功
rejected-已失败

只有异步操作的结果可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。
2、一旦状态改变，就不会再变，任何时候都可以得到这个结果。
只有两种状态改变，

pending-->fulfilled
pending-->rejected

只要这两种情况发生，状态就凝固了，不会再变，会一直保存这个结果，这时就称为resolved（已定型）。若改变已经发生了，再对Promise对象添加回调函数，也会立即得到结果。这与事件Event不同，事件的特点是，如果错过了，再去监听，是得不到结果的。

二、基本用法
Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。它们是两个函数，有js引擎提供，不用自己部署。
resolve函数在异步操作成功时调用，将异步操作的结果作为参数传递出去。同时将Promise的状态从pending变成fulfilled。
reject函数在异步操作失败时调用，将异步操作失败报出的错误作为参数传递出去。同时将Promise状态从pending变成rejected。

const promise = new Promise((resolve,reject)=>{
    if (/*异步操作成功*/) {
        resolve(value)
    } else {
        reject(error)
    }
})

promise实例生成以后，可以用then方法,then()的两个参数分别指定resolved和rejected状态的回调函数。两个参数都是可选的，它们都接受Promise对象传出的值作为参数。

promise.then((value)=>{
    /*success*/
},(error)=>{
    /*failure*/
})

实例：

const timeout = (ms)=>{
    return new Promise((resolve,reject)=>{
        setTimeout(resolve, ms, 'done')/*setTimeout()第三个参数为传给执行函数的其他参数，因此在ms秒后，将'done'作为参数传入resolve函数并执行*/
    })
}

timeout(1000).then((value)=>{//timeout函数返回一个Promise实例，表示一段时间后才会发生的结果。过了指定时间ms后，promise实例的状态从pending变成resolved，就会触发then方法绑定的回调函数
    console.log(value)  //'done'
})

promise的执行顺序：
promise新建后就会立即执行，then()指定的回调函数，将在当前脚本所有同步任务完成才会执行。

let promise = new Promise((resolve,reject)=>{
    console.log('promise');
    resolve()
})

promise.then(()=>{
    console.log('resolved')
})
console.log('Hi')  
//'promise'
//'Hi'
//'resolved'

用Promise封装一个异步交互

function myAsyncFun(url){
    return new Promise((resolve,reject)=>{
      let xhr = new XMLHttpRequest();
      xhr.open('GET',url);
      xhr.send();
      //处理结果
      xhr.onreadystatechange = function(){
        if(xhr.readyState === 4){
          if(xhr.status >= 200 && xhr.status <300){
            resolve(xhr.response)
          }else{
            reject(xhr.status)
          }
        }
      }
    })
}

---

三、util.promisify()方法读取文件
promisify()是nodeJs中内置的一个方法，传入一个错误优先的回调函数，并返回一个promise版本的函数

//引入util 
const util = require('util');
const fs = require('fs');
//将fs.readFile()转变成promise版本的新函数
let mineReadFile = util.promisify(fs.readFile);

mineReadFile('./xxx/xxx.txt').then(value=>{
  console.log(value.toString())
})

---

四、Promise实例对象的内置属性
1、PromiseState:
Promise实例中会有一个内置属性PromiseState，只有三个值：
pending：未决定的
resolve/fullfilled 成功
rejected 失败

2、PromiseResult:
保存着异步任务成功/失败的结果，只能通过resolve()和reject()修改（主动throw一个错误也可以将结果变为rejected）。一旦结果设置成功则不能修改
resolve()方法被调用，PromiseResult变为成功
reject()方法被调用，PromiseResult变为失败

---

五、promiseAPI
1、执行器函数：
我们将promise构造器函数中传递的函数参数称为执行器。执行器函数是同步调用的，不会进入到异步函数栈。异步操作在执行栈中执行。
2、Promise.prototype.then()方法：

• 参数为promise成功和失败的回调函数；
• 返回值依然是一个promise对象，该promise的结果由指定的回调函数的返回值决定。

• 中断promise链
  有且只有一个方式，返回一个pending状态的promise

3、Promise.prototype.catch()方法：
参数是promise失败后的回调函数；
一般我们利用promise的异常穿透，then链式调用时，在最后指定失败的回调。中间任何操作出了异常，都会传到最后失败的问题回调中处理

4、Promise.resolve():
只属于Promise的对象，不属于实例。作用为快速返回一个成功/失败的promise对象。
传入的参数，可将其封装成一个promise对象返回

let p1 = Promise.resolve(123);
console.log(p1) 

let p2 = Promise.resolve(new Promise((resolve,reject)=>{
  resolve('OK')
}))
console.log(p2)

若传入参数为非Promise对象，则返回的结果为成功promise对象；
若传入参数为Promise对象，则参数的结果决定了resolve的结果

5、Promise.reject()
跟Promise.resolve()一样，只属于Promise的方法，不属于实例，作用是返回一个失败的promise对象，无论传入什么，都是失败的。

6、Promise.all()
参数是一个包含多个promise的数组；
返回一个新的promise,只有所有的promise都成功才成功。

let p1 = new Promise((resolve,reject)=>{
  resolve('OK')
});
//let p2 = Promise.resolve('Hello');
let p2 = Promise.reject('Hello');
let p3 = Promise.resolve(123);

let result = Promise.all([p1,p2,p3]);
console.log(result)

都成功，则返回结果成功的数组

若失败，则结果为失败

7、Promise.race()
参数是一个包含多个promise的数组，
返回一个新的promise，第一个完成的promise的结果状态就是最终的结果状态。

let p1 = new Promise((resolve,reject)=>{
  resolve('OK')
});
let p2 = Promise.resolve('Hello');
let p3 = Promise.resolve(123);

let result = Promise.race([p1,p2,p3]);
console.log(result)

let p1 = new Promise((resolve,reject)=>{
  setTimeout(()=>{
    resolve('OK')
  },0)  
});
let p2 = Promise.resolve('Hello');
let p3 = Promise.resolve(123);

let result = Promise.race([p1,p2,p3]);
console.log(result)

---

六、Promise.all()处理并发请求
当一个页面需要有多个异步请求同时处理时，可以使用Promise.all()方法，将多个Promise包装成一个新的Promise实例.
该方法接受一个数组作为参数，数组元素为单个promise实例。then()方法的参数为封装着多个promise结果的数组。

Promise.all([
    new Promise((resolve,reject)=>{
        setTimeout(resolve, 1000, '这是第一个promise的结果')
    }),
    new Promise((resolve,reject)=>{
        setTimeout(resolve,1000,'这是第二个promise的结果')
    })
]).then(res=>{
    console.log(res[0])
    console.log(res[1])
    })

如何让Promise.all即便有函数报错也不会中断其他函数执行：在all里面的异步函数数组，先进行map处理，单独catch错误，这样就不会触发Promise.all的错误处理了。