Node.js介绍
Node.js是一个javascript运行环境。它让javascript可以开发后端程序,实现几乎其他后端语言实现的所有功能,可以与PHP、Java、Python、.NET、Ruby等后端语言平起平坐。
Nodejs是基于V8引擎,V8是Google发布的开源JavaScript引擎,本身就是用于Chrome浏览器的js解释部分,但是Ryan Dahl 这哥们,鬼才般的,把这个V8搬到了服务器上,用于做服务器的软件。
node.js的优势
1、Nodejs语法完全是js语法,只要你懂js基础就可以学会Nodejs后端开发
Node打破了过去JavaScript只能在浏览器中运行的局面。前后端编程环境统一,可以大大降低开发成本。
2、NodeJs超强的高并发能力
NodeJs的首要目标是提供一种简单的、用于创建高性能服务器及可在该服务器中运行的各种应用程序的开发工具。
首先让我们来看一下现在的服务器端语言中存在着什么问题。在Java、PHP或者.NET等服务器语言中,会为每一个客户端连接创建一个新的线程。而每个线程需要耗费大约2MB内存。也就是说,理论上,一个8GB内存的服务器可以同时连接的最大用户数为4000个左右。要让web应用程序支持更多的用户,就需要增加服务器的数量,而web应用程序的硬件成本当然就上升了。
NodeJs不为每个客户连接创建一个新的线程,而仅仅使用一个线程。当有用户连接了,就触发一个内部事件,通过非阻塞I/O、事件驱动机制,让Node.js程序宏观上也是并行的。使用Node.js,一个8GB内存的服务器,可以同时处理超过4万用户的连接。
3、实现高性能服务器
严格地说,Node.js是一个用于开发各种web服务器的开发工具。在Node.js服务器中,运行的是高性能V8 JavaScript脚本语言,该语言是一种可以运行在服务器端的脚本语言。
那么,什么是V8 JavaScript脚本语言呢?该语言是一种被V8 JavaScript引擎所解析并执行的脚本语言。V8 JavaScript引擎是由Google公司使用C++语言开发的一种高性能JavaScript引擎,该引擎并不局限于在浏览器中运行。Node.js将其转用在了服务器中,并且为其提供了许多附加的具有各种不同用途的API。例如,在一个服务器中,经常需要处理各种二进制数据。在JavaScript脚本语言中,只具有非常有限的对二进制数据的处理能力,而Node.js所提供的Buffer类则提供了丰富的对二进制数据的处理能力。
另外,在V8 JavaScript引擎内部使用一种全新的编译技术。这意味着开发者编写的高端的 JavaScript 脚本代码与开发者编写的低端的C语言具有非常相近的执行效率,这也是Node.js服务器可以提供的一个重要特性。
4、开发周期短、开发成本低、学习成本低
Node.js自身哲学,是话最小的硬件成本,追求更高的并发,更高的处理性能。
centos7安装配置node.js
命令行输入
cd /usr/local/src/
wget http://nodejs.org/dist/v0.10.24/node-v0.10.24.tar.gz
tar zxvf node-v0.10.24.tar.gz
cd node-v0.10.24
./configure --prefix=/usr/local/node/0.10.24
make
make install
vim /etc/profile#设置环境变量
#修改文件
#在 export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE HISTCONTROL 一行的上面添加如下内容:
#set for nodejs
export NODE_HOME=/usr/local/node/0.10.24
export PATH=$NODE_HOME/bin:$PATH
#:wq
#保存退出
source /etc/profile
# 查看版本
node -v
安装路径:/usr/local/node/0.10.24/lib/node_modules/
node.js应用
node.js应用由三个部分组成:
- **引入 required 模块:**我们可以使用 require 指令来载入 Node.js 模块。
- **创建服务器:**服务器可以监听客户端的请求,类似于 Apache 、Nginx 等 HTTP 服务器。
- 接收请求与响应请求 服务器很容易创建,客户端可以使用浏览器或终端发送 HTTP 请求,服务器接收请求后返回响应数据。
如helloworld.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(8888);
// 终端打印如下信息
console.log('Server running at http://127.0.0.1:8888/');
node.js交互式解释器REPL:
相当于一个shell,能够执行的任务有:
- 读取 - 读取用户输入,解析输入了Javascript 数据结构并存储在内存中。
- 执行 - 执行输入的数据结构
- 打印 - 输出结果
- 循环 - 循环操作以上步骤直到用户两次按下 ctrl-c 按钮退出。
神奇的下划线变量:
获取前一个表达式的结果的变量。
$ node
> var x = 10
undefined
> var y = 20
undefined
> x + y
30
> var sum = _
undefined
> console.log(sum)
30
undefined
>
REPL常用命令:
- ctrl + c - 退出当前终端。
- ctrl + c 按下两次 - 退出 Node REPL。
- ctrl + d - 退出 Node REPL.
- 向上/向下 键 - 查看输入的历史命令
- tab 键 - 列出当前命令
- .help - 列出使用命令
- .break - 退出多行表达式
- .clear - 退出多行表达式
- .save filename - 保存当前的 Node REPL 会话到指定文件
- .load filename - 载入当前 Node REPL 会话的文件内容。
node.js的回调函数:
可以说node.js实现超高并发的直接体现就是回调函数的存在
异步编程依托于回调来实现,但不能说使用了回调后程序就异步化了。
回调函数在完成任务后就会被调用,Node 使用了大量的回调函数,Node 所有 API 都支持回调函数。
例如,我们可以一边读取文件,一边执行其他命令,在文件读取完成后,我们将文件内容作为回调函数的参数返回。这样在执行代码时就
没有阻塞或等待文件 I/O 操作。这就大大提高了 Node.js 的性能,可以处理大量的并发请求。
关于这个回调函数的理解,相当于每一个api或者其他命令在并发执行时都会有一个回调函数跟踪并将返回值作为回调函数的参数执行回调函数,简而言之,回调函数就是用来防止异步之后产生的错误。
如下面的将命令绑定回调函数不会阻塞代码,回调函数有许多写法:
var fs = require("fs");
fs.readFile('input.txt', function (err, data) {//一边读取文件一边执行下面的命令
if (err) return console.error(err);
console.log(data.toString());
});
console.log("程序执行结束!");
//为事件监听器设置回调函数
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', 'byvoid', 1991);
//以上例子中,emitter 为事件 someEvent 注册了两个事件监听器,然后发射了 someEvent 事件。运行结果中可以看到两个事件监听器回调函数被先后调用。
阻塞代码与非阻塞代码:
#可以按照python多线程中的守护线程来理解:
//阻塞
var fs = require("fs");
var data = fs.readFileSync('input.txt');
console.log(data.toString());
console.log("程序执行结束!");
//运行
$ node main.js
W3Cschool教程官网地址:www.w3cschool.cn
程序执行结束!
//非阻塞
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
程序执行结束!
W3Cschool教程官网地址:www.w3cschool.cn
node.js事件循环
Node.js 是单进程单线程应用程序,但是通过事件和回调支持并发,所以性能非常高。
Node.js 的每一个 API 都是异步的,并作为一个独立线程运行,使用异步函数调用,并处理并发。
Node.js 基本上所有的事件机制都是用设计模式中观察者模式实现。
Node.js 单线程类似进入一个while(true)的事件循环,直到没有事件观察者退出,每个异步事件都生成一个事件观察者,如果有事件发生
就调用该回调函数.
事件驱动
Node.js 使用事件驱动模型,当web server接收到请求,就把它关闭然后进行处理,然后去服务下一个web请求。
当这个请求完成,它被放回处理队列,当到达队列开头,这个结果被返回给用户。
这个模型非常高效可扩展性非常强,因为webserver一直接受请求而不等待任何读写操作。(这也被称之为非阻塞式IO或者事件驱动IO)
在事件驱动模型中,会生成一个主循环来监听事件,当检测到事件时触发回调函数。
整个事件驱动的流程就是这么实现的,非常简洁。有点类似于观察者模式,事件相当于一个主题(Subject),而所有注册到这个事件上的处理函数相当于观察者(Observer)。
实例:
// 引入 events 模块
var events = require('events');
// 创建 eventEmitter 对象
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("程序执行完毕。");
node.js事件
Node.js 所有的异步 I/O 操作在完成时都会发送一个事件到事件队列。
Node.js 里面的许多对象都会分发事件:一个net.Server对象会在每次有新连接时分发一个事件, 一个fs.readStream对象会在文件被打
开的时候发出一个事件。 所有这些产生事件的对象都是 events.EventEmitter 的实例。 你可以通过require(“events”);来访问该模块。
下面我们用一个简单的例子说明 EventEmitter 的用法:
//event.js
var EventEmitter = require('events').EventEmitter;
var event = new EventEmitter();
event.on('some_event', function() {
console.log('some_event occured.');
});
setTimeout(function() {
event.emit('some_event');
}, 1000);
运行这段代码,1秒后控制台输出了 ‘some_event occured’。其原理是 event 对象注册了事件 some_event 的一个监听器,然后我们通过
setTimeout 在1000毫秒以后向 event 对象发送事件 some_event,此时会调用 some_event 的监听器。
EventEmitter介绍
events 模块只提供了一个对象: events.EventEmitter。EventEmitter 的核心就 是事件发射与事件监听器功能的封装。
EventEmitter 的每个事件由一个事件名和若干个参 数组成,事件名是一个字符串,通常表达一定的语义。对于每个事件,EventEmitter 支持 若干个事件监听器。
当事件发射时,注册到这个事件的事件监听器被依次调用,事件参数作 为回调函数参数传递。
让我们以下面的例子解释这个过程:
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', 'byvoid', 1991);
//listener1 byvoid 1991
//listener2 byvoid 1991
以上例子中,emitter 为事件 someEvent 注册了两个事件监听器,然后发射了 someEvent 事件。运行结果中可以看到两个事件监听器回
调函数被先后调用。 这就是EventEmitter最简单的用法。
常用api
EventEmitter.on(event, listener)、emitter.addListener(event, listener) 为指定事件注册一个监听器,接收一个字符串 event 和一个回调函数 listener。
server.on('connection', function (stream) {
console.log('someone connected!');
});
EventEmitter.emit(event, [arg1], [arg2], […]) 发射 event 事件,传 递若干可选参数到事件监听器的参数表。
EventEmitter.once(event, listener) 为指定事件注册一个单次监听器,即 监听器最多只会触发一次,触发后立刻解除该监听器。
server.once('connection', function (stream) {
console.log('Ah, we have our first user!');
});
EventEmitter.removeListener(event, listener) 移除指定事件的某个监听 器,listener 必须是该事件已经注册过的监听器。
var callback = function(stream) {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
EventEmitter.removeAllListeners([event]) 移除所有事件的所有监听器, 如果指定 event,则移除指定事件的所有监听器。
err事件:
EventEmitter 定义了一个特殊的事件 error,它包含了"错误"的语义,我们在遇到 异常的时候通常会发射 error 事件。
当 error 被发射时,EventEmitter 规定如果没有响 应的监听器,Node.js 会把它当作异常,退出程序并打印调用栈。
我们一般要为会发射 error 事件的对象设置监听器,避免遇到错误后整个程序崩溃。例如:
var events = require('events');
var emitter = new events.EventEmitter();
emitter.emit('error');
继承 EventEmitter
大多数时候我们不会直接使用 EventEmitter,而是在对象中继承它。包括 fs、net、 http 在内的,只要是支持事件响应的核心模块都是 EventEmitter 的子类。
为什么要这样做呢?原因有两点:
首先,具有某个实体功能的对象实现事件符合语义, 事件的监听和发射应该是一个对象的方法。
其次JavaScript 的对象机制是基于原型的,支持 部分多重继承,继承 EventEmitter 不会打乱对象原有的继承关系。
Node.js Buffer 缓冲
在学习js的时候我们知道了js可以使用数组在里面可以填充字符串,数字等,但是js本身确是没有二进制数据类型的,就比如c/c++存储各
种数据,指数,整型等都会在内存中使用二进制存储,但是js并不会,因为在处理像TCP流或文件流时,必须使用到二进制数据。因此
Node.js中,定义了一个 Buffer 类,该类用来创建一个专门存放二进制数据
的缓存区。
在 Node.js 中,Buffer 类是随 Node 内核一起发布的核心库。Buffer 库为 Node.js 带来了一种存储原始数据的方法,可以让 Node.js 处
理二进制数据,每当需要在 Node.js 中处理I/O操作中移动的数据时,就有可能使用 Buffer 库。原始数据存储在 Buffer 类的实例中。一
个 Buffer 类似于一个整数数组,但它对应于 V8 堆内存之外的一块原始内存。
注意在操作buffer类的时候按照字符数组的操作方法操作即可
创建buffer类
utf-8 是默认的编码方式,此外它同样支持以下编码:“ascii”, “utf8”, “utf16le”, “ucs2”, “base64” 和 “hex”。
在node REPL交互中好像会报错,换成Buffer.alloc()即可
创建长度为十字节的buffer实例:
var buf = new Buffer(10);
通过给定的数组创建buffer实例:
var buf = new Buffer([10, 20, 30, 40, 50]);
通过一个字符串创建Buffer:
var buf = new Buffer("www.w3cschool.cn", "utf-8");
写入buffer缓冲区
buf.write(string[, offset[, length]][, encoding])
- string - 写入缓冲区的字符串。
- offset - 缓冲区开始写入的索引值,默认为 0 。
- length - 写入的字节数,默认为 buffer.length
- encoding - 使用的编码。默认为 ‘utf8’ 。
返回值为返回实际写入的大小。如果 buffer 空间不足, 则只会写入部分字符串。
从buffer缓冲区读取数据
buf.toString([encoding[,start[,end]]])
- encoding - 使用的编码。默认为 ‘utf8’ 。
- start - 指定开始读取的索引位置,默认为 0。
- end - 结束位置,默认为缓冲区的末尾。
返回值为解码缓冲区数据并使用指定的编码返回字符串。
buffer转json
buf.toJSON()
var buf = new Buffer('www.w3cschool.cn');
var json = buf.toJSON(buf);
console.log(json);
//输出
{ type: 'Buffer',
data: [ 119, 119, 119, 46, 119, 51, 99, 115, 99, 104, 111, 111, 108, 46, 99, 110 ] }
返回值为一个json对象
合并两个缓冲区
加起来
Buffer.concat(list[, totalLength])
var buffer1 = new Buffer('W3Cschool教程 ');
var buffer2 = new Buffer('www.w3cschool.cn');
var buffer3 = Buffer.concat([buffer1,buffer2]);
console.log("buffer3 内容: " + buffer3.toString());
//输出
buffer3 内容: W3Cschool教程 www.w3cschool.cn
- list - 用于合并的 Buffer 对象数组列表。
- totalLength - 指定合并后Buffer对象的总长度。
返回一个多个成员合并的新 Buffer 对象。
比较两个buffer
buf.compare(otherBuffer);
- otherBuffer - 与 buf 对象比较的另外一个 Buffer 对象。
返回一个数字,表示 buf 在 otherBuffer 之前,之后或相同,-1为之前,0为相同,1为之后。
缓冲区拷贝
- targetBuffer - 要拷贝的 Buffer 对象。
- targetStart - 数字, 可选, 默认: 0
- sourceStart - 数字, 可选, 默认: 0
- sourceEnd - 数字, 可选, 默认: buffer.length
无返回值
缓冲区裁剪
buf.slice([start[, end]])
- start - 数字, 可选, 默认: 0
- end - 数字, 可选, 默认: buffer.length
返回一个新的缓冲区,它和旧缓冲区指向同一块内存,但是从索引 start 到 end 的位置剪切。
返回长度
buf.length;
node.js stream流
stream流让我们在服务器端进行一些磁盘文件、套接字、HTTP请求来交互
Stream 是 Node.js 中非常重要的一个模块,应用广泛。
Stream 是一个抽象接口,Node 中有很多对象实现了这个接口。例如,对http 服务器发起请求的request 对象就是一个 Stream,还有stdout(标准输出)。
该抽象接口是可读、可写或是既可读又可写的,通过这些接口,我们可以和磁盘文件、套接字、HTTP请求来交互,实现数据从一个地方流动到另一个地方的功能。
Node.js,Stream 有四种流类型:
- Readable - 可读操作。
- Writable - 可写操作。
- Duplex - 可读可写操作.
- Transform - 操作被写入数据,然后读出结果。
所有的 Stream 对象都是 EventEmitter 的实例。常用的事件有:
- data - 当有数据可读时触发。
- end - 没有更多的数据可读时触发。
- error - 在接收和写入过程中发生错误时触发。
- finish - 所有数据已被写入到底层系统时触发。
//读取数据
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("程序执行完毕");
//写入数据
var fs = require("fs");
var data = 'W3Cschool教程官网地址:www.w3cschool.cn';
// 创建一个可以写入的流,写入到文件 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("程序执行完毕");
//管道流,提供了一个输出流到输入流的机制。通常我们用于从一个流中获取数据并将数据传递到另外一个流中。
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 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("文件压缩完成。");
var fs = require("fs");
var zlib = require('zlib');
// 解压 input.txt.gz 文件为 input.txt
fs.createReadStream('input.txt.gz')
.pipe(zlib.createGunzip())
.pipe(fs.createWriteStream('input.txt'));
console.log("文件解压完成。");
Node.js模块系统
基本上等同于python中的库模块系统
Node.js 提供了exports 和 require 两个对象,其中 exports 是模块公开的接口,require 用于从外部获取一个模块的接口,即所获取模块的 exports 对象。
我们在调用模块时使用require方法进行引入一个模块,在模块文件中使用exports进行为外界提供一个公开的接口。
当我们只是想要在模块中写一个函数进行调用时:
例:
exports.world = function() {
console.log('Hello World');
}
当我们想要将一个对象封装到模块中去:
例:
module.exports = function() {
// ...
}
//实例
function Hello() {
var name;
this.setName = function(thyName) {
name = thyName;
};
this.sayHello = function() {
console.log('Hello ' + name);
};
};
module.exports = Hello;
//使用
var Hello = require('./hello');
hello = new Hello();
hello.setName('BYVoid');
hello.sayHello();
关于node.js是怎样进行模块的查找加载的:
从文件模块缓存中加载
尽管原生模块与文件模块的优先级不同,但是都不会优先于从文件模块的缓存中加载已经存在的模块。
从原生模块加载
原生模块的优先级仅次于文件模块缓存的优先级。require方法在解析文件名之后,优先检查模块是否在原生模块列表中。以http模块为例,尽管在目录下存在一个http/http.js/http.node/http.json文件,require(“http”)都不会从这些文件中加载,而是从原生模块中加载。
原生模块也有一个缓存区,同样也是优先从缓存区加载。如果缓存区没有被加载过,则调用原生模块的加载方式进行加载和执行。
从文件加载
当文件模块缓存中不存在,而且不是原生模块的时候,Node.js会解析require方法传入的参数,并从文件系统中加载实际的文件,加载过程中的包装和编译细节在前一节中已经介绍过,这里我们将详细描述查找文件模块的过程,其中,也有一些细节值得知晓。
require方法接受以下几种参数的传递:
- http、fs、path等,原生模块。
- ./mod或…/mod,相对路径的文件模块。
- /pathtomodule/mod,绝对路径的文件模块。
- mod,非原生模块的文件模块。
Node.js 函数
总的来说呢,函数的特点就是在函数参数中可以传入另外一个函数作为这个函数的参数,然后在这个函数中去使用这个传入的参数。
实例:
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");//在 execute 接受第一个参数的地方直接定义了我们准备传递给 execute 的函数。
使用函数传递来使HTTP服务器工作。
var http = require("http");
function onRequest(request, response) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
node.js 路由
路由的功能:我们要为路由提供请求的URL和其他需要的GET及POST参数,随后路由需要根据这些数据来执行相应的代码。说白了就是我们通过路径信息与函数进行一一对应,通过路径信息来调用特定的函数。
下面演示一个将服务器与路由功能整合在一起的功能代码实例:
//server.js
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"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
//router.js
function route(pathname) {
console.log("About to route a request for " + pathname);
}
exports.route = route;
//index.js
var server = require("./server");
var router = require("./router");
server.start(router.route);
下面进行node index.js运行index那么服务器会对本地端口8888进行监听,并在命令行显示出相应的请求路径信息。
Node.js 全局对象
本节介绍 Node.js 全局对象,global 全局对象无需引用就可以直接使用。
JavaScript 中有一个特殊的对象,称为全局对象(Global Object),它及其所有属性都可以在程序的任何地方访问,即全局变量。
在浏览器 JavaScript 中,通常window 是全局对象, 而Node.js 中的全局对象是 global,所有全局变量(除了 global 本身以外)都是 global 对象的属性。
我们在Node.js 中能够直接访问到对象通常都是 global 的属性,如 console、process 等,下面逐一介绍。
全局对象与全局变量
global 最根本的作用是作为全局变量的宿主。按照 ECMAScript 的定义,满足以下条件的变量是全局变量:
- 在最外层定义的变量;
- 全局对象的属性;
- 隐式定义的变量(未定义直接赋值的变量)。
当你定义一个全局变量时,这个变量同时也会成为全局对象的属性,反之亦然。需要注 意的是,在Node.js 中你不可能在最外层定义变量,因为所有用户代码都是属于当前模块的, 而模块本身不是最外层上下文。
注意: 永远使用var 定义变量以避免引入全局变量,因为全局变量会污染 命名空间,提高代码的耦合风险。
process
process 是一个全局变量,即 global 对象的属性。
它用于描述当前Node.js 进程状态 的对象,提供了一个与操作系统的简单接口。通常在你写本地命令行程序的时候,少不了要 和它打交道。下面将会介绍process 对象的一些最常用的成员方法。
process.argv是命令行参数数组,第一个元素是 node,第二个元素是脚本文件名, 从第三个元素开始每个元素是一个运行参数。
console.log(process.argv);
将以上代码存储为argv.js,通过以下命令运行:
$ node argv.js 1991 name=byvoid --v "Carbo Kuo"
[ 'node',
'/home/byvoid/argv.js',
'1991',
'name=byvoid',
'--v',
'Carbo Kuo' ]
-
process.stdout是标准输出流,通常我们使用的 console.log() 向标准输出打印 字符,而 process.stdout.write() 函数提供了更底层的接口。
-
process.stdin是标准输入流,初始时它是被暂停的,要想从标准输入读取数据, 你必须恢复流,并手动编写流的事件响应函数。
-
process.stdin.resume(); process.stdin.on('data', function(data) { process.stdout.write('read from console: ' + data.toString()); });
-
**process.nextTick(callback)**的功能是为事件循环设置一项任务,Node.js 会在 下次事件循环调响应时调用 callback。
初学者很可能不理解这个函数的作用,有什么任务不能在当下执行完,需要交给下次事 件循环响应来做呢?
我们讨论过,Node.js 适合I/O 密集型的应用,而不是计算密集型的应用, 因为一个Node.js 进程只有一个线程,因此在任何时刻都只有一个事件在执行。
如果这个事 件占用大量的CPU 时间,执行事件循环中的下一个事件就需要等待很久,因此Node.js 的一 个编程原则就是尽量缩短每个事件的执行时间。process.nextTick() 提供了一个这样的 工具,可以把复杂的工作拆散,变成一个个较小的事件。
functiondoSomething(args, callback) {
somethingComplicated(args);
callback();
}
doSomething(functiononEnd() {
compute();
});
我们假设compute() 和somethingComplicated() 是两个较为耗时的函数,以上 的程序在调用 doSomething() 时会先执行somethingComplicated(),然后立即调用 回调函数,在 onEnd() 中又会执行 compute()。下面用process.nextTick() 改写上 面的程序:
functiondoSomething(args, callback) {
somethingComplicated(args);
process.nextTick(callback);
}
doSomething(functiononEnd() {
compute();
});
改写后的程序会把上面耗时的操作拆分为两个事件,减少每个事件的执行时间,提高事 件响应速度。
注意: 不要使用setTimeout(fn,0)代替process.nextTick(callback), 前者比后者效率要低得多。
console
console 用于提供控制台标准输出,它是由Internet Explorer 的JScript 引擎提供的调试 工具,后来逐渐成为浏览器的事实标准。
Node.js 沿用了这个标准,提供与习惯行为一致的 console 对象,用于向标准输出流(stdout)或标准错误流(stderr)输出字符。 console.log():向标准输出流打印字符并以换行符结束。
console.log 接受若干 个参数,如果只有一个参数,则输出这个参数的字符串形式。如果有多个参数,则 以类似于C 语言 printf() 命令的格式输出。
第一个参数是一个字符串,如果没有 参数,只打印一个换行。
console.log('Hello world');
console.log('byvoid%diovyb');
console.log('byvoid%diovyb', 1991);
运行结果为:
Hello world
byvoid%diovyb
byvoid1991iovyb
- console.error():与console.log() 用法相同,只是向标准错误流输出。
- console.trace():向标准错误流输出当前的调用栈。
console.trace();
运行结果为:
Trace:
at Object.<anonymous> (/home/byvoid/consoletrace.js:1:71)
at Module._compile (module.js:441:26)
at Object..js (module.js:459:10)
at Module.load (module.js:348:31)
at Function._load (module.js:308:12)
at Array.0 (module.js:479:10)
at EventEmitter._tickCallback (node.js:192:40)
Node.js 常用工具util
这个util模块有许多会经常用到的函数的集合,对象的继承等等,下面给出几个实例介绍它的用法。
util.inherits
var util = require('util');
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();
//objSub.sayHello();
console.log(objSub);
其中要注意到的是:注意:Sub仅仅继承了Base在原型中定义的函数,而构造函数内部创造的base属性和sayHello函数都没有被Sub继承。同时,在原型中定义的属性不会被console.log作为对象的属性输出。
函数原型指的即是在Base.prototype中定义的对象的属性。
util.inspect
util.inspect(object,[showHidden],[depth],[colors])方法可以将任意对象转换为字符串,通常用于调试和错误输出。它至少接受一个object参数,即要转换的对象。
showHidden是一个可选参数,如果值为true,将会输出更多隐藏信息。
depth表示最大递归的层数,如果对象很复杂,你可以指定层数以控制输出信息的多少。如果不指定depth,则默认递归2层,指定为null时表示将不限递归层数完整遍历对象。 如果color值为true,则输出格式将会以ANSI颜色编码,通常用于在终端显示更漂亮的效果。
特别要指出的是,util.inspect并不会简单地直接把对象转换为字符串,即使该对象定义了toString方法也不会调用。
实例:
console.log(util.inspect(obj));
console.log(util.inspect(obj, true));//或者
输出样例:
{ name: 'byvoid', toString: [Function] }
{ toString:
{ [Function]
[prototype]: { [constructor]: [Circular] },
[caller]: null,
[length]: 0,
[name]: '',
[arguments]: null },
name: 'byvoid' }
util.isArray(object)
如果给定的参数 “object” 是一个数组返回true,否则返回false。
util.isRegExp(object)
如果给定的参数"object"是一个正则表达式返回true,否则返回false。
util.isDate(object)
如果给定的参数 “object” 是一个日期返回true,否则返回false。
util.isError(object)
如果给定的参数 “object” 是一个错误对象返回true,否则返回false。
Node.js 文件系统
Node.js文件系统被封装在fs模块中,它提供了文件的读取、写入、更名、删除、遍历目录、链接等POSIX文件系统操作。
与其他模块不同的是,fs模块中所有的操作都提供了异步的和同步的两个版本,例如读取文件内容的函数有异步的fs.readFile()和同步的
fs.readFileSync()。我们以几个函数为代表,介绍fs常用的功能,并列出fs所有函数的定义和功能。
fs.readFile
Node.js读取文件函数语法如下:
fs.readFile(filename,[encoding],[callback(err,data)])
- filename(必选),表示要读取的文件名。
- encoding(可选),表示文件的字符编码。
- callback 是回调函数,用于接收文件的内容。
如果不指定encoding,则callback就是第二个参数。回调函数提供两个参数err和data,err表示有没有错误发生,data是文件内容。如果指定了encoding,data是一个解析后的字符串,否则data将会是以Buffer形式表示的二进制数据。
例如以下程序,我们从content.txt中读取数据,但不指定编码:
var fs = require('fs');
fs.readFile('content.txt', function(err, data) {
if(err) {
console.error(err);
} else{
console.log(data);
}
});
假设content.txt中的内容是UTF-8编码的Text文本文件示例,运行结果如下:
<Buffer 54 65 78 74 20 e6 96 87 e6 9c ac e6 96 87 e4 bb b6 e7 a4 ba e4 be 8b>
这个程序以二进制的模式读取了文件的内容,data的值是Buffer对象。如果我们给fs.readFile的encoding指定编码:
var fs = require('fs');
fs.readFile('content.txt', 'utf-8', function(err, data) {
if (err) {
console.error(err);
} else {
console.log(data);
}
});
那么运行结果则是:
Text 文本文件示例
当读取文件出现错误时,err将会是Error对象。如果content.txt不存在,运行前面的代码则会出现以下结果:
{ [Error: ENOENT, no such file or directory 'content.txt'] errno: 34, code: 'ENOENT',
path: 'content.txt' }
fs.readFileSync
**fs.readFileSync(filename, [encoding])**是fs.readFile同步的版本。它接受和 fs.readFile 相同的参数,而读取到的文件内容会以函数返回值的形式返回。如果有错 误发生,fs将会抛出异常,你需要使用try和catch捕捉并处理异常。
**注意:**与同步I/O函数不同,Node.js中异步函数大多没有返回值。
fs.open
fs.open(path, flags, [mode], [callback(err, fd)])是POSIX open函数的封装,类似于C语言标准库中的fopen函数。它接受两个必选参数,path为文件的路径, flags 可以是以下值:
- r :以读取模式打开文件。
- r+ :以读写模式打开文件。
- w :以写入模式打开文件,如果文件不存在则创建。
- w+ :以读写模式打开文件,如果文件不存在则创建。
- a :以追加模式打开文件,如果文件不存在则创建。
- a+ :以读取追加模式打开文件,如果文件不存在则创建
fs.read
fs.read语法格式如下:
fs.read(fd, buffer, offset, length, position, [callback(err, bytesRead, buffer)])
参数说明:
- fd: 读取数据并写入buffer指向的缓冲区对象。
- offset: 是buffer的写入偏移量。
- length: 是要从文件中读取的字节数。
- position: 是文件读取的起始位置,如果position的值为null,则会从当前文件指针的位置读取。
- callback:回调函数传递bytesRead和buffer,分别表示读取的字节数和缓冲区对象。
以下是一个使用fs.open和fs.read的示例。
var fs = require('fs');
fs.open('content.txt', 'r', function(err, fd) {
if(err) {
console.error(err);
return;
}
var buf = new Buffer(8);
fs.read(fd, buf, 0, 8, null, function(err, bytesRead, buffer) {
if(err) {
console.error(err);
return;
}
console.log('bytesRead: ' + bytesRead);
console.log(buffer);
})
});
运行结果是:
bytesRead: 8
<Buffer 54 65 78 74 20 e6 96 87>
一般来说,除非必要,否则不要使用这种方式读取文件,因为它要求你手动管理缓冲区和文件指针,尤其是在你不知道文件大小的时候,这将会是一件很麻烦的事情。
Node.js web模块
Node.js 的web模块 也就是web服务器
Web服务器一般指网站服务器,是指驻留于因特网上某种类型计算机的程序。
Web服务器的基本功能就是提供Web信息浏览服务。它只需支持HTTP协议、HTML文档格式及URL,与客户端的网络浏览器配合。
大多数web服务器都支持服务端的脚本语言(php、python、ruby)等,并通过脚本语言从数据库获取数据,将结果返回给客户端浏览器。
目前最主流的三个Web服务器是Apache、Nginx、IIS。
- Client - 客户端,一般指浏览器,浏览器可以通过HTTP协议向服务器请求数据。
- Server - 服务端,一般指Web服务器,可以接收客户端请求,并向客户端发送响应数据。
- Business - 业务层, 通过Web服务器处理应用程序,如与数据库交互,逻辑运算,调用外部程序等。
- Data - 数据层,一般由数据库组成。
使用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);
response.writeHead(404, {'Content-Type': 'text/html'});
}else{
response.writeHead(200, {'Content-Type': 'text/html'});
response.write(data.toString());
}
response.end();
});
}).listen(8081);
console.log('Server running at http://127.0.0.1:8081/');
//同目录,建立index.htm
<html>
<head>
<title>Sample Page</title>
</head>
<body>
Hello World!
</body>
</html>
使用node创建web客户端
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();
Node.js 工具模块文档介绍
os模块:系统操作函数
path模块:处理转换文件路径
net模块:底层网络通信,提供服务端和客户端操作
dns模块:解析域名
dimain模块:简化异步代码的异常处理。
Node.js Express框架
Node.js RESULTful api
REST中文解释为,表述性状态传递(英文:Representational State Transfer,简称REST),是Roy Fielding博士在2000年他的博士论文中提出来的一种软件架构风格。
表述性状态转移是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是RESTful。
需要注意的是,REST是设计风格而不是标准。REST通常基于使用HTTP,URI和XML(标准通用标记语言下的一个子集)以及HTML(标准通用标记语言下的一个应用)这些现有的广泛流行的协议和标准。REST通常使用JSON数据格式。
HTTP 方法
以下为REST基本架构的四个方法:
- GET - 用于获取数据。
- PUT - 用于添加数据。
- DELETE - 用于删除数据。
- POST - 用于更新或添加数据
创建数据资源文件users.json
{
"user1" : {
"name" : "mahesh",
"password" : "password1",
"profession" : "teacher",
"id": 1
},
"user2" : {
"name" : "suresh",
"password" : "password2",
"profession" : "librarian",
"id": 2
},
"user3" : {
"name" : "ramesh",
"password" : "password3",
"profession" : "clerk",
"id": 3
}
}
基于以上数据,我们创建以下RESTful API:
序号 | URI | HTTP 方法 | 发送内容 | 结果 |
---|---|---|---|---|
1 | listUsers | GET | 空 | 显示所有用户列表 |
2 | addUser | POST | JSON 字符串 | 添加新用户 |
3 | deleteUser | DELETE | JSON 字符串 | 删除用户 |
4 | :id | GET | 空 | 显示用户详细信息 |
获取用户列表:
以下代码,我们创建了RESTful API listUsers,用于读取用户的信息列表, server.js文件代码如下所示:
var express = require('express');
var app = express();
var fs = require("fs");
app.get('/listUsers', function (req, res) {
fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
console.log( data );
res.end( data );
});
})
var server = app.listen(8081, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例,访问地址为 http://%s:%s", host, port)
})
接下来执行以下命令:
$ node server.js
应用实例,访问地址为 http://0.0.0.0:8081
在浏览器中访问http://127.0.0.1:8081/listUsers,结果如下所示:
{
"user1" : {
"name" : "mahesh",
"password" : "password1",
"profession" : "teacher",
"id": 1
},
"user2" : {
"name" : "suresh",
"password" : "password2",
"profession" : "librarian",
"id": 2
},
"user3" : {
"name" : "ramesh",
"password" : "password3",
"profession" : "clerk",
"id": 3
}
}
添加用户
如果要添加新的用户数据,可以通过创建RESTful API addUser实现,server.js文件代码如下所示:
var express = require('express');
var app = express();
var fs = require("fs");
//添加的新用户数据
var user = {
"user4" : {
"name" : "mohit",
"password" : "password4",
"profession" : "teacher",
"id": 4
}
}
app.get('/addUser', function (req, res) {
// 读取已存在的数据
fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
data = JSON.parse( data );
data["user4"] = user["user4"];
console.log( data );
res.end( JSON.stringify(data));
});
})
var server = app.listen(8081, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例,访问地址为 http://%s:%s", host, port)
})
接下来执行以下命令:
$ node server.js
应用实例,访问地址为 http://0.0.0.0:8081
在浏览器中访问http://127.0.0.1:8081/addUser,结果如下所示:
{ user1:
{ name: 'mahesh',
password: 'password1',
profession: 'teacher',
id: 1 },
user2:
{ name: 'suresh',
password: 'password2',
profession: 'librarian',
id: 2 },
user3:
{ name: 'ramesh',
password: 'password3',
profession: 'clerk',
id: 3 },
user4:
{ name: 'mohit',
password: 'password4',
profession: 'teacher',
id: 4 }
}
显示用户详情
以下代码,我们创建了RESTful API :id(用户id), 用于读取指定用户的详细信息,server.js文件代码如下所示:
var express = require('express');
var app = express();
var fs = require("fs");
app.get('/:id', function (req, res) {
// 首先我们读取已存在的用户
fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
data = JSON.parse( data );
var user = data["user" + req.params.id]
console.log( user );
res.end( JSON.stringify(user));
});
})
var server = app.listen(8081, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例,访问地址为 http://%s:%s", host, port)
})
接下来执行以下命令:
$ node server.js
应用实例,访问地址为 http://0.0.0.0:8081b
在浏览器中访问http://127.0.0.1:8081/2,结果如下所示:
{
"name":"suresh",
"password":"password2",
"profession":"librarian",
"id":2
}
删除用户
以下代码,我们创建了RESTful API deleteUser, 用于删除指定用户的详细信息,以下实例中,用户id为2,server.js文件代码如下所示:
var express = require('express');
var app = express();
var fs = require("fs");
var id = 2;
app.get('/deleteUser', function (req, res) {
// First read existing users.
fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
data = JSON.parse( data );
delete data["user" + 2];
console.log( data );
res.end( JSON.stringify(data));
});
})
var server = app.listen(8081, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例,访问地址为 http://%s:%s", host, port)
})
接下来执行以下命令:
$ node server.js
应用实例,访问地址为 http://0.0.0.0:8081
在浏览器中访问http://127.0.0.1:8081/deleteUser,结果如下所示:
{ user1:
{ name: 'mahesh',
password: 'password1',
profession: 'teacher',
id: 1 },
user3:
{ name: 'ramesh',
password: 'password3',
profession: 'clerk',
id: 3 }
}