LazyMan 面试题

课件：两个面试题.pptx

LazyMan 面试题

• 技巧一：先定框架

LazyMan = ()=>{
  return {
    sleep(){},
    eat(){},
    sleepFirst(){}
  }
}

• 技巧二：走一步看一步

> LazyMan("Hank")
你好，我是 Hank

LazyMan = (name)=>{
  console.log(`你好，我是 ${name}`)
  return {
    sleep(){},
    eat(){},
    sleepFirst(){}
  }
}

• 技巧三：疯狂打脸（只能完成前三个）

链式调用：函数内声明对象包裹子函数并返回自身（同封装 jQuery 方法）

> LazyMan("Hank").sleep(10).eat("lunch")
你好，我是 Hank
（沉默十秒）
我醒了，我刚睡了 10 秒
吃午餐

LazyMan = (name)=>{
  console.log(`你好，我是 ${name}`)
  var api = {
    sleep(n){
      var t1 = Date.now()
      while(Date.now() - t1 < 10000){}
      console.log(`我醒了，我刚睡了${n}秒`)
      return api
    },
    eat(type){
      console.log( type === 'lunch' ?'吃午餐':'吃晚餐')
      return api
    },
    sleepFirst(){ return api }
  }
  return api
}

• 技巧四：队列 + 回调 （先入先出可插队）

  • 思路
    • 所有 API 都只是往 queue 里添加函数
    • 所有 API 都执行完了，再从 queue 里面抽出函数执行
    • 每个函数执行完了之后，调用 next 执行下一个函数

简易版

//为了实现先进先出（队列）的原理：所有调用都必须是任务，所有任务都必须放入队列，函数调用都必须从队列中执行
LazyMan = (name)=>{
  var queue = [] //队列：存放任务
  const task = () => {console.log(`你好，我是${name}`)}//任务1
  queue.push(task) //插入队伍
  const next = ()=>{ //执行下一任务
     const first = queue.shift()//为了执行先进先出原则（弹出任务）
     first && first()
  }
  var api = { //为了链式调用
    sleepFirst(n){ //后声明先执行（插队）

      const task = ()=> {//延迟任务
        setTimeout(()=>{
            console.log(`我醒了，我刚睡了${n}秒`);
            next()
        },n*1000)
      }

      queue.unshift(task)//为了实现后声明先执行（插队），不用push使用unshift向上插入
      return api
    }
  }
  setTimeout(()=>{ next() })//首次执行函数
  return api
}

LazyMan('Frank').sleepFirst(2)

完成版

LazyMan = (name)=>{
  var queue = []
  const task = () => {console.log(`你好，我是${name}`); next()}
  queue.push(task)
  const next = ()=>{ const first = queue.shift(); first && first() }
  var api = {
    sleep(n){
      const task = ()=> {
        setTimeout(()=>{console.log(`我醒了，我刚睡了${n}秒`); next()},n*1000)
      }
      queue.push(task)
      return api
    },
    eat(type){
      const task = ()=> {console.log(type === 'lunch' ? '吃午餐':'吃晚餐'); next()}
      queue.push(task)
      return api
    },
    sleepFirst(n){
      const task = ()=> {
        setTimeout(()=>{console.log(`我醒了，我刚睡了${n}秒`); next()},n*1000)
      }
      queue.unshift(task)
      return api
    }
  }
  setTimeout(()=>{ next() })
  return api
}

LazyMan('Frank').sleepFirst(5).eat('supper')