promise(2)promise的api

创建promise对象

/**
         * 1. 创建promise对象，并传入【执行器函数】 new Promise(exector){}
         * 1.1:执行器函数：exector函数---》 同步执行 (resolve,reject) => {}
         * 1.2: resolve函数：内部定义成功时调用的函数 value => {}
         * 1.3：reject函数 ： 内部定义失败时调用的函数 reason => {}
         *
         * 注意：exector会在Promise内部立即同步回调，异步操作在执行器中执行
         */
         const p1 = new Promise((resolve,reject) => {
			//异步操作的执行
			resolve('成功的数据');
			reject('失败的数据');
		});

Promise.prototype.then() 和Promise.prototype.catch()

 /**
         * 2.Promise.prototype.then()----->: p.then(onResovled,onRejected);
         * 2.1: onResolved函数：成功的回调函数，用于接收得到成功value的数据 (value) => {}
         * 2.2: onRejected函数：失败的回调函数，用于接收得到失败reason的数据 (reason) => {}
         *
         * 注意：onResolved函数和onRejected函数都会返回一个promise对象
         */
           /**
         * 3.Promise.prototype.catch()---->p.catch(onRejected);
         * 3.1: onRejected函数：失败的回调函数，用于接收得到失败reason的数据 (reason) => {}
         *
         * 注意：catch方法时then()的语法糖：相当于： p.then(undefined,onRejected);
         */
         new Promise((resolve,reject) => {
            //执行异步任务
            setTimeout(()=>{
                //异步任务执行成功
                resolve('成功的数据');
                //异步任务执行失败
               reject('失败的数据');
            },1000)
        })
            // .then(
            //     //获取成功的回调的结果 onRejected
            //     (value) => {
            //         console.log(value);
            //     },
            //     //获取失败回调的结果 onRejected
            //     (reason) => {
            //         console.log(reason);
            //     }
            // )
            .then(
                value => {
                    console.log(value);
                }
            )
            .catch(
                reason => {
                    console.log(reason);
                }
            )

Promise.resolve()和Promise.reject()

 /**
         * 4.Promise.resolve() ----> Promise.resolve((value) => {})
         * value:成功的数据或promise对象
         *
         * 注意：返回一个成功的promise对象
         */
           /**
         * 5.Promise.reject() ----> Promise.reject((reason) => {})
         * reason:  失败的原因
         *
         * 注意：返回一个失败的promise对象
         */
         
        //产生一个成功值为1的promise对象
        const p1 = new Promise((resolve,reject) => {
                resolve(1);
            });
        //产生一个成功值为2的promise对象
        const p2 = Promise.resolve(2);
        //产生一个失败值为3的promise对象
        const p3 = Promise.reject(3);
        //获取数据
        p1.then(value => {console.log(value);})
        p2.then(value => {console.log(value);})
        p3.then(null,reason => {console.log(reason);})
        p3.catch(reason => {console.log(reason);})

Promise.all()

/**
         * 6.Promise.all() ---> Promise.all(promises => {})
         * promises : 包含n个promise的数组
         *
         * 返回：返回一个新的promise,只有所有的promise都成功才成功(成功的value数组)，只要有一个失败了就直接失败（失败的reason）
         */
        const promiseAll = Promise.all([p1,p2,p3]);
        promiseAll.catch(reason => {console.log(reason);}) //3
        const promiseAll1 = Promise.all([p1,p2]);
        promiseAll1.then(values => {console.log(values);}); //[1,2]

Promise.trace()

 /**
         * 7.Promise.race()----> Promise.race(promises => {})
         * promises : 包含n个promise的数组
         *
         * 说明:返回一个新的promise，第一个首先完成的promise的结果状态就是最终的结果状态
         */
        const promiseRace = Promise.race([p1,p2,p3]);
        promiseRace.then(value => {console.log(value);}) //1