Promise的认识和使用

Promise概念，then、catch方法

概念和理解：
- 一个异步操作返回的对象，用来传递异步操作的消息
- 是ES6解决异步回调问题的一种解决方案
由于js是单线程，很多异步操作都是依靠回调方法实现的，这种做法在逻辑比较复杂的回调嵌套中会相当复杂，也叫做回调地狱；
- Promise对象可以理解为一次执行的异步操作，使用Promise对象之后，使用一种链式调用的方式来组织代码，让程序更具备可读性，可维护性
=>可以将异步操作以同步的操作的流程表达出来，避免了层层嵌套的回调函数
- promise和回调函数一样，都是要解决数据的传递和消息发送问题，promise中的then一般对应成功后的数据处理，catch一般对应失败后的数据处理。
语法：

promise是一个构造函数，使用时一般都需要new 一个实例对象。

接受一个函数作为参数，函数中也有两个参数（resolve，reject），resolve将异步操作成功状态下的结果返回。reject将异步操作失败状态写的结果返回。

let p = new Promise(function(resolve,reject)=>{
           if(ture){
               resolve('成功')
           }else{
               reject('失败')
           }
       });//p就是实例化的promise对象

then方法：接受两个回调函数作为参数，第一个回调函数是promise状态为resolve状态下调用，第二个时reject状态下调用。

p.then(res=>{//第一个回调函数res是个参数,接收resolve括号里返回的结果
    console.log(res)
},err=>{//第二个回调函数，res是个参数,接收resolve括号里返回的结果
    console.log(err)
})

catch方法：promise失败状态调用。同时也可以捕获到一些编写错误的代码，让错误以字符串的形式体现，不报错影响后续代码执行。

1
2
3

p.catch(err=>{
    console.log(err)
})

Promise特点

对象的状态不受外界影响
- 三个状态：进行中pending，已成功fulfilled，已失败rejected
  
  pending表示程序正在执行但未得到结果，即异步操作没有执行完毕，fulfilled表示程序执行完毕，且执行成功，rejected表示执行完毕但失败；
  
  这里的成功和失败都是逻辑意义上的；并非是要报错
- 只有异步操作的结果可以决定当前是哪一种状态，任何其他操作都无法改变这个状态
- 一旦创建就会立即执行，处于进行中，内部直接执行的为同步，
- resolve，reject—进行中转为了成功或失败，再使用then方法调用的是属于异步。
- 没有调用resolve，reject时处理进行中状态，进行中下没有状态返回。
一旦状态改变，就不会再变，任何时候都可以得到这个结果
- Promise状态改变只有两种可能: pending =>fulfilled pending=>rejected
- 一旦这两种情况发生，状态就凝固了，会一直保持这个结果，如果改变已经发生，再对Promise对象添加回调函数，也会立即得到这个结果

let p1 = new Promise((resolve,reject)=>{});
let p2 = new Promise((resolve,reject)=>{
    resolve(p1)
})
p2.then(res=>{
    console.log(res)//此时没有结果，因为p1没有resolve或者reject调用此时是进行中的状态，没有返回值，所有p2返会p1时也没有东西。
})

Promise里面同步和异步的判定

里面是一个同步任务(状态为pending)
调用resolve/reject方法，状态就会发生改变

console.log(1)
let p = new Promise((resolve, reject) => {
    console.log("promise") //同步任务  => 进行中
    resolve("成功")
})
p.then(res => {
    console.log(123)
    console.log(res) // 异步任务 （微任务）
})

console.log(2)
//输出顺序  1   promise  2  123  成功

promise的链式操作

必须在前一个then有return返回值，如果return是一个Promise对象，then 就接收的是promise对象中成功状态下的值。

function fn(n) {
     return new Promise((resolve, reject) => {  
         setTimeout(() => {
             resolve(n)
         }, 1000)
     })
 }

 fn(5).then(res => {
     console.log(res)
     return fn(++res)
 }).then(res => {
     console.log(res)
     return fn(++res)
 }).then(res => {
     console.log(res)
 })

Promise.all()和Promise.race()

Promise.all() 处理并发，所有值就一起返回
Promise.race() 返回请求完成最快的—–(一般用于设置请求超时提示）

// 一个请求如果超过500ms，返回请求超时提示信息
        let p1 = new Promise(resolve => {
            setTimeout(() => {
                resolve("我是正确的请求")
            }, 300)
        })
        let p2 = new Promise(resolve => {
            setTimeout(() => {
                resolve("请求超时")
            }, 500)
        })
        Promise.race([p1, p2]).then(res => {
            console.log(res)
        })

错误信息的处理
- 直接在promise.all().catch(),只能返回错误信息，其他正确的信息无法返回。
- 谁报错谁自己处理，其他信息可以正确返回。

let p1 = new Promise(resolve => {
            setTimeout(() => {
                resolve("p1")
            }, 500)
        })
        let p2 = new Promise(resolve => {
            setTimeout(() => {
                resolve("p2")
            }, 3500)
        })
        let p3 = new Promise((resolve, reject) => {
            setTimeout(() => {
                reject("p3")
            }, 1000)
        }).catch(err => {
            console.log(err)
        })

        // 要求所有的值是一起返回的
        Promise.all([p1, p2, p3]).then(res => {
                console.log(res)
            })
            .catch(err => {
                console.log(err)