Nodejs学习第8天

Events - events模块是Node.js的核心模块、核心API之一，它是Node.js事件驱动模型的核心。当Events对象注册事件触发的时候，对应监听函数('listeners') 会被调用， 即在事件注册时提供的对应事件的回调函数 。

在Node.js中，所有基于事件驱动的对象都是EventEmitter class 的实例，例如，fs.ReadStream
模块、fs.WriteStream 模块 ,当文件被读取、被打开，关闭文件这些动作都会触发对应动作注册监听函数。并且，事件触发和对应回调函数执行是同步执行的。

Node.js继承机制依然基于javascript原型实现，一个模块使用原型继承类似于如下代码：

var EventEmitter = require('events').EventEmitter;
function Cat() {
    //
}

Cat.prototype.__proto__ = EventEmitter.prototype ;

这样 Cat 实例就拥有 #emit #on 等函数了， 可以使用on 注册事件，使用emit 触发指定事件，如：

var EventEmitter = require('events').EventEmitter;

function Cat() {
    //
}
//inherits
Cat.prototype.__proto__ = EventEmitter.prototype ;
var cat = new Cat() ;
cat.on('meow',function(msg) {
    console.log('call ',msg) ;
}) ;
//emit
cat.emit('meow','i\'m a cat o ~') ;

#emit 函数参数规定为： 除第一个参数外，其他参数均会传递给对应回调函数。

上面语法并不是标准的语法，__proto__属性是内部私有属性，不能线上使用，在浏览器javascript引擎中，一般使用Object.create()实现继承，或者自己利用中间函数来实现继承, Node.js对于继承也提供了工具，在Node.js源码/lib目录下的util.js模块中可以看到，源码如下：

/**

 * Inherit the prototype methods from one constructor into another.

 *

 * The Function.prototype.inherits from lang.js rewritten as a standalone

 * function (not on Function.prototype). NOTE: If this file is to be loaded

 * during bootstrapping this function needs to be rewritten using some native

 * functions as prototype setup using normal JavaScript does not work as

 * expected during bootstrapping (see mirror.js in r114903).

 *

 * @param {function} ctor Constructor function which needs to inherit the

 * prototype.

 * @param {function} superCtor Constructor function to inherit prototype from.

 * @throws {TypeError} Will error if either constructor is null, or if

 * the super constructor lacks a prototype.

 */

exports.inherits = function(ctor, superCtor) {

if (ctor === undefined || ctor === null)

throw new TypeError('The constructor to "inherits" must not be ' +

'null or undefined');

if (superCtor === undefined || superCtor === null)

throw new TypeError('The super constructor to "inherits" must not ' +

'be null or undefined');

if (superCtor.prototype === undefined)

throw new TypeError('The super constructor to "inherits" must ' +

'have a prototype');

ctor.super_ = superCtor;

Object.setPrototypeOf(ctor.prototype, superCtor.prototype);

};

导入util.js模块，然后调用 #inherits 函数，一次传入子类构造函数，和父类构造函数就可以了， 注意，这里是构造函数，不是对象,如：

var util = require('util') ;

function Person(name,age) {
    this.name = name || '' ;
    this.age = age || 20 ;
}

Person.prototype.say = function(){
    console.log('my name is ' + this.name  + ', age is ' + this.age) ;
}

function Stu(name) {
    this.name = name || '' ;
}

util.inherits(Stu,Person) ;
var stu = new Stu('palm') ;

stu.say() ; 

运行node命令，就可以看到输出：

my name is palm, age is undefined

能输出这句话，就说明，Stu 确实继承了Person ，因为 Stu 自己是没有#say 函数的， age is undefined 是因为 Stu 对象确实没有该属性，如果是第一次接触javaScript原型继承模型 的童鞋，可能会疑惑： Stu 不是已经继承Person了吗？ 而且Person 明明是有age属性的呀？ 并且是有一个默认值的，Stu 实例为什么没有呢？

这里，需要先了解javascript原型继承模式和javascript对象属性和方法查找方式; Person #age 可以暂时理解为 java之 private ,是私有的，在java中有显式继承和隐式继承，但javascript没有，因为javascript是基于原型继承的，所以子类只能继承到父类原型上的东西，Person # say 函数因为在Person 原型上，所以它的子类可以得到，Person #age属性不在#Person原型链上，所以Stu不能继承该属性。如果想了解javascript更多的原型知识，可以翻看廖雪峰老师/阮一峰老师的javascript教程，这两位都是有名的前端大神，以及知乎上的大神的回答; 在下才疏学浅，也说不明白，就不诲人不倦了。#-_-

eventEmitter.on() 只要对应事件触发都会执行，而 eventEmitter.once() 只会执行一次，在第一次事件触发后会移除该事件和注销对应回调函数。

当EventEmitter实例对象中有error错误发生时，会触发error事件，如果没有提供error 事件对应处理函数，Node.js首先抛出提示我没有error事件处理程序(unhandled 'error' event),然后处理后续参数，然后输出错误信息， 然后Node.js主线程退出程序，也就是应用挂掉，崩溃了 。。。。。
例如：

var EventEmitter = require('events').EventEmitter;
function Cat() {
    //
}
Cat.prototype.__proto__ = EventEmitter.prototype ;
/*var cat = new Cat() ;
cat.on('meow',function(msg) {
    console.log('call ',msg) ;
}) ;
cat.emit('meow','hello') ;
*/
var event = new EventEmitter() ;
event.emit('error', new Error('who...')) ;

异常输出：

[palm@arch]: ~/Desktop/js>$ node event.js 
events.js:160
      throw er; // Unhandled 'error' event
      ^

Error: who...
    at Object.<anonymous> (/home/palm/Desktop/js/event.js:24:21)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:394:7)
    at startup (bootstrap_node.js:149:9)
    at bootstrap_node.js:509:3

上面栗子缺少了监听error事件的函数。如下代码就可以稍微补救一下了。

var EventEmitter = require('events').EventEmitter;
function Cat() {
    //
}
Cat.prototype.__proto__ = EventEmitter.prototype ;
/*var cat = new Cat() ;
cat.on('meow',function(msg) {
    console.log('call ',msg) ;
}) ;
cat.emit('meow','hello') ;
*/
var event = new EventEmitter() ;
// event.emit('error', new Error('who...')) ;
event.on('error',function() {
    console.log(this) ;
}) ;
event.emit('error') ;

上面有error event handler 也就避免了应用挂掉的可能，如下：

[palm@arch]: ~/Desktop/js>$ node event.js 
EventEmitter {
  domain: null,
  _events: { error: [Function] },
  _eventsCount: 1,
  _maxListeners: undefined }

EventEmitter 中的 this
上面输出也可以看出事件回调函数(匿名函数)的Context是 EventEmitter ，在ECMAScript6版中，使用箭头函数输出如下:

var event = new EventEmitter() ;
// event.emit('error', new Error('who...')) ;
event.on('error',() => {
    console.log(this) ;
}) ;
event.emit('error') ;

//print
{}

这种区别，在不同浏览器中使用匿名函数和 箭头函数编写回调函数的时候可能需要注意this 的使用。

如果给一个EventEmitter 对象对同一个事件多次注册，则会按照注册顺序依次执行。如：

var EventEmitter = require('events').EventEmitter;


function Cat() {
    //
}


Cat.prototype.__proto__ = EventEmitter.prototype ;


/*var cat = new Cat() ;
cat.on('meow',function(msg) {
    console.log('call ',msg) ;
}) ;

cat.emit('meow','hello') ;
*/


var event = new EventEmitter() ;
// event.emit('error', new Error('who...')) ;
event.on('error',function() {
    console.log('three..') ;
}) ;
event.on('error',() => {
    console.log('one') ;
}) ;

event.on('error',function() {
    console.log('two..') ;
}) ;
event.emit('error') ;

//print
three..
one
two..

更多 class: EventEmitter 事件描述和使用在这里，如对象注册事件个数统计、移除指定事件/移除全部事件、允许注册事件个数设置、注册事件的事件(Event: 'newListener')等等.

事件 - 我认为是Node.js的核心思想吧，基于事件Node可以解决I/O服务密集问题，比如不用排队读取文件和访问数据库(这里指数据库read操作),但是由于Node.js 单线程，在事件处理中，主线程只负责调度(维护事件队列，不出理事件业务)，所以如果遇到大型计算-类似死循环，可能就比较吃力了，也叫CPU密集。据网络上大神描述，Node之父建议CPU密集使用多个Node服务来处理这种情况。

---

  各位资深Noder: 如果看到上面错误，请指正，非常感谢！