promise的实例方法、静态方法

promise概述

介绍

promise是ES6的重要特性之一

传统的异步编程的解决方案是使用回调函数，但是这样就会导致嵌套过深，产生回调地狱，那么promise异步编程的另一种解决方案，而且会更加的强大。

三种状态

pending（待定）初始状态，既没有被兑现，也没有被拒绝
fulfilled（已兑现）意味着操作成功完成
rejected（已拒绝）意味着操作失败。

特点

待定状态的 Promise 对象要么会通过一个值被兑现（fulfilled），要么会通过一个原因（错误）*被拒绝（rejected）*当这些情况之一发生时，我们用 promise 的 then 方法排列起来的相关处理程序就会被调用
Promise.prototype.then 和 Promise.prototype.catch 方法返回的是 promise，所以它们可以被链式调用

promise的三个实例方法

then（）方法

then是实例状态发生改变时的回调函数，第一个参数是resolved状态的回调函数，第二个参数是rejected状态的回调函数
then方法返回的是一个新的Promise实例，也就是promise能链式书写的原因

promise.then(result => {
    
    ···})

catch方法

当出现异常则需要catch方法进行捕获

promise.then(result => {
    
    ···}).catch(error => {
    
    ···})

finally()方法

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

promise.then(result => {
    
    ···}).catch(error => {
    
    ···}).finally(() => {
    
    ···});

promise的静态方法

resolve方法

方法返回一个以给定值解析后的Promise 对象
定值有以下几种情况：

如果这个值是一个 promise ，那么将返回这个 promise
参数不是具有then()方法的对象，或根本就不是对象，Promise.resolve()会返回一个新的 Promise 对象，状态为resolved
没有参数时，直接返回一个resolved状态的 Promise 对象

reject()方法

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

const p = Promise.reject('出错了')

等同于
const p = new Promise((resolve, reject) => reject('出错了'))
p.then(null, function (s) {
    
    console.log(s)})
//出错了Promise.reject()方法的参数，会原封不动地变成后续方法的参数

any()方法

接收一个Promise可迭代对象，只要其中的一个 promise 成功，就返回那个已经成功的 promise 。如果可迭代对象中没有一个 promise 成功（即所有的 promises 都失败/拒绝），就返回一个失败的 promise 和AggregateError类型的实例，它是 Error 的一个子类，用于把单一的错误集合在一起。本质上，这个方法和Promise.all()是相反的。

const pErr = new Promise((resolve, reject) => {
    
    
  reject("总是失败");
});

const pSlow = new Promise((resolve, reject) => {
    
    
  setTimeout(resolve, 500, "最终完成");
});

const pFast = new Promise((resolve, reject) => {
    
    
  setTimeout(resolve, 100, "很快完成");
});

Promise.any([pErr, pSlow, pFast]).then((value) => {
    
    
  console.log(value);
  // pFast fulfils first
})

All()方法

方法接收一个promise的iterable类型（注：Array，Map，Set都属于ES6的iterable类型）的输入，并且只返回一个Promise实例
```
const p = Promise.all([p1, p2, p3]);
```
实例p的状态由p1,p2,p3决定，分两种情况：
1. 只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数
2. 只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数

allSettled方法

Promise.all 会在任何一个请求失败的时候进入失败状态

由于单一 Promise 进入 rejected 状态便会立即让 Promise.all() 的结果进入 rejected 状态，以至于通过 Promise.all() 进入 rejected 状态时，其中的源 Promise 仍然可能处于 pending 状态，以至于无法获得所有 Promise 完成的时机。

Promise.allSettled() 静态方法会等待所有源 Promise 进入 fulfilled 或者 rejected 状态，从而确保不会造成时序上的冲突。

race方法

该方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例

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

只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变

率先改变的 Promise 实例的返回值则传递给p的回调函数

语法糖Async/Await

在ES8中新增了Promise的语法糖async await来更优雅的处理异步。

async 可以单独存在, 用该关键字声明的函数返回的是一个 Promise 对象。

async funtion add(){
    
    
    return 1
}
add()
add() instanceof Promise // true

await 不可以单独存在，必须要配合 async 一起存在使用

function sub() {
    
    
    await 1
}
// 这个方法定义就不满足语法的，会如下报错
// Uncaught SyntaxError: await is only valid in async function

async await 让异步处理更优雅

let fs = require('fs')

var  gen = async function() {
    
    

    const f1= await readFile('files/a.txt');//封装一个promise对象
    console.log(f1)
    const f2=  await readFile('files/b.txt');
    console.log(f2)
    const f3=  await readFile('files/c.txt');
    console.log(f3)
  
  };


  var readFile=function(path){
    
    
     return  new Promise((resolve,reject)=>{
    
    
        fs.readFile(path,'utf-8',function(err,data){
    
    
            if(!err){
    
    
          
             resolve(data)
            }else{
    
    
              reject(err)
            }
            
         });
      })
   
}


  
var obj = gen();