梳理 | NodeJS(process/event)

本文旨在进行学习过程中的知识梳理，如有问题还望多多指教。

1、process

// process 对象代表node.js应用程序，可以获取应用程序的用户，运行环境等各种信息 
console.log(process.cwd())
process.chdir('..') //切换到上级目录
console.log(process.cwd())
// { rss: 19087360, 常驻内存
//     heapTotal: 6537216, 堆的总申请量
//     heapUsed: 3871064,  已经使用的量
//     external: 8272 }   外部内存使用量
console.log(process.memoryUsage())

// nextTick & setImmediate
// nextTick 把回调函数放到当前执行栈的尾部
// setImmediate把回调函数放到事件队列的尾部
function read(){
    setImmediate(function(){
        console.log(1);
        process.nextTick(function(){
            console.log(2);
            setImmediate(function(){
                console.log(5);
            })
            process.nextTick(function(){
                console.log(3);
            })
        })
    })
    process.nextTick(function(){
        console.log(0);
    })
}
read()//0 1 2 3 5

2、EventEmitter

在Node.js的用于实现各种事件处理的event模块中，定义了EventEmitter类，所有可能触发事件的对象都是一个继承自EventEmitter类的子类实例对象

let EventEmitter = require('events')
let util = require('util')

function Bell(){
    EventEmitter.call(this) //继承私有属性
}

// 进行原型继承  Bell类继承父类EventEmitter
// Object.setPrototypeOf(otor.prototype, superCtor.prototype)
// 这样子类继承了父类的公有方法
// 子类原型对象ctor.prototype，让它的原型指向父类原型对象
//这里可以看下原型链是如何继承的
//ctor.prototype.__proto__ =  superCtor.prototype; 
util.inherits(Bell,EventEmitter)
let bell = new Bell();
function studentInClassroom(){
    console.log('go in student')
}

function teacherInClassroom(){
    console.log('go in teached')
}
bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);

bell.emit('lock') //发射事件

方法名和参数	描述
addListener(event,listener)	对指定事件绑定事件处理函数
on(event,listener)	对指定事件绑定事件处理函数
once(event,listener)	对指定事件指定只执行一次的事件处理函数
removeListener(event,listener)	对指定事件解除事件处理函数
removeAllListeners([event])	对指定事件解除所有的事件处理函数
setMaxListeners(n)	指定事件处理函数的最大数量.n为整数值，代表最大的可指定事件处理函数的数量
listeners(event)	获取指定事件的所有事件处理函数
emit(event,[arg1],[arg2],[...])	手工触发指定事件

下面简单重写event.js

//event.js
function EventEmitter(){
    this.events = {}; //所有事件监听函数放在这个对象里保存
    this._maxListeners = 10; //指定给一个事件类型增加的监听函数数量最多有多少个
    this.warned = false;  //当超出_maxListeners 触发一次警告
}

EventEmitter.prototype.setMaxListeners = function(maxListeners){
    this._maxListeners = maxListeners;
}

//指定事件的所有事件处理函数
EventEmitter.prototype.listeners = function(event){
    return this.events[event]
}

// 给指定的事件绑定事件处理函数，1 参数是事件类型 2 参数是事件监听函数
EventEmitter.prototype.on = EventEmitter.prototype.addListener =
    function (type,listener){
        if(this.events[type]){
            // 事件类型会有多个监听函数
            this.events[type].push(listener);
            // 触发警告
            if(this._maxListeners!=0 && this.events[type].length > this._maxListeners && !this.warned){
                this.warned = true;
                console.error(`MaxListenersExceededWarning: Possible EventEmitter memory leak detected. ${this.events[type].length} ${type} listeners added. Use emitter.setMaxListeners() to increase limit`);
            }
        }else{
            // 如果以前没有添加到此事件的监听函数，则赋一个新数组
            this.events[type] = [listener];
        }
    }

EventEmitter.prototype.once = function(type,listener){
    // 用完即焚 这里新定义一个wrapper
    let wrapper = (...rest) => {
        // 可能会传入多个参数 使用...rest接收   注意这里的this 使用apply 
        //这里的listener也就是前面测试代码中的masterInClassroom这个函数 传入的参数是emit那里过来的
        listener.apply(this,rest); //执行原始的监听函数
        this.removeListener(type,wrapper);
    }   
    // 绑定
    this.on(type,wrapper); 
}

EventEmitter.prototype.removeListener = function(type,listener){
    if(this.events[type]){
        // 过滤掉相等的
        this.events[type] = this.events[type].filter(l=>l!=listener);
    }
} 

// 移除某个事件的所有监听函数
EventEmitter.prototype.removeAllListeners = function(type){
    delete this.events[type];
} 

EventEmitter.prototype.emit = function(type,...rest){
    //可能会传入多个参数 使用...rest接收   使用apply 一方面是传参，一方面是指向当期emmit实例
    this.events[type] && this.events[type].forEach(listener=>listener.apply(this,rest));
}

module.exports = EventEmitter;

event.js测试

let EventEmitter = require('./events')
let util = require('util')

function Bell(){
    EventEmitter.call(this) //继承私有属性
}

// 进行原型继承  Bell类继承父类EventEmitter
// Object.setPrototypeOf(otor.prototype, superCtor.prototype)
// 这样子类继承了父类的公有方法
// 子类原型对象ctor.prototype，让它的原型指向父类原型对象
//ctor.prototype.__proto__ =  superCtor.prototype;
util.inherits(Bell,EventEmitter)
let bell = new Bell();
function studentInClassroom(roomNumber,book){
    console.log(`go in ${roomNumber} student ${book} `)
}

function teacherInClassroom(roomNumber,book){
    console.log(`go in ${roomNumber} teacher ${book} `)
}

function masterInClassroom(roomNumber,book){
    console.log(`go in ${roomNumber} master ${book} `)
}

bell.setMaxListeners(5); //最多15个 给事件添加监听函数

// 事件添加监听函数 添加多个，测试_MaxListeners
bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);

bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);bell.on('lock',studentInClassroom);
bell.on('lock',teacherInClassroom);


bell.once('ms',masterInClassroom); //只会执行一次
// bell.removeAllListeners('ms');

console.log('***************')

// 第一个参数是事件类型，第二个参数和以后的参数传递给监听函数
bell.emit('lock','300','node') //发射事件
bell.emit('lock','300','node') //发射事件
bell.emit('ms','300','JS') //发射事件
bell.emit('ms','300','JS') //发射事件