Skip to main content

【async 模块】

1、series(tasks,[callback])​

多个函数从上到下依次执行,相互之间没有数据交互

var task1 = function (callback) {
  console.log('task1')
  callback(null, 'task1')
}

var task2 = function (callback) {
  console.log('task2')
  callback(null, 'task2')
}

var task3 = function (callback) {
  console.log('task3')
  callback(null, 'task3')
}

async.series([task1, task2, task3], function (err, result) {
  console.log('series')
  if (err) {
    console.log(err)
  }
  console.log(result)
})

如果中途发生错误,则将错误传递到回调函数,并停止执行后面的函数

2、parallel(tasks,[callback])​

多个函数并行执行,不会等待其他函数

var task1 = function (callback) {
  console.log('task1')
  setTimeout(function () {
    callback(null, 'task1')
  }, 5000)
}

var task2 = function (callback) {
  console.log('task2')

  setTimeout(function () {
    callback(null, 'task2')
  }, 1000)
}

var task3 = function (callback) {
  console.log('task3')
  setTimeout(function () {
    callback(null, 'task3')
  }, 3000)
}
console.time('parallel方法')
async.parallel([task1, task2, task3], function (err, result) {
  console.log('parallel')

  if (err) {
    console.log(err)
  }
  console.log(result)
  console.timeEnd('parallel方法')
})

3 个函数分别延迟 5000ms,1000ms,3000ms 结果 5000ms 就执行完毕.

如果中途出错,则立即将 err 和值传到最终的回调函数,其他未执行完毕的函数将不再执行,但是要占一个位置

3.waterfall(tasks,[callback]) :瀑布流​

依次执行,前一个函数的输出为后一个函数的输入

var task1 = function (callback) {
  console.log('task1')
  callback(null, '11')
}

var task2 = function (q, callback) {
  console.log('task2')
  console.log('task1函数传入的值: ' + q)
  callback(null, '22')
}

var task3 = function (q, callback) {
  console.log('task3')
  console.log('task2函数传入的值: ' + q)
  callback(null, '33')
}
console.time('waterfall方法')
async.waterfall([task1, task2, task3], function (err, result) {
  console.log('waterfall')

  if (err) {
    console.log(err)
  }

  console.log('result : ' + result)
  console.timeEnd('waterfall方法')
})

如果中途出现错误,后面的函数将不在执行,之前执行的结果和错误信息将直接传到最终的回调函数

4.parallelLimit(tasks,limit,[callback])​

和 parallel 类似,只是 limit 参数限制了同时并发执行的个数,不再是无限并发

var task1 = function (callback) {
  console.log('task1')
  setTimeout(function () {
    callback(null, 'task1')
  }, 5000)
}

var task2 = function (callback) {
  console.log('task2')

  setTimeout(function () {
    callback(null, 'task2')
  }, 3000)
}

var task3 = function (callback) {
  console.log('task3')
  setTimeout(function () {
    callback(null, 'task3')
  }, 4000)
}
console.time('parallelLimit方法')
async.parallelLimit([task1, task2, task3], 2, function (err, result) {
  console.log('parallelLimit')

  if (err) {
    console.log(err)
  }

  console.log(result)
  console.timeEnd('parallelLimit方法')
})

三个函数分别是延迟 5000ms,3000ms,4000ms 结果执行时间为什么是 7000ms 呢

因为首先执行函数 1 和 2,

3 秒后函数 2 执行完毕,这个时候函数 3 开始执行,

5 秒后函数 1 执行完毕,函数 3 还有 2 秒,

7 秒后函数 3 执行完毕.

5.auto(tasks,[callback])​

多个函数有数据交互,有的并行,有的依次执行

console.time('auto方法')
async.auto(
  {
    task1: function (callback) {
      console.log('tsak1')
      setTimeout(function () {
        callback(null, 'task11', 'task12')
      }, 2000)
    },
    task2: function (callback) {
      console.log('task2')
      setTimeout(function () {
        callback(null, 'task2')
      }, 3000)
    },
    task3: [
      'task1',
      'task2',
      function (callback, results) {
        console.log('task3')
        console.log('task1和task2运行结果: ', results)
        setTimeout(function () {
          callback(null, 'task3')
        }, 1000)
      },
    ],
    task4: [
      'task3',
      function (callback, results) {
        console.log('task4')
        console.log('task1,task2,task3运行结果: ', results)
        setTimeout(function () {
          callback(null, { task41: results.task3, task42: 'task42' })
        }, 1000)
      },
    ],
  },
  function (err, results) {
    console.log('err :', err)
    console.log('最终results : ', results)
    console.timeEnd('auto方法')
  }
)

5 秒运行完毕,

函数 1 和 2 并行,3 秒执行完毕,

函数 1 和 2 执行完毕后,函数 3,4 依次执行共计 5 秒.

6.whilst(test,fn,[callback])​

相当于 while 循环,fn 函数里不管是同步还是异步都会执行完上一次循环才会执行下一次循环,对异步循环很有帮助,

test 是条件,为 true 时执行 fn 里的方法

var datalist = [
  { number: 10 },
  { number: 20 },
  { number: 30 },
  { number: 40 },
  { number: 50 },
]
var count = 0

var test = function () {
  return count < datalist.length
}

var fn = function (callback) {
  console.log(datalist[count].number)
  setTimeout(function () {
    count++
    callback()
  }, 1000)
}

async.whilst(test, fn, function (err) {
  if (err) {
    console.log(err)
  }
  console.log('whilst结束')
})

7.doWhilst​

和 whilst 类似,和 do-while 一个意思,首先执行一次 fn,再判断,和 whilst 相比它把 fn 和 test 位置交换了而已.

until 和 whilst 相反,当 test 判断为 false 的时候执行 fn 里的方法,为 true 时跳出,

doUntil 与 doWhilst 相反.

8.forever(fn,errback)​

forever 就是无限循环了.只有当中途出现错误的时候才会停止

var count = 0
async.forever(
  function (callback) {
    console.log(count)
    count++

    if (count > 10) {
      callback('errmessage')
      return
    }

    setTimeout(function () {
      callback()
    }, 1000)
  },
  function (err) {
    console.log(err)
  }
)

9.compose(fn1,fn2,fn3...)​

这个方法会创建一个异步的集合函数,执行的顺序是倒序.前一个 fn 的输出是后一个 fn 的输入.有数据交互

var task1 = function (m, callback) {
  console.log('task1')
  setTimeout(function () {
    callback(null, m * 2)
  }, 1000)
}

var task2 = function (m, callback) {
  console.log('task2')

  setTimeout(function () {
    callback(null, m + 3)
  }, 1000)
}

var task3 = function (m, callback) {
  console.log('task3')
  setTimeout(function () {
    callback(null, m * 5)
  }, 1000)
}
console.time('compose方法')

var com = async.compose(task3, task2, task1)

com(2, function (err, result) {
  if (err) {
    console.log(err)
  }
  console.log(result)
  console.timeEnd('compose方法')
})

相当于 var m=2; (m2+3)5 =35;