Node.js基础学习(1)

港控/mmm° 2023-10-13 19:12 17阅读 0赞

# 1.什么是node.js呢？ 和JavaScript又是什么关系呢？ #

*  node.js 提供了 JavaScript的`运行环境`。
 *  当`JavaScript作为后端开发语言`来说， 需要`在node.js的环境上进行`
 *  当`JavaScript作为前端开发语言`来说，需要`在浏览器的环境上进行`

# 2.Node.js 中的JavaScript运行环境？（后端开发） #

*  Node.js是一个基于`Chrome V8`引擎的`JavaScript`运行环境 （Chrome V8引擎运行效率最高）
 *  如果我们写了一段js代码，`把它放在浏览器中运行`，那么我们在做`前端开发`。
 *  如果我们写了一段js代码，`把它放在node中运行`，那么我们在做`后端开发`。

> `浏览器` 是`JavaScript的前端运行环境`。  
> `Node.js`是`JavaScript的后端运行环境`。  
> `Node.js`中`无法调用DOM和BOM等`，`浏览器内置API`。

![在这里插入图片描述][c0edb635b8844e5ab13b20a7a5c281b4.png]

# 3.Node.js 可以做什么？ #

*  `node.js`作为一个`JavaScript的运行环境`，提供了`基础的功能和API`：（基于node.js衍生了很多框架）
 *  `Express框架 (快速构建web应用)`
 *  `Electron 框架 （快速构建跨平台的桌面应用）`
 *  `restify 框架 （快速构建API接口项目）`
 *  `读写操作数据库`，创建实用的命令行工具辅助前端开发…

# 4.Node.js 怎么学习？ #

**浏览器中的JavaScript学习路径：**

`JavaScript基础语法 + 浏览器内置API（DOM+ BOM）+ 第三方库（jQuery，art-template等）`

**Node.js的学习路径：**

`JavaScript基础语法 + Node.js内置API模块（fs + path + http 等）+ 第三方API模块（express，mysql等）`

# 5.浏览器中的JavaScript由两部分组成：JS核心语法和WebAPI #

![在这里插入图片描述][914522becbde4ac2997875f7be72303d.png]

# 6.浏览器的主要构成部分有哪些？ #

*  `用户界面`
 *  `浏览器引擎(负责窗口管理、Tab进程管理等)`
 *  `渲染引擎(有叫内核，负责HTML解析、页面渲染)`
 *  `JS引擎(JS解释器，如Chrome和Nodejs采用的V8)`  
    ![在这里插入图片描述][8ae373ae2a6b49b08bd29163f85090f6.png]

# 7. 为什么JavaScript可以在浏览器中被执行？ #

因为`浏览器中有JavaScript解析引擎`，`不同的浏览器使用不同的JavaScript解析引擎`

# 8.为什么JavaScript可以操作DOM和BOM？ #

![在这里插入图片描述][0e17f43a388e4498b56df187c98e5cee.png]  
![在这里插入图片描述][e22b219c43404f23a005bd4477f3cd40.png]  
`每个浏览器都内置了DOM和BOM这样的API函数，因此，浏览器中的JavaScript才可以调用它们。`

# 9.浏览器中的JavaScript运行环境？（前端开发） #

运行环境是指代码运行所需要的必要环境。

![在这里插入图片描述][0894e99b2c204d1f9845b232eb13132e.png]

# 基础 #

## Node.js 事件循环 ##

Node.js 是`单进程单线程应用程序`，但是因为 V8 引擎提供的`异步执行回调接口`，通过这些接口可以`处理大量的并发，所以性能非常高`。

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

Node.js 基本上所有的`事件机制`都是用`设计模式中观察者模式实现`。

Node.js 单线程类似进入`一个while(true)的事件循环`，直到没有事件观察者退出，`每个异步事件都生成一个事件观察者，如果有事件发生就调用该回调函数.`

## 事件驱动程序 ##

`Node.js` 使用事件驱动模型，当`web server`接收到请求，就把它关闭然后进行处理，然后去服务下一个web请求。

`当这个请求完成，它被放回处理队列，当到达队列开头，这个结果被返回给用户。`

这个模型非常高效可扩展性非常强，因为 webserver 一直接受请求而不等待任何读写操作。（这也称之为`非阻塞式IO或者事件驱动IO`）

在事件驱动模型中，会生成一个`主循环来监听事件`，当检测到事件时触发回调函数。

![在这里插入图片描述][639d77d0f8f5471880f77547cd4d3368.png]

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

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

> // 引入 events 模块  
> var events = require(‘events’);  
> // 创建 eventEmitter 对象  
> var eventEmitter = new events.EventEmitter();  
> 以下程序绑定事件处理程序：  
> // 绑定事件及事件的处理程序  
> eventEmitter.on(‘eventName’, eventHandler);  
> 我们可以通过程序触发事件：  
> // 触发事件  
> eventEmitter.emit(‘eventName’);

// 引入 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 main.js
    连接成功。
    数据接收成功。
    程序执行完毕。

> EvenEmitter事件发射器  
> Emitter发射器

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

在 Node 应用程序中，执行异步操作的函数将回调函数作为最后一个参数， 回调函数接收错误对象作为第一个参数。

接下来让我们来重新看下前面的实例，创建一个 input.txt ,文件内容如下：

菜鸟教程官网地址：www.runoob.com  
创建 main.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("程序执行完毕");

以上程序中 fs.readFile() 是异步函数用于读取文件。 如果在读取文件过程中发生错误，错误 err 对象就会输出错误信息。

如果没发生错误，readFile 跳过 err 对象的输出，文件内容就通过回调函数输出。

执行以上代码，执行结果如下：

程序执行完毕
    菜鸟教程官网地址：www.runoob.com

接下来我们删除 input.txt 文件，执行结果如下所示：

程序执行完毕
    Error: ENOENT, open 'input.txt'

因为文件 input.txt 不存在，所以输出了错误信息。

## Node.js EventEmitter ##

Node.js 所有的`异步 I/O 操作`在完成时都会发送`一个事件到事件队列`。

Node.js 里面的许多对象都会`分发事件`：`一个 net.Server 对象会在每次有新连接时触发一个事件`， 一个`fs.readStream 对象会在文件被打开的时候触发一个事件`。 所有这些产生事件的对象都是 `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 的用法：

//event.js 文件
    var EventEmitter = require('events').EventEmitter; 
    var event = new EventEmitter(); 
    event.on('some_event', function() {
         
        console.log('some_event 事件触发'); 
    }); 
    setTimeout(function() {
         
        event.emit('some_event'); 
    }, 1000);

执行结果如下：

运行这段代码，1 秒后控制台输出了 ‘some\_event 事件触发’。  
其原理是`event`对象注册了事件 `some_event` 的一个监听器，然后我们通过`setTimeout` 在 1000 毫秒以后向 event 对象发送事件 some\_event，此时会调用some\_event 的监听器。

$ node event.js 
    some_event 事件触发

`EventEmitter` 的每个事件`由一个事件名和若干个参数组成，事件名是一个字符串，通常表达一定的语义`。对于每个事件，EventEmitter 支持 若干个事件监听器。

当事件触发时，注册到这个事件的事件监听器被依次调用，事件参数作为回调函数参数传递。

让我们以下面的例子解释这个过程：

//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 参数');

执行以上代码，运行的结果如下：

$ node event.js 
    listener1 arg1 参数 arg2 参数
    listener2 arg1 参数 arg2 参数

以上例子中，emitter 为事件 someEvent 注册了两个事件监听器，然后触发了 someEvent 事件。

运行结果中可以看到两个事件监听器回调函数被先后调用。 这就是EventEmitter最简单的用法。

EventEmitter 提供了多个属性，如 `on`和`emit`。`on 函数用于绑定事件函数`，`emit 属性用于触发一个事件`。接下来我们来具体看下 EventEmitter 的属性介绍。  
![在这里插入图片描述][239fdd8e224b402f8ef99bb7c151cd7e.png]  
![在这里插入图片描述][4d361b5c93e14f58a5d5630430adb3fa.png]

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("程序执行完毕。");

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

### error 事件 ###

`EventEmitter` 定义了一个特殊的事件 error，它包含了错误的语义，我们在遇到 `异常的时候通常会触发 error 事件`。

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

我们一般要为会触发 error 事件的对象设置监听器，避免遇到错误后整个程序崩溃。例如：

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

运行时会显示以下错误：

node.js:201 
    throw e; // process.nextTick error, or 'error' event on first tick 
    ^ 
    Error: Uncaught, unspecified 'error' event. 
    at EventEmitter.emit (events.js:50:15) 
    at Object.<anonymous> (/home/byvoid/error.js:5:9) 
    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)

### 继承 EventEmitter ###

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

`为什么要这样做呢？原因有两点：`

首先，具有某个实体功能的对象实现事件符合语义， `事件的监听和发生应该是一个对象的方法`。

其次 JavaScript 的对象机制是基于原型的，`支持 部分多重继承，继承 EventEmitter 不会打乱对象原有的继承关系`。

## Node.js 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对象。

### 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' 。`

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

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

实例

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

console.log("写入字节数 : "+ len);  
执行以上代码，输出结果为：

$node main.js
    写入字节数 : 14

### 从缓冲区读取数据 ###

从缓冲区读取数据  
**语法**  
读取 Node 缓冲区数据的语法如下所示：

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

**参数**  
参数描述如下：

encoding - 使用的编码。默认为 ‘utf8’ 。

start - 指定开始读取的索引位置，默认为 0。

end - 结束位置，默认为缓冲区的末尾。

**返回值**

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

实例

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  
执行以上代码，输出结果为：

$ node main.js
    abcdefghijklmnopqrstuvwxyz
    abcde
    abcde
    abcde

### 将 Buffer 转换为 JSON 对象 ###

**语法**  
将 `Node Buffer 转换为 JSON 对象的函数语法`格式如下：

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

**返回值**  
返回 JSON 对象。

**实例**

### 缓冲区合并 ###

语法  
Node 缓冲区合并的语法如下所示：

Buffer.concat(list[, totalLength])

参数

参数描述如下：

list - 用于合并的 Buffer 对象数组列表。

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

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

实例

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

执行以上代码，输出结果为：

buffer3 内容: 菜鸟教程www.runoob.com

### 缓冲区比较 ###

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

`buf.compare(otherBuffer);`  
参数  
参数描述如下：

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

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

实例

执行以上代码，输出结果为：

ABC在ABCD之前

### 拷贝缓冲区 ###

语法  
Node 缓冲区拷贝语法如下所示：

buf.copy(targetBuffer\[, targetStart\[, sourceStart\[, sourceEnd\]\]\])  
参数  
参数描述如下：

`targetBuffer - 要拷贝的 Buffer 对象。`

`targetStart - 数字, 可选, 默认: 0`

`sourceStart - 数字, 可选, 默认: 0`

`sourceEnd - 数字, 可选, 默认: buffer.length`

返回值  
没有返回值。

实例

var buf1 = Buffer.from('abcdefghijkl');
    var buf2 = Buffer.from('RUNOOB');
    
    //将 buf2 插入到 buf1 指定位置上
    buf2.copy(buf1, 2);
    
    console.log(buf1.toString());

执行以上代码，输出结果为：

abRUNOOBijkl

### 缓冲区裁剪 ###

Node 缓冲区裁剪语法如下所示：

`buf.slice([start[, end]])`  
参数  
参数描述如下：

start - 数字, 可选, 默认: 0

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

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

实例

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

执行以上代码，输出结果为：

buffer2 content: ru

### 缓冲区长度 ###

语法  
Node 缓冲区长度计算语法如下所示：

`buf.length;`  
返回值  
`返回 Buffer 对象所占据的内存长度。`

实例

var buffer = Buffer.from('www.runoob.com');
    //  缓冲区长度
    console.log("buffer length: " + buffer.length);

执行以上代码，输出结果为：

buffer length: 14

## Node.js Stream(流) ##

`Node.js Stream(流)`  
`Stream 是一个抽象接口`，`Node 中有很多对象实现了这个接口`。例如，对http 服务器发起请求的request 对象就是一个 Stream，还有stdout（标准输出）。

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

`Readable - 可读操作。`

`Writable - 可写操作。`

`Duplex - 可读可写操作.`

`Transform - 操作被写入数据，然后读出结果`。

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

`data - 当有数据可读时触发。`

`end - 没有更多的数据可读时触发。`

`error - 在接收和写入过程中发生错误时触发。`

`finish - 所有数据已被写入到底层系统时触发。`

本教程会为大家介绍常用的流操作。

### 从流中读取数据 ###

创建 input.txt 文件，内容如下：

菜鸟教程官网地址：www.runoob.com  
创建 main.js 文件, 代码如下：

以上代码执行结果如下：

程序执行完毕
    菜鸟教程官网地址：www.runoob.com
    写入流

创建 main.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();
    
    // 处理流事件 --> finish、error
    writerStream.on('finish', function() {
        
        console.log("写入完成。");
    });
    
    writerStream.on('error', function(err){
        
       console.log(err.stack);
    });
    
    console.log("程序执行完毕");

以上程序会将 data 变量的数据写入到 output.txt 文件中。代码执行结果如下：

$ node main.js 
    程序执行完毕
    写入完成。

查看 output.txt 文件的内容：

$ cat output.txt 
    菜鸟教程官网地址：www.runoob.com

### 管道流 ###

`管道提供了一个输出流到输入流的机制。通常我们用于从一个流中获取数据并将数据传递到另外一个流中。`  
![在这里插入图片描述][0fe84fa2da61416c93b3ad2b74203bef.png]

如上面的图片所示，我们把文件比作装水的桶，而水就是文件里的内容，`我们用一根管子(pipe)连接两个桶使得水从一个桶流入另一个桶，这样就慢慢的实现了大文件的复制过程。`

以下实例我们通过读取一个文件内容并将内容写入到另外一个文件中。

设置 input.txt 文件内容如下：

菜鸟教程官网地址：www.runoob.com
    管道流操作实例

创建 main.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("程序执行完毕");

代码执行结果如下：

$ node main.js 
    程序执行完毕

查看 output.txt 文件的内容：

$ cat output.txt 
    菜鸟教程官网地址：www.runoob.com

管道流操作实例

### 链式流 ###

`链式`是通过`连接输出流到另外一个流并创建多个流操作链的机制。链式流一般用于管道操作。`

接下来我们就是用管道和链式来压缩和解压文件。

创建 compress.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("文件压缩完成。");

代码执行结果如下：

$ node compress.js 
    文件压缩完成。

执行完以上操作后，我们可以看到当前目录下生成了`input.txt` 的压缩文件`input.txt.gz。`

接下来，让我们来解压该文件，创建 decompress.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("文件解压完成。");

代码执行结果如下：

$ node decompress.js 
    文件解压完成。

## Node.js模块系统 ##

为了让`Node.js的文件可以相互调用`，Node.js提供了一个简单的模块系统。

`模块`是`Node.js 应用程序的基本组成部分`，文`件和模块是一一对应的`。换言之，`一个 Node.js 文件就是一个模块`，这个文件可能是JavaScript 代码、JSON 或者编译过的C/C++ 扩展。

### 引入模块 ###

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

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

以上实例中，代码 require(‘./hello’) 引入了当前目录下的 hello.js 文件（./ 为当前目录，node.js 默认后缀为 js）。

`Node.js 提供了 exports 和 require 两个对象`，其中 `exports` 是`模块公开的接口`，`require` 用于`从外部获取一个模块的接口，即所获取模块的 exports 对象。`

接下来我们就来创建 hello.js 文件，代码如下：

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

在以上示例中，hello.js 通过 `exports 对象把 world 作为模块的访问接口`，在 main.js 中通过 `require('./hello') 加载这个模块`，然后就可以`直接访 问 hello.js 中 exports 对象的成员函数了`。

有时候我们只是想把`一个对象封装到模块`中，格式如下：

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

例如:

//hello.js

这样就可以直接获得这个对象了：

//main.js

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

模块接口的唯一变化是使用 `module.exports = Hello`代替了`exports.world = function(){}`。 在外部引用该模块时，其`接口对象就是要输出的 Hello 对象本身，而不是原先的 exports。`

### 服务端的模块放在哪里 ###

也许你已经注意到，我们已经在代码中使用了模块了。像这样：

var http = require("http");
    
    
    ...
    
    http.createServer(...);

`Node.js 中自带了一个叫做 http 的模块`，在我们的代码中`请求它并把返回值赋给一个本地变量`。

这把我们的本地变量变成了`一个拥有所有 http 模块所提供的公共方法的对象。`

Node.js 的`require 方法`中的文件查找策略如下：

由于`Node.js 中存在 4 类模块（原生模块和3种文件模块）`，尽管 require 方法极其简单，但是内部的加载却是十分复杂的，其加载优先级也各自不同。如下图所示：

![在这里插入图片描述][f0cdefab6e374563a03bc8009d4dcaa4.png]

#### 从文件模块缓存中加载 ####

尽管原生模块与文件模块的优先级不同，但是都会`优先从文件模块的缓存中加载已经存在的模块`。

#### 从原生模块加载 ####

`原生模块的优先级仅次于文件模块缓存的优先级`。`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 函数 ##

在 JavaScript中，`一个函数可以作为另一个函数的参数`。我们可以`先定义一个函数，然后传递，也可以在传递参数的地方直接定义函数。`

Node.js 中函数的使用与 JavaScript 类似，举例来说，你可以这样做：

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

以上代码中，我们把 `say 函数作为 execute 函数的第一个变量进行了传递`。`这里传递的不是 say 的返回值，而是 say 本身`！

这样一来， `say 就变成了execute 中的本地变量 someFunction ，execute 可以通过调用 someFunction() （带括号的形式）来使用 say 函数`。

当然，因为 say 有一个变量，`execute 在调用 someFunction 时可以传递这样一个变量`。

### 匿名函数 ###

我们可以把`一个函数作为变量传递`。但是我们不一定要绕这个`"先定义，再传递"`的圈子，我们可以`直接在另一个函数的括号中定义和传递这个函数`：

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

我们在`execute 接受第一个参数的地方直接定义了我们准备传递给 execute 的函数`。

用这种方式，我们甚至`不用给这个函数起名字，这也是为什么它被叫做匿名函数` 。

### 函数传递是如何让HTTP服务器工作的 ###

带着这些知识，我们再来看看我们简约而不简单的HTTP服务器：

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

现在它看上去应该清晰了很多：我们向 `createServer`函数传递了一个`匿名函数`。

用这样的代码也可以达到同样的目的：

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 参数`，随后路由需要根据这些数据来执行相应的代码。

因此，我们需要查看`HTTP 请求`，从中提取出`请求的 URL 以及 GET/POST 参数`。这一功能应当属于路由还是服务器（甚至作为一个模块自身的功能）确实值得探讨，但这里暂定其为我们的HTTP服务器的功能。

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

当然我们也可以用 querystring 模块来解析 POST 请求体中的参数，稍后会有演示。

现在我们来给 onRequest() 函数加上一些逻辑，用来找出浏览器请求的 URL 路径：

server.js 文件代码：

好了，我们的应用现在可以通过请求的 URL 路径来区别不同请求了–这使我们得以使用路由（还未完成）来将请求以 URL 路径为基准映射到处理程序上。

在我们所要构建的应用中，这意味着来自 /start 和 /upload 的请求可以使用不同的代码来处理。稍后我们将看到这些内容是如何整合到一起的。

现在我们可以来编写路由了，建立一个名为 router.js 的文件，添加以下内容：

router.js 文件代码：

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

如你所见，这段代码什么也没干，不过对于现在来说这是应该的。在添加更多的逻辑以前，我们先来看看如何把路由和服务器整合起来。

我们的服务器应当知道路由的存在并加以有效利用。我们当然可以通过硬编码的方式将这一依赖项绑定到服务器上，但是其它语言的编程经验告诉我们这会是一件非常痛苦的事，因此我们将使用依赖注入的方式较松散地添加路由模块。

首先，我们来扩展一下服务器的`start() 函数`，以便将路由函数作为参数传递过去，server.js 文件代码如下

server.js 文件代码：

同时，我们会相应扩展 index.js，使得路由函数可以被注入到服务器中：

index.js 文件代码：

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

在这里，我们传递的函数依旧什么也没做。

如果现在启动应用（node index.js，始终记得这个命令行），随后请求一个URL，你将会看到应用输出相应的信息，这表明我们的HTTP服务器已经在使用路由模块了，并会将请求的路径传递给路由：

$ node index.js
    Server has started.

以上输出已经去掉了比较烦人的 /favicon.ico 请求相关的部分。

[c0edb635b8844e5ab13b20a7a5c281b4.png]: https://img-blog.csdnimg.cn/c0edb635b8844e5ab13b20a7a5c281b4.png
[914522becbde4ac2997875f7be72303d.png]: https://img-blog.csdnimg.cn/914522becbde4ac2997875f7be72303d.png
[8ae373ae2a6b49b08bd29163f85090f6.png]: https://img-blog.csdnimg.cn/8ae373ae2a6b49b08bd29163f85090f6.png
[0e17f43a388e4498b56df187c98e5cee.png]: https://img-blog.csdnimg.cn/0e17f43a388e4498b56df187c98e5cee.png
[e22b219c43404f23a005bd4477f3cd40.png]: https://img-blog.csdnimg.cn/e22b219c43404f23a005bd4477f3cd40.png
[0894e99b2c204d1f9845b232eb13132e.png]: https://img-blog.csdnimg.cn/0894e99b2c204d1f9845b232eb13132e.png
[639d77d0f8f5471880f77547cd4d3368.png]: https://img-blog.csdnimg.cn/639d77d0f8f5471880f77547cd4d3368.png
[239fdd8e224b402f8ef99bb7c151cd7e.png]: https://img-blog.csdnimg.cn/239fdd8e224b402f8ef99bb7c151cd7e.png
[4d361b5c93e14f58a5d5630430adb3fa.png]: https://img-blog.csdnimg.cn/4d361b5c93e14f58a5d5630430adb3fa.png
[0fe84fa2da61416c93b3ad2b74203bef.png]: https://img-blog.csdnimg.cn/0fe84fa2da61416c93b3ad2b74203bef.png
[f0cdefab6e374563a03bc8009d4dcaa4.png]: https://img-blog.csdnimg.cn/f0cdefab6e374563a03bc8009d4dcaa4.png