目的在于提升性能。
Node利用JavaScript及其内部异步库，将异步直接提升到业务层面，这是一种创新。

函数式编程

函数是编程是作为异步编程的基础。

高阶函数

普通函数只能接受基本数据类型作为输入或输出的函数，而高阶函数是可以接受另一个函数作为输入或输出的函数。

  1. // 普通函数
  3. function foo (x) {
  4.   return x
  5. }
  7. // 高阶函数
  9. function foo(x) {
  10.     return function(x) {
  11.       return x
  12.   }
  13. }
  14. function foo(x, bar) {
  15.     return bar(x)
  16. }

例如：数组排序sort

  1. const arr = [1,3,5,6,2,0,8];
  3. arr.sort(function(a, d) {
  4.     return a - b
  5. })
  6. // 这里的sort即是一个高阶函数

高阶函数在JavaScript中比比皆是，其中ECMAScript5中提供的一些数组方法（forEach()、map()、reduce()、reduceRight()、filter()、every()、some()）十分典型。

偏函数的用法

偏函数的用法是指创建一个调用另外一个部分—参数或变量已经预置的函数—的函数的用法。

例如：

  1. const isType = function (type) {
  2.     return function (obj) {
  3.       return toString.call(obj) === `[object ${type}]`
  4.   }
  5. }
  7. const isString = isType('String');
  8. const isFunc = ifType('Function');
  10. // 这种通过指定部分参数来产生一个新的定制函数的形式就是偏函数

偏函数在异步编程中是十分常见的。

优势与难点

优势

Node最大的优势莫过于是基于事件驱动，非阻塞I/O模型。非阻塞I/O可以使cpu与I/O不相互依赖等待执行，让资源能够得到更好的利用。

难点

  1. 异常处理 ```javascript const async = function (callback) { process.nextTick(callback) }

try { async(callbakc) }catch(e) { // TODO } //调用async()方法后，callback被存放起来，直到下一个事件循环（Tick）才会取出来执行, 此时try…catch对于异常处理也无能为力。

  1. node在异常处理上形成一种约定，将异常作为回调函数的第一个参数返回，若为空值则表示没有异常抛出。
  2. ```javascript
  3. async(function (err, results) {
  4. //TODO
  5. })
  6. /* 我们自行编写的异步方法上应遵循这种一些原则
  7. 1. 必须执行调用者传入的回调函数
  8. 2. 正确传递回异常供调用者判断
  9. */
  10. // 例子
  12. const async = function（callback）{
  13.     process.nextTick(function () {
  14.       const results = something;
  15.     if (error) {
  16.         return callback(error)
  17.     }
  18.     return callback(null, results)
  19.   })
  20. }

在编写异步方法时，只要将异常正确地传递给用户的回调方法即可，无须过多处理。

  1. 函数嵌套过深
  2. 阻塞代码

javascript并没有sleep()这样的线程沉睡的功能，仅仅只有setTimeout,setInterval这两个延迟函数，但是这两个函数并不会阻塞后面代码的运行。
遇见这样的需求时，在统一规划业务逻辑之后，调用setTimeout()的效果会更好。

  1. 多线程编程

Web Workers是一个利用消息机制合理使用多核CPU的理想模型。

  1. 异步转同步

异步编程解决方案

异步编程的解决方案主要有三种

  • 事件发布/订阅模式
  • Promise/Deferred模式
  • 流程控制库

事件发布/订阅模式

事件监听模式是一直广泛的异步编程的模式，是回调函数的事件化，又称为发布/订阅模式。
NodeJs自身提供的events模块是这种模式的简单实现。它具有addListener/on()、once()、removeListener()、removeAllListeners()和emit()等基本的事件监听模式的方法实现。

  1. const events = require('events')
  2. const emmiter = new events.Emitter()
  4. // 订阅
  5. emmiter.on('event1',(msg) => {
  6.     console.log('触发事件', msg)
  7. })
  8. // 发布
  9. emmiter.emit('event1')

订阅/发布自身并无同步异步调用的问题，但在Node中，emit()调用多半是伴随事件循环而异步触发的，所以我们说事件发布/订阅广泛应用于异步编程。

订阅/发布模式通常用来解耦业务逻辑，发布者无需关注订阅的侦听器如何实现逻辑，更无需关注有多少个订阅侦听器，数据通过消息的方式可以很灵活地传递。

例如：

  1. const http = reuqire('http')
  3. const option = {
  4.     host: 'www.google.com',
  5.     port: 80,
  6.   path: '/update',
  7.   method: 'post'
  8. }
  10. const req = http.request(option, function(res) {
  11.     console.log("statusCode", res.statusCode);
  12.   res.setEncoding('utf-8')
  13.   res.on('data', function(chunk) {
  14.     console.log('data chunk', chunk)
  15.   })
  16.   res.on('end', function() {
  17.     console.log('end')
  18.   })
  19. })
  21. req.on('error', (e) => {
  22.     console.log('error', e)
  23. })
  25. req.write('data')
  26. req.end()

在这段HTTP请求的代码中，程序员只需要将视线放在error、data、end这些业务事件点上即可，至于内部的流程如何，无需过于关注

多类型异步协作

可以使用到eventproxy。

  1. npm i --save eventproxy // 安装
  3. // 使用
  4. const EventProxy = require('eventproxy')
  5. const proxy = new EventProxy()
  7. proxy.all('tpl', 'data', function (tpl, data) {
  8. // TODO
  9. // 在所有指定事件触发后将会被执行
  10. // 参数对应各自的时间名
  11. })
  13. fs.readFile(file_path, 'utf-8', function(err, template) {
  14.     proxy.emit('tpl', template)
  15. })
  16. db.query(sql, function(err, data) {
  17.     proxy.emit('data', data)
  18. })

EventProxy
all()：订阅多个事件，当所有的事件都被触发后，侦听器才会被执行。
tail(): 订阅多个事件，当侦听器满足条件时执行一次之后，如果组合事件中的某个事件被再次触发，侦听器会用最新的数据继续执行。

异步场景下，我们常常需要用一个接口多次获取数据，此时触发的事件名或许是相同的。
after(): 实现侦听器在执行多少次之后执行侦听器的单一事件组合订阅方式。
例如

  1. const proxy = new EventProxy();
  3. proxy.after(data, 10, function(data) {
  4. // 表示执行10次data事件之后执行
  5. })

EventProxy模块除了可以应用于Node中外，还可以用在前端浏览器中。

EventProxy异常处理
**
fail()

  1. const proxy = new EventProxy();
  3. proxy.fail(callback)
  5. // 等价于
  6. proxy.fail(function(err) {
  7.     callback(err)
  8. })
  10. proxy.bind('error', function(err) {
  11.   proxy.unbind() // 卸载所有处理函数
  12.     callback(err)
  13. })

done()

  1. const proxy = new EventProxy();
  3. proxy.done('data')
  4. // 等价于
  5. function (err, content) {
  6.     if (err) return proxy.emit('error', err);
  7.   proxy.emit('data', content)
  8. }
  10. // done 可以接受函数作为一个参数
  11. proxy.done(function(content) {
  12.     // TODO 
  13.   // 这里无需考虑异常
  14.   proxy.emit('data', content)
  15. })
  16. // 等价于
  17. function(err, content) {
  18.     if (err) return proxy.emit('error', err);
  19.   (function(content) {
  20.     proxy.emit('data', content)
  21.   }(content))
  22. }

当只传入一个回调函数时，需要手工调用emit()触发事件

Promise/Deferred模式

使用事件的方式时，执行流程需要被预先设定。即便是分支，也是需要预先设定，这是由于发布/订阅的运行机制决定的。
而Promise/Deferred模式是一种先执行异步调用，延迟传递处理的方式。

  1. // 普通ajax调用
  2. $.get('/api', {
  3.     success: onSuccess,
  4.   error: onError,
  5.   complete: onComplete
  6. })
  8. // 使用了Promise/Deferred模式的ajax
  9. $.get('api')
  10.   .success(onSuccess)
  11.   .error(onError)
  12.   .complete(onComplete)
  14. // 这使得即使不调用success, error等方法，ajax依然会被执行。

在原始的API中，一个事件只能处理一个回调，而通过Deferred对象，可以对事件加入任意的业务处理逻辑。

  1. $.get('api')
  2.   .success(onSuccess_1)
  3.     .success(onSuccess_2)

Promise/Deferred模式在2009年时被Kris Zyp抽象为一个提议草案，发布在CommonJS规范中。随着使用Promise/Deferred模式的应用逐渐增多，CommonJS草案目前已经抽象出了Promises/A、Promises/B、Promises/D这样典型的异步Promise/Deferred模型，这使得异步操作可以以一种优雅的方式出现

PromiseA

Promise/Deferred模式其实包含两部分，即Promise和Deferred。

Promise：
PromiseA对异步操作做出了这样的抽象定义

  • Promise操作只会处在3种状态的一种：未完成态、完成态、失败态。
  • Promise的状态只会由未完成态->完成态或未完成态->失败态。不能逆反，完成态和失败态不能相互转换。
  • Promise状态一旦改变就不能再被更改。

Promise状态转换示意图.png

Api定义上，Promises/A提议是比较简单的。一个Promise只需要具备一个then()方法即可。

  • 接受完成态、错误态的回调方法。在操作完成或出现错误时，将会调用对应方法。
  • 可选地支持progress事件回调作为第三个方法。
  • then发放只接受function对象，其余对象将被忽略。
  • then方法返回Promise对象，可以继续链式调用。

.then(fulfillHandler, errorHandler, progressHandler)
_
Deferred：
then()方法所做的事情是将回调函数存放起来。为了完成整个流程，还需要触发执行这些回调函数的地方，实现这些功能的对象通常被称为Deferred，即延迟对象。

Promise/Deferred模型简单实现

  1. // Promise
  2. const Promise = function() {
  3.     EventEmitter.call(this)
  4. }
  5. util.inherits(Promise, EventEmitter)
  7. Promise.prototype.then = function(fulfillHandler, errorHandler, progressHandler) {
  8.     if (type fulfillHandler === 'function') {
  9.       // 利用once,保证函数只执行一次
  10.     this.once('success', fulfillHandler)
  11.   }
  12.   if (type errorHandler === 'function') {
  13.       // 利用once,保证函数只执行一次
  14.     this.once('error', errorHandler)
  15.   }
  16.   if (type progressHandler === 'function') {
  17.       // 利用once,保证函数只执行一次
  18.     this.on('progress', progressHandler)
  19.   }
  20.   return this
  21. }
  23. // Deferred
  24. const Deferred = function () {
  25.   this.state = 'unfulfilled';
  26.   this.promise = new Promise();
  27. }
  28. Deferred.prototype.resolve = function(obj) {
  29.     this.state = 'unfulfilled';
  30.   this.promise.emit('success', obj)
  31. }
  32. Deferred.prototype.reject = function(err) {
  33.     this.state = 'failed';
  34.   this.promise.emit('error', err)
  35. }
  36. Deferred.prototype.progress = function(data) {
  37.     this.promise.progress('progress', data)
  38. }

在实际的业务中若想使用Promise/Deferred模型可以不用封装，可以使用Q或when模块来实现。

  1. // q安装
  2. npm i --save q
  4. //q模块将数据封装成promise
  6. /***************************************************************************************/
  8. // 利用q实现一个readFile
  9. const q = require('q');
  11. const readFile = function(path, encoding) {
  12.     const deferred = q.defer();
  13.   fs.readFile(path, encoding, deferred.makeNodeResolves());
  14.   return deferred.promise
  15. }
  16. // 调用readFile
  17. readFile('./index.txt', 'utf-8').then((data) => {
  18.     // TODO
  19. }, (err) => {
  20.     console.log(err)
  21. })
  23. //Promise通过封装异步调用，实现了正向用例和反向用例的分离以及逻辑处理延迟，这使得回调函数相对优雅

Promise中的多异步协作

  1. // 简单实现all方式
  2. Deferred.prototype.all = function(promises) {
  3.     let count = promises.lenth;
  4.   const that = this;
  5.   const results = [];
  6.   promises.forEach((promise, i) => {
  7.       promise.then((data) => {
  8.         count--;
  9.       results[i] = data;
  10.       if (count === 0) {
  11.           that.resolve(results)
  12.       }
  13.     },(err) => {
  14.         that.reject(err)
  15.     })
  16.   })
  17.   return this.promise
  18. }
  20. // 调用
  21. const promise_1 = readFile('a.txt', 'utf-8');
  22. const promise_2 = readFile('b.txt', 'utf-8');
  23. const deferred = new Deferred();
  24. deferred.all([promise_1, promise_2], (data) => {
  25. // TODO
  26. }, (err) => {
  27. // TODO error
  28. })

流程控制库

尾触发与next

尾触发目前应用最多的地方是Connect的中间件。
在Connect中，尾触发十分适合处理网络请求的场景。将复杂的处理逻辑拆解为简洁、单一的处理单元，逐层次地处理请求对象和响应对象。

  1. const connect = require('connect');
  2. const http = require('http');
  4. const app = connect();
  5. // gzip/deflate outgoing responses
  6. const compression = require('compression');
  7. app.use(compression());
  8. // store session state in browser cookie
  9. const cookieSession = require('cookie-session');
  10. app.use(cookieSession({
  11.     keys: ['secret1', 'secret2']
  12. }));
  13. // parse urlencoded request bodies into req.body
  14. const bodyParser = require('body-parser');
  15. app.use(bodyParser.urlencoded({extended: false}));
  16. // respond to all requests
  17. app.use(function(req, res){
  18.   res.end('Hello from Connect!\n');
  19. });
  20. //create node.js http server and listen on port
  21. http.createServer(app).listen(3000);

async

async模块提供了20多个方法用于处理异步的各种协作模式。
https://caolan.github.io/async/v3/

  1. // 安装
  2. yarn add async
  4. // 例子
  5. async.map(['file1','file2','file3'], fs.stat, function(err, results) {
  6.     // results is now an array of stats for each file
  7. });
  9. async.filter(['file1','file2','file3'], function(filePath, callback) {
  10.   fs.access(filePath, function(err) {
  11.     callback(null, !err)
  12.   });
  13. }, function(err, results) {
  14.     // results now equals an array of the existing files
  15. });
  16. // 异步的并行执行
  17. async.parallel([
  18.     function(callback) { ... },
  19.     function(callback) { ... }
  20. ], function(err, results) {
  21.     // optional callback
  22. });
  23. // 异步的串行执行
  24. async.series([
  25.     function(callback) { ... },
  26.     function(callback) { ... }
  27. ]);

setup

https://www.npmjs.com/package/setup

  1. // 安装
  2. yarn add setup

异步并发控制

bagpipe

https://github.com/JacksonTian/bagpipe/blob/master/README_CN.md

async

async也提供了一个方法用于处理异步调用的限制：parallelLimit()。
parallelLimit()方法的缺陷在于无法动态地增加并行任务,为此，async提供了queue()方法来满足该需求。

  1. async.parallelLimit([
  2.     function(callback) {
  3.       fs.readFile('a.txt', 'utf-8', callback)
  4.   },
  5.   function(callback) {
  6.       fs.readFile('b.txt', 'utf-8', callback)
  7.   }
  8. ], 1, function (err, results) {
  9. // TODO
  10. })
  12. // queue
  13. const q = async.queue(function(file, callback) {
  14.     fs.readFile('a.txt', 'utf-8', callback)
  15. }, 2)
  16. q.drain = function() {
  17. // 完成了队列中的所有任务之后执行
  18. }
  19. fs.readdirSync('.').forEach(function(file) {
  20.     q.push(file, function(err, data) {
  21.   // TODO
  22.   })
  23. })