});
}
function reject(data) {
if (that.PromiseState !== ‘pending’) return
that.PromiseState = ‘rejected’;
that.PromiseResult = data;
that.callbacks.forEach(item => {
setTimeout(()=>{
item.onRejected(data);
});
});
}
try {
// executor函数同步调用的
executor(resolve, reject);
} catch (e) {
reject(e);
}
}
// 添加then方法
Promise.prototype.then = function (onResolved, onRejected) {
// 异常穿透原理
if (typeof onRejected !== ‘function’) {
onRejected = reason => {
throw reason;
}
}
if (typeof onResolved !== ‘function’) {
onResolved = value => value;
}
let that = this;
return new Promise((resolve, reject) => {
function callback(type) {
try {
let result = type(that.PromiseResult);
if (result instanceof Promise) {
result.then(value => {
resolve(value);
}, reason => {
reject(reason);
});
} else {
resolve(result);
}
} catch (e) {
reject(e);
}
}
if (this.PromiseState === ‘fulfilled’) {
setTimeout(()=>{
callback(onResolved);
});
}
if (this.PromiseState === ‘rejected’) {
setTimeout(()=>{
callback(onRejected);
});
}
// 当执行器函数封装的是异步操作时,resolve和reject函数执行会等待所有同步操作完成后执行，而then方法因为不知道PromiseState是成功还是失败，无法直接执行回调函数
// 则回调函数执行时机需要延迟到PromiseState改变后，即resolve或reject函数执行完后才能执行
// 通过将回调函数保存到promise对象的属性中，保证了resolve或reject函数执行时可以直接调用
if (this.PromiseState === ‘pending’) {
// 同一个promise对象可以指定多个回调函数，并且多个回调函数都可以被执行
this.callbacks.push({
onResolved: function () {
setTimeout(()=>{
callback(onResolved);
});
},
onRejected: function () {
setTimeout(()=>{
callback(onRejected);
});
}
});
}
});
}
Promise.prototype.catch = function (onRejected) {
this.then(undefined, onRejected);
}
Promise.resolve = function (value) {
return new Promise((resolve,reject) => {
if (value instanceof Promise) {
value.then(v => {
resolve(v);
},r => {
reject®;
})
} else {
resolve(value);
}
});
}
Promise.reject = function (reason) {
return new Promise((resolve, reject) => {
reject(reason);
});
}
Promise.all = function (promises) {
return new Promise((resolve,reject)=>{
let count = 0;
let arr = [];
for (let i = 0; i < promises.length; i++) {
promises[i].then(v=>{
count++;
arr[i] = v;
if (count === promises.length) {
resolve(arr);
}
},r=>{
reject®;
})
}
// 错误代码
/*promises.forEach(item=>{
item.catch(r=>{ //因为catch指定的回调函数是异步调用的，所以必须等同步完成后，才能调用，导致不会立刻调用reject
reject®
})
})
resolve(promises)*/
});
}
Promise.race = function (arr) {
return new Promise((resolve,reject)=>{
arr.forEach(item=>{
item.then(v=>{
resolve(v);
},r=>{
reject®;
})
})
})
}
关于Promise中三个回调函数的深入解析
=====================
异步函数分为两部分：异步操作，回调函数
异步操作和回调函数是两个关联的代码，当异步操作完成后，回调函数会进入任务队列等待主线程捞取到执行栈
在传统的异步函数中，异步函数和回调函数在结构上是严重耦合的，即回调函数必须要嵌入到异步函数中，这造成一个问题：回调地狱，即异步函数的同步调用情况。
所以解决了异步函数和它的回调函数的高耦合问题，就解决了回调地狱的问题。
Promise就是将异步函数和回调函数解耦。即将异步函数封装为Promise对象，当异步函数的异步操作成功/失败后，在它的回调函数（A）中调用resolve/reject方法，改变Promise对象的状态属性PromiseState为成功/失败。
Promise对象可以在其then方法中，获取到自身的状态，根据状态就可以得知异步操作成功还是失败。
then方法还接收两个函数类型参数，分别对应异步操作成功后的回调函数（B1），和异步操作失败后的回调函数(B2)，当Promise对象是成功状态，则调用成功回调函数参数B1，否则调用失败回调函数参数B2。
这里我们发现有三个回调函数：分别是，依旧定义在异步函数中的回调函数A，被解耦出来定义到then方法形参中的回调函数B1,B2
这三个回调函数本质都是异步函数的回调函数，只是作用不同，定义时机不同，调用时机不同。
A的作用仅仅只是改变封装了异步函数的Promise对象的状态，即将异步操作的执行结果是成功还是失败通知到异步函数外界去。
小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Web前端开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：前端）
最后
由于文档内容过多，为了避免影响到大家的阅读体验，在此只以截图展示部分内容
文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频**
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：前端）
[外链图片转存中…(img-qHISZwg1-1710800623615)]
最后
[外链图片转存中…(img-AkXk51pL-1710800623615)]
[外链图片转存中…(img-lM0ySLyv-1710800623616)]
由于文档内容过多，为了避免影响到大家的阅读体验，在此只以截图展示部分内容
扫一扫
171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
