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

[suguoyao]

const sleep = (time) => {
  return new Promise(resolve => setTimeout(resolve, time))
}

sleep(1000).then(() => {
    // 这里写你的骚操作
})

[suguoyao]

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()

[lvtraveler]

4种方式：

//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

[zeroone001]

const sleep = (time) => {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, time);
    });  
};
sleep(1000).then(() => {
    console.log('sleep end');
});

大家在工作中是使用Promise最多吗

[jefferyE]

function sleep(time) {
  function* gen () {
     yield new Promise((resolve, reject) => {
         setTimeout(() => {
             resolve()
         }, time)
     })
   }
   return gen().next().value;
}
sleep(1000).then(() => {
   console.log('sleep end');
});

[Peizy]

function sleep1(time) {
   return new Promise(resolve => {
       setTimeout( resolve  , time);
     });
   }
function sleep2(time) {
  const start = Date.now();
  let stop;
  while (true) {
    stop = Date.now();
    if (stop - start > time) break;
  }
}

async function exec() {
  console.log("11111111111111111111111111111");
  await sleep1(1000);
  console.log("222222222222222222222222222222");
  sleep2(1000);
  console.log("333333333333333333333333333333");
}
exec();

[GeekQiaQia]

/**
   * 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;
      try{
           result= await sleep.sleepInPromise(delayTime);
      }catch(e){
          console.log(e);
      }
      console.log(result);
  }
  // 执行函数
  sleepAsync(1000);

[aeolusheath]

// 方法一

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)
}

[formattedzzz]

难道就不能不用定时器吗

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

[tgxhx]

在9012年的今天，其他都是异端，请使用async/await。

[te3]

//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"

[neofanfei]

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)
}

[coolliyong]

Javascript 模拟实现 Sleep 函数

这是一个伪命题，无法挂起 JS 进程，在 sleep 之后再继续，应该是写一个 sleep 的异步，通过异步实现

• 回调函数版本

//回调函数实现
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");
});

[chaijinsong]

看题目以为是实现类似于java的sleep

sleep(1000);
console.log('sleep之后做的事');

后来实在想不出来怎么实现，看了大家的答案，发现是我想多了，，确实没法实现这样的sleep

[nailfar]

function sleep(duration){
  startTime = Date.now();
  while ( Date.now() - startTime < duration );
}
sleep(3000);
console.info("sleeped 3sec!") 

[chenzesam]

4种方式：

//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