总结Promise特性以及一些关于Promise的api

总结Promise特性以及一些关于Promise的api

1.Promise是什么？

• 从语法：Promise是一个构造函数

• 从功能：Promise对象用来封装一个异步操作并可以获取其成功和失败的结构值

• Promise是js中异步编程的新的解决方案

2.Promise状态

[PromiseState]

• pending 未决定的

• resolved / fullfilled 成功

• rejected 失败

  promise对象只能改变一次

3.Promise的值

[PromiseResult]

保存异步任务【成功/失败】结果

4.Promise构造函数

Promise(excutor){}

excuter函数 ：执行器(resolve,reject) => {} 内部的执行是同步调用的

resolved函数：成功时候调用的函数 value => {}

reject函数：失败时调用的函数 resson => {}

5.Promise.prototype.then()

语法：Promise.prototype.then(onResolved, onRejected)

说明：onResolved是成功后的回调函数，onRejected是失败后的回调函数

6.Promise.prototype.catch()

语法：Promise.prototype.catch(onRejected)

说明：onRejected是失败后的回调函数

7.Promise.resolve()

语法：Prmoise.resolve(params)

params可以是一个Promise对象，也可以是非Promise对象

说明：返回一个成功的promise对象，传入非promise对象，则返回结果为成功的promise对象，参数为promise对象，则这个传入的promise决定了reslove结果

传入参数是非Promise对象：

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

传入参数是Promise对象：

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

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

Promise.reject()

语法：Prmoise.reject(params)

params可以是一个Promise对象，也可以是非Promise对象

说明：无论传什么类型，返回结果都是失败的Promise

传入普通变量：

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

传入一个成功的Promise

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

Promise.all()

语法：Promise.all([new Promise(),new Promise(), …])

说明：返回一个新promise对象，接收一个promise数组，只有当数组中的所有promise都是成功状态，这个返回的新Promise才是成功状态

        let p1 = Promise.resolve(1)
        let p2 = Promise.resolve(2)
        let p3 = Promise.resolve(3)
        let p4 = Promise.resolve(4)
        let promises = [p1, p2, p3, p4]
        let p = Promise.all(promises)
        console.log(p);

        let p1 = Promise.resolve(1)
        let p2 = Promise.resolve(2)
        let p3 = Promise.resolve(3)
        let p4 = Promise.reject(4)
        let promises = [p1, p2, p3, p4]
        let p = Promise.all(promises)
        console.log(p);

Promise.race()

语法：Promise.race([new Promise(),new Promise(), …])

说明：返回一个Promise对象，返回新的Promise的结果取决于 Promise数组 的第一个完成Promise结果状态

        let p1 = new Promise((resolve, reject) => {
            //setTimeout(() => {
            resolve(123)
            //}, 100)
        })
        let p2 = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve(456)
            }, 100)
        })
        let p = Promise.race([p1, p2])
        console.log(p);

        let p1 = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve(123)
            }, 100)
        })
        let p2 = new Promise((resolve, reject) => {
            //setTimeout(() => {
            resolve(456)
            //}, 100)
        })
        let p = Promise.race([p1, p2])
        console.log(p);

如何修改Promise对象状态

• resolve() --> pending => fulfilled
• reject() --> pending => rejected
• throw --> pending => rejected

一个Promise指定多个回调函数，都会调用吗？

当Promise改变为对应状态时，都会执行。

        let p1 = new Promise((resolve, reject) => {
            resolve(123)
        })
        p1.then(val => {       //都会执行
            console.log(val);
        })
        p1.then(val => {
            alert(val);
        })

改变Promise状态和指定回调函数谁先谁后？

都有可能，取决于Promise内部的异步任务。

• 如果时异步任务，then()方法先执行，promise状态改变后执行

          let p1 = new Promise((resolve, reject) => {
              setTimeout(() => {
                  resolve(123)
              }, 1000)
          })
          console.log(p1);
          p1.then((val) => {
              console.log("hhh");
          })
  		console.log(p1)
  

  

• 如果时同步任务，改变promise对象后才会执行回调

          let p1 = new Promise((resolve, reject) => {
              resolve(123)
          })
          console.log(p1);
          p1.then((val) => {
              console.log("hhh");
          })
          console.log(p1);
  

  

then()返回结果的特点

返回是一个Promise对象

返回结果由指定的回调函数结果去确定的

• 返回结果为非promise对象时。最后就是一个成功的promise
• 抛出异常时，返回结果就是一个失败的Promise
• return一个成功的promise时，最后结果就取决于返回的promise
• return一个失败的promise时，最后结果就取决于返回的promise

let p1 = new Promise((resolve, reject) => {
            resolve('ok')
        })
        let result = p1.then((val) => {
            //1.返回一个非promise
            return 123
            //2.抛出异常
            throw 'error'
            //3.返回一个成功的promise
            return new Promise((resolve, reject) => {
                resolve('success')
            })
            //4.返回一个失败的promise
            return new Promise((resolve, reject) => {
                reject('faild')
            })
        })
        console.log(result);
        //1.[[PromiseState]]:"fulfilled" , [[PromiseResult]]:123
        //2.[[PromiseState]]:"rejected" , [[PromiseResult]]:"error"
        //3.[[PromiseState]]:"fulfilled" , [[PromiseResult]]:"success"
        //4.[[PromiseState]]:"fulfilled" , [[PromiseResult]]:"faild"

串联多个任务

        let p1 = new Promise((resolve, reject) => {
            resolve('ok')
        })
        p1.then(() => {
            return new Promise((resolve, reject) => {
                resolve('success')
            })
        }).then((val) => {
            console.log(val);  //success
        }).then((val) => {
            console.log(val);  //undefined
        })