第 42 题：实现一个 sleep 函数，比如 sleep(1000) 意味着等待1000毫秒，可从 Promise、Generator、Async/Await 等角度实现

相关文章推荐
温文尔雅的圣诞树 · 清华大学教育研究院2023年教育博士专业学位 ...· 7 月前 ·
豪爽的枕头 · 长征六号首飞成功· 1 年前 ·
听话的小摩托 · 2022软科中国大学排名发布，长沙学院位列第 ...· 1 年前 ·
瘦瘦的鸡蛋面 · 贾连翔-清华大学出土文献研究与保护中心· 1 年前 ·
酒量小的凳子 · 失恋文案短句干净治愈_失恋文案短句干净治愈配 ...· 1 年前 ·
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
const sleep = (time) => {
  return new Promise(resolve => setTimeout(resolve, time))
sleep(1000).then(() => {
    // 这里写你的骚操作
  x-power, yzhclear, rocky-191, HiroTang, fi3ework, Vikingama, dongtaotao, dora1988, xzzdll, AzronChan, and 70 more reacted with thumbs up emoji
  jackcong, qq635030106, ItemLxL, l704863851, starry, qianhui119120, ChenCong6837, ihoneys, wulichenyang, ylinwind, and 3 more reacted with laugh emoji
  coveyz, ylinwind, and Benborba-github reacted with rocket emoji
    All reactions
          const sleep = (time) => {
  return new Promise(resolve => setTimeout(resolve, time))
async function sleepAsync() {
  console.log('fuck the code')
  await sleep(1000)
  console.log('fuck the code again')
sleepAsync()
  Moriarty02, suguoyao, yezongyang, LJJCherry, IronKinoko, hello-hyh, MoonCheung, zhujiasheng, csq529, Vikingama, and 49 more reacted with thumbs up emoji
  rjwx60, 1039355201, RIN2333, liandao0815, croatialu, houchaowei, HuangShaoNan, zhihaoYoung, bettermu, millertiga, and 20 more reacted with laugh emoji
  tiananxiao, 392237960, yuwangi, Straighty94, roooollo, eleven032, and 1322641861 reacted with rocket emoji
    All reactions
//Promise
const sleep = time => {
  return new Promise(resolve => setTimeout(resolve,time))
sleep(1000).then(()=>{
  console.log(1)
//Generator
function* sleepGenerator(time) {
  yield new Promise(function(resolve,reject){
    setTimeout(resolve,time);
sleepGenerator(1000).next().value.then(()=>{console.log(1)})
//async
function sleep(time) {
  return new Promise(resolve => setTimeout(resolve,time))
async function output() {
  let out = await sleep(1000);
  console.log(1);
  return out;
output();
//ES5
function sleep(callback,time) {
  if(typeof callback === 'function')
    setTimeout(callback,time)
function output(){
  console.log(1);
sleep(output,1000);
Promise | 自个写一个Promise | Generator
  JonathonChen, yygmind, bohancen, Ray-56, shifengdiy, jerryjiao, nomoreyou, DannySu09, kdashl, rjwx60, and 130 more reacted with thumbs up emoji
  BFjacky, ZengHaiTao1, brilliant-js, and everzi reacted with thumbs down emoji
  dousongting and oolongstack reacted with laugh emoji
  lizengguangxx, dousongting, and skadieyes reacted with hooray emoji
  lizengguangxx, dousongting, and Chanjunj99 reacted with heart emoji
  zhangwellyear, bulingTang, lizengguangxx, dousongting, Chocolate1999, and oolongstack reacted with rocket emoji
    All reactions
          const sleep = (time) => {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, time);
    });  
sleep(1000).then(() => {
    console.log('sleep end');
});
大家在工作中是使用Promise最多吗
function sleep(time) {
  function* gen () {
     yield new Promise((resolve,




    
 reject) => {
         setTimeout(() => {
             resolve()
         }, time)
   return gen().next().value;
sleep(1000).then(() => {
   console.log('sleep end');
});
  console.log("11111111111111111111111111111");
  await sleep1(1000);
  console.log("222222222222222222222222222222");
  sleep2(1000);
  console.log("333333333333333333333333333333");
exec();
   * DailyIssue42:
   42:实现一个 sleep 函数，
   比如 sleep(1000) 意味着等待1000毫秒，可从 Promise、Generator、Async/Await 等角度实现:
   // Promise:
   *https://blog.csdn.net/ImagineCode/article/details/81089107
  let sleep={
      // sleep  in promise;
      sleepInPromise:function(delayTime){
          return new Promise((resolve,reject)=>{
              setTimeout(function () {
                  resolve('do something in promise');
              },delayTime)
      sleepInGenerator:function *(delayTime){
          yield new Promise(function(resolve,reject){
              setTimeout(function(){
                  resolve('do in generator');
              },delayTime);
      sleepInES5:function(callback,delayTime){
          if( typeof callback==='function'){
              setTimeout(()=>{
                  callback();
              },delayTime);
  // 执行函数；
  function doSomeThing(){
      console.log('sleepInES5');
  sleep.sleepInES5(doSomeThing,1000);
  // 执行函数
  sleep.sleepInPromise(1000)
      .then(function (res) {
          console.log(res);
      .catch(function (err) {
          console.log(err);
  // 执行函数
  sleep.sleepInGenerator(1000).next().value
      .then(res=>{
          console.log(res);
  // async 函数声明；
   async function sleepAsync(delayTime){
      let result;
           result= await sleep.sleepInPromise(delayTime);
      }catch(e){
          console.log(e);
      console.log(result);
  // 执行函数
  sleepAsync(1000);
function sleep(time) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(time)
    }, time)
sleep(5000).then((time) => { console.log(`你睡了${time / 1000}s，然后做你的事情`) })
// 方法二
function async sleep2(time) {
  await sleep(time)
  // then do you thing
  console.log(`你睡了${time / 1000}s，然后做你的事情`)
  // async 函数返回的是一个promise对象
// 方法三

// 通过generator 还是返回一个promise，这个不知道具体的意义,这和返回一个普通的promise有区别么
function* sleep3(time) {
  yield new Promise(resolve => {
    setTimeout(resolve, time)
sleep3(5000).next().value.then(() => { console.log("睡了一会儿，然后做你做的事情")})
// 方法四

// 通过传统的setTimeout去做
function sleep4(func, time) {
  setTimeout(func, time)
function sleep (time) {
	var now = +Date.now()
	while (+Date.now() - now <= time) {}
	return
console.time(1)
sleep(2000)
console.log(123)
console.timeEnd(1)
console.time(1)
sleep(3000)
console.log(456)
console.timeEnd(1)
// 123
// 2000.244140625ms
// 456
// 3001.861328125ms
  formattedzzz, ahabhgk, liwangyong, pan-Z2l0aHVi, coldantLian, binghong-chen, and hanzehua666 reacted with thumbs up emoji
  WindyNanzi, glbb666, formattedzzz, justsoup, and Mixlong reacted with eyes emoji
    All reactions
  ahabhgk, wuzhenquan, formattedzzz, hcl-z, Chester-Chen, vanishcode, miyukoarc, willysliang, and hanzehua666 reacted with thumbs down emoji
  Esdiarap reacted with laugh emoji
    All reactions
          //1. Promise
const sleep1 = time => new Promise(resolve => setTimeout(resolve, time));
//2.without Promise
const sleep2 = time => ({
  then: cb => {
    setTimeout(cb, time);
});
//3. Generator, without Promise code
const sleep3 = time => {
  function* gen() {
    yield {
      then: cb => {
        setTimeout(cb, time);
  return gen().next().value;
//4. async/await without Promise code and Generator
const sleep4 = async time=>{
    await sleep2(time);
//call
(async ()=>{
    console.time('sleep1');
    await sleep1(1000);
    console.timeEnd('sleep1');
    console.time('sleep2');
    await sleep2(1000);
    console.timeEnd(




    
'sleep2');
    console.time('sleep3');
    await sleep3(1000);
    console.timeEnd('sleep3');
    console.time('sleep4');
    await sleep4(1000);
    console.timeEnd('sleep4');
})();
//typeof callback === "hell"
          function timeout (time) {
	return new Promise(function(res,rej){
		setTimeout(res,time)
async function sleep (time) {
	console.log(1)
	await timeout(time)
	console.log(2)
//回调函数实现
const sleepCb = (wait, cb) => setTimeout(cb, wait);
sleepCb(5500, () => {
  console.log("cb");
});
Promise
const sleep = wait => new Promise(resolve => setTimeout(resolve, wait));
sleep(1500).then(res => {
  // sleep 之后干的事
  console.log("sleep");
});
Generator 基于 promise
function* sleep2(wait) {
  yield new Promise(resolve => setTimeout(resolve, wait));
sleep2(2500)
  .next()
  .value.then(() => {
    // sleep 之后干的事
    console.log("sleep2");
  });
async/await 基于 promise
async function sleep3(wait) {
  await new Promise(resolve => {
    setTimeout(resolve, wait);
  });
sleep3(3500).then(() => {
  console.log("sleep3");
});
          function sleep(duration){
  startTime = Date.now();
  while ( Date.now() - startTime < duration );
sleep(3000);
console.info("sleeped 3sec!") 
//Promise
const sleep = time => {
  return new Promise(resolve => setTimeout(resolve,time))
sleep(1000).then(()=>{
  console.log(1)
//Generator
function* sleepGenerator(time) {
  yield new Promise(function(resolve,reject){
    setTimeout(resolve,time);
sleepGenerator(1000).next().value.then(()=>{console.log(1)})
//async
function sleep(time) {
  return new Promise(resolve => setTimeout(resolve,time))
async function output() {
  let out = await sleep(1000);
  console.log(1);
  return out;
output();
//ES5
function sleep(callback,time) {
  if(typeof callback === 'function')
    setTimeout(callback,time)
function output(){
  console.log(1);
sleep(output,1000);
Promise | 自个写一个Promise | Generator
其实都是 promise
          function sleep(wait) {
    let date = new Date().getTime();
    console.log('wait...')
    while ((new Date().getTime()) - date < wait) {




    

      continue;
          var sloop=function(time){
  return new Promise(function (resolve, reject) {
   setTimeout(function(){
     resolve(time)
   },time)
  sloop(1000).then(function (value) {
    console.log(value)
~~~ 虽然我是菜鸟，但我还是要记录一下我的答案
          let sleep = function (time){
    return new Promise((resolve,reject)=>{
       setTimeout(resolve,time)
sleep(1000).then(res=>{
    //do something
async function sleep(time) {
  await new Promise(resolve => {
    setTimeout(resolve, time)
 // do something
     ...
generator
function * sleep (time) {
    yield new Promise(resolve => {setTimeout(resolve, time)})
sleep(1000).next().value.then(() => {
    console.log('已经等待1s')
          promise:

const sleep1 = (time)=>{ return new Promise((resolve)=>{  setTimeout(resolve, time)  }) } sleep1(1000).then(()=>{ console.log(1) })

async/awiat:

const sleep1 = (time)=>{ return new Promise((resolve)=>{  setTimeout(resolve, time)  }) } async function output(){ await sleep1(1000) console.log(1) } output()

generator:
function* gen(time) {

yield new Promise(function(resolve,reject){

setTimeout(resolve,time);

gen(1000).next().value.then(()=>{console.log(1)})

          什么是sleep? 什么实现用Promise 或是 async await的方法和setTimeout有本质上的区别吗? sleep不应该用代码的方式 阻塞住进程,让他啥也干不了吗?
function sleep(time){
	let currentTime=Date.now();
	while(Date.now()-currentTime<=time){
	return;
console.log("aaa")
sleep(5000);
console.log("bbb")
sleep(1000);
console.log('sleep之后做的事');
后来实在想不出来怎么实现，看了大家的答案，发现是我想多了，，确实没法实现这样的sleep
用while一直循环，直到时间到退出循环那个是真sleep啊
const sleep = (time) => {
  return new Promise(resolve => setTimeout(resolve, time))
sleep(1000).then(() => {
    // 这里写你的骚操作
我为什么不直接settimeout呢，还要包一下
function sleep(time, callback){
	if(typeof callback === "function"){
		setTimeout(callback, time);
sleep(1000, function(){
	console.log("1");
Promise
const sleep = time => {
	return new Promise(resolve => setTimeout(resolve, time));
sleep(1000).then(() => console.log("1"));
Generator
function* sleepGenerator(time){
	yield new Promise(resolve => setTimeout(resolve, time));
const sleep = time => sleepGenerator(time).next().value;
sleep(1000).then(() => console.log("1"));
await/async（做了改动）
async function sleep(time){
	await new Promise(resolve => {
		setTimeout(resolve, time);
sleep(1000).then(() => console.log("1"));
async function sleep(time){
	await new Promise(resolve => {
		setTimeout(resolve, time);
	console.log("1");
sleep(1000);
function sleep (time) {
	var now = +Date.now()
	while (+Date.now() - now <= time) {}
	return
console.time(1)
sleep(2000)
console.log(123)
console.timeEnd(1)
console.time(1)
sleep(3000)
console.log(456)
console.timeEnd(1)
// 123
// 2000.244140625ms
// 456
// 3001.861328125ms
这种方式会阻塞代码的
          // Promise

function sleep(seconds) { return new Promise((resolve, reject) => { setTimeout(() => { resolve(); }, seconds); }) }
// generator

function* sleep(fn, seconds) { yield setTimeout(() => { fn.call(null); }, seconds); } sleep(demo,1000).next()
  function demo() { console.log('233'); }
// async await

async function sleep(fn, seconds) { await setTimeout(() => { fn.call(null); }, seconds); } sleep(demo,1000) 
不对之处,请指出一起讨论,谢谢
Promise：
function sleepForPromise(delay) {
	return new Promise(res => setTimeout(res, delay));
sleepForPromise(1000).then(con);
Generator：
function* sleepForGenerator(fn, delay) {
	yield setTimeout(() => {
		fn();
	}, delay);
var g = sleepForGenerator(con, 1000);
g.next();
Async/Await：
async function sleepForAsyncAwait(fn,delay) {
	await new Promise(res => setTimeout(res, delay));
	fn();
sleepForAsyncAwait(




    
con ,1000);
sleep(1000);
console.log('sleep之后做的事');
后来实在想不出来怎么实现，看了大家的答案，发现是我想多了，，确实没法实现这样的sleep
是啊，这题出的就有问题，直接setTimeout不好嘛，为啥还要加这么多花里胡哨的
const s = sleep2(1500);
s.next().value.then(() => console.log("sleep2"));
// Async/Await
async function sleep3(time) {
  await sleep1(time);
(async () => {
  await sleep3(2000);
  console.log("sleep3")
})()

          function sleep(ms) {
	return new Promise((resolve, reject)=>{
		setTimeout(()=>{
			resolve();
		}, ms)
// promise
sleep(1000).then(()=>{
	console.log('1000ms after');
// async / await
async function main() {
	await sleep(1000);
	console.log('1000ms after');
// generator
function* main() {
	yield sleep(1000);
main().next().value.then(()=>{
	console.log('1000ms after');
// generator co
function co (generator) {
	const gen = generator();
	function cb (param) {
		let tmp = gen.next(param);
		if (tmp.done) return Promise.resolve(tmp.value);
		tmp.value.then((ret)=>{
			cb(ret)
		});
	cb();
function* main() {
	yield sleep(1000);
	console.log('1000ms after');
	yield sleep(1000);
	console.log('2000ms after');
co(main);
// 回调
const sleep = (time, cb) => setTimeout(cb, time)
sleep(1000, () => console.log('开始搞事情~'))
// Promise
const sleep = (time) => {
  return new Promise((re, rj) => {
    setTimeout(re, time)
sleep(1000).then(() => console.log('开始搞事情~'))
// Generator
const gen = function* (time) {
  console.log('开始搞事情~')
const sleep = (gen, time) => {
  let g = gen()
  setTimeout(() => g.next(), time)
sleep(gen, 1000)
// async/await
const sleep= async (time) => {
  await new Promise((re, rj) => {
    setTimeout(re, time)
  console.log('开始搞事情~')
sleep(1000).then(() => console.log('或者这样搞事情~'))
          function sleep(interval) {
	return new Promise((resolve, reject) => {
		let timer
		const now = Date.now
		let startTime = now()
		let endTime = startTime
		const loop = () => {
			timer = window.requestAnimationFrame(loop)
			endTime = now()
			if (endTime - startTime >= interval) {
				window.cancelAnimationFrame(timer)
				resolve()
		timer = window.requestAnimationFrame(loop)
sleep(2000).then(() => {
	// ...
	console.log('hello world!')
可能会比setTimeout精确一点点
function sleep(callback,time) {

if(typeof callback === 'function')

setTimeout(callback,time)

function output(){

console.log(1);

sleep(output,1000);
* [Promise | 自个写一个Promise | Generator](https://blog.csdn.net/ImagineCode/article/details/81089107)
前几个方法都很棒，就这个ES5的咋感觉就是用setTimout实现了个setTimeout😂