Node.js co 常见使用场景介绍

定时器 Timers

co 模块可以与 co-defer 结合使用来处理异步定时器。以下是一个示例：

var defer = require('co-defer')

defer.setImmediate(function* () {
  console.log('setImmediate');
});

defer.nextTick(function* () {
  console.log('nextTick');
});

var timer1 = defer.setInterval(function* () {
  console.log('setInterval 100ms');
  clearInterval(timer1);
}, 100);

var timer2 = defer.setTimeout(function* () {
  console.log('setTimeout 100ms');
  clearTimeout(timer2);
}, 100);

这段代码展示了如何使用 co-defer 来处理 setImmediate, nextTick, setInterval 和 setTimeout 的异步操作。

并发

数组形式

co(function* () {
  var rs = yield [
    get(1),
    get(2),
    get(3),
    get(4),
  ];
  console.log(rs);
  // [1, 2, 3, 4]
})();

上述代码中，get 函数可以是任何返回 Promise 的异步函数。co 会并行执行这些函数，并将结果收集到一个数组中。

键值对形式

co(function* () {
  var data = yield {
    name: getName(),
    age: getAge()
  };
  console.log(data);
  // { name: 'fengmk2', age: 18 }
})();

这段代码展示了如何并行执行多个异步操作，并将结果组织成对象的形式。

限制最大并发数

使用 co-parallel 可以限制并发数量：

var parallel = require('co-parallel');
var request = require('co-request');
var co = require('co');

var urls = [
  'http://google.com',
  'http://yahoo.com',
  'http://ign.com',
  'http://cloudup.com',
  'http://myspace.com',
  'http://facebook.com',
  'http://segment.io'
];

function* status(url) {
  console.log('GET %s', url);
  return (yield request(url)).statusCode;
}

co(function* () {
  var reqs = urls.map(status);
  var res = yield parallel(reqs, 2);
  console.log(res);
})();

这段代码限制了最多同时进行两个并发请求。

并发请求容错处理

使用 co-gather 可以处理并发请求的容错问题：

var gather = require('co-gather');
var wait = require('co-wait');
var co = require('co');

var index = 0;
function* random(val) {
  var i = index++;
  yield wait(Math.random() * 100);
  if (Math.random() > 0.5) {
    throw new Error('error');
  }
  return {index: i, value: val};
}

co(function* () {
  var ret = yield gather([
    random(1),
    random(2),
    random(3),
    random(4),
    random(5)
  ]);
  console.log(ret);
})();

输出结果类似于：

[
  { isError: false, value: {index: 0, value: 1} },
  { isError: true, error: [Error: error] },
  { isError: true, error: [Error: error] },
  { isError: true, error: [Error: error] },
  { isError: false, value: {index: 4, value: 5} }
]

co-gather 会捕获所有异常并返回一个包含结果和错误信息的对象数组。

只取最快响应的

使用 co-any 可以获取最快的响应结果：

var any = require('co-any');
var wait = require('co-wait');
var co = require('co');

function* random(val) {
  yield wait(Math.random() * 100);
  if (Math.random() > 0.5) {
    throw new Error('error');
  }
  return val;
}

co(function* () {
  var ret = yield any([
    random(1),
    random(2),
    random(3),
    random(4),
    random(5)
  ]);
  console.log(ret);
})();

输出结果类似于：

{
  _key: 1,
  value: 2
}

co-any 会返回最快完成的异步操作的结果。

事件 EventEmitter

事件监听者支持 GeneratorFunction

使用 co-event-wrap 可以处理事件监听：

var co = require('co');
var http = require('http');
var eventWrap = require('co-event-wrap');
var fs = require('co-fs');

co(function* () {
  var req = http.get('http://cnodejs.org');
  eventWrap(req);
  req.on('response', function* (res) {
    res = eventWrap(res);
    var datas = [];
    res.on('data', function* (data) {
      datas.push(data);
    });
    res.on('end', function* () {
      var body = Buffer.concat(datas);
      yield fs.writeFile(__dirname + '/cnodejs.html', body);
      console.log('got %d bytes, headers: %j', body.length, res.headers);
    });
  });
})();

通过 while 方式处理事件

使用 co-event 可以简化事件处理逻辑：

var event = require('co-event');

var e;
while (e = yield event(emitter)) {
  switch (e.type) {
    case 'end':
      break;

    case 'close':
      break;

    case 'error':
      break;
  }
}

这样可以方便地处理事件流，并且避免了直接处理错误事件导致的抛出异常问题。

希望本文对你有用 ^_^