nodejs

JavaScript/11JavaScript原型链.md

@@ -0,0 +1,93 @@
+# 原型与继承
+[参考文献](cnblogs.com/loveyaxin/p/11151586.html)
+## 1 函数与对象的表面关系
+
+* 函数是函数，对象是对象。
+* 函数本身也是特殊对象，typeof 返回function。函数返回值可以是对象。
+* 对象可以包含函数属性。typeof 返回object
+* 函数可以作为对象的模板，称为对象构造器，typeof返回值，返回object。常见的内置类型构造器，首字母大写，通过new关键字，返回新的对象。new Array（）；new Function()；
+* 变量可以指向函数，也可以指向对象。
+* 函数的定义方法 function(){}匿名函数；或者function name(){}
+* 对象的定义方法 new Creator();或者{}。从对象构造器中创建对象，或者直接创建对象。通过new创建的对象，proto指向Creator()对象构造器。通过{}创建的对象，proto指向Object()对象构造起，会形成，proto链。
+
+
+
+## 2 原型
+
+### 函数原型
+* 原型的概念：每一个javascript对象(除null外)创建的时候，就会与之关联另一个对象，这个对象就是我们所说的原型，每一个对象都会从原型中“继承”属性。
+
+
+```javascript
+function Person(age) {
+    this.age = age       
+}
+Person.prototype.name = 'kavin'
+var person1 = new Person()
+var person2 = new Person()
+console.log(person1.name) //kavin
+console.log(person2.name)  //kavin
+```
+* 在JavaScript中，每个函数都有一个prototype属性，这个属性指向函数的原型对象。函数的prototype指向了一个对象，而这个对象正是调用构造函数时创建的实例的原型，也就是person1和person2的原型。
+![](img/prototype.png)
+
+### 对象原型
+
+* 每个对象(除null外)都会有的属性，叫做__proto__，这个属性会指向该对象的原型。
+
+![](img/proto.png)
+
+### construtor构造函数
+
+* 每个原型都有一个constructor属性，指向该关联的构造函数。
+
+![](img/constructor.png)
+
+### 实例与原型
+* 当读取实例的属性时，如果找不到，就会查找与对象关联的原型中的属性，如果还查不到，就去找原型的原型，一直找到最顶层为止。
+```
+function Person() {
+
+}
+
+Person.prototype.name = 'Kevin';
+
+var person = new Person();
+
+person.name = 'Daisy';
+console.log(person.name) // Daisy
+
+delete person.name;
+console.log(person.name) // Kevin
+```
+
+### 原型的原型
+
+原型也是一个对象，既然是对象，我们就可以用最原始的方式创建它，那就是：
+```
+var obj = new Object();
+obj.name = 'Kevin'
+console.log(obj.name) // Kevin
+```
+
+其实原型对象就是通过 Object 构造函数生成的，结合之前所讲，实例的 __proto__ 指向构造函数的 prototype .
+
+![](img/proto_proto.png)
+
+### 原型链
+
+*  简单的回顾一下构造函数、原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。那么假如我们让原型对象等于另一个类型的实例，结果会怎样？显然，此时的原型对象将包含一个指向另一个原型的指针，相应地，另一个原型中也包含着一个指向另一个构造函数的指针。假如另一个原型又是另一个类型的实例，那么上述关系依然成立。如此层层递进，就构成了实例与原型的链条。这就是所谓的原型链的基本概念。
+
+![](img/protolist.png)
+
+
+### 补充
+
+* 函数的原型属性，指向原型对象。prototype属性。
+* 对象的原型属性，指向原型对象。__proto__属性。
+* 原型对象是实例的原型。
+* 原型对象的constructor指向对象构造器，也就是函数。
+* 原型对象通过constructor和对象构造器通过prototype构成了指向环。
+* 原型对象本身也是实例，她本身也具有原型对象。通过原型对象的原型对象，形成了原型链。原型对象通过__prpto__属性指向自己的原型。
+
+> 也就是说，原型对象，有两个属性，一个是构造器constructor，指向对象构造器。另一个属性指向自身的原型对象。普通对象没有constructor属性。

JavaScript/NodeJS/5fs模块.md

@@ -1 +0,0 @@
-const fs = re

JavaScript/NodeJS/6异步回调.md

@@ -1,86 +0,0 @@
-> nodejs最著名的地方，可能就是异步回调了吧。通过异步非阻塞的编程方式，通过回调函数，实现了通信。可以实现宏观上的单线程并发。
-
-## ES6新特性
-### let const
-
-let const 都是块作用域。不是函数的作用域。或是对象作用域。
-
-### 模板字符串
-
-```
-name = 'zhangsan'
-age = 10
-console.log(`${name}${age}`)
-```
-
-### 箭头函数
-
-```
-(err,data)={
-
-}
-```
-
-## 2 异步方法获取数据
-
-### 不能通过返回值获取异步方法中的数据
-
-因为return语句执行的时候，内部的运算还没有结束。
-
-### 通过回调函数获取异步方法中的数据
-
-```
-function getData(callback){
-    //异步调用
-    setTimeout(function(){
-        var name = "zhangsan ";
-        callback(name)
-    },1000);
-}
-
-getData(function(aaa){
-    console.log(aaa);
-})
-```
-
-### 通过promise获取异步方法中的数据
-
-promise添加回调方法。p.then调用的时候，复写回调方法。与之前的回调方法很相似。相当于promise代替了之前的getData方法，调用异步方法。
-```
-var p = new Promise(function(resolve,reject){
-    //异步调用
-    setTimeout(function(){
-        var name = "zhangsan ";
-        callback(name)
-    },1000);
-})
-
-p.then(function(data){
-    console.log(data);
-})
-```
-
-### async、await和promise实现异步非阻塞通信
-
-* async，想要同步必须返回promise类型
-* await，等待异步方法执行完成
-* promise,能够作为异步方法标记，await会等被标记为promise的异步方法执行完毕后，获取返回值。
-
-```
-async function test(){
-    return new Promise((resolv,reject)=>{
-        var name = "zhang san "
-        resolve(name);
-    },1000)
-}
-
-async function main(){
-    var data = await test();
-    console.log(data);
-}
-
-main
-```
-
-
-

JavaScript/NodeJS/7流读写.md

@@ -1,5 +0,0 @@
-## 1 文件读入流fs.createReadStream
-
-## 2 文件写入流fs.createWriteStream
-
-## 3 管道流reStream.pipe(writeStream)

JavaScript/NodeJS/8静态web服务器.md

@@ -1,6 +0,0 @@
-## 1 URL解析
-
-
-## 2 URL路由
-
- 

JavaScript/NodeJS/9Ejs.md

@@ -1,8 +0,0 @@
-# 文件渲染
-
-页面渲染主要有两种方式，后端渲染和前端渲染。
-
-1. 后端渲染主要在服务器将动态数据，加载到HTML页面，然后返回HTML页面。
-2. 前端渲染主要在客户端（浏览器）上异步请求数据，加载到当前页面，然后返回HTML页面。
-
-后端渲染速度慢，但逻辑简单。前端渲染速度快，响应速度快。

NodeJS/10工具模块.md

@@ -0,0 +1,5 @@
+## 1 os模块
+## 2 path模块
+## 3 net模块
+## 4 dns模块
+## 5 domain模块

NodeJS/2工程构建.md

@@ -6,22 +6,8 @@
 * 循环 - 循环操作以上步骤直到用户两次按下 ctrl-c 按钮退出。
 
 > nodeJS提供了交互式解释器的功能，可以进行基本的运算和调试。
-## 2回调函数
 
-通过回调函数实现了异步编程。
-
-```
-var fs = require("fs");
-
-fs.readFile('input.txt', function (err, data) {
-    if (err) return console.error(err);
-    console.log(data.toString());
-});
-
-console.log("程序执行结束!");
-```
-
-## 3工程构建
+## 2工程构建
 > CommonJS是nodejs的标准。nodejs是commonjs的实现。
 ### 包目录构成
 * package.json 包描述文件

NodeJS/3回调函数.md

@@ -0,0 +1,26 @@
+## 2回调函数
+> 在javascript中，一切都是变量，一起都是对象，基本数据类型的变量、函数类型的变量、对象类型的变量。也就是说，变量可以指向，基础数据类型、函数数据类型、对象数据类型等。
+通过回调函数实现了异步编程。
+
+### 同步阻塞
+
+```
+var fs = require("fs");
+
+var data = fs.readFileSync('input.txt');
+
+console.log(data.toString());
+console.log("程序执行结束!");
+```
+
+### 异步回调
+```
+var fs = require("fs");
+
+fs.readFile('input.txt', function (err, data) {
+    if (err) return console.error(err);
+    console.log(data.toString());
+});
+
+console.log("程序执行结束!");
+```

NodeJS/4模块系统.md

@@ -0,0 +1,47 @@
+# 1 说明
+
+* 模块是Node.js 应用程序的基本组成部分，文件和模块是一一对应的。一个 Node.js 文件就是一个模块，这个文件可能是JavaScript 代码、JSON 或者编译过的C/C++ 扩展。
+* Node.js 提供了 exports 和 require 两个对象，其中 exports 是模块公开的接口，require 用于从外部获取一个模块的接口，即所获取模块的 exports 对象。
+
+
+## 2示例
+
+### 代码示例
+* main.js
+```java
+var hello = require('./hello');
+hello.world();
+```
+* hello.js
+```java
+exports.world = function() {
+  console.log('Hello World');
+}
+```
+### 暴露对象
+
+```java
+//hello.js 
+function Hello() { 
+    var name; 
+    this.setName = function(thyName) { 
+        name = thyName; 
+    }; 
+    this.sayHello = function() { 
+        console.log('Hello ' + name); 
+    }; 
+}; 
+module.exports = Hello;
+```
+
+```java
+//main.js 
+var Hello = require('./hello'); 
+hello = new Hello(); 
+hello.setName('BYVoid'); 
+hello.sayHello(); 
+```
+### require过程
+
+![](img/nodejs-require.jpg)
+

NodeJS/5buffer模块.md

@@ -0,0 +1,113 @@
+# buffer模块
+
+## 1 模块说明
+
+### 作用
+* Buffer 类，该类用来创建一个专门存放二进制数据的缓存区
+
+### 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 - 将每个字节编码为两个十六进制字符。
+
+## 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 实例
+
+```
+// 创建一个长度为 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');
+```
+
+### 写入缓冲区
+
+```
+buf.write(string[, offset[, length]][, encoding])
+```
+* string - 写入缓冲区的字符串。
+
+* offset - 缓冲区开始写入的索引值，默认为 0 。
+
+* length - 写入的字节数，默认为 buffer.length
+
+* encoding - 使用的编码。默认为 'utf8' 。
+
+### 读取缓冲区
+```
+buf.toString([encoding[, start[, end]]])
+```
+
+* encoding - 使用的编码。默认为 'utf8' 。
+
+* start - 指定开始读取的索引位置，默认为 0。
+
+* end - 结束位置，默认为缓冲区的末尾。
+
+### 将 Buffer 转换为 JSON 对象
+```javascript
+buf.toJSON()
+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);
+```
+
+### 缓冲区合并
+
+```
+Buffer.concat(list[, totalLength])
+```
+
+* list - 用于合并的 Buffer 对象数组列表。
+
+* totalLength - 指定合并后Buffer对象的总长度。
+

NodeJS/6events模块.md

@@ -0,0 +1,122 @@
+# 事件循环
+
+## 1 模块说明
+
+### 过程
+* Node.js 是单进程单线程应用程序
+* Node.js 几乎每一个 API 都是支持回调函数的。
+* Node.js 基本上所有的事件机制都是用设计模式中观察者模式实现。
+* Node.js 单线程类似进入一个while(true)的事件循环，直到没有事件观察者退出，每个异步事件都生成一个事件观察者，如果有事件发生就调用该回调函数.
+
+### 示例
+
+![](img/event_loop.jpg)
+
+* Node.js 使用事件驱动模型，当web server接收到请求，就把它关闭然后进行处理，然后去服务下一个web请求。当这个请求完成，它被放回处理队列，当到达队列开头，这个结果被返回给用户。
+* 非阻塞式IO，事件驱动IO
+* 事件相当于一个主题(Subject)，而所有注册到这个事件上的处理函数相当于观察者(Observer)。
+
+## 2 模块应用
+
+### 示例
+```javascript
+// 引入 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("程序执行完毕。");
+```
+
+### 方法
+
+1. addListener(event, listener)
+为指定事件添加一个监听器到监听器数组的尾部。
+2.	on(event, listener)
+为指定事件注册一个监听器，接受一个字符串 event 和一个回调函数。
+server.on('connection', function (stream) {
+  console.log('someone connected!');
+});
+3. once(event, listener)
+为指定事件注册一个单次监听器，即 监听器最多只会触发一次，触发后立刻解除该监听器。
+server.once('connection', function (stream) {
+  console.log('Ah, we have our first user!');
+});
+4.	removeListener(event, listener)
+移除指定事件的某个监听器，监听器必须是该事件已经注册过的监听器。
+它接受两个参数，第一个是事件名称，第二个是回调函数名称。
+```
+var callback = function(stream) {
+  console.log('someone connected!');
+};
+server.on('connection', callback);
+// ...
+server.removeListener('connection', callback);
+```
+5.	removeAllListeners([event])
+移除所有事件的所有监听器， 如果指定事件，则移除指定事件的所有监听器。
+6.	setMaxListeners(n)
+默认情况下， EventEmitters 如果你添加的监听器超过 10 个就会输出警告信息。 setMaxListeners 函数用于提高监听器的默认限制的数量。
+7.	listeners(event)
+返回指定事件的监听器数组。
+8.	emit(event, [arg1], [arg2], [...])
+按监听器的顺序执行执行每个监听器，如果事件有注册监听返回 true，否则返回 false
+
+### 应用
+```
+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("程序执行完毕。");
+```

NodeJS/7http&url模块.md

@@ -0,0 +1,37 @@
+# http&url模块
+
+## 1 模块说明
+* 用来构建nodejs的原声的服务器程序。
+
+## 2 代码示例
+
+### server.js
+```java
+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;
+```
+### index.js
+```java
+var server = require("./server");
+var router = require("./router");
+ 
+server.start(router.route);
+```

NodeJS/8全局对象.md

@@ -0,0 +1,15 @@
+## 1 全局变量
+
+* __filename 表示当前正在执行的脚本的文件名。
+* __dirname 表示当前执行脚本所在的目录。
+* console 用于提供控制台标准输出，它是由 Internet Explorer 的 JScript 引擎提供的调试工具，后来逐渐成为浏览器的实施标准。
+* process 是一个全局变量，用于描述当前Node.js 进程状态的对象，提供了一个与操作系统的简单接口。
+
+## 全局函数
+* setTimeout(cb, ms) 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。：setTimeout() 只执行一次指定函数。返回一个代表定时器的句柄值。
+* clearTimeout( t ) 全局函数用于停止一个之前通过 setTimeout() 创建的定时器。 参数 t 是通过 setTimeout() 函数创建的定时器。
+* setInterval(cb, ms) 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。
+
+
+
+

NodeJS/9fs模块.md

@@ -0,0 +1,291 @@
+# fs模块
+## 1 流读写
+### 流的四种状态
+
+* Readable - 可读操作。
+
+* Writable - 可写操作。
+
+* Duplex - 可读可写操作.
+
+* Transform - 操作被写入数据，然后读出结果。
+
+### 流对象事件
+
+* data - 当有数据可读时触发。
+
+* end - 没有更多的数据可读时触发。
+
+* error - 在接收和写入过程中发生错误时触发。
+
+* finish - 所有数据已被写入到底层系统时触发。
+
+### 流读取
+```js
+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("程序执行完毕");
+```
+
+### 流写入
+```js
+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("程序执行完毕");
+```
+### 管道流
+通过读取一个文件内容并将内容写入到另外一个文件中。
+```js
+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("程序执行完毕");
+```
+
+### 链式流
+链式是通过连接输出流到另外一个流并创建多个流操作链的机制。链式流一般用于管道操作。接下来我们就是用管道和链式来压缩和解压文件。
+
+压缩过程链式流：
+```js
+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("文件压缩完成。");
+```
+
+解压过程链式流
+```js
+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("文件解压完成。");
+```
+## 2 文件操作
+
+### 文件读取
+```js
+var fs = require("fs");
+
+// 异步读取
+fs.readFile('input.txt', function (err, data) {
+   if (err) {
+       return console.error(err);
+   }
+   console.log("异步读取: " + data.toString());
+});
+
+// 同步读取
+var data = fs.readFileSync('input.txt');
+console.log("同步读取: " + data.toString());
+
+console.log("程序执行完毕。");
+```
+
+### 打开文件
+### 获取文件信息
+### 写入文件
+### 读取文件
+### 关闭文件
+### 截取文件
+### 删除文件
+### 创建目录
+### 读取目录
+### 删除目录
+## 3 fs...
+1	fs.rename(oldPath, newPath, callback)
+异步 rename().回调函数没有参数，但可能抛出异常。
+2	fs.ftruncate(fd, len, callback)
+异步 ftruncate().回调函数没有参数，但可能抛出异常。
+3	fs.ftruncateSync(fd, len)
+同步 ftruncate()
+4	fs.truncate(path, len, callback)
+异步 truncate().回调函数没有参数，但可能抛出异常。
+5	fs.truncateSync(path, len)
+同步 truncate()
+6	fs.chown(path, uid, gid, callback)
+异步 chown().回调函数没有参数，但可能抛出异常。
+7	fs.chownSync(path, uid, gid)
+同步 chown()
+8	fs.fchown(fd, uid, gid, callback)
+异步 fchown().回调函数没有参数，但可能抛出异常。
+9	fs.fchownSync(fd, uid, gid)
+同步 fchown()
+10	fs.lchown(path, uid, gid, callback)
+异步 lchown().回调函数没有参数，但可能抛出异常。
+11	fs.lchownSync(path, uid, gid)
+同步 lchown()
+12	fs.chmod(path, mode, callback)
+异步 chmod().回调函数没有参数，但可能抛出异常。
+13	fs.chmodSync(path, mode)
+同步 chmod().
+14	fs.fchmod(fd, mode, callback)
+异步 fchmod().回调函数没有参数，但可能抛出异常。
+15	fs.fchmodSync(fd, mode)
+同步 fchmod().
+16	fs.lchmod(path, mode, callback)
+异步 lchmod().回调函数没有参数，但可能抛出异常。Only available on Mac OS X.
+17	fs.lchmodSync(path, mode)
+同步 lchmod().
+18	fs.stat(path, callback)
+异步 stat(). 回调函数有两个参数 err, stats，stats 是 fs.Stats 对象。
+19	fs.lstat(path, callback)
+异步 lstat(). 回调函数有两个参数 err, stats，stats 是 fs.Stats 对象。
+20	fs.fstat(fd, callback)
+异步 fstat(). 回调函数有两个参数 err, stats，stats 是 fs.Stats 对象。
+21	fs.statSync(path)
+同步 stat(). 返回 fs.Stats 的实例。
+22	fs.lstatSync(path)
+同步 lstat(). 返回 fs.Stats 的实例。
+23	fs.fstatSync(fd)
+同步 fstat(). 返回 fs.Stats 的实例。
+24	fs.link(srcpath, dstpath, callback)
+异步 link().回调函数没有参数，但可能抛出异常。
+25	fs.linkSync(srcpath, dstpath)
+同步 link().
+26	fs.symlink(srcpath, dstpath[, type], callback)
+异步 symlink().回调函数没有参数，但可能抛出异常。 type 参数可以设置为 'dir', 'file', 或 'junction' (默认为 'file') 。
+27	fs.symlinkSync(srcpath, dstpath[, type])
+同步 symlink().
+28	fs.readlink(path, callback)
+异步 readlink(). 回调函数有两个参数 err, linkString。
+29	fs.realpath(path[, cache], callback)
+异步 realpath(). 回调函数有两个参数 err, resolvedPath。
+30	fs.realpathSync(path[, cache])
+同步 realpath()。返回绝对路径。
+31	fs.unlink(path, callback)
+异步 unlink().回调函数没有参数，但可能抛出异常。
+32	fs.unlinkSync(path)
+同步 unlink().
+33	fs.rmdir(path, callback)
+异步 rmdir().回调函数没有参数，但可能抛出异常。
+34	fs.rmdirSync(path)
+同步 rmdir().
+35	fs.mkdir(path[, mode], callback)
+S异步 mkdir(2).回调函数没有参数，但可能抛出异常。 访问权限默认为 0777。
+36	fs.mkdirSync(path[, mode])
+同步 mkdir().
+37	fs.readdir(path, callback)
+异步 readdir(3). 读取目录的内容。
+38	fs.readdirSync(path)
+同步 readdir().返回文件数组列表。
+39	fs.close(fd, callback)
+异步 close().回调函数没有参数，但可能抛出异常。
+40	fs.closeSync(fd)
+同步 close().
+41	fs.open(path, flags[, mode], callback)
+异步打开文件。
+42	fs.openSync(path, flags[, mode])
+同步 version of fs.open().
+43	fs.utimes(path, atime, mtime, callback)
+ 
+44	fs.utimesSync(path, atime, mtime)
+修改文件时间戳，文件通过指定的文件路径。
+45	fs.futimes(fd, atime, mtime, callback)
+ 
+46	fs.futimesSync(fd, atime, mtime)
+修改文件时间戳，通过文件描述符指定。
+47	fs.fsync(fd, callback)
+异步 fsync.回调函数没有参数，但可能抛出异常。
+48	fs.fsyncSync(fd)
+同步 fsync.
+49	fs.write(fd, buffer, offset, length[, position], callback)
+将缓冲区内容写入到通过文件描述符指定的文件。
+50	fs.write(fd, data[, position[, encoding]], callback)
+通过文件描述符 fd 写入文件内容。
+51	fs.writeSync(fd, buffer, offset, length[, position])
+同步版的 fs.write()。
+52	fs.writeSync(fd, data[, position[, encoding]])
+同步版的 fs.write().
+53	fs.read(fd, buffer, offset, length, position, callback)
+通过文件描述符 fd 读取文件内容。
+54	fs.readSync(fd, buffer, offset, length, position)
+同步版的 fs.read.
+55	fs.readFile(filename[, options], callback)
+异步读取文件内容。
+56	fs.readFileSync(filename[, options])
+57	fs.writeFile(filename, data[, options], callback)
+异步写入文件内容。
+58	fs.writeFileSync(filename, data[, options])
+同步版的 fs.writeFile。
+59	fs.appendFile(filename, data[, options], callback)
+异步追加文件内容。
+60	fs.appendFileSync(filename, data[, options])
+The 同步 version of fs.appendFile.
+61	fs.watchFile(filename[, options], listener)
+查看文件的修改。
+62	fs.unwatchFile(filename[, listener])
+停止查看 filename 的修改。
+63	fs.watch(filename[, options][, listener])
+查看 filename 的修改，filename 可以是文件或目录。返回 fs.FSWatcher 对象。
+64	fs.exists(path, callback)
+检测给定的路径是否存在。
+65	fs.existsSync(path)
+同步版的 fs.exists.
+66	fs.access(path[, mode], callback)
+测试指定路径用户权限。
+67	fs.accessSync(path[, mode])
+同步版的 fs.access。
+68	fs.createReadStream(path[, options])
+返回ReadStream 对象。
+69	fs.createWriteStream(path[, options])
+返回 WriteStream 对象。
+70	fs.symlink(srcpath, dstpath[, type], callback)
+异步 symlink().回调函数没有参数，但可能抛出异常。

NodeJS/demo/events_test.js

@@ -0,0 +1,25 @@
+// 引入 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("程序执行完毕。");