自己封装的requestData 需要设计好 callback回调函数如果使用第三方插件还是别人封装的异步函数需要知道参数的传入

Promise(类)

给予调用者一个承诺待会会给你一个回调函数会给Promise 划分3种状态。状态一旦确定了就固定了 1.pending 待定的 2.fulfiled/resolved 固定的 3.rejected 拒绝的

function requestData(url, successCallback, failtureCallback) {
  setTimeout(() => {
    if (url === 'xsh') {
      successCallback();
    } else {
      failtureCallback();
    }
  }, 3000);
  return new Promise((resolve, reject) => {});
}

requestData(
  'xsh',
  () => {
    console.log('成功');
  },
  () => {
    console.log('失败了');
  }
);

class Person {
  constructor(callback) {}
}

// resolve 在成功的时候调用
// reject 在失败的时候调用
const promise = new Promise((resolve, reject) => {
  // console.log("它将会立即执行，称这个函数为executer")
  resolve('成功了');
});

// then 方法传入的方法 会在promise中调用resolve的时候 执行传入的第一个回调函数 ，如果失败了 可以给then传入第二个回调函数
promise.then(
  res => {
    console.log(res);
  },
  err => {
    console.log(err);
  }
);
// catch 方法传入的方法 会在promise中调用reject的时候 执行传入的回调函数
promise.catch(err => {
  console.log(err);
});
new Promise((resolve, reject) => {
  resolve(
    new Promise((resolve, reject) => {
      resolve();
    })
  );
  resolve({
    then: function (resolve, reject) {
      resolve();
    },
  });
  // pending  待定的
})
  .then(res => {
    //  fulfiled/resolved 固定的
  })
  .catch(err => {
    // rejected 拒绝的
  });

resolve

可以传入一个正常参数
可以传入一个Promise 那么当前Promise的状态会根据传入的Promise来决定。状态的移交
可以传入一个对象该对象有then方法（并且这个对象实现了thenable）那他会执行对象的then方法并且根据then方法进行返回

const promise123 = new Promise((resolve, reject) => {
  throw new Error('控制台报错');
});

// 当excutor抛出异常的时候 也会调用reject(也就是catch)函数显示的
promise123.then(res => {});

// 通用catch也会接受reject拒绝（错误的）回调函数
// 但是这种写法不符合promise a+的规范 但是catch也是Promise提出的一种写法
// 他会优先捕获promise123 的异常  如果在promise的then有异常的话  他会捕获then里面的异常
// promise123.then(res => {});和promise123.catch(err => {}); 他俩是单独两个处理方式 所以当then里面没有异常处理的函数 他会报错的
promise123
  .then(res => {})
  .then(res => {})
  .catch(err => {
    console.log(err);
  });

Promise的实例方法

then catch finally 都是promise上面的方法正常看 Promise.prototype 是看不见的因为他的可枚举属性为 false 所以得需要 Object.getOwnPropertyDescriptors(Promise.prototype)

const promise111 = Promise.resolve({ name: 'xsh' });

const promise2 = new Promise((resolve, reject) => {
  resolve('111');
});

promise111.then(res => {
  console.log(res);
});

// Promise.reject()

const promise1113 = Promise.reject({ name: 'xsh' });

const promise23 = new Promise((resolve, reject) => {
  reject('111');
});

promise111.catch(res => {
  console.log(res);
});

// Promise.all()
// 当所有的Promise 都变成resolve （传入的函数又了结果） 在拿到结果
const p1 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('11');
  }, 1000);
});
const p2 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('11');
  }, 2000);
});
const p3 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('11');
  }, 3000);
});
当所有的Promise都有了结果 才会调用then 如果传入了字符串或者其他类型 他都会自动转换成为Promise 都执行完了才会返回一个数组 并且顺序是传入参数的顺序 
如果有一个Promise 有了reject 他就会中断了 将会毁掉catch{}
Promise.all([p1,p2,p3,'name'])
.then(res=>{
  console.log(res)
}).catch(err=>{
  
})

Promise.allSettled es11新增
所有的Promise都有了结果 无论是resolve还是reject 都执行完了（不会中断）会给一个对应的结果
他的结果是一个数组 里面是一个对象 他会返回每一个Promise的成功还是失败 并且还有返回值[{status:'fulfilled',value:'111'}]

Promise.allSettled([p1,p2,p3])
.then(res=>{})
.catch(err=>{})

Promise.race() 竞速
只要第一个Promise 变成了fulfilled 那么就返回这个结果then
如果第一个Promise 变成了reject 那么直接返回到catch里面
Promise.race([p1, p2, p3])
  .then(res => {
    console.log(res);
  })
  .catch(err => {
    console.log(err);
  });
  
  //Promise.any es12
// 至少等到一个fulfilled 也就是resolve 他才回返回结果到then
// 如果都是reject Promise 都是拒绝的  他才会返回到catch 在err.errors里面可以拿到所有错误
Promise.any([p1, p2, p3])
  .then(res => {
    console.log(res);
  })
  .catch(err => {
    console.log(err);
  });

同一个Promise可以多次调用then方法

当我们resolve方法被回调的时候所有的then方法传入的回调函数都将被调用
then方法传入的回调函数可以有返回值为promise then本身也有返回值他的返回值是一个promise
如果我们返回的是一个普通值(字符串对象) 这个普通纸将会被作为一个新的promise的resolve的值 如果没有写返回值 默认返回一个是undefined
如果我们返回的是一个promise 由内部的状态来决定返回的promise的结果
如果返回的是一个对象并且该对象实现了thenable方法

promise.then(res=>{
return 'aaaa'
<!-- // return new Promise(resolve,reject=>{resolve('aaa')}) -->
}
).then(res=>{
console.log(res) //'aaa'
})

catch

1.通用 catch 也会接受 reject 拒绝（错误的）回调函数 2.但是这种写法不符合 promise a+的规范(社区的规范) 但是 catch 也是 Promise 提出的一种写法 3.他会优先捕获 promise123 的异常如果在 promise 的 then 有异常的话他会捕获 then 里面的异常 promise123.then(res => {});和 promise123.catch(err => {}); 他俩是单独两个处理方式所以当 then 里面没有异常处理的函数他报错错的 4. 当 catch 里面有了返回值 return ‘11’ 这种情况他会继续调用下面的 then 因为他 return 一个 Primise 然后调用一个 resolve（）所以他会调用 then 的

finally 当 then 或者 catch 执行完毕他始终会执行 finally 里面的函数

Promise 常用知识点总结

Promise(类)

resolve

Promise的实例方法

同一个Promise可以多次调用then方法

catch