最近在一个项目中，遇到这么一个需求：一个页面中，大概有四五个元素需要按一定次序依次进场，setTimeout来实现吧，仔细一想，那样的代码实在是写不下去，大概是这样的：

setTimeout(()=>{
    this.setState({view1Visible: true})
    setTimeout(()=>{
        this.setState({view2Visible: true})
        setTimeout(()=>{
            this.setState({view3Visible: true})
            setTimeout(()=>{
                // 没完没了的setTimout...
            },500)
        },500)
    },500)
},100)

 明显的回调地狱，对症下药，用Promise来简单封装一下：

const timer=(task,ms)=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{
            task && task()
            resolve()
        },ms)
    })
}

 然后之前的代码大致可以写成这样：

timer(()=>this.setState({view1Visible: true}),100)
    .then(()=>timer(()=>this.setState({view2Visible: true}),500))
    .then(()=>timer(()=>this.setState({view3Visible: true}),500))
    .then(()=>timer(()=>this.setState({view4Visible: true}),500))

 到这里基本已经满足我的需求了，如果对不喜欢用then，或者只是对它有意见，也可以用async/await来改写一下：

async layout(){
    await timer(()=>this.setState({view1Visible: true}),100)
    await timer(()=>this.setState({view2Visible: true}),500)
    await timer(()=>this.setState({view3Visible: true}),500)
    await timer(()=>this.setState({view4Visible: true}),500)
}

 写到这里，已经足够了，不过我个人对timer的两个参数不喜欢，而且我更喜欢写链式风格的代码，理想的代码是这样的：

new Schedule()
    .delay(100).task(()=>this.setState({view1Visible:true}))
    .task(()=>this.setState({view1Visible:true}))
    .task(()=>this.setState({view2Visible:true}))
    .task(()=>this.setState({view3Visible:true}))

 首先task和delay分别用两个方法传参，语义化嘛，一眼就能看出这个参数指的是什么；然后delay要能够复用，很多情下我们任务之间的间隔是相等的，就不用每次都传了。

 实现方法嘛，在Schedule类中，要有个promise来处理这些任务，然后需要一个变量来保存delay，来达到复用的目的，然后就是delay和task两个方法，都返回this来实现链式调用。最后把上面那个timer方法拿过来，解决回调地狱。先看看最后的代码吧：

export default class Schedule{
  constructor(){
    this._delay=0
    this.p = null
  }
  timer(task,ms){
    return new Promise((resolve,reject)=>{
      setTimeout(()=>{
        task && task()
        resolve()
      },ms)
    })
  }
  task(task){
    const {_delay:delay,timer,p}=this
    this.p = p ?p.then(()=>timer(task,delay)) :timer(task,delay)
    return this
  }
  delay(_delay){
    this._delay = _delay
    return this
  }
}

 也没啥特别的，要注意的一点是，第一次调用task的时候，p为空，直接给他赋值即可。或者你一可以给p一个初始的promise，之后就不用考虑是否为空了，直接p.then()就可以了，需要先用一个临时变量把delay缓存起来，否则最后再执行到当前task的时候，delay很有可能取到的是后面赋的值。

 对于一般的需求，现在这个Schedule应该完全能够搞定，可能你想这样做：先把任务队列定义好，到了特定的时机再去触发它执行，那我们要怎么做呢？

 其实也不难，每次调用task的时候，不放到promise里面，而是把task和当前delay先保存到一个数组里面，最后再写一个方法，在调用的时候遍历这个数组，把他们放到promise里面去，直接上代码好了：

export default class Schedule{
  constructor(){
    this._delay=0
    this.tasks=[]
  }
  timer(task,ms){
    return new Promise((resolve,reject)=>{
      setTimeout(()=>{
        task && task()
        resolve()
      },ms)
    })
  }
  task(task){
    this.tasks.push({task,delay:this._delay})
    return this
  }
  delay(_delay){
    this._delay = _delay
    return this
  }
  exec(){
    this.tasks.length>0 && this.tasks.reduce(
      (p,t)=>p.then(()=>this.timer(t.task,t.delay)),
      Promise.resolve()
    )
  }
}

 一个小小的技巧就是用数组的reduce方法来把这些task依次放到promise中，在reduce的第二个参数传入一个空的Promise，就避免了判断是否有初始Promise的问题。用的时候需要手动去调用exec方法，整个队列才回开始执行：

new Schedule()
    .delay(100).task(()=>this.setState({view1Visible:true}))
    .task(()=>this.setState({view1Visible:true}))
    .task(()=>this.setState({view2Visible:true}))
    .task(()=>this.setState({view3Visible:true}))
    .exec() // 可以在任何你需要的时候调用

 需要介绍的就这些了，最后其实有不少可以改进的地方，比如上面说的两种情况，完全可以写在一起，构造方法中传个参数来决定是否是需要延迟执行的队列。又或者引入cron表达式，来决定在特定的时间点执行任务……当然这些不在本文讨论的范畴，感兴趣的朋友可以去试试。