Promise 源码和分析
Promise 介绍
什么是 Promise？解决哪些问题？node
- 回调地狱，代码很差维护，错误处理很是的麻烦，不能统一处理错误
- 处理多个请求并发问题
ES6 将其写进了语言标准，统一了用法，原生提供了 Promise 对象。npm
- Promise 是一个对象，使用的时候 new 便可
- Promise 在 new 的时候传入一个执行器，即 executor，这个函数在 new Promise 时当即执行
- Promise 的 executor 函数有两个参数，一个是 resolve，一个是 reject。resolve 让 Promise 由 pending 等待态变成 fulfilled 成功态，reject 让 Promise 由 pending 等待态变成 rejected 失败态。resolve 和 reject 是 Promise 提供的。
- Promise 的 3 个状态：pending 等待态、fulfilled 成功态、rejected 失败态
- Promise 的 resolve 或者 reject 只能调用一次，一旦成功以后不能再失败，一旦失败以后不能再成功
- 每一个 Promise 实例有个 then() 方法，该方法内部传递两个函数，第一个是成功回调函数，第二个是失败回调函数
- 让一个 Promise 失败能够调用 reject，也能够抛出一个错误
- Promise 的 then() 方法返回的仍是一个新的 Promise，因此 then() 以后还能够再 then
// 定义三种状态
const REJECTED = 'REJECTED';
const FULFILLED = 'FULFILLED';
const PENDING = 'PENDING';
/**
* 判断一个变量是不是 Promise 的函数
* 1. 是不是对象而且不是 null
* 2. 是否有 then 属性而且 then 是一个方法
* @param {*} val
*/
function isPromise(val) {
if (typeof val === 'object' && val !== null || typeof val === 'function') {
return typeof val.then === 'function';
}
return false;
}
console.log('--------------------- MY Promise ---------------------');
// 实现链式调用
/**
* 处理 then 中的成功、失败回调函数返回值是不是 Promise 的状况
* @param {*} promise2 参见 Promise A+ 规范说明 new Promise
* @param {*} x 是成功、失败回调的返回值
*/
const resolvePromise = (promise2, x) => {
const { resolve, reject } = promise2;
// 这里的判断是可能本身的 Promise 要和别人的 Promise 混用，可能不一样的 Promise 库之间相互调用
// 若是 new 出来的 Promise2 和 x 是同一个，那么 x 永远不能成功或者失败，因此卡死了，直接报错
if (promise2 === x) return reject(new TypeError('Chaining cycle detected for promise #<Promise>'));
// 须要判断 x 的状态，判断 x 是否是 Promise
// 先判断是否是对象或者函数
if (typeof x === 'object' && x !== null || typeof x === 'function') {
let called; // 这里考虑别人的 Promise 是否健壮，不健壮须要再判断一下，调用了成功就不能失败，调用的失败就不能成功。不能屡次调用成功或者失败
try {
const then = x.then; // 内部可能抛出错误
// 若是 then 不是函数就说明是一个普通值，直接返回 x
if (typeof then !== 'function') resolve(x); // 好比：{ then: 'mhq' }
else {
// 这里不要再次调用 x.then 是防止取 then 的时候报错，万一 then 方法里面抛出了一个错误呢？
then.call(x, y => {
if (called) return;
called = true;
// 若是 x 是一个 Promise，那么就继续解析成功的值
resolvePromise(promise2, y);
}, f => {
if (called) return;
called = true;
reject(f); // 直接调用 r 做为失败的结果
});
}
} catch(err) {
if (called) return;
called = true;
reject(err);
}
} else {
resolve(x);
}
};
class Promise {
constructor(executor) {
// Promise 的状态
this.status = PENDING;
// 成功后的值
this.value = undefined;
// 失败后的值
this.reason = undefined;
// 成功回调函数，发布订阅
this.onResolvedCallbacks = [];
// 失败回调函数，发布订阅
this.onRejectedCallbacks = [];
/**
* Promise 内部提供的 resolve，让 Promise 的状态变成成功态，并让成功回调执行
* @param {*} value
*/
const resolve = value => {
if (value instanceof Promise) {
return value.then(resolve, reject);
}
if (this.status === PENDING) {
this.status = FULFILLED;
this.value = value;
this.onResolvedCallbacks.forEach(fn => fn());
}
};
/**
* Promise 内部提供的 reject，让 Promise 的状态变成失败态，并让失败回调执行
* @param {*} reason
*/
const reject = reason => {
if (this.status === PENDING) {
this.status = REJECTED;
this.reason = reason;
this.onRejectedCallbacks.forEach(fn => fn());
}
};
// try + catch 只能捕获同步异常
try {
executor(resolve, reject);
} catch(err) {
reject(err);
}
}
// 只要 x 是一个普通值，就会让一个 Promise 变成成功态
// 这个 x 有多是一个 Promise，须要菜哟个这个 Promise 的状态
then(onFulfilled, onRejected) {
// 好比.then().then().then(() => {}); 这种调用，对可选参数的处理，透传
onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : val => val;
onRejected = typeof onRejected === 'function' ? onRejected : err => { throw err };
const promise2 = new Promise((resolve, reject) => { // 一旦 new 则当即执行
if(this.status === FULFILLED) {
setTimeout(() => {
promise2.resolve = resolve;
promise2.reject = reject;
try {
const x = onFulfilled(this.value);
resolvePromise(promise2, x);
} catch (err) {
reject(err);
}
}, 0);
}
if (this.status === REJECTED) {
setTimeout(() => {
promise2.resolve = resolve;
promise2.reject = reject;
try {
const x = onRejected(this.reason);
resolvePromise(promise2, x);
} catch (err) {
reject(err);
}
}, 0);
}
if (this.status === PENDING) { // 自己是异步的
this.onResolvedCallbacks.push(() => {
setTimeout(() => { // 这里须要加上，不加上跑测试跑不通
promise2.resolve = resolve;
promise2.reject = reject;
try {
const x = onFulfilled(this.value);
resolvePromise(promise2, x);
} catch (err) {
reject(err);
}
});
});
this.onRejectedCallbacks.push(() => {
setTimeout(() => {
promise2.resolve = resolve;
promise2.reject = reject;
try {
const x = onRejected(this.reason);
resolvePromise(promise2, x);
} catch (err) {
reject(err);
}
});
});
}
});
return promise2;
}
/**
* Promise 中的 catch 指代的就是 then 没有成功回调的一个别名而已
* @param {*} errCallback
*/
catch(errCallback) {
return this.then(null, errCallback);
}
}
// 不管如何都会执行，把上一个 then 的结果向下传递，若是 finally 中返回了一个 Promise 会等待这个 Promise 执行完成后继续执行
Promise.prototype.finally = function(callback) {
return this.then(val => {
return Promise.resolve(callback()).then(() => val);
}, (err) => {
return Promise.resolve(callback()).then(() => { throw err; });
});
};
// npm install promises-aplus-tests -g
// promises-aplus-tests promise.js
// 测试本身写的 Promise 是否符合规范的包
Promise.deferred = () => {
const dfd = {};
dfd.promise = new Promise((resolve, reject) => {
dfd.resolve = resolve;
dfd.reject = reject;
});
return dfd;
};
/**
* Promise.resolve 他会等待里面的 Promise 执行成功
* @param {*} val
*/
Promise.resolve = val => {
return new Promise((resolve) => {
resolve(val);
});
};
/**
* Promise.reject 不会等待参数中的 Promise 执行完毕
*/
Promise.reject = () => {
return new Promise((_, reject) => {
reject(val);
});
};
/**
* Promise.all 方法表示等待全部的 Promise 所有成功后才会执行回调，若是有一个 Promise 失败则 Promise 就失败了
* @param {*} promises
*/
Promise.all = promises => {
return new Promise((resolve, reject) => {
const res = [];
let count = 0;
const resolveRes = (index, data) => {
res[index] = data;
if (++count === promises.length) {
resolve(res);
}
};
for(let i = 0; i < promises.length; i++) {
const current = promises[i];
if (isPromise(current)) {
current.then((data) => {
resolveRes(i, data);
}, (err) => {
reject(err);
});
} else {
resolveRes(i, current);
}
}
});
}
/**
* Promise.race 赛跑，谁是第一个完成的，就用他的结果，若是是失败这个 Promise 就失败，若是第一个是成功就是成功
* @param {*} promises
*/
Promise.race = (promises) => {
return new Promise((resolve, reject) => {
for(let i = 0; i < promises.length; i++) {
let current = promises[i];
if (isPromise(current)) {
current.then(resolve, reject);
} else {
resolve(current);
break;
}
}
});
}
// 专门给 node 的 api 作的 promisify 方法，如 fs.readFile
Promise.promisify = fn => {
return (...arg) => {
return new Promise((resolve, reject) => {
fn(...arg, (err, data) => {
if (err) reject(err);
resolve(data);
});
});
}
};
module.exports = Promise;
相关文章
- 1. Promise 源码和分析
- 2. Promise 源码分析
- 3. promise源码分析
- 4. Promise的源码分析
- 5. promise源码解析
- 6. Promise源码解析
- 7. Promise 源码解析
- 8. promise源码深度解析
- 9. 【源码系列】redux-chunk、redux-promise 源码分析
- 10. netty中的future和promise源码分析（二）
- 更多相关文章...
- • 高并发系统的分析和设计 - 红包项目实战
- • ASP.NET Razor - C# 和 VB 代码语法 - ASP.NET 教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • IntelliJ IDEA 代码格式化配置和快捷键
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 升级Gradle后报错Gradle‘s dependency cache may be corrupt (this sometimes occurs
- 2. Smarter, Not Harder
- 3. mac-2019-react-native 本地环境搭建(xcode-11.1和android studio3.5.2中Genymotion2.12.1 和VirtualBox-5.2.34 )
- 4. 查看文件中关键字前后几行的内容
- 5. XXE萌新进阶全攻略
- 6. Installation failed due to: ‘Connection refused: connect‘安卓studio端口占用
- 7. zabbix5.0通过agent监控winserve12
- 8. IT行业UI前景、潜力如何？
- 9. Mac Swig 3.0.12 安装
- 10. Windows上FreeRDP-WebConnect是一个开源HTML5代理，它提供对使用RDP的任何Windows服务器和工作站的Web访问
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Promise 源码和分析
- 2. Promise 源码分析
- 3. promise源码分析
- 4. Promise的源码分析
- 5. promise源码解析
- 6. Promise源码解析
- 7. Promise 源码解析
- 8. promise源码深度解析
- 9. 【源码系列】redux-chunk、redux-promise 源码分析
- 10. netty中的future和promise源码分析（二）