Node.JS简单记录

作者: 坚持到底v2 | 来源:发表于2017-10-26 19:28 被阅读93次

官网

个人总结1

个人感觉 node.js 给人最大的困惑是
有时 js文件的作用 是类似于Java(或者说替代Java), 是用来提供服务器端的代码逻辑,包括创建web服务器或提供其他命令行操作;
而有时 js文件的作用 是运行在前端浏览器中的普通js代码,
这一点要区分清楚.

本文后面记录的应该都是作为运行在服务器端的js代码及用法,
而大部分的使用npm管理的项目基本都已经封装好了 node 这一层要做的工作,只是使用了 npm 的包管理器那一部分.

一. 基础

1. 下载及安装

从官网下载windows或linux的版本

windows的下载安装即可.

以下是centos7的安装过程

basePath="$HOME"
# 定义tarball下载地址,具体版本及链接地址可能会变
downloadUrl="https://nodejs.org/dist/v10.14.1/node-v10.14.1-linux-x64.tar.xz"

curl -LJso "${basePath}/nodejs.tar"  "${downloadUrl}"

# 解压
tar -C ${basePath} -xf ${basePath}/nodejs.tar
# 获取解压后的目录名称
nodejsTarBallDirName=$(getTarballDirName "${basePath}/nodejs.tar")

# 设置环境变量
cat >> /etc/bashrc << EOF
# set for nodejs
export NODE_HOME=${basePath}/${nodejsTarBallDirName}
export PATH=\$PATH:\$NODE_HOME/bin
EOF

2. 查看node版本

node -v 
# 输出 v10.14.1

3. 最简单的Hello World!

新建一个文件 helloworld.js, 内容如下:

cat > helloworld.js << EOF
console.log("Hello World");
EOF

# 运行
node helloworld.js

4.交互模式

# 进入交互模式
node

# 打印到控制台
console.log("Hello World");

# 可以使用tab键补全命令

5. 最简单的服务器

新建一个文件 server.js ,内容如下:

cat > server.js <<EOF
// 使用 require 指令载入 node.js 模块
// 这里载入 http 模块,用于创建服务器
var http= require("http");

// 使用模块提供的命令创建服务器
http.createServer(function(request,response) {
 response.writeHead(200,{'Content-Type':'text/plain; charset=utf-8'});
 response.end('Hello World\n');
}).listen(8888);

// 在终端打印信息
console.log('Server running at http://127.0.0.1:8888/');
EOF

# 然后运行这个js
node server.js

# 然后你可以访问 `http://127.0.0.1:8888` 看看效果

6. npm介绍

npm 是随同NodeJS一起安装的包管理工具，能解决NodeJS代码部署上的很多问题.
它允许用户从 npm 服务器下载别人编写的第三方包或命令行程序到本地使用;
它允许用户向 npm 服务器上传自己编写的第三方包或命令行程序供别人使用;

7. 查看 npm 版本

npm -v 
# 输出 6.4.1

8. 升级npm

npm install npm -g

# 查看npm版本
npm -v 
# 输出 6.5.0

国内使用 npm 速度很慢,你可以使用淘宝定制的 cnpm (gzip 压缩支持) 命令行工具代替默认的 npm:

npm install -g cnpm --registry=https://registry.npm.taobao.org
npm config set registry https://registry.npm.taobao.org

然后升级npm时可以使用

cnpm install npm -g

9. 使用 npm 命令安装模块

# 安装 web框架模块 -- express
npm install express

安装好之后, express 包 就放在了 ./node_modules/ 中(一般也就是 ${projectDir}/node_modules/ 中),
然后在 服务端js文件 中,可以像 引入http 模块 那样引入并使用它

// 载入 express 模块
var express=require('express');

10. npm 的包安装模式

分为: 本地安装(local)和全局安装(global)

10.1 全局安装

# 全局安装express模块
npm install express -g

如果出现错误 "npm err! Error: connect ECONNREFUSED 127.0.0.1:8087"

npm config set proxy null

全局安装的包位于 ${NODE_HOME}/node_modules/ 中, 并且可以直接在命令行里使用

查看所有全局安装的模块

npm list -g

查看某个具体模块的版本及安装位置

# 查看 express 模块
npm list express -g 
# 输出
# /home/nodejs/lib
#  └── express@4.16.4 

npm list express 
# 输出
# /[currentDir]
#  └── express@4.16.4

模块的版本号使用 X.Y.Z , 表示 主版本号.次版本号.补丁版本号

Z 位置的变动表示修复bug
Y 位置的变动表示新增了功能但是向下兼容
X 位置的变动表示向下不兼容

每个模块都有自己的 package.json 文件, 用于定义 包的属性 ,其中包括

dependencies 属性和 devDependencies 属性 : 这个属性的内容对应了依赖的 第三方包的名称和版本 .
main 属性 : 该属性指定了程序的主入口文件，require('moduleName') 时就会加载这个文件。
这个字段的默认值是模块根目录下面的 index.js。

卸载模块

# 卸载 express 模块
npm uninstall express 

# 查看 express 模块是否还存在
npm list

更新模块

# 更新 express 模块
npm update express

搜索模块

# 搜索 express 模块
npm search express

发布自己的模块

# 首先创建 package.json , 运行下面的命令 根据提示输入内容
npm init

# 然后在 npm 资源库中注册用户（使用邮箱注册） 
npm adduser

# 发布模块 
npm publish

11. Node.js REPL(Read Eval Print Loop:交互式解释器)

执行 node 命令进入交互式解释器, 然后输入下面的内容感受一下

1+4
x=10
var y=20
x+y
//使用_获取上一个表达式的值
var sum=_
console.log("hello world!")

退出终端 Ctrl+C
退出 node REPL: Ctrl+C 两次或 Ctrl+D
补全命令 tab
帮助 .help
退出多行表达式 .clear / .break
保存或加载文件 .save filename / .load filename

12. node.js 回调函数

没什么新鲜的,举个例子完事

12.1 同步方式的代码

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

12.2 异步方式的代码

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

13. node.js 事件循环

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

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

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

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

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

EventEmitter 的每个事件由一个事件名和若干个参数组成。
对于每个事件，EventEmitter 支持若干个事件监听器。
当事件发射时，注册到这个事件的事件监听器被依次调用，事件参数作为回调函数参数传递。

13.1 带参数的事件例子

eventEmitter.emit('someEvent', 'arg1 参数', 'arg2 参数');
eventEmitter.on('someEvent', function(arg1, arg2) { 
    console.log('listener1', arg1, arg2); 
});

13.2 EventEmitter 的其他属性和方法

eventEmitter.addListener(event,listener)

eventEmitter.once(event,listener)

eventEmitter.removeListener(event,listener)

//不指定事件就是移除所有监听器
eventEmitter.removeAllListeners([event]) 

//默认为10个
eventEmitter.setMaxListeners(n) 

//返回指定事件的监听器数组
eventEmitter.listeners(event) 

//返回指定事件的监听器数量
EventEmitter.listenerCount(emitter, event)

eventEmitter 本身也有事件

例如在 eventEmitter.addListener(event,listener) 或 eventEmitter.removeListener(event,listener) 时会发出 newListener事件或removeListener事件,参数是 event 和 listener

EventEmitter 定义了一个特殊的事件 error

当 error 发射时, EventEmitter 规定如果没有响应的监听器，Node.js 会把它当作异常，退出程序并输出错误信息。例如:

var events = require('events'); 
var emitter = new events.EventEmitter(); 
emitter.emit('error'); 

// 运行该js文件, 会报告 Uncaught, unspecified 'error' event

14. Node.js Buffer(缓冲区)

Buffer 库为 Node.js 带来了一种存储原始数据的方法，可以让 Node.js 处理二进制数据，每当需要在 Node.js 中处理I/O操作中移动的数据时，就有可能使用 Buffer 库。

原始数据存储在 Buffer 类的实例中。

一个 Buffer 类似于一个整数数组，但它对应于 V8 堆内存之外的一块原始内存

14.1 创建 Buffer 类

创建长度为 10 字节的 Buffer 实例

var buf = new Buffer(10);
var buf = new Buffer([10, 20, 30, 40, 50]);
var buf = new Buffer("www.runoob.com", "utf-8");

14.2 写入缓冲区

语法:

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

offset默认为0,
length 默认为 buffer.length,
encoding默认为utf-8

例子:

buf = new Buffer(256);
len = buf.write("www.runoob.com");

14.3 从缓冲区读取数据

语法

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

encoding默认为utf-8,
start默认为0,
end 默认为缓冲区的末尾

例子:

var buf = new Buffer('www.runoob.com');
var json = buf.toJSON(buf);
console.log(json); 
// 输出 { type: 'Buffer', data: [ 119, 119, 119, 46, 114, 117, 110, 111, 111, 98, 46, 99, 111, 109 ] }

14.4 缓冲区合并

语法

Buffer.concat(list[, totalLength])

totalLength 是指定合并后Buffer对象的总长度

例子:

var buffer1 = new Buffer('菜鸟教程 ');
var buffer2 = new Buffer('www.runoob.com');
var buffer3 = Buffer.concat([buffer1,buffer2]);
console.log("buffer3 内容: " + buffer3.toString());

14.5 缓冲区比较

buf.compare(otherBuffer);

14.6 拷贝缓冲区

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

targetStart默认为0,
sourceStart默认为0,
sourceEnd 默认为 buffer.length

14.7 缓冲区裁剪

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

start 默认: 0
end 默认: buffer.length

14.8 缓冲区长度

buf.length

14.8

还有好多其他函数, 略过

15. Node.js Stream(流)

15.1 Stream 类型

Readable; Writable; Duplex; Transform(转换)

15.2 Stream 事件:

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

15.3 读取流

例子:

var fs = require("fs");
var data = '';
// 创建可读流
var readerStream = fs.createReadStream('input.txt');
// 设置编码为 utf8。
readerStream.setEncoding('UTF8');

// 处理流事件 --> data, end, and error
readerStream.on('data', function(chunk) {
   data += chunk;
});

readerStream.on('end',function(){
   console.log(data);
});

readerStream.on('error', function(err){
   console.log(err.stack);
});

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

15.4 写入流

例子:

var fs = require("fs");
var data = '菜鸟教程官网地址：www.runoob.com';

// 创建一个可以写入的流，写入到文件 output.txt 中
var writerStream = fs.createWriteStream('output.txt');

// 使用 utf8 编码写入数据
writerStream.write(data,'UTF8');

// 标记文件末尾
writerStream.end();

// 处理流事件 --> data, end, and error
writerStream.on('finish', function() {
    console.log("写入完成。");
});

writerStream.on('error', function(err){
   console.log(err.stack);
});

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

15.5 管道流

例子

var fs = require("fs");

// 创建一个可读流
var readerStream = fs.createReadStream('input.txt');

// 创建一个可写流
var writerStream = fs.createWriteStream('output.txt');

// 管道读写操作
// 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
readerStream.pipe(writerStream);

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

链式流(对比管道流):

var zlib = require('zlib');
// 先压缩再写入文件
readerStream.pipe(zlib.createGzip()).pipe(writerStream);
// 先解压缩再写入文件
readerStream.pipe(zlib.createGunzip()).pipe(writerStream);

16. node.js 模块系统

模块是Node.js 应用程序的基本组成部分，文件和模块是一一对应的。

换言之，一个 Node.js 文件就是一个模块，这个文件可能是JavaScript 代码、JSON 或者编译过的C/C++ 扩展。

例子:

// 引入当前目录下的hello.js文件 (node.js默认后缀为js)
var hello = require('./hello');
// 执行 world 方法
hello.world();

world 方法怎么来的?

Node.js 提供了 exports 和 require 两个对象，其中 exports 用于公开模块的接口, require 用于获取一个模块的接口

例如 hello.js 的内容为

var world=function() {
  console.log('Hello World');
};
exports.world=world;

注意 javascript 一切都是类, 所以有时候我们如果想把一个对象封装到模块,应该如下所示:

var Hello=function() {
  var name;
  this.setName=function(thyName) {
    name =thyName;
  };
  this.sayHello = function() { 
    console.log('Hello ' + name); 
  }; 
};
module.exports=Hello;

对应的 main.js 文件内容为:

var Hello = require('./hello'); 
hello = new Hello(); 
hello.setName('BYVoid'); 
hello.sayHello();

那么服务端的模块在哪里呢?

也许你已经注意到，我们已经在代码中使用了模块 (例如 var http = require("http"); ), Node.js中存在4类模块（原生模块和3种文件模块），尽管require方法极其简单，但是内部的加载却是十分复杂的，其加载优先级也各自不同。

Node.js 的 require方法中的文件查找策略如下:
(1) 首先从文件模块缓存中加载
(2) 然后从原生模块加载. require方法在解析文件名之后，优先检查模块是否在原生模块列表中。以http模块为例，尽管在目录下存在一个http/http.js/http.node/http.json文件，require("http")都不会从这些文件中加载，而是从原生模块中加载。原生模块也有一个缓存区，同样也是优先从缓存区加载。如果缓存区没有被加载过，则调用原生模块的加载方式进行加载和执行。
(3) 然后才从文件加载并缓存文件模块

17. node.js函数

没有新意,解释了下函数作为参数和匿名函数

// 重写一下 创建服务器 的代码 
var http= require("http");
// 声明函数
var onRequest=function(request,response) {
 response.writeHead(200,{'Content-Type':'text/plain; charset=utf-8'});
 response.end('Hello World\n');
};
// 使用模块提供的命令创建服务器
http.createServer(onRequest).listen(8888);

18. node.js路由

我们要为路由提供请求的URL和其他需要的GET及POST参数, 所需要的数据都包含在 onRequest 函数的第一个对象 request 中.
但是为了解析这些数据，我们需要额外的Node.JS模块，它们分别是 url 和 querystring 模块。

var url = require('url');
var querystring = require('querystring');

18.1 用法示例

获取 url 中的 query 部分

var queryStr=url.parse(urlStr).query; 
var queryObj=url.parse(urlStr,true).query;// 加上true 参数后会将query解析成对象格式

获取 url 中的 path 部分

var pathNameStr=url.parse(urlStr).pathname;

检索 query 字符串中的key

var paramFoo=querystring.parse(queryStr)["foo"]; //或
var paramFoo=queryObj.foo;

为了搭建一个看起来正常点的服务器,我们将代码进行重构一下

新建 ./server.js , 用来启动服务器并负责解析 url 中的path , 内容如下:

var http = require("http");
var url = require("url");
function start(route) {
  function onRequest(request, response) {
    var pathname = url.parse(request.url).pathname;
    console.log("Request for " + pathname + " received.");

    route(pathname);

    response.writeHead(200, {"Content-Type": "text/plain; charset=utf-8"});
    response.write("Hello World");
    response.end();
  }

  http.createServer(onRequest).listen(8888);
  console.log("Server has started.");
}

exports.start = start;

新建 ./router.js, 用来处理各种不同的 path ,内容如下:

function route(pathname) {
  console.log("About to route a request for " + pathname);
} 
exports.route = route;

新建main.js,作为主入口,内容如下:

var server = require("./server");
var router = require("./router");

server.start(router.route);

19. node.js全局对象

正如在浏览器 JavaScript 中，通常 window 是全局对象;

在 Node.js 中的全局对象是 global , 所有全局变量（除了 global 本身以外）都是 global 对象的属性。

在 Node.js 我们可以直接访问到 global 的属性，而不需要在应用中包含它

__filename 表示当前正在执行的脚本的文件名。它将输出文件所在位置的绝对路径; 如果在模块中使用它，返回的值是模块文件的路径。

__dirname 表示当前执行脚本所在的目录

console.log( __filename );
console.log( __dirname );
// var t = setTimeout(callback,delay) 全局函数,表示在指定的毫秒(ms)数后执行指定函数,该函数返回的是一个代表定时器的句柄值.
// clearTimeout(t); //停止定时器
// var t=setInterval(cb, ms);
// clearInterval(t);

// console.log([data][,...]); //提供类似于C语言的printf()函数
// console.info | error | warn
// console.time(label) 和 console.timeEnd(label) : 计时开始和结束,使用 console.log(label) 来打印计时时间
// console.trace(message[,...]); //当前执行的代码在堆栈中的调用路径，这个测试函数运行很有帮助，只要给想测试的函数里面加入 console.trace 就行了
// console.assert(value[,message][,...]); //只有第一个参数为false时才会输出内容


// process 全局变量用于描述当前Node.js 进程状态的对象，提供了一个与操作系统的简单接口, 它提供了如下事件: exit(当进程准备退出时触发)、beforeExit、uncaughtException(默认的监视器是 打印堆栈跟踪信息并退出)、Signal事件(当进程接收到信号时就触发,例如 SIGINT,SIGUSR1等)
// 示例:
process.on('exit',function(code) {console.log('退出码为:', code);});

// process 还提供了很多有用的属性, 以便我们更好的控制系统的交互:
// process.stdout | stderr | stdin:
// process.argv: 它的第一个成员总是node,第二个成员是脚本文件名,其余成员是脚本文件的参数,因为执行时的命令总是: node xx.js paramA paramB ...
// process.execPath: 返回 node 命令的绝对路径
// ...

示例:

process.stdout.write("Hello World!" + "\n");
process.argv.forEach(function(val, index, array) {
 console.log(index + ': ' + val);
});
console.log(process.execPath);

process 还提供了很多有用的方法,以便我们更好的控制系统的交互:

触发 abort 事件, 并让 node 退出: process.abort() ;
返回 node 已经运行的时间: process.uptime() ;

示例:

console.log('当前目录: ' + process.cwd());
console.log('当前版本: ' + process.version);
// 输出内存使用情况
console.log(process.memoryUsage());

20. node.js 常用工具

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

20.1 util.inherits

util.inherits 用于提供类的继承特性(原始的js基于prototype原型继承,不易控制),

示例

var util = require('util'); 
function Base() { ... };
function Sub() { ... };
util.inherits(Sub,Base); // 相当于 Sub 继承了 Base
var objSub=new Sub(); // objSub 可以使用 Base中定义的函数和变量

20.2 util.inspect

util.inspect(object,[showHidden],[depth],[colors]) 用于打印对象为字符串(原始的js打印不了对象内容),

示例:

var util = require('util'); 
function Person() { ... }
var obj = new Person(); 
console.log(util.inspect(obj)); 
console.log(util.inspect(obj, true));

20.3 其他示例

var util = require('util');
// 判断是否是数组
util.isArray([]); // true
util.isArray(new Array); // true
// 判断是否是正则表达式
util.isRegExp(/some regexp/); // true
util.isRegExp(new RegExp('another regexp')); // true
// 判断是否是日期
util.isDate(new Date()); // true
// 判断是否是error
util.isError(new Error()); // true

21. node.js 文件系统( fs模块 )

// 引入 fs 模块
var fs = require("fs");
// 异步读取
var callBackForRead=function(err, data) { ... };
fs.readFile('input.txt',callBackForRead);
// 同步读取
var data = fs.readFileSync('input.txt');
// 打开文件
var callBackForOpen=function(err, fd) { ... };
fs.open('input.txt', 'r+',callBackForOpen);
// 获取文件信息
var callBackForStat=function (err, stats) { ... };
fs.stat('input.txt',callBackForStat);
// 写入文件
var callBackForWrite=function(err)  { ... };
fs.writeFile('input.txt', '我是通过写入的文件内容！',  callBackForWrite);
// ... 还有很多,不再赘述 ...

22. node.js GET/POST请求

// 复习前面的内容,获取get请求内容
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);

http.createServer(function(req, res){
  res.writeHead(200, {'Content-Type': 'text/plain; charset=utf-8'});

  // 解析 url 参数
  var params = url.parse(req.url, true).query;
  res.write("网站名：" + params.name);
  res.write("\n");
  res.write("网站 URL：" + params.url);
  res.end(); 
}).listen(3000);

// 获取 POST 请求内容
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);

23. node.js 工具模块

// (1) OS模块: 
var os = require("os")
// 方法: os.hostname(); ...
// (2) Path模块:
var path = require("path")
// 方法: path.dirname(p);path.basename(p[,ext])
// (3) Net模块:
var net = require("net")
// 方法: net.createServer([options][, connectionListener]) 创建一个 TCP 服务器
// (4) DNS模块
var dns = require("dns")
// 方法: dns.lookup(hostname);
// (5) Domain  模块
var domain = require("domain")
//  把处理多个不同的IO的操作作为一个组。注册事件和回调到domain，当发生一个错误事件或抛出一个错误时，domain对象会被通知，不会丢失上下文环境，也不导致程序错误立即推出，与process.on('uncaughtException')不同。// Domain 模块可分为隐式绑定和显式绑定：

24. node.js WEB模块( 就是http模块 )

// 使用 Node 创建 Web 服务器
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/plain
       response.writeHead(404, {'Content-Type': 'text/html; charset=utf-8'});
    }else{           
       // HTTP 状态码: 200 : OK
       // Content Type: text/plain
       response.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});   
       
       // 响应文件内容
       response.write(data.toString());     
    }
    //  发送响应数据
    response.end();
 });   
}).listen(8081);

// 控制台会输出以下信息
console.log('Server running at http://127.0.0.1:8081/');


// 模拟客户端
var http = require('http');

// 用于请求的选项
var options = {
 host: 'localhost',
 port: '8081',
 path: '/index.htm'  
};

// 处理响应的回调函数
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();

25. node.js Express 框架

Express 是一个简洁而灵活的 node.js Web应用框架, 提供了一系列强大特性帮助你创建各种 Web 应用，和丰富的 HTTP 工具。

使用 Express 可以快速地搭建一个完整功能的网站。

安装,运行下面的命令会将 Express 框架安装在当前目录的 node_modules 目录中,node_modules 目录下会自动创建 express 目录

npm install express --save

同时安装其他模块

npm install body-parser --save
npm install cookie-parser --save
npm install multer --save

使用 express 搭建服务器

var express = require('express');
var app = express();

app.get('/', function (req, res) {
 res.send('Hello World');
})

var server = app.listen(8081, function () {

  var host = server.address().address
  var port = server.address().port

  console.log("应用实例，访问地址为 http://%s:%s", host, port)

})

26. Node.js 多进程

const child_process = require('child_process');
child_process.exec : 使用子进程执行命令
child_process.spawn 使用指定的命令行参数创建新进程
child_process.fork 是 spawn()的特殊形式. 与spawn方法不同的是，fork会在父进程与子进程之间，建立一个通信管道，用于进程之间的通信。

27. node.js JXcore打包

27.1 windows安装

直接下载安装

27.2 Linux 安装

https://github.com/jxcore/jxcore/blob/master/doc/INSTALLATION.md

curl https://raw.githubusercontent.com/jxcore/jxcore/master/tools/jx_install.sh | bash

27.3 显示版本号

jx --version ;#输出 v0.10.32

27.4 打包

jx package index.js index

打包完成后,会生成2个文件, index.jxp(中间文件)和index.jx(打包文件)

27.5 载入jx文件

jx index.jx

28. node.js 连接 mysql

28.1 安装

npm install mysql

28.2 使用示例

var mysql = require('mysql');
var connection = mysql.createConnection({
  host : 'localhost',
  user : 'root',
  password : '123456',
  database : 'test'
});

connection.connect();

connection.query('SELECT 1 + 1 AS solution', function (error, results, fields) {
  if (error) throw error;
  console.log('The solution is: ', results[0].solution);
});

29. node.js 连接 MongoDB

29.1 安装

npm install mongodb

29.2 示例

var MongoClient = require('mongodb').MongoClient;