Promise

Promise是JavaScript中用于处理异步操作的一个核心对象，它是ES6引入的原生属性。Promise提供了一中更优雅的方式来组织复杂的异步代码，并解决了回调地狱的问题。

Promise 基本概念

1.构造函数：Promise 是一个构造函数，可以使用new关键字创建一个新的Promise实例。

let promise = new Promise(()=>{
	//异步操作的代码
	if(/*异步操作成功*/){
		resolve(value) // 成功时调用resolve方法传递结果
	}else{
		reject(error) // 失败时调用reject方法传递错误原因
	}
})

2.状态：

• Pending (进行中)：初始状态，等待异步操作完成。
• Fulfilled (已成功)：操作成功后，Promise状态变为fulfilled，并且会有一个值传递给后续处理程序。
• Rejected (已失败)：操作失败后，Promise状态变为rejected，并且会又一个错误原因传递给后续处理程序。

3.不可变性：一旦Promise的状态从pending变为fufilled或者rejected，它就不能再改变。

4.链式调用：Promise对象通过.then()方法链接在一起，形成一个执行链条，每个.then()可以接收两个回调函数，分别对应resolved和rejected状态。

promise.then(value => {
  // 处理成功情况
}).catch(reason => {
  // 处理失败情况
});

5..catch()：专门用来捕获和处理Promise链中的任何错误。

        let p = new Promise((resolve,reject)=>{
            setTimeout(()=>{
                resolve(123)
                // reject('err')
            },1000)
        })
  
 
        let p1 = p.then(res=>{
            console.log(1);
        }).then(res=>{
            console.log(2);
            // 1:在then的链式调用用,只要有一个出现问题,后面的都不执行,执行catch
            throw new Error('出错了出错了')
        }).then(res=>{
            console.log(3);
        }).catch((err)=>{
            console.log(4);
            console.log(err);
        })
 
        // catch()
        // 返回值是:pending状态的 全新的promise实例对象
        console.log(p1);

6..finally()：无论Promise最终是fufilled还是rejected，都会执行.finally()中的回调函数。

let p = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve(123)
            }, 1000)
        })
        let p1 = p.then(res=>{
            console.log(1);
        }).then(res=>{
            console.log(2);
        }).then(res=>{
            console.log(3);
        }).catch((err)=>{
            console.log(4);
            console.log(err);
        }).finally(()=>{
            // finally()方法用于指定不管 Promise 对象最后状态如何，都会执行的操作
            console.log('finally');
        })
        .then(res=>{
           console.log('验证finally后是否能够继续then');    
        })
        console.log(p1);

7..all()：用于并发执行多个Promise，并在所有Promise完成后返回一个新的Promise，该Promise在所有输入的Promise都fufilled时fufilled，如果有任何一个rejected，则立即rejected。

   let p = new Promise((resolve,reject)=>{
            console.log('第一个异步任务开始了');
            setTimeout(() => {
                resolve('第一次异步结果')
            }, 1000);
        })
        let p2 = new Promise((resolve,reject)=>{
            console.log('第二个异步任务开始了');
            setTimeout(() => {
                resolve('第二次异步结果')
                // reject()
            }, 2000);
        })
        let p3 = new Promise((resolve,reject)=>{
            console.log('第三个异步任务开始');
            setTimeout(() => {
                resolve('第三次异步结果')
            }, 3000);
        })
        // 并发：
        // p p2 p3 同时触发。等三个都接受在执行下一个任务。
        let state = new Date().getTime();
      
        
        Promise.all([p,p2,p3]).then(arr=>{
            // arr 数组
            // 数组元素：对应的promise对象.[[PromiseResult]]
            let timer = (new Date().getTime()) - state;
            console.log('三个异步都结束了');
            console.log(arr);
            console.log(timer);
        },()=>{
            console.log('有一个拒绝的');
        })

创建一个简单的 Promise

let myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    if (Math.random() > 0.5) {
      resolve('Success!');
    } else {
      reject(new Error('Failed!'));
    }
  }, 1000);
});

// 使用 then 和 catch 处理结果
myPromise.then(result => {
  console.log(result); // 如果异步操作成功，输出 'Success!'
}).catch(err => {
  console.error(err); // 如果异步操作失败，输出错误信息
});