Promise

JavaScript 中存在很多异步操作,Promise 将异步操作队列化，按照期望的顺序执行，返回符合预期的结果。可以通过链式调用多个 Promise 达到我们的目的。
1.异步状态
Promise包含*pending、fulfilled、rejected三种状态。
pending 指初始等待状态，初始化 promise 时的状态
resolve 指已经解决，将 promise 状态设置为fulfilled***
reject 指拒绝处理，将 promise 状态设置为rejected
promise 是生产者，通过 resolve 与 reject 函数告之结果
promise 非常适合需要一定执行时间的异步任务
状态一旦改变将不可更改
1.1动态改变
第一种情况：p1的状态是rejected
，p2返回了p1,所以p2的状态已经变得没有意义。那么后面的then是对p1状态的处。

  const p1 = new Promise((resolve, reject) => {
      // resolve("fulfilled");
      reject("rejected");
    });//
    const p2 = new Promise((resolve,reject)=>{
      resolve(p1);
    }).then(
      value =>{
        console.log(value);
      },
      reason=>{
        console.log(reason);//rejected
      }
    )const p1 = new Promise((resolve,reject)=>{
     reject("rejected");
})

第二种情况 :p1(promise) 的resolve 参数是一个 p2(promise),p1的状态将被改变为p2的状态

 const p1 = new Promise((resolve,reject)=>{
    resolve(
      new Promise((s,e)=>{
        s("成功");
      })
    );
  }).then(msg=>{
    console.log(msg);//成功
  });

第三种情况：P1（promise）做为参数传递时，需要等到p1执行完才可以继承，下面的p2需要等到p1执行完成。

const p1 = new Promise((resolve, reject) => {
setTimeout(() => {
  resolve("操作成功");
}, 2000);
});
const p2 = new Promise((resolve, reject) => {
resolve(p1);
}).then(
**加粗样式**msg => {
  console.log(msg);//操作成功
},
error => {
  console.log(error);
}
);

2. then
一个promise 提供一个then方法访问promise的结果，then 用于定于当promise 状态发生改变是的处理 。

2.1 语法说明

promise.then(onFulfilled, onRejected)

onFulfilled 函数处理 fulfilled 状态， onRejected函数处理 rejected 状态

1.onFulfilled 或 onRejected 不是函数将被忽略
2.两个函数只会被调用一次
3.onFulfilled 在 promise 执行成功时调用,如果只关心成功则不需要传递 then 的第二个参数
4.onRejected 在 promise 执行拒绝时调用,如果只关心失败时状态，then 的第一个参数传递 null
5.promise 传向then的传递值，如果then没有可处理函数，会一直向后传递

let p1 = new Promise((resolve, reject) => {
	reject("rejected");
})
.then()
.then(
  null,
  f => console.log(f)//rejected
);

2.2 链式调用
每次的then 都是一个全新的状态，默认的then返回的promise状态是fulfilled;

new Promise((resolve, reject) => {
  reject();
})
.then(
  resolve => console.log("fulfilled"),
  reject => console.log("rejected")//  rejected
)
.then(
  resolve => console.log("fulfilled"),//  fulfilled
  reject => console.log("rejected")
)
.then(
  resolve => console.log("fulfilled"),//  fulfilled
  reject => console.log("rejected")
);
  

如果then返回promise时，后面的then就是对返回的promise的处理，需要等待promise变更状态后执行

  let promise = new Promise(resolve => resolve());
let p1 = promise.then(() => {
  return new Promise(resolve => {
    setTimeout(() => {
      console.log(`p1`);
      resolve();
    }, 2000);
  });
}).then(() => {
  return new Promise((a, b) => {
    console.log(`p2`);
  });
});
  

3.catch
catch用于失败状态的处理函数，等同于 then(null,reject){}
catch 可以捕获之前所有 promise 的错误，所以建议将 catch 放在最后。
下例中 catch 也可以捕获到了第一个 then 返回 的 promise 的错误。

new Promise((resolve, reject) => {
  resolve();
})
.then(() => {
  return new Promise((resolve, reject) => {
    reject(".then ");
  });
})
.then(() => {})
.catch(msg => {
  console.log(msg);//.then
});

catch 也可以捕获对 then 抛出的错误处理

new Promise((resolve, reject) => {
  resolve();
})
.then(msg => {
  throw new Error("这是then 抛出的错误");
})
.catch(() => {
  console.log("33");
});

4.finally
无论状态是resolve 或 reject 都会执行此动作，finally 与状态无关。