JavaScript 异步编程
文章目录
Callback
场景一:
在微信小程序中,我们对请求做了一层封装,如果请求时,检测到没有token 或者token已过期,则需要重新调用 刷新token方法,更新token后再去请求,然而我们打开微信小程序首页,此时可能并发多个请求,就会出现多次请求刷新token方法,我们需求是:在第一个请求刷新token后再执行后面的业务请求
模拟代码:
function requestA(){
setTimeout(()=>{
console.log('requestA')
},1000)
}
function requestB(){
setTimeout(()=>{
console.log('requestB')
},800)
}
function requestC(){
setTimeout(()=>{
console.log('requestC')
},600)
}
function requestD(){
setTimeout(()=>{
console.log('requestD')
},400)
}
function requestE(){
setTimeout(()=>{
console.log('requestE')
},200)
}
requestA 改造:
//对 requestA 进行 回调 改变
function requestA(callback){
setTimeout(()=>{
console.log('requestA')
callback && callback()
},1000)
}
执行:
requestA(()=>{
requestB()
requestC()
requestD()
requestE()
})
场景二:
多个请求逐层向上依赖上个请求的数据
示例:
function requestA(callback){
setTimeout(()=>{
callback && callback('requestA请求的结果')
},1000)
}
function requestB(ret,callback){
if(ret === 'requestA请求的结果'){
setTimeout(()=>{
callback && callback('requestB请求的结果')
},800)
}
}
function requestC(ret,callback){
if(ret === 'requestB请求的结果'){
setTimeout(()=>{
callback && callback('requestC请求的结果')
},600)
}
}
function requestD(ret,callback){
if(ret === 'requestC请求的结果'){
setTimeout(()=>{
callback && callback('requestD请求的结果')
},400)
}
}
function requestE(ret,callback){
if(ret === 'requestD请求的结果'){
setTimeout(()=>{
callback && callback('requestE请求的结果')
},200)
}
}
执行:
requestA(ret=>{
console.log(ret)
requestB('requestA请求的结果',ret=>{
console.log(ret)
requestC('requestB请求的结果',ret=>{
console.log(ret)
requestD('requestC请求的结果',ret=>{
console.log(ret)
requestE('requestD请求的结果',ret=>{
console.log(ret)
})
})
})
})
})
依次打印出了:requestA请求的结果->requestB请求的结果->requestC请求的结果->requestD请求的结果->requestE请求的结果
Promise
场景:多个请求逐层向上依赖上个请求的数据, 用 promise 改造
function requestA(){
return new Promise((resolve,reject)=>{
setTimeout(()=>{
resolve('requestA请求的结果')
},1000)
})
}
function requestB(param){
return new Promise((resolve,reject)=>{
if(param==='requestA请求的结果'){
setTimeout(()=>{
resolve('requestB请求的结果')
},800)
}else{
reject('requestB请求失败')
}
})
}
function requestC(param){
return new Promise((resolve,reject)=>{
if(param==='requestB请求的结果'){
setTimeout(()=>{
resolve('requestC请求的结果')
},600)
}else{
reject('requestC请求失败')
}
})
}
function requestD(param){
return new Promise((resolve,reject)=>{
if(param==='requestC请求的结果'){
setTimeout(()=>{
resolve('requestD请求的结果')
},400)
}else{
reject('requestD请求失败')
}
})
}
function requestE(param){
return new Promise((resolve,reject)=>{
if(param==='requestD请求的结果'){
setTimeout(()=>{
resolve('requestE请求的结果')
},200)
}else{
reject('requestE请求失败')
}
})
}
使用:
requestA()
.then(ret=>requestB(ret))
.then(ret=>requestC(ret))
.then(ret=>requestD(ret))
.then(ret=>requestE(ret))
.then(ret=>{
console.log(ret)//requestE请求的结果
}).catch(err=>{
console.log(err)
})
Generator
模拟请求:
function requestA(){
return new Promise((resolve,reject)=>{
setTimeout(()=>{
resolve('requestA请求的结果')
},1000)
})
}
function requestB(param){
return new Promise((resolve,reject)=>{
if(param==='requestA请求的结果'){
setTimeout(()=>{
resolve('requestB请求的结果')
},800)
}else{
reject('requestB请求失败')
}
})
}
function requestC(param){
return new Promise((resolve,reject)=>{
if(param==='requestB请求的结果'){
setTimeout(()=>{
resolve('requestC请求的结果')
},600)
}else{
reject('requestC请求失败')
}
})
}
function requestD(param){
return new Promise((resolve,reject)=>{
if(param==='requestC请求的结果'){
setTimeout(()=>{
resolve('requestD请求的结果')
},400)
}else{
reject('requestD请求失败')
}
})
}
function requestE(param){
return new Promise((resolve,reject)=>{
if(param==='requestD请求的结果'){
setTimeout(()=>{
resolve('requestE请求的结果')
},200)
}else{
reject('requestE请求失败')
}
})
}
Generator的异步使用:
function* gen(){
let result = yield requestA();
// console.log(result+'result')
let result1 = yield requestB(result);
// console.log(result1+'result1')
let result2 = yield requestC(result1);
// console.log(result2+'result2')
let result3 = yield requestD(result2);
// console.log(result3+'result3')
let result4 = yield requestE(result3);
// console.log(result4+'result4')
return result4
}
var g = gen();
var result = g.next();
result.value.then(function(data){
console.log(data+' requestA请求的数据')
return g.next(data).value
}).then(function(data){
console.log(data+' requestB请求的数据')
return g.next(data).value
}).then(function(data){
console.log(data+' requestC请求的数据')
return g.next(data).value
}).then(function(data){
console.log(data+' requestD请求的数据')
return g.next(data).value
}).then(function(data){
console.log(data+' requestE请求的数据')
})
Async
模拟请求:
function requestA(){
return new Promise((resolve,reject)=>{
setTimeout(()=>{
resolve('requestA请求的结果')
},1000)
})
}
function requestB(param){
return new Promise((resolve,reject)=>{
if(param==='requestA请求的结果'){
setTimeout(()=>{
resolve('requestB请求的结果')
},800)
}else{
reject('requestB请求失败')
}
})
}
function requestC(param){
return new Promise((resolve,reject)=>{
if(param==='requestB请求的结果'){
setTimeout(()=>{
resolve('requestC请求的结果')
},600)
}else{
reject('requestC请求失败')
}
})
}
function requestD(param){
return new Promise((resolve,reject)=>{
if(param==='requestC请求的结果'){
setTimeout(()=>{
resolve('requestD请求的结果')
},400)
}else{
reject('requestD请求失败')
}
})
}
function requestE(param){
return new Promise((resolve,reject)=>{
if(param==='requestD请求的结果'){
setTimeout(()=>{
resolve('requestE请求的结果')
},200)
}else{
reject('requestE请求失败')
}
})
}
Async的异步使用:
async function init(){
let ret1 =await requestA()
let ret2 =await requestB(ret1)
let ret3 =await requestC(ret2)
let ret4 =await requestD(ret3)
let ret5 =await requestE(ret4)
return ret5
}
init().then(res=>{
console.log(res)//requestE请求的结果
}).catch(err=>{
console.log(err)
})
事件监听
脚本的执行不取决代码的顺序,而取决于某一个事件是否发生。
案列:
$(document).ready(function(){
console.log('DOM 已经 ready')
});
发布/订阅
发布/订阅模式是利用一个消息中心,发布者发布一个消息给消息中心,订阅者从消息中心订阅该消息
案例:
//订阅done事件
$('#box').on('done',function(data){
console.log(data)
})
//发布事件
$('#box').trigger('done,'data')
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论