node.js 笔记

项目需求分析

1. 看一下本期需求的页数和接口数。
2. 分析要做的需求，找出技术难点。
3. 评估时间。
4. 先最主要的，最快能实现的。
5. 针对每个技术难点进行攻克。
6. 测试优化项目。
7. 项目上线。

Node.js

BFF 层：backend for Frontend

1.对用户侧提供 HTTP 服务
2.使用后端 RPC 服务

node.js 是怎么跑起来的？它的底层实现是如何的？

安装 node.js，配置 node.js 环境

Node.js 应用是由哪几部分组成的：

1. 引入 required 插件：我们可以使用 require 指令来载入 Node.js 插件。

2. 创建服务器：服务器可以监听客户端的请求，类似于 Apache 、Nginx 等 HTTP 服务器。

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

创建 Node.js 第一个 “Hello, World!” 应用

NPM 使用介绍

NPM是随同NodeJS一起安装的包管理工具。
安装 node 时，会自动一起安装完毕。

查看 npm 版本号：

npm -v

升级 npm 版本（默认的 npm 与 node 是配套的，不建议仅仅升级 npm 版本）：

sudo npm install npm -g

使用 npm 安装 node 插件：

$ npm install

比如：
使用 npm 命令安装常用的 Node.js web框架插件 express:
$ npm install express # 本地安装
$ npm install express -g # 全局安装

安装好之后，express 包就放在了工程目录下的 node_modules 目录中，因此在代码中只需要通过 require(‘express’) 的方式就好，无需指定第三方包路径。
var express = require(‘express’);

安装插件时，如果出现以下错误：
npm err! Error: connect ECONNREFUSED 127.0.0.1:8087

解决办法为：
$ npm config set proxy null

使用 npm 卸载 node 插件：

$ npm uninstall 卸载当前项目里安装的该插件
$ npm uninstall -g 卸载全局安装的该插件

使用 npm 更新 node 插件：

$ npm update 更新该插件

使用 npm 查找 node 插件：

$ npm search 查找该插件

创建模块——package.json

$ npm init

举个例子：
$ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See npm help json for definitive documentation on these fields
and exactly what they do.

Use npm install <pkg> --save afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
name: (node_modules) runoob # 模块名
version: (1.0.0)
description: Node.js 测试模块(www.runoob.com) # 描述
entry point: (index.js)
test command: make test
git repository: https://github.com/runoob/runoob.git # Github 地址
keywords:
author:
license: (ISC)
About to write to ……/node_modules/package.json: # 生成地址

{
“name”: “runoob”,
“version”: “1.0.0”,
“description”: “Node.js 测试模块(www.runoob.com)”,
……
}

Is this ok? (yes) yes
以上的信息，你需要根据你自己的情况输入。在最后输入 “yes” 后会生成 package.json 文件。

npm 版本号管控规则

语义版本号分为X.Y.Z三位，分别代表主版本号、次版本号和补丁版本号。当代码变更时，版本号按以下原则更新。

1. 如果只是修复bug，需要更新Z位。
2. 如果是新增了功能，但是向下兼容，需要更新Y位。
3. 如果有大变动，向下不兼容，需要更新X位。

Node.js REPL(交互式解释器)

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

Node 自带了交互式解释器，可以执行以下任务：

1. 读取 - 读取用户输入，解析输入的 Javascript 数据结构并存储在内存中。

2. 执行 - 执行输入的数据结构

3. 打印 - 输出结果

4. 循环 - 循环操作以上步骤直到用户两次按下 ctrl-c 按钮退出。

Node 的交互式解释器可以很好的调试 Javascript 代码。

开启 node 编程

$ node

熟悉常用的 node 编程：

1. 表达式运算
2. 使用变量
3. 多行表达式
4. 下划线(_)变量：获取上一个表达式的运算结果。

了解 REPL 命令

Node.js 回调函数

Node.js 异步编程的直接体现就是回调。

创建一个文件 input.txt ，内容如下：
江天一色无纤尘，皎皎空中孤月轮。

阻塞调用

创建 main.js 文件, 代码如下：
var fs = require(“fs”);

var data = fs.readFileSync(‘input.txt’);

console.log(data.toString());
console.log(“程序执行结束!”);

以上代码执行结果如下：
$ node main.js
江天一色无纤尘，皎皎空中孤月轮。

程序执行结束!

非阻塞调用

创建 main.js 文件, 代码如下：

var fs = require(“fs”);

fs.readFile(‘input.txt’, function (err, data) {
if (err) return console.error(err);
console.log(data.toString());
});

console.log(“程序执行结束!”);
以上代码执行结果如下：

$ node main.js
程序执行结束!
江天一色无纤尘，皎皎空中孤月轮。

对比两个例子可知：

1. 第一个实例在文件读取完后才执行程序。 第二个实例我们不需要等待文件读取完，这样就可以在读取文件时同时执行接下来的代码，大大提高了程序的性能。
2. 阻塞是按顺序执行的，而非阻塞是不需要按顺序的。

Node.js 几乎每一个 API 都是支持回调函数的。

Node.js 事件循环

Node.js 是 “单进程”、“单线程” 应用程序。

1. 进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。
2. 线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

为了实现高并发：Node.js采用了 V8 引擎。
V8 引擎提供的 “异步执行回调接口”，通过这些接口可以处理大量的并发，所以性能非常高。

Node.js 几乎所有的事件机制都是用设计模式中的 “观察者模式” 实现。
Node.js 单线程类似进入一个while(true)的事件循环，直到没有事件观察者退出，每个异步事件都生成一个事件观察者，如果有事件发生就调用该回调函数。

Node.js 事件驱动程序的原理：

Node.js 使用事件驱动模型。当web server接收到请求，就把它关闭然后进行处理，然后去服务下一个web请求。
当这个请求完成，它被放回处理队列，当到达队列开头，这个结果被返回给用户。
这个模型非常高效可扩展性非常强，因为 webserver 一直接受请求而不等待任何读写操作。（这也称之为非阻塞式IO或者事件驱动IO）
在事件驱动模型中，会生成一个主循环来监听事件，当检测到事件时触发回调函数。

整个事件驱动的流程类似于观察者模式，事件相当于一个主题(Subject)，而所有注册到这个事件上的处理函数相当于观察者(Observer)。

Node.js 的内置事件

Node.js 有多个内置的事件，我们可以通过引入 events 模块，并通过实例化 EventEmitter 类来绑定和监听事件。

举个例子：

// 引入 events 模块
var events = require(‘events’);

// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();

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

// 触发事件
eventEmitter.emit(‘eventName’);

Node 应用程序是如何工作的？

在 Node 应用程序中，执行异步操作的函数接收 2 个参数：回调函数接收错误对象 和 回调函数。

Node.js EventEmitter

Node.js 所有的异步 I/O 操作在完成时都会发送一个事件到事件队列。
Node.js 里面的许多对象都会分发事件，这些对象都是 events.EventEmitter 的实例。

EventEmitter 类

events 模块只提供了一个对象： events.EventEmitter。EventEmitter 的核心就是事件触发与事件监听器功能的封装。

你可以通过require(“events”);来访问该模块。
// 引入 events 模块
var events = require(‘events’);
// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();

EventEmitter 对象如果在实例化时发生错误，会触发 error 事件。当添加新的监听器时，newListener 事件会触发，当监听器被移除时，removeListener 事件被触发。

EventEmitter 类的方法

listenerCount(emitter, event)

EventEmitter 实例的方法

1. addListener(event, listener)
2. on(event, listener)
3. once(event, listener)
4. removeListener(event, listener)
5. removeAllListeners([event])
6. setMaxListeners(n)
7. listeners(event)
8. emit(event, [arg1], [arg2], […])

事件

1. newListener 事件
2. removeListener 事件
3. error

Node.js Buffer(缓冲区)

Buffer(缓冲区)：用来创建一个专门存放二进制数据的缓存区。

JavaScript 语言，没有二进制数据类型。但在处理像TCP流或文件流时，必须使用到二进制数据。因此在 Node.js中，定义了一个 Buffer 类。

Buffer 与字符编码

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

例如：
const buf = Buffer.from(‘runoob’, ‘ascii’);

// 输出 72756e6f6f62
console.log(buf.toString(‘hex’));

// 输出 cnVub29i
console.log(buf.toString(‘base64’));

Node.js 目前支持的字符编码包括：

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

创建 Buffer 类

Buffer 提供了以下 API 来创建 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 实例

例如：
// 创建一个长度为 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’);

写入缓冲区

写入 Node 缓冲区的语法如下所示：
buf.write(string[, offset[, length]][, encoding])

参数描述如下：

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

返回值
返回实际写入的大小。如果 buffer 空间不足， 则只会写入部分字符串。

从缓冲区读取数据

读取 Node 缓冲区数据的语法如下所示：
buf.toString([encoding[, start[, end]]])

参数描述如下：

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

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

将 Buffer 转换为 JSON 对象

将 Node Buffer 转换为 JSON 对象的函数语法格式如下：
buf.toJSON()

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

返回值
返回 JSON 对象。

缓冲区合并

Node 缓冲区合并的语法如下所示：
Buffer.concat(list[, totalLength])

参数描述如下：

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

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

缓冲区比较

Node Buffer 比较的函数语法如下所示, 该方法在 Node.js v0.12.2 版本引入：
buf.compare(otherBuffer);

参数描述如下：

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

返回值
返回一个数字，表示 buf 在 otherBuffer 之前，之后或相同。

拷贝缓冲区

Node 缓冲区拷贝语法如下所示：
buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]])

参数描述如下：

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

返回值
没有返回值。

缓冲区裁剪

Node 缓冲区裁剪语法如下所示：
buf.slice([start[, end]])

参数描述如下：

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

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

缓冲区长度

Node 缓冲区长度计算语法如下所示：
buf.length;

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

Node.js Buffer 模块常用的方法

https://www.runoob.com/nodejs/nodejs-buffer.html

Node.js Stream(流)

Node.js，Stream 有四种流类型：

1. Readable - 可读操作。
2. Writable - 可写操作。
3. Duplex - 可读可写操作.
4. Transform - 操作被写入数据，然后读出结果。

所有的 Stream 对象都是 EventEmitter 的实例。常用的事件有：

data - 当有数据可读时触发。
end - 没有更多的数据可读时触发。
error - 在接收和写入过程中发生错误时触发。
finish - 所有数据已被写入到底层系统时触发。

从流中读取数据

写入流

管道流

链式流

Node.js模块系统

一个 Node.js 文件就是一个模块。

创建模块

在 Node.js 中，创建一个模块非常简单，如下我们创建一个 main.js 文件，代码如下:

var hello = require(’./hello’);
hello.world();

Node.js 提供了 exports 和 require 两个对象：

1. exports 是模块公开的接口；
2. require 用于从外部获取一个模块的接口，即所获取模块的 exports 对象。

exports 和 module.exports 的使用区别：

如果要对外暴露属性或方法，就用 exports 就行，要暴露对象(类似class，包含了很多属性和方法)，就用 module.exports。

不建议同时使用 exports 和 module.exports。
如果先使用 exports 对外暴露属性或方法，再使用 module.exports 暴露对象，会使得 exports 上暴露的属性或者方法失效。
原因在于，exports 仅仅是 module.exports 的一个引用。

服务端的模块放在哪里？

Node.js 中自带了一个叫做 http 的模块。

Node.js 函数

与 JavaScript 函数一样。

Node.js 路由

我们要为路由提供请求的 URL 和其他需要的 GET 及 POST 参数，随后路由需要根据这些数据来执行相应的代码。
因此，我们需要查看 HTTP 请求，从中提取出请求的 URL 以及 GET/POST 参数。

我们需要的所有数据都会包含在 request 对象中，该对象作为 onRequest() 回调函数的第一个参数传递。但是为了解析这些数据，我们需要额外的 Node.JS 模块，它们分别是 url 和 querystring 模块。

               url.parse(string).query
                                       |
       url.parse(string).pathname      |
                   |                   |
                   |                   |
                 ------ -------------------

http://localhost:8888/start?foo=bar&hello=world
— -----
| |
| |
querystring.parse(queryString)[“foo”] |
|
querystring.parse(queryString)[“hello”]

Node.js 全局对象

在浏览器 JavaScript 中，通常 window 是全局对象， 而 Node.js 中的全局对象是 global，所有全局变量（除了 global 本身以外）都是 global 对象的属性。

https://www.runoob.com/nodejs/nodejs-global-object.html

Node.js 常用工具

util 是一个Node.js 核心模块，提供常用函数的集合，用于弥补核心 JavaScript 的功能 过于精简的不足。

Node.js 文件系统

Node.js 提供一组类似 UNIX（POSIX）标准的文件操作API。 Node 导入文件系统模块(fs)语法如下所示：

var fs = require(“fs”)

异步和同步

Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 fs.readFile() 和同步的 fs.readFileSync()。
异步的方法函数最后一个参数为回调函数，回调函数的第一个参数包含了错误信息(error)。
建议大家使用异步方法，比起同步，异步方法性能更高，速度更快，而且没有阻塞。

打开文件

以下为在异步模式下打开文件的语法格式：
fs.open(path, flags[, mode], callback)

参数使用说明如下：

path - 文件的路径。
flags - 文件打开的行为。具体值详见下文。
mode - 设置文件模式(权限)，文件创建默认权限为 0666(可读，可写)。
callback - 回调函数，带有两个参数如：callback(err, fd)。

获取文件信息

以下为通过异步模式获取文件信息的语法格式：
fs.stat(path, callback)

参数使用说明如下：

path - 文件路径。
callback - 回调函数，带有两个参数如：(err, stats), stats 是 fs.Stats 对象。

写入文件

以下为异步模式下写入文件的语法格式：
fs.writeFile(file, data[, options], callback)

writeFile 直接打开文件默认是 w 模式，所以如果文件存在，该方法写入的内容会覆盖旧的文件内容。

参数使用说明如下：

file - 文件名或文件描述符。
data - 要写入文件的数据，可以是 String(字符串) 或 Buffer(缓冲) 对象。
options - 该参数是一个对象，包含 {encoding, mode, flag}。默认编码为 utf8, 模式为 0666 ， flag 为 ‘w’
callback - 回调函数，回调函数只包含错误信息参数(err)，在写入失败时返回。

读取文件

以下为异步模式下读取文件的语法格式：
fs.read(fd, buffer, offset, length, position, callback)

该方法使用了文件描述符来读取文件。

参数使用说明如下：

fd - 通过 fs.open() 方法返回的文件描述符。
buffer - 数据写入的缓冲区。
offset - 缓冲区写入的写入偏移量。
length - 要从文件中读取的字节数。
position - 文件读取的起始位置，如果 position 的值为 null，则会从当前文件指针的位置读取。
callback - 回调函数，有三个参数err, bytesRead, buffer，err 为错误信息， bytesRead 表示读取的字节数，buffer 为缓冲区对象。

关闭文件

以下为异步模式下关闭文件的语法格式：
fs.close(fd, callback)

该方法使用了文件描述符来读取文件。

参数使用说明如下：

fd - 通过 fs.open() 方法返回的文件描述符。
callback - 回调函数，没有参数。

截取文件

以下为异步模式下截取文件的语法格式：
fs.ftruncate(fd, len, callback)

该方法使用了文件描述符来读取文件。

参数使用说明如下：

fd - 通过 fs.open() 方法返回的文件描述符。
len - 文件内容截取的长度。
callback - 回调函数，没有参数。

删除文件

以下为删除文件的语法格式：
fs.unlink(path, callback)

参数使用说明如下：

path - 文件路径。
callback - 回调函数，没有参数。

创建目录

以下为创建目录的语法格式：
fs.mkdir(path[, options], callback)

参数使用说明如下：

path - 文件路径。
options 参数可以是：
recursive - 是否以递归的方式创建目录，默认为 false。
mode - 设置目录权限，默认为 0777。
callback - 回调函数，没有参数。

读取目录

以下为读取目录的语法格式：
fs.readdir(path, callback)

参数使用说明如下：

path - 文件路径。
callback - 回调函数，回调函数带有两个参数err, files，err 为错误信息，files 为 目录下的文件数组列表。

删除目录

以下为删除目录的语法格式：
fs.rmdir(path, callback)

参数使用说明如下：

path - 文件路径。
callback - 回调函数，没有参数。

https://www.runoob.com/nodejs/nodejs-fs.html

Node.js GET/POST请求

获取GET请求内容

由于GET请求直接被嵌入在路径中，URL是完整的请求路径，包括了?后面的部分，因此你可以手动解析后面的内容作为GET请求的参数。

node.js 中 url 模块中的 parse 函数提供了这个功能。

获取 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);

Node.js 工具模块

1 OS 模块
提供基本的系统操作函数。
2 Path 模块
提供了处理和转换文件路径的工具。
3 Net 模块
用于底层的网络通信。提供了服务端和客户端的的操作。
4 DNS 模块
用于解析域名。
5 Domain 模块
简化异步代码的异常处理，可以捕捉处理try catch无法捕捉的。

Node.js Web 模块

什么是 Web 服务器？
Web服务器一般指网站服务器，是指驻留于因特网上某种类型计算机的程序，Web服务器的基本功能就是提供Web信息浏览服务。它只需支持HTTP协议、HTML文档格式及URL，与客户端的网络浏览器配合。

大多数 web 服务器都支持服务端的脚本语言（php、python、ruby）等，并通过脚本语言从数据库获取数据，将结果返回给客户端浏览器。

目前最主流的三个Web服务器是Apache、Nginx、IIS。

Web 应用架构

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

使用 Node 创建 Web 服务器

Node.js 提供了 http 模块，http 模块主要用于搭建 HTTP 服务端和客户端，使用 HTTP 服务器或客户端功能必须调用 http 模块，代码如下：

var http = require(‘http’);

使用 Node 创建 Web 客户端

Node 创建 Web 客户端需要引入 http 模块，创建 client.js 文件。

Node.js Express 框架

Express 是一个简洁而灵活的 node.js Web应用框架, 提供了一系列强大特性帮助你创建各种 Web 应用，和丰富的 HTTP 工具。
使用 Express 可以快速地搭建一个完整功能的网站。

Express 框架核心特性：

可以设置中间件来响应 HTTP 请求。
定义了路由表用于执行不同的 HTTP 请求动作。
可以通过向模板传递参数来动态渲染 HTML 页面。

安装 Express

$ npm install express --S

Node.js RESTful API

什么是 REST？
REST即表述性状态传递。

HTTP 方法——以下为 REST 基本架构的四个方法：

GET - 用于获取数据。
PUT - 用于更新或添加数据。
DELETE - 用于删除数据。
POST - 用于添加数据。

Node.js 多进程

我们都知道 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会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信。

Node.js JXcore 打包

Node.js 是一个开放源代码、跨平台的、用于服务器端和网络应用的运行环境。
JXcore 是一个支持多线程的 Node.js 发行版本，基本不需要对你现有的代码做任何改动就可以直接线程安全地以多线程运行。

Node.js 连接 MySQL

安装驱动

$ npm install mysql

Node.js 连接 MongoDB

安装驱动

$ npm install mongodb