Node.js编程之异步

异步操作

Node采用V8引擎处理JavaScript脚本，最大特点就是单线程运行，一次只能运行一个任务。这导致Node大量采用异步操作（asynchronous opertion），即任务不是马上执行，而是插在任务队列的尾部，等到前面的任务运行完后再执行。

由于这种特性，某一个任务的后续操作，往往采用回调函数（callback）的形式进行定义。

var isTrue = function(value, callback) {
  if (value === true) {
    callback(null, "Value was true.");
  }
  else {
    callback(new Error("Value is not true!"));
  }
}

上面代码就把进一步的处理，交给回调函数callback。

如果没有发生错误，回调函数的第一个参数就传入null。这种写法有一个很大的好处，就是说只要判断回调函数的第一个参数，就知道有没有出错，如果不是null，就肯定出错了。另外，这样还可以层层传递错误。

Node约定，如果某个函数需要回调函数作为参数，则回调函数是最后一个参数。另外，回调函数本身的第一个参数，约定为上一步传入的错误对象。

var callback = function (error, value) {
  if (error) {
    return console.log(error);
  }
  console.log(value);
}

异步开发的难题

在创建异步程序时，你必须密切关注程序的执行流程，并盯牢程序状态：事件轮训的条件、程序变量以及其他随着程序逻辑执行而发生变化的资源。如果不小心，程序的变量也可能会出现意想不到的变化。下面这段代码是一段因为执行顺序而导致混乱的异步代码。

如果例子中的代码能够同步执行，可以肯定输出的应该是"The color is blue",可这个例子是异步的，在console.log执行前color的值还在变化，所以输出是"The color is green".

function asyncFunction(callback) {
  setTimeout(callback, 200)  
}

var color = 'blue'

asyncFunction(function(){
  console.log('The color is ' + color)  // The color is green.(这个最后执行(200ms之后))
})

color = 'green'

用JavaScript闭包可以"冻结"color的值，在如下代码中，对asyncFunction的调用被封装到了一个以color为参数的匿名函数里，这样就可以马上执行这个匿名函数，把当前的color的值传给它。而color变成了匿名函数的参数，也就是这个匿名函数内部的本地变量，当匿名函数外面的color值发生变化时，本地版的color不会受影响。

function asyncFunction(callback) {
  setTimeout(callback, 200)  
}

var color = 'blue'

(function(color) {
  asyncFunction(function(){
    console.log('The color is ' + color)  // The color is blue.
  })
})(color);

color = 'green 

在Node开发中需要用到很多JavaScript编程技巧，这只是其中之一。

现在我们知道怎么用闭包控制程序的状态了，接下来我们看看怎么让异步逻辑顺序执行。

异步流程的顺序化

让一组异步任务顺序执行的概念被Node社区称为流程控制。这种控制分为两类：串行和并行，

什么时候使用串行流程控制

可以使用回调让几个异步任务按顺序执行，但如果任务很多，必须组织一下，否则会陷入回调地狱。

下面这段代码就是用回调让任务顺序执行的。

setTimeout(function(){
   console.log('I execute first.')
   setTimeout(function(){
      console.log('I execute next.')
      setTimeout(function(){
         console.log('I execute last.')
      }, 100)
   }, 500)
}, 1000)    

此外，也可以用Promise这样的流程控制工具来执行这些代码

 promise.then(function(result){
        // dosomething
        return result;
    }).then(function(result) {
        // dosomething
        return promise1;   
    }).then(function(result) {
        // dosomething
    }).catch(function(ex) {
        console.log(ex);
    }).finally(function(){
        console.log("final");
    });

接着我们通过例子，自己来实现串行化流程控制和并行化流程控制

实现串行化流程控制

为了用串行化流程控制让几个异步任务按顺序执行，需要先把这些任务按预期的执行顺序放到一个数组中。如下图所示：

下面是一个串行化流程控制的demo，实现了从随机选择的RSS预定源中获取一篇文章的标题和URL，源文件

// 在一个简单的程序中实现串行化流程控制
var fs = require('fs')
var request = require('request') // 用它获取RSS数据
var htmlparser = require('htmlparser') // 把原始的RSS数据转换成JavaScript结构
var configFilename = './rss_feeds.txt'

function checkForRSSFile() { // 任务1：确保包含RSS预定源URL列表的文件存在
  fs.exists(configFilename, function(exists) {
    if (!exists) {
      return next(new Error('Missing RSS file: ' + configFilename)) // 只要有错误就尽早返回
    }
    next(null, configFilename)
  })
}

function readRSSFile (configFilename) { // 任务2：读取并解析包含预定源URL的文件
  fs.readFile(configFilename, function(err, feedList) {
    if (err) {
      return next(err)
    }

    feedList = feedList                          // 讲预定源URL列表转换成字符串，然后分隔成一个数组
                 .toString()
                 .replace(/^\s+|\s+$/g, '')
                 .split("\n");
    var random = Math.floor(Math.random()*feedList.length)  // 从预定源URL数组中随机选择一个预定源URL
    next(null, feedList[random])
  })
}
// console.log('进入')

function downloadRSSFeed(feedUrl) {  // 任务3：向选定的预定源发送HTTP请求以获取数据
  request({uri: feedUrl}, function(err, res, body) {
    if (err) {
      return next(err)
    }
    if (res.statusCode != 200) {
      return next(new Error('Abnormal response status code'))
    }

    next(null, body)
  })
}

function parseRSSFeed(rss) {  // 任务4：将预定源数据解析到一个条目数组中
  var handler = new htmlparser.RssHandler()
  var parser = new htmlparser.Parser(handler)
  parser.parseComplete(rss)
  if (!handler.dom.items.length) {
    return next(new Error('No RSS items found'))
  }
  console.log(handler.dom.items)
  var item = handler.dom.items.shift()
  console.log(item.title)
  console.log(item.link)
}
var tasks = [ checkForRSSFile,      // 把所有要做的任务按执行顺序添加到一个数组中
              readRSSFile,
              downloadRSSFeed,
              parseRSSFeed ]

function next(err, result) {
  if (err) {
    throw err
  }

  var currentTask = tasks.shift()   // 从任务数组中取出下个任务

  if (currentTask) {
    currentTask(result)   // 执行当前任务
  }
}

next()  // 开始任务的串行化执行

如本例所示，串行化流程控制本质上是在需要时让回调进场，而不是简单地把它们嵌套起来

实现并行化流程控制

为了让异步任务并行执行，仍然是要把任务放到数组中，但任务的存放顺序无关紧要。每个任务都应该调用处理器函数增加已完成任务的计数值。当所有任务都完成后，处理器函数应该执行后续的逻辑。

来看一个并行化流程控制的小demo，该demo实现了在控制台中统计打印出所有单词分别出现的总数。源文件

// 在一个简单的程序中实现并行流程控制
var fs = require('fs')
var completedTasks = 0
var tasks = []
var wordCounts = {}
var filesDir = './text'

function checkIfComplete() {   // 当所有任务全部完成后，列出文件中用到的每个单词以及用了多少次
  completedTasks++
  // console.log(completedTasks)
  console.log(tasks.length)
  if (completedTasks == tasks.length) {
    for(var index in wordCounts) {
      console.log(index + ': ' + wordCounts[index])
    }
  }
}

function countWordsInText(text) {
  var words = text
    .toString()
    .toLowerCase()
    .split(/\W+/)
    .sort()
  for (var index in words) {     // 对文本中出现的单词计数
    var word = words[index]
    if (word) {
      wordCounts[word] = (wordCounts[word]) ? wordCounts[word] + 1 : 1
    }
  }
}

fs.readdir(filesDir, function(err, files) {    // 得出text目录中的文件列表
  if (err) {
    throw err
  }
  for(var index in files) {
    var task = (function(file) {     // 定义处理每个文件的任务，每个任务中都会调用一个异步读取文件的函数并对文件中使用的单词计数
      return function() {
        fs.readFile(file, function(err, text) {   // 这里注意fs.readFile()是一个异步进程，countWordsInText(),checkIfComplete()方法会在tasks.push()方法后面进行
          if (err) {
            throw err
          }
          countWordsInText(text)
          checkIfComplete()
        })
      }
    })(filesDir + '/' + files[index])
    tasks.push(task)
  }
  for(var task in tasks) {
    tasks[task]()
  }
})

如上两个demos阐述了串行和并行化流程控制的底层机制。 

总结

可以用回调、事件发射器和流程控制管理异步逻辑。回调适用于一次性异步逻辑；事件发射器对组织异步逻辑很有帮助，因为它们可以把异步逻辑跟一个概念实体关联起来，可以通过监听器轻松管理；流程控制可以管理异步任务的执行顺序，可以让它们一个接一个执行，也可以同步执行。你可以自己实现流程管理，但社区附加模块可以帮你解决这个麻烦。选择哪个流程控制附加模块很大程度取决于个人喜好以及项目或设计的需求。