JS 通过 Promise 实现延时执行，支持链式调用

• 延时执行
• • sleep 版本一
  • • 同步执行
    • 异步方式
  • sleep 版本二
• 支持链式调用
• • 版本一
  • 版本二
• 参考资料

延时执行

定义sleep函数

sleep 版本一

/*** 定义延时函数* delaytime 延时时长，单位毫秒*/
var sleep = (delaytime = 1000) => {return new Promise(resolve => setTimeout(resolve, delaytime))
}

(async () => {await sleep(000);cole.log(());
})();

/*** 定义延时函数* delaytime 延时时长，单位毫秒。默认1000*/
var sleep = (delaytime = 1000) => {return new Promise(resolve => setTimeout(resolve, delaytime))
}
/*** 遍历数据，调用 foo 逐个处理。* arr         待遍历的数组* callback    处理数组元素的业务逻辑。默认输出日志* delaytime   延时时长*/
async function delayDo(arr, callback = data=>cole.log(`数据：${data}`), delaytime) {var len = arr.length;for (let i = 0; i <len  ; i) {        await sleep(delaytime);callback(arr[i]);}
};
// 遍历数组，间隔 1 秒处理一个元素。
function main(){var arr = [1,2,,	呵呵哒！	,5,6,7,8,9];delayDo(arr);
}
main();

sleep(000).then(() => {  cole.log(());
});

var sleep = (delaytime) => {return new Promise(resolve => setTimeout(resolve, delaytime))
}
sleep(1000).then(() => {  cole.log(());sleep(1000).then(() => {  cole.log(());sleep(1000).then(() => {  cole.log(());});});
});

sleep 版本二

/*** 睡眠。并每秒执行一次 callback，最终执行一次 final* * @param {number}    times    睡眠秒数（默认2）* @param {function}  callback 回调函数* @param {function}  final    扫尾方法（所有循环完成，最后执行一次它扫尾）*/
async function sleep(times = 2, callback = ()=>{}, final = ()=>{}) {for (let i = times; i > 0; i--) {callback(i);await new Promise(resolve => setTimeout(resolve, 1000));}final(times);
}

test

(async()=>{cole.log((new Date()).toLocaleString());await sleep(, i=>cole.log(`起床倒计时：${i}`), t=>cole.log(`睡了${t}秒，好饱啊。准备起床。`));cole.log((new Date()).toLocaleString());
})();

202//0 上午9:41:4
起床倒计时：
起床倒计时：2
起床倒计时：1
睡了秒，好饱啊。准备起床。
202//0 上午9:41:46

支持链式调用

版本一

今天需要按顺序执行一组方法，并支持结果向后传递。
照着别人的代码改了一下：

class Jdelay {ctructor() {this.params = []; // 用来缓存链式调用的结果进行传递this.queue = Promise.resolve();}/*** 睡眠指定时间。默认1秒*/sleep(time=1) {this.queue = this.(() => {return new Promise(res => {setTimeout(res, time * 1000)})})return this;}/*** 执行传入的方法*/do(callback) {this.queue = this.(() => {if(typeof callback == 	function	){// 将上一次执行结果作为参数传入。将本次执行结果保存备用。 this.params.push(callback(this.params.pop()));}else{cole.info(	请传入回调函数，当前是个：	, typeof callback);}})return this;}
}/*** 被调用的方法*/
function foo(data){var now = (new Date()).toLocaleString().match(/(\d)/g).map((d,i)=>d[	-	,	-	,	 	,	:	,	:	,		][i]).join(		);cole.info(now, 	前一个方法结果：	, data); return now  	某些事情发生了！	;
}// 链式调用次
new Jdelay().sleep().do(foo).sleep().do(foo).sleep().do(foo);

输出结果

2021-1-6 8:02:1 前一个方法结果： undefined
2021-1-6 8:02:4 前一个方法结果： 2021-1-6 8:02:1某些事情发生了！
2021-1-6 8:02:7 前一个方法结果： 2021-1-6 8:02:4某些事情发生了！

版本二

class JerryQueue {ctructor() {this.queue = [];}addSync(fn) {this.queue.push(param => Promise.resolve().then(()=>fn(param)));return this;}addAsync(fn) {this.queue.push(fn);return this;}sleep(times = 2, callback = i=>cole.log(`CD${i}...`), final = t=>cole.log(`睡眠${t}秒，结束！`)) {this.queue.push(async param => {for (let i = times; i > 0; i--) {callback(i);await new Promise(resolve => setTimeout(resolve, 1000));}final(times);return param;});return this;}async execute(param) {if(this.queue.length == 0)cole.log(`当前队列为空！`);let stack = param;for (ct fn of this.queue) {stack = await fn(stack);}return stack ;}
}

var executor = new JerryQueue();
var result = await executor.addSync(function(data){ cole.log(	1 同步操作	, data); return data1; })
.sleep()
.addAsync(async function(data){cole.log(	2 异步操作	, data); await fetch(		).then(cole.log);return data1;
})
.sleep()
.addSync(function(data){ cole.log(	 同步操作	, data); return data1; })
.sleep()
.execute(100); cole.log(	最终结果：	, result);

参考资料

用Promise实现：带延时功能的链式调用