2021/11/30 Promise

Promise：

//创建一个Promise实例
// let p=new Promise((resolve,reject)=>{
//     //一顿异步操作后
//     //判断成功或失败后执行resolve或reject
//     if(false){
//         // console.log("异步成功！");
//         resolve("异步成功")
//     }else{
//         // console.log("异步失败!");
//         reject("异步失败!")
//     }
// });

// p.then((value)=>{  //then可执行resolve回调函数
//     console.log(value);
// }).catch((reason)=>{  //catch可执行reject回调函数
//     console.log(reason);
// })

//把多层嵌套的回调函数给分离出来，通过 then 和 catch 来实现；

// p.then((value)=>{
//     console.log(value);
// },(reject)=>{
//     console.log(reject);
// })
//catch()方法还可以作为 then 第二参数进行存在，方便多层回调


//-----------测试

let p1=new Promise((resolve,reject)=>{
    //一顿异步操作后
    //模拟异步1
    setTimeout(()=>{
        // console.log("异步1");
        resolve("1.异步");
    },3500);
});

let p2=new Promise((resolve,reject)=>{
    //一顿异步操作后
    //模拟异步2
    setTimeout(()=>{
        // console.log("异步2");
        resolve("2.异步");
    },800);
});

let p3=new Promise((resolve,reject)=>{
    //一顿异步操作后
    //模拟异步3
    setTimeout(()=>{
        // console.log("异步3");
        resolve("3.异步");
    },1500);
});

//执行回调
p1.then((value)=>{
    console.log(value);
    return p2;
}).then((value)=>{
    console.log(value);
    return p3;
}).then((value)=>{
    console.log(value);
})

// //模拟异步1
// setTimeout(()=>{
//     console.log("异步1");
// },3500);

// //模拟异步2
// setTimeout(()=>{
//     console.log("异步2");
// },500);


// //模拟异步1
// setTimeout(()=>{
//     console.log("异步3");
// },1500);

状态特点：

let p1=new Promise((resolve,reject)=>{
    //一顿异步操作后
    //模拟异步1
    setTimeout(()=>{
        // console.log("异步1");
        resolve("1.异步");
    },3500);
});

let p2=new Promise((resolve,reject)=>{
    //一顿异步操作后
    //模拟异步2
    setTimeout(()=>{
        // console.log("异步2");
        resolve("2.异步");
    },800);
});

let p3=new Promise((resolve,reject)=>{
    //一顿异步操作后
    //模拟异步3
    setTimeout(()=>{
        // console.log("异步3");
        resolve("3.异步");
    },1500);
});

// console.log(p1);//Promise { <pending> }

//执行回调
// p1.then((value)=>{
//     console.log(value);
//     console.log(p1);//已完成
//     return p2;
// }).then((value)=>{
//     console.log(value);
//     return p3;
// }).then((value)=>{
//     console.log(value);
// })

////p1,p2,p3 是三个 Promise 实例，数组元素顺序即输出顺序
let p=Promise.all([p1,p2,p3]);
//将三个 Promise 实例的回调组合成数组输出
p.then(value=>{
    console.log(value);//[ '1.异步', '2.异步', '3.异步' ]
})
//虽然 p1,p2,p3 都是异步操作，但最终要等待所有异步完成，才可以输出；
//只要 p1,p2,p3 中有一个出现了 Rejected，则会执行失败


//Promise 提供了一个 race()方法，只输出第一个改变状态的实例；
////p1,p2,p3 只要有一个改变状态，即回调
let p=Promise.race([p1,p2,p3]);
p.then(value=>{
    console.log(value);//2.异步 2的时间是0.8秒，时间最短，所以返回p2
})


//Promise 提供了 resolve()和 reject()，直接返回一个成功或失败的实例；
let ps=Promise.resolve("成功");
let pj = Promise.reject('失败')
console.log(ps);//Promise { '成功' } object类型
ps.then(value=>{
    console.log(value);//成功
}).catch(reason=>{
    console.log(reason);
})
//等价于
new Promise(resolve => resolve('成功'));


//类型一致性
function getP(){
    if(true){
        return new Promise(resolve=>{
            resolve('成功');
        })
    }else{
        // return 0;//如果是false 就会报错，需要类型一致，才不会报错  强制类型一致保证程序正确性 Promise.resolve(0)
        return Promise.resolve(0);
    }
}
getP().then(value=>{
    console.log(value);//成功
})

// //模拟异步1
// setTimeout(()=>{
//     console.log("异步1");
// },3500);

// //模拟异步2
// setTimeout(()=>{
//     console.log("异步2");
// },500);


// //模拟异步1
// setTimeout(()=>{
//     console.log("异步3");
// },1500);