目录
  1. Hello World
  2. 创建第一个Node.js应用
  3. REPL （调试Javascript）
  4. 回调函数
  5. 事件循环
  6. 函数
  7. 模块系统
  8. 路由

少壮不努力，老大徒伤悲。

本文为本人略读官网文档后的大略笔记，实在不适合他人阅读。

前言

Node.js : 运行在服务端的JavaScript

是一个事件驱动I/O服务端JavaScript环境，基于Google的V8引擎。

安装

安装node
brew install node

查看当前node版本
node -v

1. Hello World

创建test.js (内容如下)

console.log("Hello World"); 

终端执行 node test.js

输出Hello World

效果图

交互模式（终端输入node）效果图

2. 创建第一个Node.js应用

Node.js应用的组成部分

1. 引入required模块
  使用require指令来载入Node.js模块。

2. 创建服务器
  服务器监听客户端请求。
  Apache、Nginx等HTTP 服务器。

3. 接收请求与响应请求 
  客户端可以使用浏览器或终端发送HTTP请求，服务器接收请求后返回响应数据。

步骤1: 引入required模块

// 使用require指令载入http 模块，并将实例化的HTTP赋值给变量http
var http = require("http");

步骤2: 创建服务器

创建 server.js文件

var http = require('http');

// 创建服务器
http.createServer(function (request, response) {
    // 发送 HTTP 头部 
    // HTTP 状态值: 200 : OK
    // 内容类型: text/plain
    response.writeHead(200, {'Content-Type': 'text/plain'});

    // 发送响应数据 "Hello World"
    response.end('Hello World\n');
}).listen(8088);

// 终端打印如下信息
console.log('Server running at http://127.0.0.1:8088/');

终端运行 node server.js

如果运行出错，可能是端口号冲突，换一个端口即可。

运行效果

3. REPL （调试Javascript）

REPL(Read Eval Print Loop:交互式解释器)
一个电脑的环境，类似 Window 系统的终端或 Unix/Linux shell，我们可以在终端中输入命令，并接收系统的响应。

Node自带了交互式解释器，可以执行以下任务：
    1. 读取 
      读取用户输入，解析输入了Javascript 数据结构并存储在内存中。
    2. 执行 
      执行输入的数据结构
    3. 打印
      输出结果
    4. 循环
      循环操作以上步骤直到用户两次按下 ctrl-c 按钮退出。

退出当前终端
    ctrl + c 。

按下两次 - 退出 Node REPL
    ctrl + c 。

退出 Node REPL
    ctrl + d - 

查看输入的历史命令
    向上/向下键 

补全当前命令
    tab 键 

列出可使用命令
    .help  

退出多行表达式
    .break 

退出多行表达式
    .clear 

保存当前的 Node REPL 会话到指定文件
    .save filename  

载入当前 Node REPL 会话的文件内容
    .load filename 

首先，在终端输入node

可使用
  1. 表达式运算
  2. 变量
  3. 多行语句
  4. _获取上一个表达式的值

运行效果

4. 回调函数

Node 所有 API 都支持回调函数

回调函数一般作为函数的最后一个参数出现
  function foo1(name, age, callback) { }
  function foo2(value, callback1, callback2) { }

例1 （阻塞）

创建content.txt文件

Hello World!
Hello cx,,,

创建main.js文件

var fs = require("fs");

var data = fs.readFileSync('content.txt');
console.log(data.toString());
console.log("程序执行结束!");

终端执行 node main.js

Hello World!
Hello cx,,,
程序执行结束!

例2 （非阻塞）

创建content.txt文件

Hello World!
Hello cx,,,

创建main.js文件

var fs = require("fs");

fs.readFile('content.txt', function (err, data) {
    if (err) return console.error(err);
    console.log(data.toString());
});
console.log("程序执行结束!");

终端执行 node main.js

程序执行结束!
Hello World!
Hello cx,,,

5. 事件循环

NOde.js是单进程单线程应用程序，但V8引擎提供了异步执行回调接口，可处理大量的并发，所以性能非常高。
几乎所有API都支持回调函数。
几乎所有事件机制都是通过观察者模式实现的。

第一步：导入事件模块，创建eventEmitter 对象
第二步：绑定事件
    回调函数作为最后一个参数。
    err对象作为回调函数第一个参数。
    当添加新的监听器时，newListener 事件会触发。
    当监听器被移除时，removeListener 事件被触发。
第三步：触发事件
    类似于观察者模式，所有注册在某一事件上的处理函数都相当于观察者。当事件触发时依次调用处理函数。

// 1
// 引入 events 模块
var events = require('events');
// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();

// 2
// 绑定事件及事件的处理程序
eventEmitter.on('eventName', eventHandler);

// 3
// 触发事件
eventEmitter.emit('eventName');

例1

创建test.js文件(内容如下)
执行node test.js 输出：
  连接成功。
  数据接收成功。
  程序执行完毕。

// 引入 events 模块
var events = require('events');
// 创建 eventEmitter 对象（在实例化时发生错误，会触发 error 事件）
var eventEmitter = new events.EventEmitter();
 
// 创建事件处理程序
var connectHandler = function connected() {
   console.log('连接成功。');
  
   // 触发 data_received 事件 
   eventEmitter.emit('data_received');
}
 
// 绑定 connection 事件处理程序
eventEmitter.on('connection', connectHandler);
 
// 使用匿名函数绑定 data_received 事件
eventEmitter.on('data_received', function(){
   console.log('数据接收成功。');
});
 
// 触发 connection 事件 
eventEmitter.emit('connection');
 
console.log("程序执行完毕。");

例2（err：回调函数的第一个参数）

============== input.txt ==============
Hello World!
Hello cx,,,

============== test.js ==============
var fs = require("fs");
fs.readFile('input.txt', function (err, data) {
   if (err){
      console.log(err.stack);
      return;
   }
   console.log(data.toString());
});
console.log("程序执行完毕");

============== node test.js ==============
程序执行完毕
Hello World!
Hello cx,,,
==============删除input.txt node test.js ==============
程序执行完毕
Error: ENOENT: no such file or directory, open 'input.txt'

例3

输出：
  listener1 arg1 参数 arg2 参数
  listener2 arg1 参数 arg2 参数

//event.js 文件
var events = require('events'); 
var emitter = new events.EventEmitter(); 
emitter.on('someEvent', function(arg1, arg2) { 
    console.log('listener1', arg1, arg2); 
}); 
emitter.on('someEvent', function(arg1, arg2) { 
    console.log('listener2', arg1, arg2); 
}); 
emitter.emit('someEvent', 'arg1 参数', 'arg2 参数'); 

1. EventEmitter

多数情况下不会直接使用 EventEmitter，而是在对象中继承它。包括 fs、net、 http 在内的，只要是支持事件响应的核心模块都是 EventEmitter 的子类。

通过require("events");导入events模块。
events模块只提供了一个对象，就是events.EventEmitter。
EventEmitter的核心就是对事件触发与事件监听器功能进行封装。
EventEmitter的每个事件由一个事件名和若干个参数组成。事件名是一个字符串。

Node.js 所有的异步 I/O 操作在完成时都会发送一个事件到事件队列。
Node.js 里面的许多对象都会分发事件：
  一个 net.Server 对象会在每次有新连接时触发一个事件
  一个 fs.readStream 对象会在文件被打开的时候触发一个事件。 

所有这些产生事件的对象都是 events.EventEmitter 的实例。

例1

输出

2 个监听器监听连接事件。
监听器 listener1 执行。
监听器 listener2 执行。
listener1 不再受监听。
监听器 listener2 执行。
1 个监听器监听连接事件。
程序执行完毕。 

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

// 监听器 #1
var listener1 = function listener1() {
   console.log('监听器 listener1 执行。');
}

// 监听器 #2
var listener2 = function listener2() {
  console.log('监听器 listener2 执行。');
}

// 绑定 connection 事件，处理函数为 listener1 
eventEmitter.addListener('connection', listener1);

// 绑定 connection 事件，处理函数为 listener2
eventEmitter.on('connection', listener2);

var eventListeners = eventEmitter.listenerCount('connection');
console.log(eventListeners + " 个监听器监听连接事件。");

// 处理 connection 事件 
eventEmitter.emit('connection');

// 移除监绑定的 listener1 函数
eventEmitter.removeListener('connection', listener1);
console.log("listener1 不再受监听。");

// 触发连接事件
eventEmitter.emit('connection');

eventListeners = eventEmitter.listenerCount('connection');
console.log(eventListeners + " 个监听器监听连接事件。");

console.log("程序执行完毕。");

 大多数时候我们不会直接使用 EventEmitter，而是在对象中继承它。包括 fs、net、 http 在内的，只要是支持事件响应的核心模块都是 EventEmitter 的子类。

为什么要这样做呢？原因有两点：
首先，具有某个实体功能的对象实现事件符合语义， 事件的监听和发生应该是一个对象的方法。
其次 JavaScript 的对象机制是基于原型的，支持 部分多重继承，继承 EventEmitter 不会打乱对象原有的继承关系。

6. 函数

函数作参

在JavaScript中，一个函数可以作为另一个函数的参数。

function say(word) {
  console.log(word);
}
function execute(someFunction, value) {
  someFunction(value);
}
execute(say, "Hello");

匿名函数

function execute(someFunction, value) {
  someFunction(value);
}

execute(function(word){ console.log(word) }, "Hello");

http.createServer方法就是传入了一个匿名函数

var http = require("http");

http.createServer(function(request, response) {
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("Hello World");
  response.end();
}).listen(8888);
==================等价
function onRequest(request, response) {
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("Hello World");
  response.end();
}
http.createServer(onRequest).listen(8888);

7. 模块系统

模块是Node.js 应用程序的基本组成部分。
文件和模块是一一对应的，即：一个 Node.js 文件就是一个模块。这个文件可以是js代码、JSON 、编译过的C/C++ 扩展。

Node.js提供了exports、require两个对象，分别用于导出、导入。

exports 
  暴露属性和方法
module.exports
  暴露对象

require 方法中的文件查找策略

Node.js存在4类模块（原生模块和3种文件模块）

原生模块
    http、fs、path等。
相对路径的文件模块
    ./mod或../mod。
绝对路径的文件模块
    /pathtomodule/mod。
非原生模块的文件模块
    mod。

在路径 Y 下执行 require(X) 语句执行顺序

1. 如果 X 是内置模块
   a. 返回内置模块
   b. 停止执行
2. 如果 X 以 '/' 开头
   a. 设置 Y 为文件根路径
3. 如果 X 以 './' 或 '/' or '../' 开头
   a. LOAD_AS_FILE(Y + X)
   b. LOAD_AS_DIRECTORY(Y + X)
4. LOAD_NODE_MODULES(X, dirname(Y))
5. 抛出异常 "not found"

LOAD_AS_FILE(X)
1. 如果 X 是一个文件, 将 X 作为 JavaScript 文本载入并停止执行。
2. 如果 X.js 是一个文件, 将 X.js 作为 JavaScript 文本载入并停止执行。
3. 如果 X.json 是一个文件, 解析 X.json 为 JavaScript 对象并停止执行。
4. 如果 X.node 是一个文件, 将 X.node 作为二进制插件载入并停止执行。

LOAD_INDEX(X)
1. 如果 X/index.js 是一个文件,  将 X/index.js 作为 JavaScript 文本载入并停止执行。
2. 如果 X/index.json 是一个文件, 解析 X/index.json 为 JavaScript 对象并停止执行。
3. 如果 X/index.node 是一个文件,  将 X/index.node 作为二进制插件载入并停止执行。

LOAD_AS_DIRECTORY(X)
1. 如果 X/package.json 是一个文件,
   a. 解析 X/package.json, 并查找 "main" 字段。
   b. let M = X + (json main 字段)
   c. LOAD_AS_FILE(M)
   d. LOAD_INDEX(M)
2. LOAD_INDEX(X)

LOAD_NODE_MODULES(X, START)
1. let DIRS=NODE_MODULES_PATHS(START)
2. for each DIR in DIRS:
   a. LOAD_AS_FILE(DIR/X)
   b. LOAD_AS_DIRECTORY(DIR/X)

NODE_MODULES_PATHS(START)
1. let PARTS = path split(START)
2. let I = count of PARTS - 1
3. let DIRS = []
4. while I >= 0,
   a. if PARTS[I] = "node_modules" CONTINUE
   b. DIR = path join(PARTS[0 .. I] + "node_modules")
   c. DIRS = DIRS + DIR
   d. let I = I - 1
5. return DIRS

例1（创建模块）

================ hello.js ================
// 导出world
exports.world = function() {
  console.log('Hello World');
}
================ test.js ================
// ./ 为当前目录，node.js 默认后缀为 js
var hello = require('./hello');
hello.world();

例2（当只导出一个对象时）

module.exports = function() {
  // ...
}


如：http模块
var http = require("http");
http.createServer(...);

================  hello.js ================
//hello.js 
function Hello() { 
    var name; 
    this.setName = function(thyName) { 
        name = thyName; 
    }; 
    this.sayHello = function() { 
        console.log('Hello ' + name); 
    }; 
}; 
module.exports = Hello;
================  main.js ================
//main.js 
var Hello = require('./hello'); 
hello = new Hello(); 
hello.setName('BYVoid'); 
hello.sayHello(); 

8. 路由

屏幕快照 2020-04-03 11.09.49.png

. 工具 模块

1. OS 模块（系统操作函数）

引入

var os = require("os")

例1 （test.js）

var os = require("os");

// CPU 的字节序
console.log('endianness : ' + os.endianness());

// 操作系统名
console.log('type : ' + os.type());

// 操作系统名
console.log('platform : ' + os.platform());

// 系统内存总量
console.log('total memory : ' + os.totalmem() + " bytes.");

// 操作系统空闲内存量
console.log('free memory : ' + os.freemem() + " bytes.");

node test.js输出

endianness : LE
type : Darwin
platform : darwin
total memory : 17179869184 bytes.
free memory : 562544640 bytes.

2. Path 模块 (处理文件路径的小工具)

引入

var path = require("path")

path.resolve([from ...], to)   例：

// 返回: '/foo/bar/baz'    
path.resolve('/foo/bar', './baz');  
// 返回: '/tmp/file'  
path.resolve('/foo/bar', '/tmp/file/');  
// 如果当前工作目录为 /home/myself/node，则返回 '/home/myself/node/wwwroot/static_files/gif/image.gif'
path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif');  

path.relative(from, to)

在 Linux 上：
path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
// 返回: '../../impl/bbb'

在 Windows 上：
path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb');
// 返回: '..\\..\\impl\\bbb'

例1（test.js）

var path = require("path");

// 格式化路径
console.log('normalization : ' + path.normalize('/test/test1//2slashes/1slash/tab/..'));

// 连接路径
console.log('joint path : ' + path.join('/test', 'test1', '2slashes/1slash', 'tab', '..'));

// 转换为绝对路径
console.log('resolve : ' + path.resolve('main.js'));

// 路径中文件的后缀名
console.log('ext name : ' + path.extname('main.js'));

ode test.js输出

normalization : /test/test1/2slashes/1slash
joint path : /test/test1/2slashes/1slash
resolve : /Users/cx/Desktop/nodejs/main.js
ext name : .js

3. Net 模块(用于底层的网络通信的小工具，包含了创建服务器/客户端的方法)

引入

var net = require("net")

》》》net.Server
通常用于创建一个 TCP 或本地服务器

》》》net.Socket
net.Socket对象是 TCP 或 UNIX Socket 的抽象。
net.Socket 实例实现了一个双工流接口。
他们可以在用户创建客户端(使用 connect())时使用, 或者由 Node 创建它们，并通过 connection 服务器事件传递给用户。

例1

============== server.js  ===============
var net = require('net');
var server = net.createServer(function(connection) { 
   console.log('client connected');
   connection.on('end', function() {
      console.log('客户端关闭连接');
   });
   connection.write('Hello World!\r\n');
   connection.pipe(connection);
});
server.listen(8088, function() { 
  console.log('server is listening');
});


============== client.js  ===============
var net = require('net');
var client = net.connect({port: 8088}, function() {
   console.log('连接到服务器！');  
});
client.on('data', function(data) {
   console.log(data.toString());
   client.end();
});
client.on('end', function() { 
   console.log('断开与服务器的连接');
});

============== 在两个终端下分别执行 node server.js、node client.js  ===============
服务端输出
server is listening
client connected
客户端关闭连接


客户端输出
  连接到服务器！
  Hello World!

  断开与服务器的连接

4. DNS 模块 (解析域名)

引入


var dns = require("dns")

dns.resolve() 方法中有效的 rrtypes值:
    'A' IPV4 地址, 默认
    'AAAA' IPV6 地址
    'MX' 邮件交换记录
    'TXT' text 记录
    'SRV' SRV 记录
    'PTR' 用来反向 IP 查找
    'NS' 域名服务器记录
    'CNAME' 别名记录
    'SOA' 授权记录的初始值

每次 DNS 查询都可能返回以下错误码：

    dns.NODATA: 无数据响应。
    dns.FORMERR: 查询格式错误。
    dns.SERVFAIL: 常规失败。
    dns.NOTFOUND: 没有找到域名。
    dns.NOTIMP: 未实现请求的操作。
    dns.REFUSED: 拒绝查询。
    dns.BADQUERY: 查询格式错误。
    dns.BADNAME: 域名格式错误。
    dns.BADFAMILY: 地址协议不支持。
    dns.BADRESP: 回复格式错误。
    dns.CONNREFUSED: 无法连接到 DNS 服务器。
    dns.TIMEOUT: 连接 DNS 服务器超时。
    dns.EOF: 文件末端。
    dns.FILE: 读文件错误。
    dns.NOMEM: 内存溢出。
    dns.DESTRUCTION: 通道被摧毁。
    dns.BADSTR: 字符串格式错误。
    dns.BADFLAGS: 非法标识符。
    dns.NONAME: 所给主机不是数字。
    dns.BADHINTS: 非法HINTS标识符。
    dns.NOTINITIALIZED: c c-ares 库尚未初始化。
    dns.LOADIPHLPAPI: 加载 iphlpapi.dll 出错。
    dns.ADDRGETNETWORKPARAMS: 无法找到 GetNetworkParams 函数。
    dns.CANCELLED: 取消 DNS 查询。

例1（test.js）

var dns = require('dns');

dns.lookup('www.github.com', function onLookup(err, address, family) {
   console.log('ip 地址:', address);
   dns.reverse(address, function (err, hostnames) {
   if (err) {
      console.log(err.stack);
   }

   console.log('反向解析 ' + address + ': ' + JSON.stringify(hostnames));
});  
});

node test.js输出

ip 地址: 13.250.177.223
反向解析 13.250.177.223: ["ec2-13-250-177-223.ap-southeast-1.compute.amazonaws.com"]

5. Domain 模块 (捕捉处理try catch无法捕捉的异常)

引入

var domain = require("domain")

Domain 模块分为
    1. 隐式绑定
      把在domain上下文中定义的变量，自动绑定到domain对象
    2. 显式绑定
      把不是在domain上下文中定义的变量，以代码的方式绑定到domain对象

把处理多个不同的IO的操作作为一个组。注册事件和回调到domain，当发生一个错误事件或抛出一个错误时，domain对象会被通知，不会丢失上下文环境，也不导致程序错误立即退出，与process.on('uncaughtException')不同

例1（test.js）

var EventEmitter = require("events").EventEmitter;
var domain = require("domain");

var emitter1 = new EventEmitter();
// 创建域
var domain1 = domain.create();
domain1.on('error', function(err){
   console.log("domain1 处理这个错误 ("+err.message+")");
});

// 显式绑定
domain1.add(emitter1);
emitter1.on('error',function(err){
   console.log("监听器处理此错误 ("+err.message+")");
});

emitter1.emit('error',new Error('通过监听器来处理'));
emitter1.removeAllListeners('error');
emitter1.emit('error',new Error('通过 domain1 处理'));

var domain2 = domain.create();
domain2.on('error', function(err){
   console.log("domain2 处理这个错误 ("+err.message+")");
});
// 隐式绑定
domain2.run(function(){
   var emitter2 = new EventEmitter();
   emitter2.emit('error',new Error('通过 domain2 处理'));   
});

domain1.remove(emitter1);
emitter1.emit('error', new Error('转换为异常，系统将崩溃!'));

node test.js输出

监听器处理此错误 (通过监听器来处理)
domain1 处理这个错误 (通过 domain1 处理)
domain2 处理这个错误 (通过 domain2 处理)
events.js:298
      throw er; // Unhandled 'error' event
      ^

Error: 转换为异常，系统将崩溃!
    at Object.<anonymous> (/Users/cx/Desktop/nodejs/client.js:40:24)
    at Module._compile (internal/modules/cjs/loader.js:1151:30)
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1171:10)
    at Module.load (internal/modules/cjs/loader.js:1000:32)
    at Function.Module._load (internal/modules/cjs/loader.js:899:14)
    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:71:12)
    at internal/main/run_main_module.js:17:47
Emitted 'error' event at:
    at Object.<anonymous> (/Users/cx/Desktop/nodejs/client.js:40:10)
    at Module._compile (internal/modules/cjs/loader.js:1151:30)
    [... lines matching original stack trace ...]
    at internal/main/run_main_module.js:17:47

6. util 模块(Node.js核心）常用函数

引入

const util = require('util');

将 async 异步函数（或者一个返回值为 Promise 的函数）转换成遵循异常优先的回调风格的函数

// (err, value) => ... 回调,作为最后一个参数
// 在回调函数中，第一个参数为拒绝的原因（如果 Promise 解决，则为 null），第二个参数则是解决的值。
util.callbackify(original)

例1

const util = require('util');

async function fn() {
  return 'hello world';
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  if (err) throw err;
  console.log(ret);
});


输出
hello world

例2

function fn() {
  return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  // 当 Promise 被以 `null` 拒绝时，它被包装为 Error 并且原始值存储在 `reason` 中。
  err && err.hasOwnProperty('reason') && err.reason === null;  // true
});

实现对象间原型继承的函数

util.inherits(constructor, superConstructor)

JavaScript 的面向对象特性是基于原型的，与常见的基于类的不同。JavaScript 没有提供对象继承的语言级别特性，而是通过原型复制来实现的。

例

============= test.js =============
var util = require('util'); 
function Base() { 
    this.name = 'cx'; 
    this.base = 2000; 
    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(); 
//objSub.sayHello(); 
console.log(objSub); 
=============终端输出=============
cx
Hello cx
Base { name: 'cx', base: 2000, sayHello: [Function (anonymous)] }
sub
Sub { name: 'sub' }

=============注意=============
Sub 仅仅继承了Base 在原型中定义的函数，而构造函数内部创造的 base 属 性和 sayHello 函数都没有被 Sub 继承。
在原型中定义的属性不会被 console.log 作 为对象的属性输出。

将任意对象转换为字符串

// object 要转换的对象
// showHidden 是否显示隐藏信息
// depth 最大递归的层数，默认2层，null则表示不限递归层数完整遍历
// colors 以 ANSI 颜色编码，在终端显示更漂亮
util.inspect(object,[showHidden],[depth],[colors])

例

============= test.js =============
var util = require('util'); 
function Person() { 
    this.name = 'cx'; 
    this.toString = function() { 
    return this.name; 
    }; 
} 
var obj = new Person(); 
console.log(util.inspect(obj)); 
console.log(util.inspect(obj, true)); 

=============终端输出=============
Person { name: 'cx', toString: [Function (anonymous)] }
Person {
  name: 'cx',
  toString: <ref *1> [Function (anonymous)] {
    [length]: 0,
    [name]: '',
    [arguments]: null,
    [caller]: null,
    [prototype]: { [constructor]: [Circular *1] }
  }
}

是否是数组

util.isArray(object)

例

var util = require('util');
// true
util.isArray([])
// true 
util.isArray(new Array)
// false 
util.isArray({})

是否是正则表达式

util.isRegExp(object)

例

var util = require('util');
// true
util.isRegExp(/some regexp/)
// true
util.isRegExp(new RegExp('another regexp'))
// false 
util.isRegExp({})

是否是日期

util.isDate(object)

例

var util = require('util');
// true
util.isDate(new Date())
// false (without 'new' returns a String)
util.isDate(Date())
// false  
util.isDate({})

Web 模块

Node.js 提供了 http 模块。http 模块主要用于搭建 HTTP 服务端和客户端,使用 HTTP 服务器或客户端功能必须调用 http 模块。
var http = require('http');

1. Web应用架构

Web服务器,目前最主流的3个: Apache、Nginx、IIS

Web应用架构

Web应用架构说明
  1. Client 
    客户端，一般指浏览器。浏览器可以通过 HTTP 协议向服务器请求数据。
  2. Server 
    服务端，一般指 Web 服务器。可以接收客户端请求，并向客户端发送响应数据。
  3. Business 
    业务层， 通过 Web 服务器处理应用程序，如与数据库交互，逻辑运算，调用外部程序等。
  4. Data 
    数据层，一般由数据库组成。

2. 例

index.html

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Hello World</title>
</head>
<body>
    <h1>我的第一个标题</h1>
    <p>我的第一个段落。</p>
</body>
</html>

server.js 服务器 (同一目录下创建该文件)

var http = require('http');
var fs = require('fs');
var url = require('url');
 
 
// 创建服务器
http.createServer( function (request, response) {  
   // 解析请求，包括文件名
   var pathname = url.parse(request.url).pathname;
   
   // 输出请求的文件名
   console.log("Request for " + pathname + " received.");
   
   // 从文件系统中读取请求的文件内容
   fs.readFile(pathname.substr(1), function (err, data) {
      if (err) {
         console.log(err);
         // HTTP 状态码: 404 : NOT FOUND
         // Content Type: text/html
         response.writeHead(404, {'Content-Type': 'text/html'});
      }else{             
         // HTTP 状态码: 200 : OK
         // Content Type: text/html
         response.writeHead(200, {'Content-Type': 'text/html'});    
         
         // 响应文件内容
         response.write(data.toString());        
      }
      //  发送响应数据
      response.end();
   });   
}).listen(8088);
 
// 控制台会输出以下信息
console.log('Server running at http://127.0.0.1:8088/');

终端启动服务器：node server.js

浏览器输入http://127.0.0.1:8088/index.html

终端输出：Request for /index.html received.

client.js 客户端

var http = require('http');
 
// 用于请求的选项
var options = {
   host: 'localhost',
   port: '8088',
   path: '/index.html'  
};
 
// 处理响应的回调函数
var callback = function(response){
   // 不断更新数据
   var body = '';
   response.on('data', function(data) {
      body += data;
   });
   
   response.on('end', function() {
      // 数据接收完成
      console.log(body);
   });
}
// 向服务端发送请求
var req = http.request(options, callback);
req.end();

执行客户端：node client.js（新开一个终端）

服务端-终端会输出：
Request for /index.html received.

客户端-终端会输出html内容：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Hello World</title>
</head>
<body>
    <h1>我的第一个标题</h1>
    <p>我的第一个段落。</p>
</body>
</html>

GET/POST请求

1. 获取GET请求内容

server.js

var http = require('http');
var url = require('url');
var util = require('util');
 
http.createServer(function(req, res){
    res.writeHead(200, {'Content-Type': 'text/plain; charset=utf-8'});
    res.end(util.inspect(url.parse(req.url, true)));
}).listen(3000);

node server.js

浏览器输入http://localhost:3000/user?name=cx&hello

server.js

var http = require('http');
var url = require('url');
var util = require('util');
 
http.createServer(function(req, res){
    res.writeHead(200, {'Content-Type': 'text/plain'});
 
    // 解析 url 参数
    var params = url.parse(req.url, true).query;
    res.write("name=" + params.name);
    res.write("\n");
    res.write("hello=" + params.hello);
    res.end();
 
}).listen(3000);

node server.js

浏览器输入hhttp://localhost:3000/user?name=cx&hello=world

2. 获取POST请求内容

 POST 请求的内容全部的都在请求体中，http.ServerRequest 并没有一个属性内容为请求体，原因是等待请求体传输可能是一件耗时的工作。

比如上传文件，而很多时候我们可能并不需要理会请求体的内容，恶意的POST请求会大大消耗服务器的资源，所以 node.js 默认是不会解析请求体的，当你需要的时候，需要手动来做。

var http = require('http');
var querystring = require('querystring');
var util = require('util');
 
http.createServer(function(req, res){
    // 定义了一个post变量，用于暂存请求体的信息
    var post = '';     
 
    // 通过req的data事件监听函数，每当接受到请求体的数据，就累加到post变量中
    req.on('data', function(chunk){    
        post += chunk;
    });
 
    // 在end事件触发后，通过querystring.parse将post解析为真正的POST请求格式，然后向客户端返回。
    req.on('end', function(){    
        post = querystring.parse(post);
        res.end(util.inspect(post));
    });
}).listen(3000);

例1（server.js）

var http = require('http');
var querystring = require('querystring');
 
var postHTML = 
  '<html><head><meta charset="utf-8"><title>Hello World</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 body = "";
  req.on('data', function (chunk) {
    body += chunk;
  });
  req.on('end', function () {
    // 解析参数
    body = querystring.parse(body);
    // 设置响应头部信息及编码
    res.writeHead(200, {'Content-Type': 'text/html; charset=utf8'});
 
    if(body.name && body.url) { // 输出提交的数据
        res.write("网站名：" + body.name);
        res.write("<br>");
        res.write("网站 URL：" + body.url);
    } else {  // 输出表单
        res.write(postHTML);
    }
    res.end();
  });
}).listen(3000);

node server.js

浏览器输入http://localhost:3000

提交结果

多进程

引入

const child_process = require('child_process');

Node.js 是以单线程的模式运行的，但它使用的是事件驱动来处理并发，这样有助于在多核 cpu 的系统上创建多个子进程，从而提高性能。
每个子进程总是带有三个流对象：child.stdin,child.stdout 和child.stderr。他们可能会共享父进程的 stdio 流，或者也可以是独立的被导流的流对象。

1. child_process.exec(command[, options], callback)

使用子进程执行命令，缓存子进程的输出,并将子进程的输出以回调函数参数的形式返回
等待进程结束，一次性返回缓冲区的内容

command
  将要执行的命令
  是个字符串，参数使用空格隔开（例：'node support.js '）

options 
  参数
  是个对象
    1. cwd 
      子进程的当前工作目录
      字符串
    2. env 
      环境变量键值对
      对象
    3. encoding
      字符编码（默认： 'utf8'）
      字符串
    4. shell
      将要执行命令的 Shell（默认: 在 UNIX 中为/bin/sh， 在 Windows 中为cmd.exe， Shell 应当能识别 -c开关在 UNIX 中，或 /s /c 在 Windows 中。 在Windows 中，命令行解析应当能兼容cmd.exe）
      字符串
    5. timeout
      超时时间（默认： 0）
      数字
    6. maxBuffer
      在 stdout 或 stderr 中允许存在的最大缓冲（二进制），如果超出那么子进程将会被杀死 （默认: 200*1024）
      数字
    7. killSignal 
      结束信号（默认：'SIGTERM'）
      字符串
    8. uid
      设置用户进程的 ID
      数字
    9. gid
      设置进程组的 ID
      数字

callback 
  回调函数
  包含三个参数error, stdout 和 stderr。（例：function (error, stdout, stderr) {} ）

例1

================ support.js  ================
console.log("进程 " + process.argv[2] + " 执行。" );

================ test.js ================
const fs = require('fs');
const child_process = require('child_process');
 
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);
    });
 
    workerProcess.on('exit', function (code) {
        console.log('子进程已退出，退出码 '+code);
    });
}

================ node test.js ================
子进程已退出，退出码 0
子进程已退出，退出码 0
子进程已退出，退出码 0
stdout: 进程 2 执行。

stderr: 
stdout: 进程 1 执行。

stderr: 
stdout: 进程 0 执行。

stderr: 

2. child_process.spawn(command[, args][, options])

使用指定的命令行参数创建新进程
返回流 (stdout & stderr)，在进程返回大量数据时使用。进程一旦开始执行时 spawn() 就开始接收响应。

command
  将要执行的命令
  是个字符串
args
  字符串参数数组
  是个Array 

options 
    是个Object
    1. cwd 
      子进程的当前工作目录
      String 
    2. env  
      环境变量键值对
      Object
    3. stdio  
      子进程的 stdio 配置
      Array|String
    4. detached  
      这个子进程将会变成进程组的领导
      Boolean
    5. uid 
      设置用户进程的 ID
      Number
    6. gid  
      设置进程组的 ID
      Number

例1

================ support.js  ================
console.log("进程 " + process.argv[2] + " 执行。" );

================ test.js ================
const fs = require('fs');
const child_process = require('child_process');
 
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);
   });
}

================ node test.js ================
stdout: 进程 0 执行。

stdout: 进程 1 执行。

stdout: 进程 2 执行。

子进程已退出，退出码 0
子进程已退出，退出码 0
子进程已退出，退出码 0

3. child_process.fork(modulePath[, args][, options])

spawn() 方法的特殊形式，用于创建进程。
如 fork('./son.js') 相当于 spawn('node', ['./son.js']) 。
与spawn方法不同的是，fork会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信

modulePath
  将要在子进程中运行的模块
  String

args
  字符串参数数组
  Array

options
  Object
    1. cwd  
      子进程的当前工作目录
      String
    2. env  
      环境变量键值对
      Object
    3. execPath  
      创建子进程的可执行文件
      String
    4. execArgv  
      子进程的可执行文件的字符串参数数组（默认： process.execArgv）
      Array
    5. silent  
      如果为true，子进程的stdin，stdout和stderr将会被关联至父进程，
      如果为false，它们将会从父进程中继承。（默认为：false）
      Boolean
    6. uid  
      设置用户进程的 ID
      Number
    7. gid  
      设置进程组的 ID
      Number

================ support.js  ================
console.log("进程 " + process.argv[2] + " 执行。" );

================ test.js ================
const fs = require('fs');
const child_process = require('child_process');
 
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);
   });
}

================ node test.js ================
进程 0 执行。
进程 1 执行。
进程 2 执行。
子进程已退出，退出码 0
子进程已退出，退出码 0
子进程已退出，退出码 0

JXcore（打包）

JXcore：一个支持多线程的Node.js发行版本

1. 安装JXcore

JXcore安装包github地址

1. 下载JXcore安装包
2. 解压后找到对应平台的zip包，解压后将jx可执行文件复制到/usr/local/bin目录下
3. export PATH=$PATH:/usr/local/bin
4. 查看是否安装成功（出现jx版本号，则成功） 
  jx --version

2. 将项目打包成一个可运行的.jx文件

打包（指定 index.js 为 Node.js 项目的主文件）
  jx package index.js index

会生成2文件
  1. index.jxp。中间件文件，包含了需要编译的完整项目信息。
  2. index.jx。完整包信息的二进制文件，可运行在客户端上。

运行
  jx index.jx

Buffer(缓冲区)

JavaScript只有字符串数据类型，没有二进制数据类型。
但在处理像TCP流或文件流时，必须使用到二进制数据。因此在 Node.js中，定义了一个 Buffer 类，该类用来创建一个专门存放二进制数据的缓存区。

在 Node.js 中，Buffer 类是随 Node 内核一起发布的核心库。
Buffer 库为 Node.js 带来了一种存储原始数据的方法，可以让 Node.js 处理二进制数据，每当需要在 Node.js 中处理I/O操作中移动的数据时，就有可能使用 Buffer 库。
原始数据存储在 Buffer 类的实例中。
一个 Buffer 类似于一个整数数组，但它对应于 V8 堆内存之外的一块原始内存。

在v6.0之前创建Buffer对象直接使用new Buffer()构造函数来创建对象实例，但是Buffer对内存的权限操作相比很大，可以直接捕获一些敏感信息，所以在v6.0以后，官方文档里面建议使用 Buffer.from() 接口去创建Buffer对象。

1. Buffer 与字符编码

Buffer实例一般用于表示编码字符的序列，比如 UTF-8 、 UCS2 、 Base64 、或十六进制编码的数据。
通过使用显式的字符编码，就可以在 Buffer 实例与普通的 JavaScript 字符串之间进行相互转换。

Node.js 目前支持的字符编码包括：
  1. ascii 
    仅支持 7 位 ASCII 数据。如果设置去掉高位的话，这种编码是非常快的。
  2. utf8 
    多字节编码的 Unicode 字符。许多网页和其他文档格式都使用 UTF-8 。
  3. utf16le 
    2 或 4 个字节，小字节序编码的 Unicode 字符。支持代理对（U+10000 至 U+10FFFF）。
  4. ucs2 
    utf16le 的别名。
  5. base64 
    Base64 编码。
  6. latin1  
    一种把 Buffer 编码成一字节编码的字符串的方式。
  7. binary 
    latin1 的别名。
  8. hex 
    将每个字节编码为两个十六进制字符

例1

const buf = Buffer.from('cx', 'ascii');

// 输出 6378
console.log(buf.toString('hex'));

// 输出 Y3g=
console.log(buf.toString('base64'));

2. 创建 Buffer 类

Buffer.alloc(size[, fill[, encoding]])
    返回一个指定大小的 Buffer 实例，如果没有设置 fill，则默认填满 0
Buffer.allocUnsafe(size)
    返回一个指定大小的 Buffer 实例，但是它不会被初始化，所以它可能包含敏感的数据
Buffer.allocUnsafeSlow(size)
Buffer.from(array)
    返回一个被 array 的值初始化的新的 Buffer 实例（传入的 array 的元素只能是数字，不然就会自动被 0 覆盖）
Buffer.from(arrayBuffer[, byteOffset[, length]])
    返回一个新建的与给定的 ArrayBuffer 共享同一内存的 Buffer。
Buffer.from(buffer)
    复制传入的 Buffer 实例的数据，并返回一个新的 Buffer 实例
Buffer.from(string[, encoding])
    返回一个被 string 的值初始化的新的 Buffer 实例

例1

// 创建一个长度为 10、且用 0 填充的 Buffer。
const buf1 = Buffer.alloc(10);

// 创建一个长度为 10、且用 0x1 填充的 Buffer。 
const buf2 = Buffer.alloc(10, 1);

// 创建一个长度为 10、且未初始化的 Buffer。
// 这个方法比调用 Buffer.alloc() 更快，
// 但返回的 Buffer 实例可能包含旧数据，
// 因此需要使用 fill() 或 write() 重写。
const buf3 = Buffer.allocUnsafe(10);

// 创建一个包含 [0x1, 0x2, 0x3] 的 Buffer。
const buf4 = Buffer.from([1, 2, 3]);

// 创建一个包含 UTF-8 字节 [0x74, 0xc3, 0xa9, 0x73, 0x74] 的 Buffer。
const buf5 = Buffer.from('tést');

// 创建一个包含 Latin-1 字节 [0x74, 0xe9, 0x73, 0x74] 的 Buffer。
const buf6 = Buffer.from('tést', 'latin1');

3. 写入缓冲区

buf.write(string[, offset[, length]][, encoding])

根据 encoding 的字符编码写入 string 到 buf 中的 offset 位置。 
length 参数是写入的字节数。 如果 buf 没有足够的空间保存整个字符串，则只会写入 string 的一部分。 只部分解码的字符不会被写入。
返回实际写入的大小。如果 buffer 空间不足， 则只会写入部分字符串。

参数说明

  1. string 
    写入缓冲区的字符串。
  2. offset 
    缓冲区开始写入的索引值，默认为 0 。
  3. length 
    写入的字节数，默认为 buffer.length
  4. encoding 
    使用的编码。默认为 'utf8' 。

例1

buf = Buffer.alloc(256);
len = buf.write("www.baidu.com");

console.log("写入字节数 : "+  len);

================
写入字节数 : 13

4. 从缓冲区读取数据

buf.toString([encoding[, start[, end]]])

解码缓冲区数据并使用指定的编码返回字符串。

参数说明

  1. encoding 
    使用的编码。默认为 'utf8' 。
  2. start 
    指定开始读取的索引位置，默认为 0。
  3. end 
    结束位置，默认为缓冲区的末尾。

例1

buf = Buffer.alloc(26);
for (var i = 0 ; i < 26 ; i++) {
  buf[i] = i + 97;
}

console.log( buf.toString('ascii'));       // 输出: abcdefghijklmnopqrstuvwxyz
console.log( buf.toString('ascii',0,5));   //使用 'ascii' 编码, 并输出: abcde
console.log( buf.toString('utf8',0,5));    // 使用 'utf8' 编码, 并输出: abcde
console.log( buf.toString(undefined,0,5)); // 使用默认的 'utf8' 编码, 并输出: abcde

================
abcdefghijklmnopqrstuvwxyz
abcde
abcde
abcde

5. 将 Buffer 转换为 JSON 对象

buf.toJSON()

当字符串化一个 Buffer 实例时，JSON.stringify() 会隐式地调用该 toJSON()。

例1

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);

// 输出: {"type":"Buffer","data":[1,2,3,4,5]}
console.log(json);

const copy = JSON.parse(json, (key, value) => {
  return value && value.type === 'Buffer' ?
    Buffer.from(value.data) :
    value;
});

// 输出: <Buffer 01 02 03 04 05>
console.log(copy);
==================

{"type":"Buffer","data":[1,2,3,4,5]}
<Buffer 01 02 03 04 05>

6. 缓冲区合并

Buffer.concat(list[, totalLength])

返回一个多个成员合并的新 Buffer 对象

参数说明

  1. list 
    用于合并的 Buffer 对象数组列表。
  2. totalLength 
    指定合并后Buffer对象的总长度。

例1

var buffer1 = Buffer.from(('hello'));
var buffer2 = Buffer.from(('world'));
var buffer3 = Buffer.concat([buffer1,buffer2]);
console.log("buffer3 内容: " + buffer3.toString());
=====================
buffer3 内容: helloworld

7. 缓冲区比较

buf.compare(otherBuffer);
返回一个数字，表示 buf 在 otherBuffer 之前，之后或相同。

参数说明

  1. otherBuffer 
    与 buf 对象比较的另外一个 Buffer 对象。 

例1

var buffer1 = Buffer.from('ABC');
var buffer2 = Buffer.from('ABCD');
var result = buffer1.compare(buffer2);

if(result < 0) {
   console.log(buffer1 + " 在 " + buffer2 + "之前");
}else if(result == 0){
   console.log(buffer1 + " 与 " + buffer2 + "相同");
}else {
   console.log(buffer1 + " 在 " + buffer2 + "之后");
}
======================
ABC 在 ABCD之前

8. 拷贝缓冲区

buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]])

参数说明

  1. targetBuffer 
    要拷贝的 Buffer 对象。
  2. targetStart 
    数字, 可选, 默认: 0
  3. sourceStart 
    数字, 可选, 默认: 0
  4. sourceEnd 
    数字, 可选, 默认: buffer.length

例1

var buf1 = Buffer.from('abcdefghijkl');
var buf2 = Buffer.from('RUNOOB');

//将 buf2 插入到 buf1 指定位置上
buf2.copy(buf1, 2);

console.log(buf1.toString());

===================
abRUNOOBijkl

9. 缓冲区裁剪

buf.slice([start[, end]])

返回一个新的缓冲区，它和旧缓冲区指向同一块内存，但是从索引 start 到 end 的位置剪切。

参数说明

  1. start 
    数字, 可选, 默认: 0
  2. end 
    数字, 可选, 默认: buffer.length

例1

var buffer1 = Buffer.from('runoob');
// 剪切缓冲区
var buffer2 = buffer1.slice(0,2);
console.log("buffer2 content: " + buffer2.toString());
==================
buffer2 content: ru

10. 缓冲区长度

buf.length;

返回 Buffer 对象所占据的内存长度

例1

var buffer = Buffer.from('hello world');
//  缓冲区长度
console.log("buffer length: " + buffer.length);
==================
buffer length: 11

const buf = Buffer.allocUnsafe(6);
buf.writeUIntLE(0x1234567890ab, 0, 6);
// 输出: <Buffer ab 90 78 56 34 12>
console.log(buf);

const buf = Buffer.allocUnsafe(6);
buf.writeUIntBE(0x1234567890ab, 0, 6);
// 输出: <Buffer 12 34 56 78 90 ab>
console.log(buf);

待续。。。。。