首页 >> js开发 >> js代码JavaScript实现串行请求的示例代码
js代码JavaScript实现串行请求的示例代码
发布时间: 2021年1月13日 | 浏览:
| 分类:js开发
使用async和await使用async和await
var fn = async function(promiseArr) {
for(let i = 0,len = arr.length; i
currentPromise = (promiseArr[i] instanceOf Promise) ? promiseArr[i] : Promise.resolve(promiseArr[i]);
var result = await currentPromise;
console.log(result)
}
}
fn(arr)
var fn = async function(promiseArr) {
for(let i = 0,len = arr.length; i
currentPromise = (promiseArr[i] instanceOf Promise) ? promiseArr[i] : Promise.resolve(promiseArr[i]);
var result = await currentPromise;
console.log(result)
}
}
fn(arr)Promise实现Promise实现依照 promises 规范，一旦一个 promise 被创建，它就被执行了。如果then方法里返回的是一个promise对象，那么执行下一个then 的时候必定是在上一个then执行完之后执行。关键点在于then的时候再创建
var createPromise = function(time) {
return (resolve, reject)=> {
return new Promise((resolve, reject)=>{
setTimeout(()=>{
console.log('timein'+time)
resolve();
}, time*1000)
})
}
}
function serpromise(arr) {
arr.reduce((pre, next, index, carr)=>{
return pre.then(next)
}, Promise.resolve())
}
var arr=[createPromise(2),createPromise(1),createPromise(3),createPromise(4),createPromise(5)];
// 相当于
// Promise.resolve().then(createPromise(2)).then(createPromise(1))......
serpromise(arr)
var createPromise = function(time) {
return (resolve, reject)=> {
return new Promise((resolve, reject)=>{
setTimeout(()=>{
console.log('timein'+time)
resolve();
}, time*1000)
})
}
}
function serpromise(arr) {
arr.reduce((pre, next, index, carr)=>{
return pre.then(next)
}, Promise.resolve())
}
var arr=[createPromise(2),createPromise(1),createPromise(3),createPromise(4),createPromise(5)];
// 相当于
// Promise.resolve().then(createPromise(2)).then(createPromise(1))......
serpromise(arr)Array.prototype.reduce + async/await 版本Array.prototype.reduce + async/await 版本
const reduceAsync = ( arr ) => {
arr.reduce( async ( prev, curr ) => {
const { rep } = await prev;
const obj = await promise( curr, rep );
console.log( obj );
return obj;
}, Promise.resolve( {} ) );
};
const reduceAsync = ( arr ) => {
arr.reduce( async ( prev, curr ) => {
const { rep } = await prev;
const obj = await promise( curr, rep );
console.log( obj );
return obj;
}, Promise.resolve( {} ) );
};Array.prototype.reduce + Promise 版本Array.prototype.reduce + Promise 版本
const reducePromise = ( arr ) => {
arr.reduce( ( prev, curr ) => {
return prev.then( data => {
return new Promise( ( resolve, reject ) => {
promise( curr, data.rep ).then( res => {
console.log( res );
resolve( res );
} );
} );
} );
}, Promise.resolve( {} ) );
};
const reducePromise = ( arr ) => {
arr.reduce( ( prev, curr ) => {
return prev.then( data => {
return new Promise( ( resolve, reject ) => {
promise( curr, data.rep ).then( res => {
console.log( res );
resolve( res );
} );
} );
} );
}, Promise.resolve( {} ) );
};
# 执行结果
{ req: 'PM:04:49:08', rep: 'PM:04:49:11', item: 1 }
{ req: 'PM:04:49:11', rep: 'PM:04:49:14', item: 2 }
{ req: 'PM:04:49:14', rep: 'PM:04:49:17', item: 3 }
{ req: 'PM:04:49:17', rep: 'PM:04:49:20', item: 4 }
# 执行结果
{ req: 'PM:04:49:08', rep: 'PM:04:49:11', item: 1 }
{ req: 'PM:04:49:11', rep: 'PM:04:49:14', item: 2 }
{ req: 'PM:04:49:14', rep: 'PM:04:49:17', item: 3 }
{ req: 'PM:04:49:17', rep: 'PM:04:49:20', item: 4 }
Array.prototype.map + Promise 版本Array.prototype.map + Promise 版本
const mapPromise = ( arr ) => {
let temporary = Promise.resolve( {} );
arr.map( ( item, index ) => {
temporary = temporary.then( ( data ) => {
if (i !== 0) {
// 第一个初始promise
console.log( data );
}
return promise( item, data.rep );
} );
} );
// 最后一个promise
temporary.then( data => console.log( data ) );
};
const mapPromise = ( arr ) => {
let temporary = Promise.resolve( {} );
arr.map( ( item, index ) => {
temporary = temporary.then( ( data ) => {
if (i !== 0) {
// 第一个初始promise
console.log( data );
}
return promise( item, data.rep );
} );
} );
// 最后一个promise
temporary.then( data => console.log( data ) );
};用 map 遍历时，需要过滤初始promise的返回值，并且在遍历结束后，需手动执行最后以后一个promise，否则就会变成如下结果
# 执行结果
{}
{ req: 'PM:04:49:08', rep: 'PM:04:49:11', item: 1 }
{ req: 'PM:04:49:11', rep: 'PM:04:49:14', item: 2 }
{ req: 'PM:04:49:14', rep: 'PM:04:49:17', item: 3 }
# 执行结果
{}
{ req: 'PM:04:49:08', rep: 'PM:04:49:11', item: 1 }
{ req: 'PM:04:49:11', rep: 'PM:04:49:14', item: 2 }
{ req: 'PM:04:49:14', rep: 'PM:04:49:17', item: 3 }以上结果明显不是我们所需要的，但是需要手动过滤第一个promise和执行最后一个promise，会增项不必要的代码量和出错率 后将 mapPromise 修改如下，其原理和Array.prototype.reduce+Promise版本类似
const mapPromise = ( arr ) => {
let temporary = Promise.resolve( {} );
arr.map( ( item, index ) => {
temporary = temporary.then( ( data ) => {
// if (i !== 0) {
//
// 第一个promise
//
console.log( data );
// }
return new Promise( ( resolve, reject ) => {
promise( item, data.rep ).then( data => {
console.log( data );
resolve( data );
} );
} );
} );
} );
// 最后一个promise
// temporary.then( d => console.log( d ) );
};
const mapPromise = ( arr ) => {
let temporary = Promise.resolve( {} );
arr.map( ( item, index ) => {
temporary = temporary.then( ( data ) => {
// if (i !== 0) {
//
// 第一个promise
//
console.log( data );
// }
return new Promise( ( resolve, reject ) => {
promise( item, data.rep ).then( data => {
console.log( data );
resolve( data );
} );
} );
} );
} );
// 最后一个promise
// temporary.then( d => console.log( d ) );
};其他
其他Array.prototype.forEach、Array.prototype.filter、Array.prototype.some、Array.prototype.every等方法和Array.prototype.map类似，就不过多赘述以上就是JavaScript实现串行请求的示例代码的详细内容，关于JavaScript实现串行请求的资料请关注其它相关文章！
var fn = async function(promiseArr) {
for(let i = 0,len = arr.length; i
currentPromise = (promiseArr[i] instanceOf Promise) ? promiseArr[i] : Promise.resolve(promiseArr[i]);
var result = await currentPromise;
console.log(result)
}
}
fn(arr)
var fn = async function(promiseArr) {
for(let i = 0,len = arr.length; i
currentPromise = (promiseArr[i] instanceOf Promise) ? promiseArr[i] : Promise.resolve(promiseArr[i]);
var result = await currentPromise;
console.log(result)
}
}
fn(arr)Promise实现Promise实现依照 promises 规范，一旦一个 promise 被创建，它就被执行了。如果then方法里返回的是一个promise对象，那么执行下一个then 的时候必定是在上一个then执行完之后执行。关键点在于then的时候再创建
var createPromise = function(time) {
return (resolve, reject)=> {
return new Promise((resolve, reject)=>{
setTimeout(()=>{
console.log('timein'+time)
resolve();
}, time*1000)
})
}
}
function serpromise(arr) {
arr.reduce((pre, next, index, carr)=>{
return pre.then(next)
}, Promise.resolve())
}
var arr=[createPromise(2),createPromise(1),createPromise(3),createPromise(4),createPromise(5)];
// 相当于
// Promise.resolve().then(createPromise(2)).then(createPromise(1))......
serpromise(arr)
var createPromise = function(time) {
return (resolve, reject)=> {
return new Promise((resolve, reject)=>{
setTimeout(()=>{
console.log('timein'+time)
resolve();
}, time*1000)
})
}
}
function serpromise(arr) {
arr.reduce((pre, next, index, carr)=>{
return pre.then(next)
}, Promise.resolve())
}
var arr=[createPromise(2),createPromise(1),createPromise(3),createPromise(4),createPromise(5)];
// 相当于
// Promise.resolve().then(createPromise(2)).then(createPromise(1))......
serpromise(arr)Array.prototype.reduce + async/await 版本Array.prototype.reduce + async/await 版本
const reduceAsync = ( arr ) => {
arr.reduce( async ( prev, curr ) => {
const { rep } = await prev;
const obj = await promise( curr, rep );
console.log( obj );
return obj;
}, Promise.resolve( {} ) );
};
const reduceAsync = ( arr ) => {
arr.reduce( async ( prev, curr ) => {
const { rep } = await prev;
const obj = await promise( curr, rep );
console.log( obj );
return obj;
}, Promise.resolve( {} ) );
};Array.prototype.reduce + Promise 版本Array.prototype.reduce + Promise 版本
const reducePromise = ( arr ) => {
arr.reduce( ( prev, curr ) => {
return prev.then( data => {
return new Promise( ( resolve, reject ) => {
promise( curr, data.rep ).then( res => {
console.log( res );
resolve( res );
} );
} );
} );
}, Promise.resolve( {} ) );
};
const reducePromise = ( arr ) => {
arr.reduce( ( prev, curr ) => {
return prev.then( data => {
return new Promise( ( resolve, reject ) => {
promise( curr, data.rep ).then( res => {
console.log( res );
resolve( res );
} );
} );
} );
}, Promise.resolve( {} ) );
};
# 执行结果
{ req: 'PM:04:49:08', rep: 'PM:04:49:11', item: 1 }
{ req: 'PM:04:49:11', rep: 'PM:04:49:14', item: 2 }
{ req: 'PM:04:49:14', rep: 'PM:04:49:17', item: 3 }
{ req: 'PM:04:49:17', rep: 'PM:04:49:20', item: 4 }
# 执行结果
{ req: 'PM:04:49:08', rep: 'PM:04:49:11', item: 1 }
{ req: 'PM:04:49:11', rep: 'PM:04:49:14', item: 2 }
{ req: 'PM:04:49:14', rep: 'PM:04:49:17', item: 3 }
{ req: 'PM:04:49:17', rep: 'PM:04:49:20', item: 4 }
Array.prototype.map + Promise 版本Array.prototype.map + Promise 版本
const mapPromise = ( arr ) => {
let temporary = Promise.resolve( {} );
arr.map( ( item, index ) => {
temporary = temporary.then( ( data ) => {
if (i !== 0) {
// 第一个初始promise
console.log( data );
}
return promise( item, data.rep );
} );
} );
// 最后一个promise
temporary.then( data => console.log( data ) );
};
const mapPromise = ( arr ) => {
let temporary = Promise.resolve( {} );
arr.map( ( item, index ) => {
temporary = temporary.then( ( data ) => {
if (i !== 0) {
// 第一个初始promise
console.log( data );
}
return promise( item, data.rep );
} );
} );
// 最后一个promise
temporary.then( data => console.log( data ) );
};用 map 遍历时，需要过滤初始promise的返回值，并且在遍历结束后，需手动执行最后以后一个promise，否则就会变成如下结果
# 执行结果
{}
{ req: 'PM:04:49:08', rep: 'PM:04:49:11', item: 1 }
{ req: 'PM:04:49:11', rep: 'PM:04:49:14', item: 2 }
{ req: 'PM:04:49:14', rep: 'PM:04:49:17', item: 3 }
# 执行结果
{}
{ req: 'PM:04:49:08', rep: 'PM:04:49:11', item: 1 }
{ req: 'PM:04:49:11', rep: 'PM:04:49:14', item: 2 }
{ req: 'PM:04:49:14', rep: 'PM:04:49:17', item: 3 }以上结果明显不是我们所需要的，但是需要手动过滤第一个promise和执行最后一个promise，会增项不必要的代码量和出错率 后将 mapPromise 修改如下，其原理和Array.prototype.reduce+Promise版本类似
const mapPromise = ( arr ) => {
let temporary = Promise.resolve( {} );
arr.map( ( item, index ) => {
temporary = temporary.then( ( data ) => {
// if (i !== 0) {
//
// 第一个promise
//
console.log( data );
// }
return new Promise( ( resolve, reject ) => {
promise( item, data.rep ).then( data => {
console.log( data );
resolve( data );
} );
} );
} );
} );
// 最后一个promise
// temporary.then( d => console.log( d ) );
};
const mapPromise = ( arr ) => {
let temporary = Promise.resolve( {} );
arr.map( ( item, index ) => {
temporary = temporary.then( ( data ) => {
// if (i !== 0) {
//
// 第一个promise
//
console.log( data );
// }
return new Promise( ( resolve, reject ) => {
promise( item, data.rep ).then( data => {
console.log( data );
resolve( data );
} );
} );
} );
} );
// 最后一个promise
// temporary.then( d => console.log( d ) );
};其他
其他Array.prototype.forEach、Array.prototype.filter、Array.prototype.some、Array.prototype.every等方法和Array.prototype.map类似，就不过多赘述以上就是JavaScript实现串行请求的示例代码的详细内容，关于JavaScript实现串行请求的资料请关注其它相关文章！
相关文章:
- jsvue 验证两次输入的密码是否一致的方法示例js大全
- js微信小程序对图片进行canvas压缩的方法示例详解js大全
- jsPHP 502bad gateway原因及解决方案js大全
- js详解Java中String JSONObject JSONArray List<实体类>转换js大全
- jsvue 获取url里参数的两种方法小结js大全
- jsVant Weapp组件踩坑:picker的初始赋值解决js大全
- JavaScriptjs前端传json后台接收‘‘被转为quot的问题解决
- jsvue 获取url参数、get参数返回数组的操作js大全
- JavaScriptjs禁止查看源文件屏蔽Ctrl+u/s、F12、右键等兼容IE火狐chrome
- jsJSONObject与JSONArray使用方法解析js大全
刚刚发布热门点击发布时间
- [02/23]chrome 浏览器插件外包:定制您的专属Chrome插件！专业外包团队助您轻松实现创意！
- [02/23]专业电脑浏览器插件外包服务，助力企业数字化转型！
- [02/23]解放双手，效率翻倍！Chrome插件前端自动化外包服务，助您轻松实现业务流程自动化！
- [02/23]定制您的专属Chrome插件！专业外包团队助您轻松实现创意！
- [02/23]Chrome插件外包：为你的浏览器赋能，开启无限可能
- [09/06]node js 调用kimi 接口批量生成网页
- [07/21]Node.js数据采集外包服务-数据采集专家-用Node.js释放数据的力量
- [07/21]专业前端开发-从PSD到响应式网页的无缝转换
- [07/18]专业Chrome插件开发- 为您的业务插上翅膀
- [07/18]智能数据抓取 -浏览器插件接口抓取服务外包
- [07/17]vue3 setup 监听url变化
- [07/17]git 回滚到指定 commit
- [07/15]浏览器插件使用场景:浏览器插件在数据抓取方面的使用场景非常广泛
- [07/15]Chrome 浏览器插件的使用场景
- [07/15]Chrome 浏览器插件开发的特点
