【Promise】第二部分 Promise 深入了解

文章目录

【Promise】第二部分 Promise 深入了解
2. Promise 深入了解
总结

2. Promise 深入了解

2.1 Promise 对象状态属性 & Promise 对象结果值属性介绍

1.在实例对象中一个属性 promiseState

pending 未决定
resolved / fulfilled 成功
rejected 失败

promise对象状态只能改变一次

要么 pending –> resolved
要么 pending –> rejected

2.在实例对象中另一个属性 promiseResult

作用: 保存对象成功 / 失败的结果
无论是成功还是失败，都会有一个结果数据 .
成功结果的数据一般称为 value ，失败结果的数据一般称为 reason .

const fs = require('fs')

const p = new Promise((resolve, reject) => {
    fs.readFile('D:\\vs code\\Promise\\book.txt', (err, data) => {
        if (err) {
            reject(err)  // 改变为失败状态
        }
        resolve(data)  // 改变为成功状态
    })

})
/*
	value 成功结果的数据
	reason 失败结果的数据
*/
p.then((value) => {
    console.log(value.toString());
}, (reason) => {
    console.log(reason);
})

2.2 Promise 工作流程

对上述流程图进行讲解：

一开始状态为pending , 然后执行异步操作，如果成功了，执行resolve( )函数将状态设置为resolved，then( )执行成功的回调,then() 返回一个新的Promise对象，反之同理.

2.3 相关API

2.3.1 Promise 构造函数: Promise (excutor) {}

(1) executor 函数: 执行器 (resolve, reject) => {}

(2) resolve 函数: 内部定义成功时我们调用的函数 value => {}

(3) reject 函数: 内部定义失败时我们调用的函数 reason => {}

说明: executor 会在 Promise 内部立即同步调用,异步操作在执行器中执行

const p = new Promise((resolve,reject)=>{
  // 执行器函数在内部是同步调用的
	console.log('111')
})
console.log('222')

输出的顺序是 
111 
222

2.3.2 Promise.prototype.then 方法

(1) onResolved 函数: 成功的回调函数 (value) => {}

(2) onRejected 函数: 失败的回调函数(reason) => {}

(3) then()方法回调是异步执行的

let p = new Promise((resolve,reject)=>{
})

p.then((value)=>{},(reason)=>{})

2.3.3 Promise.prototype.catch 方法

(1) onRejected 函数: 该方法只能在失败的情况下使用，失败的回调函数 (reason) => {}

let p = new Promise((resolve,reject)=>{
	reject('error')
})

p.catch((reason)=>{
	console.log('reason')
})

2.3.4 Promise.resolve方法

 /* 
            1. 如果传入的参数为非Promise类型的对象,如number,String...,
               则返回的结果都为成功的Promise对象,值为:传入的参数
       
            2. 如果传入的参数为Promise类型的对象,则参数的状态和结果决定了resolve的状态和结果
            
            3. 综述：可以返回一个成功/失败的 promise 对象
        */
        let p1 = Promise.resolve(6666)
        console.log(p1)  // 值:6666   状态:fulfilled

        let p2 = Promise.resolve(new Promise((resolve,reject)=>{
            resolve('成功!')
        }))
        console.log(p2);  // 值:成功!  状态:fulfilled

        let p3 = Promise.resolve(new Promise((resolve,reject)=>{
            reject('error!') //值:error!  状态:rejected
        }))
        console.log(p3)

        p3.catch((reason=>{
            console.log(reason)
        }))

2.3.5 Promise.reject方法

				/* 
            返回的永远是一个失败的promise对象
            不管是非promise对象还是promise对象
            值为：传入的值
        */
        let p1 = Promise.reject(666)
        let p2 = Promise.reject('love')
        let p3 = Promise.reject(new Promise((resolve,reject)=>{
            resolve('成功')
        }))

2.3.6 Promise.all()方法

 			/* 
            Promise.all([x,y,...])
            返回一个新的promise, 只有所有的 promise对象 
            都成功才成功, 只要有一个失败了就直接失败
            1. 如果都成功，返回的状态为fulfilled,值为传入的值
            2. 如果由一个失败或者多个失败，则返回的状态都为rejected，
                值为最近失败的值
        */
 let p1 = Promise.resolve('love')
        let p2 = Promise.resolve(1223)
        let p3 = new Promise((resolve,reject)=>{
            resolve('成功')
        })
        
        let p4 = Promise.all([p1,p2,p3])
        console.log(p4);

        let p1 = Promise.resolve('love')
        let p2 = Promise.resolve(1223)
        let p3 = new Promise((resolve,reject)=>{
            reject('失败')
        })
        
        let p4 = Promise.all([p1,p2,p3])
        console.log(p4);

2.3.7 Promise.race()

 				/* 
            Promise.race([x,y,...])
            返回一个新的 promise对象, 第一个完成的 promise 的结果状态就是最终的结果状态
        */
       let p = new Promise((resolve,reject)=>{
           setTimeout(() => {
                resolve('我是第一个')
           }, 1000);
       })

        let p2 = Promise.resolve('我是第二个')
        let p3 = Promise.resolve('我是第三个')
        
        let p4 = Promise.race([p,p2,p3])
        console.log(p4);