//1. EventEmitter
/*
大多数时候我们不会直接使用 EventEmitter，而是在对象中继承它。包括 fs、net、 http 在内的，只要是支持事件响应的核心模块都是 EventEmitter 的子类。
为什么要这样做呢？原因有两点：
首先，具有某个实体功能的对象实现事件符合语义， 事件的监听和发生应该是一个对象的方法。
其次 JavaScript 的对象机制是基于原型的，支持 部分多重继承，继承 EventEmitter 不会打乱对象原有的继承关系。
*/
var EventEmitter = require('events').EventEmitter;
var event = new EventEmitter();
event.addListener('some_event', function() {
console.log('some_event addListener 事件触发');
});
event.on('some_event', function() {
console.log('some_event on 事件触发');
});
/*
1秒后输出：
2 个监听器监听连接事件。
some_event addListener 事件触发
some_event on 事件触发
*/
eventListeners = event.listenerCount('some_event');
console.log(eventListeners + " 个监听器监听连接事件。");
event.emit('some_event');
//2. buffer
/**
* Buffer.alloc(size[, fill[, encoding]])
* Buffer.from(array)：
* Buffer.from(string[, encoding])：
*/
buf = Buffer.alloc(256);
len = buf.write("thisismyname");
console.log("写入字节数 : "+ len);
//buffer输出
buf = Buffer.alloc(26);
for (var i = 0 ; i < 26 ; i++) {
buf[i] = i + 97;
}
console.log( buf.toString('utf8', 0, 5));
console.log( buf.toString('utf8'));
//2.1 buf变成json
buf2 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf2);
console.log(json);//{"type":"Buffer","data":[1,2,3,4,5]}
//2.N 对buf的合并，比较，裁剪，合并等常规操作
//3. stream
//3.1 pipe 管道
var fs = require("fs");
// 创建一个可读流
var readerStream = fs.createReadStream('input.txt');
// 创建一个可写流
var writerStream = fs.createWriteStream('output.txt');
// 管道读写操作
// 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
readerStream.pipe(writerStream);
//3.2 链式流
var fs = require("fs");
var zlib = require('zlib');
// 压缩 input.txt 文件为 input.txt.gz
fs.createReadStream('input.txt')
.pipe(zlib.createGzip())
.pipe(fs.createWriteStream('input.txt.gz'));
console.log("文件压缩完成。");
//4. 模块化
var hello = require("./Hello");
h = new hello();
h.setName('Tom');
h.sayHello();
//5. 函数
function say(word) {
console.log(word);
}
function execute(myFunc, value) {
myFunc(value);
}
execute(say, "Hello");//输出Hello
//6. 路由
/*
var url = require("url");
var http = require("http");
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");//显示http://localhost:3000/aa/bb?a=1中的 “Request for /aa/bb received.”
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(3000);
console.log("Server has started.");
*/
//7. 全局对象
console.log( __filename );
console.log( __dirname );
//setTimeout, clearTimeout, setInterval, console，process等
//8. 常用工具 util模块的使用
//8.1 callbackify
const util = require('util');
async function async_function() {
return 'message from async function';
}
const callback_function = util.callbackify(async_function);
console.log(1111);
callback_function((err, ret) => {
if (err) throw err;
console.log(ret);
});
console.log(2222);
//以上代码先输出 1111 2222 最后输出 message from async function
//8.2 inherits
function Base() {
this.name = 'base';
this.base = 1991;
this.sayHello = function() {
console.log('Hello ' + this.name);
};
}
Base.prototype.showName = function() {
console.log(this.name);
};
function Sub() {
this.name = 'sub';
}
util.inherits(Sub, Base);
var objBase = new Base();
objBase.showName();
objBase.sayHello();
console.log(objBase);
var objSub = new Sub();
objSub.showName(); //Sub 仅仅继承了Base 在原型中定义的函数，而构造函数内部创造的 base 属 性和 sayHello 函数都没有被 Sub 继承。
//objSub.sayHello(); //会报错，因为在构造函数内的不会被继承
console.log(objSub);
//8.3 任意对象转换 为字符串的方法，通常用于调试和错误输出
console.log(util.inspect(Base, true));
//8.4 util.isArray
//8.5 util.isDate
//8.6 util.isRegExp
//9.文件系统
var fs = require("fs");
fs.readFile('input.txt', function (err, data) {
if (err) {
return console.error(err);
}
console.log("异步读取: " + data.toString());
});
// 同步读取
var data = fs.readFileSync('input.txt');
console.log("同步读取: " + data.toString());
console.log("程序执行完毕。");
//10. GET/POST 请求
var http = require('http');
var querystring = require('querystring');
var postHTML =
'<html><head><meta charset="utf-8"><title>my site</title></head>' +
'<body>' +
'<form method="post">' +
'网站名： <input name="name"><br>' +
'网站 URL： <input name="url"><br>' +
'<input type="submit">' +
'</form>' +
'</body></html>';
http.createServer(function(req, res){
var post = '';
req.on('data', function(chunk){
post += chunk;
});
req.on('end', function (){//post的数据，需要放到req.on('end')里去捕获
postData = querystring.parse(post);
if(postData.name && postData.url){
res.write('postData:' + postData.name + ' - ' + postData.url);
}else{
res.write(postHTML);
}
res.end();
});
}).listen(3000);
//11. 工具模块
/**
* os模块，path模块，net模块（底层的网络通信），dns模块，domain模块
*
*/
//12. express框架 3001端口，上面已经有一个在3000端口了
var express = require('express');
var app = express();
app.get('/', function (req, res) {//不同的路由可以去不同的页面，路由的方式很多种，还可以正则匹配等
res.send('Hello World');
});
var server = app.listen(3001, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
});
//12.1 获取cookie, GET/POST，文件上传
//13. RESTfull Api, REST即表述性状态传递
/*
GET - 用于获取数据。
PUT - 用于更新或添加数据。
DELETE - 用于删除数据。
POST - 用于添加数据。
*/
//14. nodeJs 多进程 参考：https://www.runoob.com/nodejs/nodejs-process.html
/**
* Node.js 是以单线程的模式运行的，但它使用的是事件驱动来处理并发，这样有助于我们在多核 cpu 的系统上创建多个子进程，从而提高性能。
每个子进程总是带有三个流对象：child.stdin, child.stdout 和child.stderr。他们可能会共享父进程的 stdio 流，或者也可以是独立的被导流的流对象。
Node 提供了 child_process 模块来创建子进程，方法有：
exec - child_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。
spawn - child_process.spawn 使用指定的命令行参数创建新进程。
fork - child_process.fork 是 spawn()的特殊形式，用于在子进程中运行的模块，如 fork('./son.js') 相当于 spawn('node', ['./son.js']) 。与spawn方法不同的是，fork会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信。
*/
const child_process = require('child_process');
//14.1 exec
//support.js的内容是console.log("进程 " + process.argv[2] + " 执行。" );
/*
for(var i=0; i<3; i++) {
var workerProcess = child_process.exec('node support.js '+i, function (error, stdout, stderr) {
if (error) {
console.log(error.stack);
console.log('Error code: '+error.code);
console.log('Signal received: '+error.signal);
}
console.log('stdout: ' + stdout);
console.log('stderr: ' + stderr);
console.log('-----------');
});
workerProcess.on('exit', function (code) {
console.log('子进程已退出，退出码 '+code);
});
}
*/
//14.2 spawn
/*
for(var i=0; i<3; i++) {
var workerProcess = child_process.spawn('node', ['support.js', i]);
workerProcess.stdout.on('data', function (data) {
console.log('stdout: ' + data);
});
workerProcess.stderr.on('data', function (data) {
console.log('stderr: ' + data);
});
workerProcess.on('close', function (code) {
console.log('子进程已退出，退出码 '+code);
});
}
*/
//14.3 fork
for(var i=0; i<3; i++) {
var worker_process = child_process.fork("support.js", [i]);
worker_process.on('close', function (code) {
console.log('子进程已退出，退出码 ' + code);
});
}
//15. JXcore打包 todo
//16. Mysql
var mysql = require('mysql');
var connection = mysql.createConnection({
host : 'xxx',
user : 'xxx',
password : 'xxx',
database : 'xxx'
});
connection.connect();
connection.query('SELECT * from users where id = xx', function (error, results, fields) {
if (error) throw error;
console.log('The solution is: ', results[0]);
});
网友评论