Pormise

//Pormise
function MyPromise (executor) {
var self = this
self.status = 'pending'
self.resolveValue = null
self.rejectValue = null
self.resolveCallbackList = [] //用来存储resolve的回调函数
self.rejectCallbackList = [] //用来存储reject的回调函数

function resolve (value) {
if (self.status === 'pending') {
self.status = 'Fulfilled'
self.resolveValue = value
self.resolveCallbackList.forEach(function (item) {
item()
})
}
}

function reject (value) {
if(self.status === 'pending') {
self.status = 'Rejected'
self.rejectValue = value
self.rejectCallbackList.forEach(function (item) {
item()
})
}
}
try {
executor(resolve, reject)
} catch (e) {
reject(e)
}
}
function resultIsPromise (nextValue, res, rej) {
if(nextValue instanceof MyPromise) {
nextValue.then(function (val) {
res(val)
}, function(reason) {
rej(reason)
})
} else {
res(nextValue)
}
}
MyPromise.prototype.then = function (resolve, reject) {
if (!resolve) {
resolve = function(val) {
return val
}
}
if (!reject) {
reject = function (val) {
throw new Error(val)
}
}
var self = this
var nextPromise = new MyPromise(function(res, rej) {
setTimeout(function() {
if (self.status === 'Fulfilled') {
try{
// var newResolveVal = resolve(self.resolveValue)
// res(newResolveVal)
var newResolveVal = resolve(self.resolveValue)
resultIsPromise(newResolveVal, res, rej)
} catch(e) {
rej(e)
}
}
}, 0)

setTimeout(function () {
if (self.status === 'Rejected') {
try{
var newRejectVal = reject(self.rejectValue)
resultIsPromise(newRejectVal, res, rej)
} catch(e) {
rej(e)
}
}
}, 0)

if (self.status === 'pending') {
if(typeof resolve === 'function') {
self.resolveCallbackList.push(function () {
setTimeout(function() {
try{
var newResolveVal = resolve(self.resolveValue)
resultIsPromise(newResolveVal, res, rej)
} catch (e) {
rej(e)
}
})
})
}
if(typeof reject === 'function') {
setTimeout(function () {
self.rejectCallbackList.push(function () {
try{
var newRejectVal = reject(self.rejectValue)
resultIsPromise(newRejectVal, res, rej)
} catch(e) {
rej(e)
}
})
}, 0)
}
}
})
return nextPromise
}
//race
MyPromise.race = function (promises) {
return new MyPromise(function (res, rej) {
promises.forEach( function (item) {
item.then(res, rej)
})
})
}
MyPromise.resolve = function (val) {
return new MyPromise(function (resolve) {
resolve(val)
})
}
MyPromise.catch = function (val) {
return new MyPromise(function (undefined,reject) {
reject(val)
})
}
MyPromise.all = function (promises) {
return new MyPromise(function(resolve, reject){
var countNum=0;
var promiseNum=promises.length;
var resolvedValue=[];
for(var i=0;i<promiseNum;i++){
(function(i){
promises[i].then(function(value){
countNum++;
resolvedValue[i]=value;
if(countNum===promiseNum){
return resolve(resolvedValue)
}
},function(reason){
return reject(reason)
})
})(i)
}
})
}
 
 

 

转载于:https://www.cnblogs.com/CoderZX/p/10792216.html

### Promise 的工作原理 Promise 是 JavaScript 中处理异步操作的一种核心机制,其设计基于状态管理和回调注册的思想。Promise 本质上是一个对象,表示一个异步操作的最终完成(或失败)及其结果值。Promise 有三种状态:`pending`(等待态)、`fulfilled`(成功态)和 `rejected`(失败态)。一旦状态发生变化,就不会再变,这种状态的不可逆性是 Promise 的核心特性之一[^2]。 在内部实现上,Promise 采用了发布-订阅模式。当异步操作尚未完成时,Promise 处于 `pending` 状态,此时可以通过 `then` 方法注册回调函数,等待状态变为 `fulfilled` 或 `rejected` 时触发相应的回调。这种机制类似于事件监听,但更结构化和可控,避免了传统回调地狱的问题[^3]。 Promise 的执行是同步的,构造一个 Promise 实例时,其传入的执行函数会立即执行,但其内部的异步操作(如 setTimeout)会进入事件循环的微任务队列,等待当前同步任务执行完毕后才被处理。这使得 Promise 具有良好的调度顺序[^1]。 ### Promise 的使用方法 #### 基本结构 ```javascript const promise = new Promise((resolve, reject) => { // 异步操作 if (/* 成功 */) { resolve(value); // 成功状态 } else { reject(error); // 失败状态 } }); ``` #### 链式调用 Promise 支持链式调用,通过 `then` 方法可以依次处理异步操作的结果,每个 `then` 返回一个新的 Promise,从而实现异步流程控制: ```javascript promise .then(value => { console.log('Success:', value); return value + 1; }) .then(newValue => { console.log('New value:', newValue); }) .catch(error => { console.error('Error:', error); }); ``` #### 错误处理 Promise 的错误处理通过 `catch` 方法进行,它可以捕获链式调用中任意一个环节抛出的错误。建议始终使用 `catch` 来统一处理错误,以避免未捕获的 Promise rejection 导致程序崩溃。 #### 静态方法 Promise 构造函数自身提供了一些静态方法,用于处理多个 Promise 的组合和控制: - `Promise.resolve(value)`:返回一个以给定值解析的 Promise。 - `Promise.reject(reason)`:返回一个以给定原因拒绝的 Promise。 - `Promise.all(iterable)`:接收一个 Promise 数组,全部成功才成功,有一个失败就立即失败。 - `Promise.race(iterable)`:接收一个 Promise 数组,只要有一个 Promise 状态改变,就触发后续操作。 ### 常见问题与注意事项 - **避免未处理的 rejection**:如果一个 Promise 被拒绝但没有对应的 `catch` 捕获,可能导致程序运行异常。应始终为 Promise 链添加错误处理。 - **链式调用中的返回值**:在 `then` 中返回的值会作为下一个 `then` 的输入。若返回的是另一个 Promise,则会等待该 Promise 解析后再继续执行链式流程。 - **异步顺序问题**:由于 Promise 使用微任务队列,其回调执行顺序优先于 `setTimeout` 等宏任务,但在多个 Promise 回调之间仍然遵循注册顺序。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值