Dieses Mal werde ich Ihnen die Implementierungsschritte von PromiseA+ ausführlich erläutern. Was sind die Vorsichtsmaßnahmen für die Implementierung von PromiseA+?
Promise
Schreiben Sie handschriftlich eine Implementierung von PromiseA+. Beachten Sie, dass dies nur eine Simulation ist. Tatsächlich gehört das native Versprechen zur microTask in der Ereigniswarteschlange. Es ist nicht besonders geeignet, hier setTimeout zur Simulation zu verwenden. Weil setTimeout eine Makroaufgabe ist.
1. Die einfachste Grundfunktion
/**
* 定义Promise
* 先实现一个最简单的。用setTimeout模拟一个异步的请求。
*/
function Promise(fn){
var value= null;
var callbacks = [];
this.then = function(onFulfilled) {
callbacks.push(onFulfilled);
}
function resolve(value){
callbacks.forEach(function(cb){
cb(value);
})
}
fn(resolve);
}
// 使用Promise
var p = new Promise(function(resolve){
setTimeout(function(){
resolve('这是响应的数据')
},2000)
})
p.then(function(response){
console.log(response);
})Nach dem Login kopieren
2. Kettenaufruf
/**
* 先看一下前一个例子存在的问题
* 1.在前一个例子中不断调用then需要支持链式调用，每次执行then都要返回调用对象本身。
* 2.在前一个例子中，当链式调用的时候，每次then中的值都是同一个值，这是有问题的。其实第一次then中的返回值，应该是第二次调用then中的函数的参数，依次类推。
* 所以，我们进一步优化一下代码。
*
*/
function Promise(fn){
var value= null;
var callbacks = [];
this.then = function(onFulfilled) {
callbacks.push({f:onFulfilled});
return this;
}
function resolve(value){
callbacks.map(function(cb,index){
if(index === 0){
callbacks[index].value = value;
}
var rsp = cb.f(cb.value);
if(typeof callbacks[index+1] !== 'undefined'){
callbacks[index+1].value = rsp;
}
})
}
fn(resolve);
}
// 使用Promise
var p = new Promise(function(resolve){
setTimeout(function(){
resolve('这是响应的数据')
},2000)
})
p.then(function(response){
console.log(response);
return 1;
}).then(function(response){
console.log(response);
return 2;
}).then(function(response){
console.log(response);
})Nach dem Login kopieren
4. Zustandsmechanismus
/**
* 先看一下前一个例子存在的问题
* 1. 如果在then方法注册回调之前，resolve函数就执行了，怎么办？比如 new Promise的时候传入的函数是同步函数的话，
* then还没被注册，resolve就执行了。。这在PromiseA+规范中是不允许的，规范明确要求回调需要通过异步的方式执行。
* 用来保证一致可靠的执行顺序。
*
* 因此我们需要加入一些处理。把resolve里的代码放到异步队列中去。这里我们利用setTimeout来实现。
* 原理就是通过setTimeout机制，将resolve中执行回调的逻辑放置到JS任务队列末尾，以保证在resolve执行时，
* then方法的回调函数已经注册完成
*
*/
function Promise(fn){
var value= null;
var callbacks = [];
this.then = function(onFulfilled) {
callbacks.push({f:onFulfilled});
return this;
}
function resolve(value){
setTimeout(function(){
callbacks.map(function(cb,index){
if(index === 0){
callbacks[index].value = value;
}
var rsp = cb.f(cb.value);
if(typeof callbacks[index+1] !== 'undefined'){
callbacks[index+1].value = rsp;
}
})
},0)
}
fn(resolve);
}
// 使用Promise,现在即使是同步的立马resolve，也能正常运行了。
var p = new Promise(function(resolve){
resolve('这是响应的数据')
})
p.then(function(response){
console.log(response);
return 1;
}).then(function(response){
console.log(response);
return 2;
}).then(function(response){
console.log(response);
})Nach dem Login kopieren
e
/**
* 先看一下前一个例子存在的问题
* 1.前一个例子还存在一些问题，如果Promise异步操作已经成功，在这之前注册的所有回调都会执行，
* 但是在这之后再注册的回调函数就再也不执行了。具体的运行下面这段代码，可以看到“can i invoke”并没有打印出来
* 想要解决这个问题，我们就需要加入状态机制了。具体实现看本文件夹下的另一个js文件里的代码。
*
*/
function Promise(fn){
var value= null;
var callbacks = [];
this.then = function(onFulfilled) {
callbacks.push({f:onFulfilled});
return this;
}
function resolve(value){
setTimeout(function(){
callbacks.map(function(cb,index){
if(index === 0){
callbacks[index].value = value;
}
var rsp = cb.f(cb.value);
if(typeof callbacks[index+1] !== 'undefined'){
callbacks[index+1].value = rsp;
}
})
},0)
}
fn(resolve);
}
//
var p = new Promise(function(resolve){
resolve('这是响应的数据')
})
p.then(function(response){
console.log(response);
return 1;
}).then(function(response){
console.log(response);
return 2;
}).then(function(response){
console.log(response);
})
setTimeout(function(){
p.then(function(response){
console.log('can i invoke?');
})
},0)Nach dem Login kopieren
5. Behandeln Sie die Situation, wenn der Rückgabewert der registrierten Funktion ein Versprechen ist
/**
* 在promise01.js中，我们已经分析了，我们需要加入状态机制
* 在这里实现一下PromiseA+中关于状态的规范。
*
* Promises/A+规范中的2.1Promise States中明确规定了，pending可以转化为fulfilled或rejected并且只能转化一次，
* 也就是说如果pending转化到fulfilled状态，那么就不能再转化到rejected。
* 并且fulfilled和rejected状态只能由pending转化而来，两者之间不能互相转换
*
*/
function Promise(fn){
var status = 'pending'
var value= null;
var callbacks = [];
this.then = function(onFulfilled) {
// 如果是pending状态，则加入到注册队列中去。
if(status === 'pending'){
callbacks.push({f:onFulfilled});
return this;
}
// 如果是fulfilled 状态，此时直接执行传入的注册函数即可。
onFulfilled(value);
return this;
}
function resolve(newValue){
value = newValue;
status = 'fulfilled';
setTimeout(function(){
callbacks.map(function(cb,index){
if(index === 0){
callbacks[index].value = newValue;
}
var rsp = cb.f(cb.value);
if(typeof callbacks[index+1] !== 'undefined'){
callbacks[index+1].value = rsp;
}
})
},0)
}
fn(resolve);
}
//
var p = new Promise(function(resolve){
resolve('这是响应的数据')
})
p.then(function(response){
console.log(response);
return 1;
}).then(function(response){
console.log(response);
return 2;
}).then(function(response){
console.log(response);
})
setTimeout(function(){
p.then(function(response){
console.log('can i invoke?');
})
},1000)Nach dem Login kopieren
Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln die chinesische PHP-Website!
Empfohlene Lektüre:
Detaillierte Erläuterung der Schritte zur Kombination von React mit TypeScript und Mobx
Detaillierte Erläuterung der Schritte für die Verwendung von React-router v4
Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Implementierungsschritte von PromiseA+. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
