Node.js 教程

我不是女神ヾ 2024-04-01 09:46 11阅读 0赞

## Node.js 教程 ##

简单的说 Node.js 就是**运行在服务端的 JavaScript**。

*  Node.js 是一个基于 Chrome JavaScript 运行时建立的一个平台。
 *  Node.js 是一个事件驱动 I/O 服务端 JavaScript 环境，基于 Google 的 V8 引擎，V8 引擎执行 Javascript 的速度非常快，性能非常好。

### 1. Node.js 创建第一个应用 ###

在我们创建 Node.js 第一个 “Hello, World!” 应用前，让我们先了解下 Node.js 应用是由哪几部分组成的：

1.  **引入 required 模块**：我们可以使用 **require** 指令来载入 Node.js 模块。
2.  **创建服务器**：服务器可以监听客户端的请求，类似于 Apache 、Nginx 等 HTTP 服务器。
3.  **接收请求与响应请求** 服务器很容易创建，客户端可以使用浏览器或终端发送 HTTP 请求，服务器接收请求后返回响应数据。

#### 1.1 步骤一、引入 required 模块 ####

我们使用 **require** 指令来载入 http 模块，并将实例化的 HTTP 赋值给变量 http，实例如下：

var http = require("http");

#### 1.2 步骤二、创建服务器 ####

接下来我们使用 http.createServer() 方法创建服务器，并使用 listen 方法绑定 8888 端口。 函数通过 request, response 参数来接收和响应数据。

实例如下，在你项目的根目录下创建一个叫 server.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/');

#### 1.3 步骤三、接收请求与响应请求 ####

以上代码我们完成了一个可以工作的 HTTP 服务器。

使用 **node** 命令执行以上的代码：

node server.js
    Server running at http://127.0.0.1:8888/

![de264f2a79ba4c5285a1125051346b28.png][]

接下来，打开浏览器访问 http://127.0.0.1:8888/，你会看到一个写着 "Hello World"的网页。

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

#### 1.4 总结 ####

**分析Node.js 的 HTTP 服务器：**

*  第一行请求（require）Node.js 自带的 http 模块，并且把它赋值给 http 变量。
 *  接下来我们调用 http 模块提供的函数： createServer 。这个函数会返回 一个对象，这个对象有一个叫做 listen 的方法，这个方法有一个数值参数， 指定这个 HTTP 服务器监听的端口号。

### 2. NPM使用介绍 ###

NPM是随同NodeJS一起安装的包管理工具，能解决NodeJS代码部署上的很多问题，常见的使用场景有以下几种：

*  允许用户从NPM服务器下载别人编写的第三方包到本地使用。
 *  允许用户从NPM服务器下载并安装别人编写的命令行程序到本地使用。
 *  允许用户将自己编写的包或命令行程序上传到NPM服务器供别人使用。

由于新版的nodejs已经集成了npm，所以之前npm也一并安装好了。同样可以通过输入 **“npm -v”** 来测试是否成功安装。

如果你安装的是旧版本的 npm，可以很容易得通过 npm 命令来升级，命令如下：

$ sudo npm install npm -g

如果是 Window 系统使用以下命令即可：

npm install npm -g

使用淘宝镜像的命令：

npm install -g cnpm --registry=https://registry.npmmirror.com

#### 2.1 使用 npm 命令安装模块 ####

npm 安装 Node.js 模块语法格式如下：

$ npm install <Module Name>

以下实例，我们使用 npm 命令安装常用的 Node.js web框架模块 **express**:

$ npm install express

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

var express = require('express');

#### 2.2 全局安装与本地安装 ####

npm 的包安装分为本地安装（local）、全局安装（global）两种，从敲的命令行来看，差别只是有没有-g而已，比如

npm install express          # 本地安装
    npm install express -g       # 全局安装

如果出现以下错误：

npm err! Error: connect ECONNREFUSED 127.0.0.1:8087

解决办法为：

$ npm config set proxy null

##### 2.2.1 本地安装 #####

1.  将安装包放在 ./node\_modules 下（运行 npm 命令时所在的目录），如果没有 node\_modules 目录，会在当前执行 npm 命令的目录下生成 node\_modules 目录。
2.  可以通过 require() 来引入本地安装的包。

##### 2.2.2 全局安装 #####

1.  将安装包放在 /usr/local 下或者你 node 的安装目录。
2.  可以直接在命令行里使用。

如果你希望具备两者功能，则需要在两个地方安装它或使用 **npm link**。

接下来我们使用全局方式安装 express

$ npm install express -g

安装过程输出如下内容，第一行输出了模块的版本号及安装位置。

express@4.13.3 node_modules/express
    ├── escape-html@1.0.2
    ├── range-parser@1.0.2
    ├── merge-descriptors@1.0.0
    ├── array-flatten@1.1.1
    ├── cookie@0.1.3
    ├── utils-merge@1.0.0
    ├── parseurl@1.3.0
    ├── cookie-signature@1.0.6
    ├── methods@1.1.1
    ├── fresh@0.3.0
    ├── vary@1.0.1
    ├── path-to-regexp@0.1.7
    ├── content-type@1.0.1
    ├── etag@1.7.0
    ├── serve-static@1.10.0
    ├── content-disposition@0.5.0
    ├── depd@1.0.1
    ├── qs@4.0.0
    ├── finalhandler@0.4.0 (unpipe@1.0.0)
    ├── on-finished@2.3.0 (ee-first@1.1.1)
    ├── proxy-addr@1.0.8 (forwarded@0.1.0, ipaddr.js@1.0.1)
    ├── debug@2.2.0 (ms@0.7.1)
    ├── type-is@1.6.8 (media-typer@0.3.0, mime-types@2.1.6)
    ├── accepts@1.2.12 (negotiator@0.5.3, mime-types@2.1.6)
    └── send@0.13.0 (destroy@1.0.3, statuses@1.2.1, ms@0.7.1, mime@1.3.4, http-errors@1.3.1)

##### 2.2.3 查看安装信息 #####

你可以使用以下命令来查看所有全局安装的模块：

$ npm list -g
    
    ├─┬ cnpm@4.3.2
    │ ├── auto-correct@1.0.0
    │ ├── bagpipe@0.3.5
    │ ├── colors@1.1.2
    │ ├─┬ commander@2.9.0
    │ │ └── graceful-readlink@1.0.1
    │ ├─┬ cross-spawn@0.2.9
    │ │ └── lru-cache@2.7.3
    ……

如果要查看某个模块的版本号，可以使用命令如下：

$ npm list grunt
    
    projectName@projectVersion /path/to/project/folder
    └── grunt@0.4.1

--------------------

#### 2.3 使用 package.json ####

package.json 位于模块的目录下，用于定义包的属性。接下来让我们来看下 express 包的 package.json 文件，位于 node\_modules/express/package.json 内容：

{
        
      "name": "express",
      "description": "Fast, unopinionated, minimalist web framework",
      "version": "4.13.3",
      "author": {
        
        "name": "TJ Holowaychuk",
        "email": "tj@vision-media.ca"
      },
      "contributors": [
        {
        
          "name": "Aaron Heckmann",
          "email": "aaron.heckmann+github@gmail.com"
        },
        {
        
          "name": "Ciaran Jessup",
          "email": "ciaranj@gmail.com"
        },
        {
        
          "name": "Douglas Christopher Wilson",
          "email": "doug@somethingdoug.com"
        },
        {
        
          "name": "Guillermo Rauch",
          "email": "rauchg@gmail.com"
        },
        {
        
          "name": "Jonathan Ong",
          "email": "me@jongleberry.com"
        },
        {
        
          "name": "Roman Shtylman",
          "email": "shtylman+expressjs@gmail.com"
        },
        {
        
          "name": "Young Jae Sim",
          "email": "hanul@hanul.me"
        }
      ],
      "license": "MIT",
      "repository": {
        
        "type": "git",
        "url": "git+https://github.com/strongloop/express.git"
      },
      "homepage": "http://expressjs.com/",
      "keywords": [
        "express",
        "framework",
        "sinatra",
        "web",
        "rest",
        "restful",
        "router",
        "app",
        "api"
      ],
      "dependencies": {
        
        "accepts": "~1.2.12",
        "array-flatten": "1.1.1",
        "content-disposition": "0.5.0",
        "content-type": "~1.0.1",
        "cookie": "0.1.3",
        "cookie-signature": "1.0.6",
        "debug": "~2.2.0",
        "depd": "~1.0.1",
        "escape-html": "1.0.2",
        "etag": "~1.7.0",
        "finalhandler": "0.4.0",
        "fresh": "0.3.0",
        "merge-descriptors": "1.0.0",
        "methods": "~1.1.1",
        "on-finished": "~2.3.0",
        "parseurl": "~1.3.0",
        "path-to-regexp": "0.1.7",
        "proxy-addr": "~1.0.8",
        "qs": "4.0.0",
        "range-parser": "~1.0.2",
        "send": "0.13.0",
        "serve-static": "~1.10.0",
        "type-is": "~1.6.6",
        "utils-merge": "1.0.0",
        "vary": "~1.0.1"
      },
      "devDependencies": {
        
        "after": "0.8.1",
        "ejs": "2.3.3",
        "istanbul": "0.3.17",
        "marked": "0.3.5",
        "mocha": "2.2.5",
        "should": "7.0.2",
        "supertest": "1.0.1",
        "body-parser": "~1.13.3",
        "connect-redis": "~2.4.1",
        "cookie-parser": "~1.3.5",
        "cookie-session": "~1.2.0",
        "express-session": "~1.11.3",
        "jade": "~1.11.0",
        "method-override": "~2.3.5",
        "morgan": "~1.6.1",
        "multiparty": "~4.1.2",
        "vhost": "~3.0.1"
      },
      "engines": {
        
        "node": ">= 0.10.0"
      },
      "files": [
        "LICENSE",
        "History.md",
        "Readme.md",
        "index.js",
        "lib/"
      ],
      "scripts": {
        
        "test": "mocha --require test/support/env --reporter spec --bail --check-leaks test/ test/acceptance/",
        "test-ci": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --require test/support/env --reporter spec --check-leaks test/ test/acceptance/",
        "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --require test/support/env --reporter dot --check-leaks test/ test/acceptance/",
        "test-tap": "mocha --require test/support/env --reporter tap --check-leaks test/ test/acceptance/"
      },
      "gitHead": "ef7ad681b245fba023843ce94f6bcb8e275bbb8e",
      "bugs": {
        
        "url": "https://github.com/strongloop/express/issues"
      },
      "_id": "express@4.13.3",
      "_shasum": "ddb2f1fb4502bf33598d2b032b037960ca6c80a3",
      "_from": "express@*",
      "_npmVersion": "1.4.28",
      "_npmUser": {
        
        "name": "dougwilson",
        "email": "doug@somethingdoug.com"
      },
      "maintainers": [
        {
        
          "name": "tjholowaychuk",
          "email": "tj@vision-media.ca"
        },
        {
        
          "name": "jongleberry",
          "email": "jonathanrichardong@gmail.com"
        },
        {
        
          "name": "dougwilson",
          "email": "doug@somethingdoug.com"
        },
        {
        
          "name": "rfeng",
          "email": "enjoyjava@gmail.com"
        },
        {
        
          "name": "aredridel",
          "email": "aredridel@dinhe.net"
        },
        {
        
          "name": "strongloop",
          "email": "callback@strongloop.com"
        },
        {
        
          "name": "defunctzombie",
          "email": "shtylman@gmail.com"
        }
      ],
      "dist": {
        
        "shasum": "ddb2f1fb4502bf33598d2b032b037960ca6c80a3",
        "tarball": "http://registry.npmjs.org/express/-/express-4.13.3.tgz"
      },
      "directories": {
        },
      "_resolved": "https://registry.npmjs.org/express/-/express-4.13.3.tgz",
      "readme": "ERROR: No README data found!"
    }

##### 2.3.1 Package.json 属性说明 #####

*  **name** \- 包名。
 *  **version** \- 包的版本号。
 *  **description** \- 包的描述。
 *  **homepage** \- 包的官网 url 。
 *  **author** \- 包的作者姓名。
 *  **contributors** \- 包的其他贡献者姓名。
 *  **dependencies** \- 依赖包列表。如果依赖包没有安装，npm 会自动将依赖包安装在 node\_module 目录下。
 *  **repository** \- 包代码存放的地方的类型，可以是 git 或 svn，git 可在 Github 上。
 *  **main** \- main 字段指定了程序的主入口文件，require(‘moduleName’) 就会加载这个文件。这个字段的默认值是模块根目录下面的 index.js。
 *  **keywords** \- 关键字

#### 2.4 卸载模块 ####

我们可以使用以下命令来卸载 Node.js 模块。

$ npm uninstall express

卸载后，你可以到 /node\_modules/ 目录下查看包是否还存在，或者使用以下命令查看：

$ npm ls

#### 2.5 更新模块 ####

我们可以使用以下命令更新模块：

$ npm update express

#### 2.6 搜索模块 ####

使用以下来搜索模块：

$ npm search express

#### 2.7 创建模块 ####

创建模块，package.json 文件是必不可少的。我们可以使用 NPM 生成 package.json 文件，生成的文件包含了基本的结果。

$ 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 资源库中注册用户（使用邮箱注册）：

$ npm adduser
    Username: mcmohd
    Password:
    Email: (this IS public) mcmohd@gmail.com

接下来我们就用以下命令来发布模块：

$ npm publish

如果你以上的步骤都操作正确，你就可以跟其他模块一样使用 npm 来安装。

#### 2.8 版本号 ####

使用 NPM 下载和发布代码时都会接触到版本号。NPM 使用语义版本号来管理代码，这里简单介绍一下。

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

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

版本号有了这个保证后，在申明第三方包依赖时，除了可依赖于一个固定版本号外，还可依赖于某个范围的版本号。例如 “argv”: “0.0.x” 表示依赖于 0.0.x 系列的最新版 argv 。

NPM 支持的所有版本号范围指定方式可以查看[官方文档][Link 1]。

#### 2.9 NPM 常用命令 ####

除了本章介绍的部分外，NPM还提供了很多功能，package.json里也有很多其它有用的字段。

除了可以在 [npmjs.org/doc/][npmjs.org_doc] 查看官方文档外，这里再介绍一些NPM常用命令。

NPM提供了很多命令，例如install和publish，使用npm help可查看所有命令。

*  NPM提供了很多命令，例如`install`和`publish`，使用`npm help`可查看所有命令。
 *  使用`npm help <command>`可查看某条命令的详细帮助，例如`npm help install`。
 *  在`package.json`所在目录下使用`npm install . -g`可先在本地安装当前命令行程序，可用于发布前的本地测试。
 *  使用`npm update <package>`可以把当前目录下`node_modules`子目录里边的对应模块更新至最新版本。
 *  使用`npm update <package> -g`可以把全局安装的对应命令行程序更新至最新版。
 *  使用`npm cache clear`可以清空NPM本地缓存，用于对付使用相同版本号发布新版本代码的人。
 *  使用`npm unpublish <package>@<version>`可以撤销发布自己发布过的某个版本代码。

#### 2.10 使用淘宝 NPM 镜像 ####

由于国内直接使用 npm 的官方镜像是非常慢的，这里推荐使用淘宝 NPM 镜像。

淘宝 NPM 镜像是一个完整 npmjs.org 镜像，你可以用此代替官方版本(只读)，同步频率目前为 10分钟 一次以保证尽量与官方服务同步。

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

$ npm install -g cnpm --registry=https://registry.npmmirror.com

这样就可以使用 cnpm 命令来安装模块了：

$ cnpm install [name]

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

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

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

*  **读取** \- 读取用户输入，解析输入的 Javascript 数据结构并存储在内存中。
 *  **执行** \- 执行输入的数据结构
 *  **打印** \- 输出结果
 *  **循环** \- 循环操作以上步骤直到用户两次按下 **ctrl-c** 按钮退出。

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

#### 3.1 启动 Node 的终端 ####

我们可以输入以下命令来启动 Node 的终端：

$ node
    >

这时我们就可以在 > 后输入简单的表达式，并按下回车键来计算结果。

#### 3.2 简单的表达式运算 ####

接下来让我们在 Node.js REPL 的命令行窗口中执行简单的数学运算：

$ node
    > 1 +4
    5
    > 5 / 2
    2.5
    > 3 * 6
    18
    > 4 - 1
    3
    > 1 + ( 2 * 3 ) - 4
    3
    >

#### 3.3 使用变量 ####

你可以将数据存储在变量中，并在你需要的时候使用它。

变量声明需要使用 **var** 关键字，如果没有使用 var 关键字变量会直接打印出来。

使用 **var** 关键字的变量可以使用 console.log() 来输出变量。

$ node
    > x = 10
    10
    > var y = 10
    undefined
    > x + y
    20
    > console.log("Hello World")
    Hello World
    undefined
    > console.log("www.runoob.com")
    www.runoob.com
    undefined

#### 3.4 多行表达式 ####

Node REPL 支持输入多行表达式，这就有点类似 JavaScript。接下来让我们来执行一个 do-while 循环：

$ node
    > var x = 0
    undefined
    > do {
    ... x++;
    ... console.log("x: " + x);
    ... } while ( x < 5 );
    x: 1
    x: 2
    x: 3
    x: 4
    x: 5
    undefined
    >

**…** 三个点的符号是系统自动生成的，你回车换行后即可。Node 会自动检测是否为连续的表达式。

#### 3.5 下划线(\_)变量 ####

你可以使用下划线(\_)获取上一个表达式的运算结果：

$ node
    > var x = 10
    undefined
    > var y = 20
    undefined
    > x + y
    30
    > var sum = _
    undefined
    > console.log(sum)
    30
    undefined
    >

#### 3.6 REPL 命令 ####

*  **ctrl + c** \- 退出当前终端。
 *  **ctrl + c 按下两次** \- 退出 Node REPL。
 *  **ctrl + d** \- 退出 Node REPL.
 *  **向上/向下 键** \- 查看输入的历史命令
 *  **tab 键** \- 列出当前命令
 *  **.help** \- 列出使用命令
 *  **.break** \- 退出多行表达式
 *  **.clear** \- 退出多行表达式
 *  **.save \*filename\*** \- 保存当前的 Node REPL 会话到指定文件
 *  **.load \*filename\*** \- 载入当前 Node REPL 会话的文件内容。

#### 3.7 停止 REPL ####

前面我们已经提到按下两次 **ctrl + c** 键就能退出 REPL:

$ node
    >
    (^C again to quit)
    >

### 4. Node.js 回调函数 ###

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

异步编程（多线程）依托于回调来实现，但不能说使用了回调后程序就异步化了。

回调函数在完成任务后就会被调用，Node 使用了大量的回调函数，Node 所有 API 都支持回调函数。

例如，我们可以一边读取文件，一边执行其他命令，在文件读取完成后，我们将文件内容作为回调函数的参数返回。这样在执行代码时就没有阻塞或等待文件 I/O 操作。这就大大提高了 Node.js 的性能，可以处理大量的并发请求。

回调函数一般作为函数的最后一个参数出现：

function foo1(name, age, callback) {
         }
    function foo2(value, callback1, callback2) {
         }

#### 4.1 阻塞代码实例 ####

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

新迎二十大，奋进新征程！

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

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

以上代码执行结果如下：

$ node main.js
    新迎二十大，奋进新征程！
    
    程序执行结束!

#### 4.2 非阻塞代码实例 ####

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

新迎二十大，奋进新征程！

创建 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
    程序执行结束!
    新迎二十大，奋进新征程！

以上两个实例我们了解了阻塞与非阻塞调用的不同。第一个实例在文件读取完后才执行程序。 第二个实例我们不需要等待文件读取完，这样就可以在读取文件时同时执行接下来的代码，大大提高了程序的性能。

因此，阻塞是按顺序执行的，而非阻塞是不需要按顺序的，所以如果需要处理回调函数的参数，我们就需要写在回调函数内。

### 5. Node.js 事件循环 ###

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

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

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

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

#### 5.1 事件驱动程序 ####

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

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

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

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

![在这里插入图片描述][7506f34d973f466198645c340e6d6145.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');

##### 5.1.1 实例 #####

创建 main.js 文件，代码如下所示：

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

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

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

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

新迎二十大，奋进新征程！

创建 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 对象的输出，文件内容就通过回调函数输出。

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

程序执行完毕
    新迎二十大，奋进新征程！

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

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

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

### 6. Node.js EventEmitter ###

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

Node.js 里面的许多对象都会分发事件：一个 net.Server 对象会在每次有新连接时触发一个事件， 一个 fs.readStream 对象会在文件被打开的时候触发一个事件。 所有这些产生事件的对象都是 events.EventEmitter 的实例。

#### 6.1 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 的属性介绍。

#### 6.2 方法 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">方法 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>addListener(event, listener)</strong> 为指定事件添加一个监听器到监听器数组的尾部。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>on(event, listener)</strong> 为指定事件注册一个监听器，接受一个字符串 event 和一个回调函数。<code>server.on('connection', function (stream) { console.log('someone connected!'); });</code></td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>once(event, listener)</strong> 为指定事件注册一个单次监听器，即 监听器最多只会触发一次，触发后立刻解除该监听器。<code>server.once('connection', function (stream) { console.log('Ah, we have our first user!'); });</code></td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>removeListener(event, listener)</strong> 移除指定事件的某个监听器，监听器必须是该事件已经注册过的监听器。它接受两个参数，第一个是事件名称，第二个是回调函数名称。<code>var callback = function(stream) { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);</code></td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><strong>removeAllListeners([event])</strong> 移除所有事件的所有监听器， 如果指定事件，则移除指定事件的所有监听器。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><strong>setMaxListeners(n)</strong> 默认情况下， EventEmitters 如果你添加的监听器超过 10 个就会输出警告信息。 setMaxListeners 函数用于改变监听器的默认限制的数量。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><strong>listeners(event)</strong> 返回指定事件的监听器数组。</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><strong>emit(event, [arg1], [arg2], […])</strong> 按监听器的顺序执行执行每个监听器，如果事件有注册监听返回 true，否则返回 false。</td> 
  </tr> 
 </tbody> 
</table>

#### 6.3 类方法 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">方法 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>listenerCount(emitter, event)</strong> 返回指定事件的监听器数量。</td> 
  </tr> 
 </tbody> 
</table>

events.EventEmitter.listenerCount(emitter, eventName) //已废弃，不推荐
    events.emitter.listenerCount(eventName) //推荐

#### 6.4 事件 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">事件 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>newListener</strong> <strong>event</strong> - 字符串，事件名称<strong>listener</strong> - 处理事件函数该事件在添加新监听器时被触发。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>removeListener</strong> <strong>event</strong> - 字符串，事件名称<strong>listener</strong> - 处理事件函数从指定监听器数组中删除一个监听器。需要注意的是，此操作将会改变处于被删监听器之后的那些监听器的索引。</td> 
  </tr> 
 </tbody> 
</table>

#### 6.5 实例 ####

以下实例通过 connection（连接）事件演示了 EventEmitter 类的应用。

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

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 个监听器监听连接事件。
    程序执行完毕。

#### 6.6 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)

#### 6.7 继承 EventEmitter ####

大多数时候我们不会直接使用 EventEmitter，而是在对象中继承它。包括 fs、net、 http 在内的，只要是支持事件响应的核心模块都是 EventEmitter 的子类。为什么要这样做呢？原因有两点：

*  首先，具有某个实体功能的对象实现事件符合语义， 事件的监听和发生应该是一个对象的方法。
 *  其次 JavaScript 的对象机制是基于原型的，支持部分多重继承，继承 EventEmitter 不会打乱对象原有的继承关系。

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

#### 7.1 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** \- 将每个字节编码为两个十六进制字符。

#### 7.2 创建 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');

#### 7.3 写入缓冲区 ####

##### 7.3.1 语法 #####

写入 Node 缓冲区的语法如下所示：

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

##### 7.3.2 参数 #####

参数描述如下：

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

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

##### 7.3.3 返回值 #####

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

##### 7.3.4 实例 #####

buf = Buffer.alloc(256);
    len = buf.write("新迎二十大，奋进新征程！");
    
    console.log("写入字节数 : "+  len);

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

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

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

##### 7.4.1 语法 #####

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

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

##### 7.4.2 参数 #####

参数描述如下：

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

##### 7.4.3 返回值 #####

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

##### 7.4.4 实例 #####

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

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

##### 7.5.1 语法 #####

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

buf.toJSON()

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

##### 7.5.2 返回值 #####

返回 JSON 对象。

##### 7.5.3 实例 #####

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

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

{"type":"Buffer","data":[1,2,3,4,5]}
    <Buffer 01 02 03 04 05>

#### 7.6 缓冲区合并 ####

##### 7.6.1 语法 #####

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

Buffer.concat(list[, totalLength])

##### 7.6.2 参数 #####

参数描述如下：

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

##### 7.6.3 返回值 #####

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

##### 7.6.4 实例 #####

var buffer1 = Buffer.from(('新迎二十大，'));
    var buffer2 = Buffer.from(('奋进新征程！'));
    var buffer3 = Buffer.concat([buffer1,buffer2]);
    console.log("buffer3 内容: " + buffer3.toString());

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

buffer3 内容: 新迎二十大，奋进新征程！

#### 7.7 缓冲区比较 ####

##### 7.7.1 语法 #####

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

buf.compare(otherBuffer);

##### 7.7.2 参数 #####

参数描述如下：

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

##### 7.7.3 返回值 #####

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

##### 7.7.4 实例 #####

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

ABC在ABCD之前

#### 7.8 拷贝缓冲区 ####

##### 7.8.1 语法 #####

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

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

##### 7.8.2 参数 #####

参数描述如下：

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

##### 7.8.3 返回值 #####

没有返回值。

##### 7.8.4 实例 #####

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

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

abRUNOOBijkl

#### 7.9 缓冲区裁剪 ####

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

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

##### 7.9.1 参数 #####

参数描述如下：

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

##### 7.9.2 返回值 #####

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

##### 7.9.3 实例 #####

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

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

buffer2 content: ru

##### 7.9.4 注意点 #####

注意：裁剪功能返回的实际是原始缓存区 buffer 或者一部分，操作的是与原始 buffer 同一块内存区域。

// 裁剪
    var buffer_origin = Buffer.from('runoob');
    var buffer_slice = buffer_origin.slice(0,2);
    console.log("buffer slice content: "+buffer_slice.toString());
    console.log("buffer origin content: "+buffer_origin.toString());
    buffer_slice.write("wirte"); // Write buffer slice
    
    // 裁剪前与原始字符串的改变
    console.log("buffer slice content: "+buffer_slice.toString());
    console.log("buffer origin content: "+buffer_origin.toString());

输出：

buffer slice content: ru
    buffer origin content: runoob
    buffer slice content: wi
    buffer origin content: winoob
    可以看到对裁剪返回的 buffer 进行写操作同时，也对原始 buffer 进行了写操作。

#### 7.10 缓冲区长度 ####

##### 7.10.1 语法 #####

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

buf.length;

##### 7.10.2 返回值 #####

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

##### 7.10.3 实例 #####

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

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

buffer length: 14

#### 7.11 方法参考手册 ####

以下列出了 Node.js Buffer 模块常用的方法（注意有些方法在旧版本是没有的）：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">方法 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>new Buffer(size)</strong> 分配一个新的 size 大小单位为8位字节的 buffer。 注意, size 必须小于 kMaxLength，否则，将会抛出异常 RangeError。废弃的: 使用 Buffer.alloc() 代替（或 Buffer.allocUnsafe()）。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>new Buffer(buffer)</strong> 拷贝参数 buffer 的数据到 Buffer 实例。废弃的: 使用 Buffer.from(buffer) 代替。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>new Buffer(str[, encoding])</strong> 分配一个新的 buffer ，其中包含着传入的 str 字符串。 encoding 编码方式默认为 ‘utf8’。 废弃的: 使用 Buffer.from(string[, encoding]) 代替。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>buf.length</strong> 返回这个 buffer 的 bytes 数。注意这未必是 buffer 里面内容的大小。length 是 buffer 对象所分配的内存数，它不会随着这个 buffer 对象内容的改变而改变。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><strong>buf.write(string[, offset[, length]][, encoding])</strong> 根据参数 offset 偏移量和指定的 encoding 编码方式，将参数 string 数据写入buffer。 offset 偏移量默认值是 0, encoding 编码方式默认是 utf8。 length 长度是将要写入的字符串的 bytes 大小。 返回 number 类型，表示写入了多少 8 位字节流。如果 buffer 没有足够的空间来放整个 string，它将只会只写入部分字符串。 length 默认是 buffer.length - offset。 这个方法不会出现写入部分字符。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><strong>buf.writeUIntLE(value, offset, byteLength[, noAssert])</strong> 将 value 写入到 buffer 里， 它由 offset 和 byteLength 决定，最高支持 48 位无符号整数，小端对齐，例如： <code>const buf = Buffer.allocUnsafe(6); buf.writeUIntLE(0x1234567890ab, 0, 6); // 输出: &lt;Buffer ab 90 78 56 34 12&gt; console.log(buf);</code>noAssert 值为 true 时，不再验证 value 和 offset 的有效性。 默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><strong>buf.writeUIntBE(value, offset, byteLength[, noAssert])</strong> 将 value 写入到 buffer 里， 它由 offset 和 byteLength 决定，最高支持 48 位无符号整数，大端对齐。noAssert 值为 true 时，不再验证 value 和 offset 的有效性。 默认是 false。<code>const buf = Buffer.allocUnsafe(6); buf.writeUIntBE(0x1234567890ab, 0, 6); // 输出: &lt;Buffer 12 34 56 78 90 ab&gt; console.log(buf);</code></td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><strong>buf.writeIntLE(value, offset, byteLength[, noAssert])</strong> 将value 写入到 buffer 里， 它由offset 和 byteLength 决定，最高支持48位有符号整数，小端对齐。noAssert 值为 true 时，不再验证 value 和 offset 的有效性。 默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><strong>buf.writeIntBE(value, offset, byteLength[, noAssert])</strong> 将value 写入到 buffer 里， 它由offset 和 byteLength 决定，最高支持48位有符号整数，大端对齐。noAssert 值为 true 时，不再验证 value 和 offset 的有效性。 默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><strong>buf.readUIntLE(offset, byteLength[, noAssert])</strong> 支持读取 48 位以下的无符号数字，小端对齐。noAssert 值为 true 时， offset 不再验证是否超过 buffer 的长度，默认为 false。</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><strong>buf.readUIntBE(offset, byteLength[, noAssert])</strong> 支持读取 48 位以下的无符号数字，大端对齐。noAssert 值为 true 时， offset 不再验证是否超过 buffer 的长度，默认为 false。</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><strong>buf.readIntLE(offset, byteLength[, noAssert])</strong> 支持读取 48 位以下的有符号数字，小端对齐。noAssert 值为 true 时， offset 不再验证是否超过 buffer 的长度，默认为 false。</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><strong>buf.readIntBE(offset, byteLength[, noAssert])</strong> 支持读取 48 位以下的有符号数字，大端对齐。noAssert 值为 true 时， offset 不再验证是否超过 buffer 的长度，默认为 false。</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><strong>buf.toString([encoding[, start[, end]]])</strong> 根据 encoding 参数（默认是 ‘utf8’）返回一个解码过的 string 类型。还会根据传入的参数 start (默认是 0) 和 end (默认是 buffer.length)作为取值范围。</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left"><strong>buf.toJSON()</strong> 将 Buffer 实例转换为 JSON 对象。</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left"><strong>buf[index]</strong> 获取或设置指定的字节。返回值代表一个字节，所以返回值的合法范围是十六进制0x00到0xFF 或者十进制0至 255。</td> 
  </tr> 
  <tr> 
   <td align="left">17</td> 
   <td align="left"><strong>buf.equals(otherBuffer)</strong> 比较两个缓冲区是否相等，如果是返回 true，否则返回 false。</td> 
  </tr> 
  <tr> 
   <td align="left">18</td> 
   <td align="left"><strong>buf.compare(otherBuffer)</strong> 比较两个 Buffer 对象，返回一个数字，表示 buf 在 otherBuffer 之前，之后或相同。</td> 
  </tr> 
  <tr> 
   <td align="left">19</td> 
   <td align="left"><strong>buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]])</strong> buffer 拷贝，源和目标可以相同。 targetStart 目标开始偏移和 sourceStart 源开始偏移默认都是 0。 sourceEnd 源结束位置偏移默认是源的长度 buffer.length 。</td> 
  </tr> 
  <tr> 
   <td align="left">20</td> 
   <td align="left"><strong>buf.slice([start[, end]])</strong> 剪切 Buffer 对象，根据 start(默认是 0 ) 和 end (默认是 buffer.length ) 偏移和裁剪了索引。 负的索引是从 buffer 尾部开始计算的。</td> 
  </tr> 
  <tr> 
   <td align="left">21</td> 
   <td align="left"><strong>buf.readUInt8(offset[, noAssert])</strong> 根据指定的偏移量，读取一个无符号 8 位整数。若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 如果这样 offset 可能会超出buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">22</td> 
   <td align="left"><strong>buf.readUInt16LE(offset[, noAssert])</strong> 根据指定的偏移量，使用特殊的 endian 字节序格式读取一个无符号 16 位整数。若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出 buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">23</td> 
   <td align="left"><strong>buf.readUInt16BE(offset[, noAssert])</strong> 根据指定的偏移量，使用特殊的 endian 字节序格式读取一个无符号 16 位整数，大端对齐。若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出 buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">24</td> 
   <td align="left"><strong>buf.readUInt32LE(offset[, noAssert])</strong> 根据指定的偏移量，使用指定的 endian 字节序格式读取一个无符号 32 位整数，小端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">25</td> 
   <td align="left"><strong>buf.readUInt32BE(offset[, noAssert])</strong> 根据指定的偏移量，使用指定的 endian 字节序格式读取一个无符号 32 位整数，大端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">26</td> 
   <td align="left"><strong>buf.readInt8(offset[, noAssert])</strong> 根据指定的偏移量，读取一个有符号 8 位整数。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出 buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">27</td> 
   <td align="left"><strong>buf.readInt16LE(offset[, noAssert])</strong> 根据指定的偏移量，使用特殊的 endian 格式读取一个 有符号 16 位整数，小端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出 buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">28</td> 
   <td align="left"><strong>buf.readInt16BE(offset[, noAssert])</strong> 根据指定的偏移量，使用特殊的 endian 格式读取一个 有符号 16 位整数，大端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出 buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">29</td> 
   <td align="left"><strong>buf.readInt32LE(offset[, noAssert])</strong> 根据指定的偏移量，使用指定的 endian 字节序格式读取一个有符号 32 位整数，小端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">30</td> 
   <td align="left"><strong>buf.readInt32BE(offset[, noAssert])</strong> 根据指定的偏移量，使用指定的 endian 字节序格式读取一个有符号 32 位整数，大端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">31</td> 
   <td align="left"><strong>buf.readFloatLE(offset[, noAssert])</strong> 根据指定的偏移量，使用指定的 endian 字节序格式读取一个 32 位双浮点数，小端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出buffer的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">32</td> 
   <td align="left"><strong>buf.readFloatBE(offset[, noAssert])</strong> 根据指定的偏移量，使用指定的 endian 字节序格式读取一个 32 位双浮点数，大端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出buffer的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">33</td> 
   <td align="left"><strong>buf.readDoubleLE(offset[, noAssert])</strong> 根据指定的偏移量，使用指定的 endian字节序格式读取一个 64 位双精度数，小端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">34</td> 
   <td align="left"><strong>buf.readDoubleBE(offset[, noAssert])</strong> 根据指定的偏移量，使用指定的 endian字节序格式读取一个 64 位双精度数，大端对齐。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 offset 可能会超出buffer 的末尾。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">35</td> 
   <td align="left"><strong>buf.writeUInt8(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量将 value 写入 buffer。注意：value 必须是一个合法的无符号 8 位整数。 若参数 noAssert 为 true 将不会验证 offset 偏移量参数。 这意味着 value 可能过大，或者 offset 可能会超出 buffer 的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">36</td> 
   <td align="left"><strong>buf.writeUInt16LE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer。注意：value 必须是一个合法的无符号 16 位整数，小端对齐。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value 可能过大，或者 offset 可能会超出buffer的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">37</td> 
   <td align="left"><strong>buf.writeUInt16BE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer。注意：value 必须是一个合法的无符号 16 位整数，大端对齐。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value 可能过大，或者 offset 可能会超出buffer的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">38</td> 
   <td align="left"><strong>buf.writeUInt32LE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式(LITTLE-ENDIAN:小字节序)将 value 写入buffer。注意：value 必须是一个合法的无符号 32 位整数，小端对齐。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着value 可能过大，或者offset可能会超出buffer的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">39</td> 
   <td align="left"><strong>buf.writeUInt32BE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式(Big-Endian:大字节序)将 value 写入buffer。注意：value 必须是一个合法的有符号 32 位整数。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value 可能过大，或者offset可能会超出buffer的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">40</td> 
   <td align="left"><strong>buf.writeInt8(value, offset[, noAssert])</strong></td> 
  </tr> 
  <tr> 
   <td align="left">41</td> 
   <td align="left"><strong>buf.writeInt16LE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer。注意：value 必须是一个合法的 signed 16 位整数。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value 可能过大，或者 offset 可能会超出 buffer 的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false 。</td> 
  </tr> 
  <tr> 
   <td align="left">42</td> 
   <td align="left"><strong>buf.writeInt16BE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer。注意：value 必须是一个合法的 signed 16 位整数。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value 可能过大，或者 offset 可能会超出 buffer 的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false 。</td> 
  </tr> 
  <tr> 
   <td align="left">43</td> 
   <td align="left"><strong>buf.writeInt32LE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer。注意：value 必须是一个合法的 signed 32 位整数。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value 可能过大，或者 offset 可能会超出 buffer 的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">44</td> 
   <td align="left"><strong>buf.writeInt32BE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer。注意：value 必须是一个合法的 signed 32 位整数。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value 可能过大，或者 offset 可能会超出 buffer 的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">45</td> 
   <td align="left"><strong>buf.writeFloatLE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer 。注意：当 value 不是一个 32 位浮点数类型的值时，结果将是不确定的。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value可能过大，或者 offset 可能会超出 buffer 的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">46</td> 
   <td align="left"><strong>buf.writeFloatBE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer 。注意：当 value 不是一个 32 位浮点数类型的值时，结果将是不确定的。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value可能过大，或者 offset 可能会超出 buffer 的末尾从而造成 value 被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">47</td> 
   <td align="left"><strong>buf.writeDoubleLE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer。注意：value 必须是一个有效的 64 位double 类型的值。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value 可能过大，或者 offset 可能会超出 buffer 的末尾从而造成value被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">48</td> 
   <td align="left"><strong>buf.writeDoubleBE(value, offset[, noAssert])</strong> 根据传入的 offset 偏移量和指定的 endian 格式将 value 写入 buffer。注意：value 必须是一个有效的 64 位double 类型的值。 若参数 noAssert 为 true 将不会验证 value 和 offset 偏移量参数。 这意味着 value 可能过大，或者 offset 可能会超出 buffer 的末尾从而造成value被丢弃。 除非你对这个参数非常有把握，否则尽量不要使用。默认是 false。</td> 
  </tr> 
  <tr> 
   <td align="left">49</td> 
   <td align="left"><strong>buf.fill(value[, offset][, end])</strong> 使用指定的 value 来填充这个 buffer。如果没有指定 offset (默认是 0) 并且 end (默认是 buffer.length) ，将会填充整个buffer。</td> 
  </tr> 
 </tbody> 
</table>

### 8. Node.js Stream(流) ###

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

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

*  **Readable** \- 可读操作。
 *  **Writable** \- 可写操作。
 *  **Duplex** \- 可读可写操作.
 *  **Transform** \- 操作被写入数据，然后读出结果。

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

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

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

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

菜鸟教程官网地址：www.runoob.com

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

以上代码执行结果如下：

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

#### 8.2 写入流 ####

创建 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

#### 8.3 管道流 ####

管道提供了一个输出流到输入流的机制。通常我们用于从一个流中获取数据并将数据传递到另外一个流中。

![在这里插入图片描述][e0c0f0f15a7747c0ad75218155d3d947.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
    管道流操作实例

#### 8.4 链式流 ####

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

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

创建 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 
    文件解压完成。

### 9. Node.js模块系统 ###

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

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

#### 9.1 引入模块 ####

在 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 
    function Hello() {
         
        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();

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

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

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

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

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

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

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

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

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

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

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

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

原生模块的优先级仅次于文件模块缓存的优先级。require 方法在解析文件名之后，优先检查模块是否在原生模块列表中。以http模块为例，尽管在目录下存在一个 http/http.js/http.node/http.json 文件，require(“http”) 都不会从这些文件中加载，而是从原生模块中加载。

原生模块也有一个缓存区，同样也是优先从缓存区加载。如果缓存区没有被加载过，则调用原生模块的加载方式进行加载和执行。

###### 9.2.3 从文件加载 ######

当文件模块缓存中不存在，而且不是原生模块的时候，Node.js 会解析 require 方法传入的参数，并从文件系统中加载实际的文件，加载过程中的包装和编译细节在前一节中已经介绍过，这里我们将详细描述查找文件模块的过程，其中，也有一些细节值得知晓。

require方法接受以下几种参数的传递：

*  http、fs、path等，原生模块。
 *  ./mod或…/mod，相对路径的文件模块。
 *  /pathtomodule/mod，绝对路径的文件模块。
 *  mod，非原生模块的文件模块。

在路径 Y 下执行 require(X) 语句执行顺序：

1. 如果 X 是内置模块
       a. 返回内置模块
       b. 停止执行
    2. 如果 X 以 '/' 开头
       a. 设置 Y 为文件根路径
    3. 如果 X 以 './' 或 '/' or '../' 开头
       a. LOAD_AS_FILE(Y + X)
       b. LOAD_AS_DIRECTORY(Y + X)
    4. LOAD_NODE_MODULES(X, dirname(Y))
    5. 抛出异常 "not found"
    
    LOAD_AS_FILE(X)
    1. 如果 X 是一个文件, 将 X 作为 JavaScript 文本载入并停止执行。
    2. 如果 X.js 是一个文件, 将 X.js 作为 JavaScript 文本载入并停止执行。
    3. 如果 X.json 是一个文件, 解析 X.json 为 JavaScript 对象并停止执行。
    4. 如果 X.node 是一个文件, 将 X.node 作为二进制插件载入并停止执行。
    
    LOAD_INDEX(X)
    1. 如果 X/index.js 是一个文件,  将 X/index.js 作为 JavaScript 文本载入并停止执行。
    2. 如果 X/index.json 是一个文件, 解析 X/index.json 为 JavaScript 对象并停止执行。
    3. 如果 X/index.node 是一个文件,  将 X/index.node 作为二进制插件载入并停止执行。
    
    LOAD_AS_DIRECTORY(X)
    1. 如果 X/package.json 是一个文件,
       a. 解析 X/package.json, 并查找 "main" 字段。
       b. let M = X + (json main 字段)
       c. LOAD_AS_FILE(M)
       d. LOAD_INDEX(M)
    2. LOAD_INDEX(X)
    
    LOAD_NODE_MODULES(X, START)
    1. let DIRS=NODE_MODULES_PATHS(START)
    2. for each DIR in DIRS:
       a. LOAD_AS_FILE(DIR/X)
       b. LOAD_AS_DIRECTORY(DIR/X)
    
    NODE_MODULES_PATHS(START)
    1. let PARTS = path split(START)
    2. let I = count of PARTS - 1
    3. let DIRS = []
    4. while I >= 0,
       a. if PARTS[I] = "node_modules" CONTINUE
       b. DIR = path join(PARTS[0 .. I] + "node_modules")
       c. DIRS = DIRS + DIR
       d. let I = I - 1
    5. return DIRS

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

### 10. 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 时可以传递这样一个变量。

#### 10.1 匿名函数 ####

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

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

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

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

#### 10.2 函数传递是如何让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);

### 11. Node.js 路由 ###

我们要为路由提供请求的 URL 和其他需要的 GET 及 POST 参数，随后路由需要根据这些数据来执行相应的代码。

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

我们需要的所有数据都会包含在 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"]

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

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

// server.js 文件代码
    var http = require("http");
    var url = require("url");
     
    function start() {
        
      function onRequest(request, response) {
        
        var pathname = url.parse(request.url).pathname;
        console.log("Request for " + pathname + " received.");
        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;

好了，我们的应用现在可以通过请求的 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 文件代码：
    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，使得路由函数可以被注入到服务器中：

// 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 请求相关的部分。

浏览器访问 **http://127.0.0.1:8888/**，输出结果如下：

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

根据前面的 event 绑定，直接将事件名定义成路径还是很不错的，不过要区分 request.method 是 get 还是 post ，可以分两个文件处理

### 12. Node.js 全局对象 ###

JavaScript 中有一个特殊的对象，称为全局对象（Global Object），它及其所有属性都可以在程序的任何地方访问，即全局变量。

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

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

#### 12.1 全局对象与全局变量 ####

global 最根本的作用是作为全局变量的宿主。按照 ECMAScript 的定义，满足以下条 件的变量是全局变量：

*  在最外层定义的变量；
 *  全局对象的属性；
 *  隐式定义的变量（未定义直接赋值的变量）。

当你定义一个全局变量时，这个变量同时也会成为全局对象的属性，反之亦然。需要注 意的是，在 Node.js 中你不可能在最外层定义变量，因为所有用户代码都是属于当前模块的， 而模块本身不是最外层上下文。

**注意：** 最好不要使用 var 定义变量以避免引入全局变量，因为全局变量会污染命名空间，提高代码的耦合风险。

#### 12.2 \_\_filename ####

**\_\_filename** 表示当前正在执行的脚本的文件名。它将输出文件所在位置的绝对路径，且和命令行参数所指定的文件名不一定相同。 如果在模块中，返回的值是模块文件的路径。

##### 12.2.1 实例 #####

创建文件 main.js ，代码如下所示：

// 输出全局变量 __filename 的值
    console.log( __filename );

执行 main.js 文件，代码如下所示:

$ node main.js
    /web/com/runoob/nodejs/main.js

#### 12.3 \_\_dirname ####

**\_\_dirname** 表示当前执行脚本所在的目录。

##### 12.3.1 实例 #####

创建文件 main.js ，代码如下所示：

// 输出全局变量 __dirname 的值
    console.log( __dirname );

执行 main.js 文件，代码如下所示:

$ node main.js
    /web/com/runoob/nodejs

#### 12.4 setTimeout(cb, ms) ####

**setTimeout(cb, ms)** 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。：setTimeout() 只执行一次指定函数。

返回一个代表定时器的句柄值。

##### 12.4.1 实例 #####

创建文件 main.js ，代码如下所示：

function printHello(){
        
       console.log( "Hello, World!");
    }
    // 两秒后执行以上函数
    setTimeout(printHello, 2000);

执行 main.js 文件，代码如下所示:

$ node main.js
    Hello, World!

#### 12.5 clearTimeout(t) ####

**clearTimeout( t )** 全局函数用于停止一个之前通过 setTimeout() 创建的定时器。 参数 **t** 是通过 setTimeout() 函数创建的定时器。

##### 12.5.1 实例 #####

创建文件 main.js ，代码如下所示：

function printHello(){
        
       console.log( "Hello, World!");
    }
    // 两秒后执行以上函数
    var t = setTimeout(printHello, 2000);
    
    // 清除定时器
    clearTimeout(t);

执行 main.js 文件，代码如下所示:

$ node main.js

#### 12.6 setInterval(cb, ms) ####

**setInterval(cb, ms)** 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。

返回一个代表定时器的句柄值。可以使用 **clearInterval(t)** 函数来清除定时器。

setInterval() 方法会不停地调用函数，直到 clearInterval() 被调用或窗口被关闭。

##### 12.6.1 实例 #####

创建文件 main.js ，代码如下所示：

function printHello(){
        
       console.log( "Hello, World!");
    }
    // 两秒后执行以上函数
    setInterval(printHello, 2000);

执行 main.js 文件，代码如下所示:

$ node main.js

Hello, World! Hello, World! Hello, World! Hello, World! Hello, World! ……

以上程序每隔两秒就会输出一次"Hello, World!"，且会永久执行下去，直到你按下 **ctrl + c** 按钮。

#### 12.7 console ####

console 用于提供控制台标准输出，它是由 Internet Explorer 的 JScript 引擎提供的调试工具，后来逐渐成为浏览器的实施标准。

Node.js 沿用了这个标准，提供与习惯行为一致的 console 对象，用于向标准输出流（stdout）或标准错误流（stderr）输出字符。

##### 12.7.1 console 方法 #####

以下为 console 对象的方法:

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">方法 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>console.log([data][, …])</strong> 向标准输出流打印字符并以换行符结束。该方法接收若干 个参数，如果只有一个参数，则输出这个参数的字符串形式。如果有多个参数，则 以类似于C 语言 printf() 命令的格式输出。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>console.info([data][, …])</strong> 该命令的作用是返回信息性消息，这个命令与console.log差别并不大，除了在chrome中只会输出文字外，其余的会显示一个蓝色的惊叹号。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>console.error([data][, …])</strong> 输出错误消息的。控制台在出现错误时会显示是红色的叉子。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>console.warn([data][, …])</strong> 输出警告消息。控制台出现有黄色的惊叹号。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><strong>console.dir(obj[, options])</strong> 用来对一个对象进行检查（inspect），并以易于阅读和打印的格式显示。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><strong>console.time(label)</strong> 输出时间，表示计时开始。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><strong>console.timeEnd(label)</strong> 结束时间，表示计时结束。</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><strong>console.trace(message[, …])</strong> 当前执行的代码在堆栈中的调用路径，这个测试函数运行很有帮助，只要给想测试的函数里面加入 console.trace 就行了。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><strong>console.assert(value[, message][, …])</strong> 用于判断某个表达式或变量是否为真，接收两个参数，第一个参数是表达式，第二个参数是字符串。只有当第一个参数为false，才会输出第二个参数，否则不会有任何结果。</td> 
  </tr> 
 </tbody> 
</table>

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)

##### 12.7.2 实例 #####

创建文件 main.js ，代码如下所示：

console.info("程序开始执行：");
    
    var counter = 10;
    console.log("计数: %d", counter);
    
    console.time("获取数据");
    //
    // 执行一些代码
    // 
    console.timeEnd('获取数据');
    
    console.info("程序执行完毕。")

执行 main.js 文件，代码如下所示:

$ node main.js
    程序开始执行：
    计数: 10
    获取数据: 0ms
    程序执行完毕

#### 12.8 process ####

process 是一个全局变量，即 global 对象的属性。

它用于描述当前 Node.js 进程状态的对象，提供了一个与操作系统的简单接口。通常在你写本地命令行程序的时候，少不了要 和它打交道。下面将会介绍 process 对象的一些最常用的成员方法。

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">事件 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>exit</strong> 当进程准备退出时触发。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>beforeExit</strong> 当 node 清空事件循环，并且没有其他安排时触发这个事件。通常来说，当没有进程安排时 node 退出，但是 ‘beforeExit’ 的监听器可以异步调用，这样 node 就会继续执行。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>uncaughtException</strong> 当一个异常冒泡回到事件循环，触发这个事件。如果给异常添加了监视器，默认的操作（打印堆栈跟踪信息并退出）就不会发生。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>Signal 事件</strong> 当进程接收到信号时就触发。信号列表详见标准的 POSIX 信号名，如 SIGINT、SIGUSR1 等。</td> 
  </tr> 
 </tbody> 
</table>

##### 12.8.1 实例 #####

创建文件 main.js ，代码如下所示：

process.on('exit', function(code) {
        
    
      // 以下代码永远不会执行
      setTimeout(function() {
        
        console.log("该代码不会执行");
      }, 0);
      
      console.log('退出码为:', code);
    });
    console.log("程序执行结束");

执行 main.js 文件，代码如下所示:

$ node main.js
    程序执行结束
    退出码为: 0

##### 12.8.2 退出状态码 #####

退出状态码如下所示：

<table> 
 <thead> 
  <tr> 
   <th align="left">状态码</th> 
   <th align="left">名称 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>Uncaught Fatal Exception</strong> 有未捕获异常，并且没有被域或 uncaughtException 处理函数处理。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>Unused</strong> 保留，由 Bash 预留用于内置误用</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>Internal JavaScript Parse Error</strong> JavaScript的源码启动 Node 进程时引起解析错误。非常罕见，仅会在开发 Node 时才会有。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>Internal JavaScript Evaluation Failure</strong> JavaScript 的源码启动 Node 进程，评估时返回函数失败。非常罕见，仅会在开发 Node 时才会有。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><strong>Fatal Error</strong> V8 里致命的不可恢复的错误。通常会打印到 stderr ，内容为： FATAL ERROR</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><strong>Non-function Internal Exception Handler</strong> 未捕获异常，内部异常处理函数不知为何设置为on-function，并且不能被调用。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><strong>Internal Exception Handler Run-Time Failure</strong> 未捕获的异常， 并且异常处理函数处理时自己抛出了异常。例如，如果 process.on(‘uncaughtException’) 或 domain.on(‘error’) 抛出了异常。</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><strong>Unused</strong> 保留，在以前版本的 Node.js 中，退出码 8 有时表示未捕获的异常。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><strong>Invalid Argument</strong> 可能是给了未知的参数，或者给的参数没有值。</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><strong>Internal JavaScript Run-Time Failure</strong> JavaScript的源码启动 Node 进程时抛出错误，非常罕见，仅会在开发 Node 时才会有。</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><strong>Invalid Debug Argument</strong> 设置了参数–debug 和/或 --debug-brk，但是选择了错误端口。</td> 
  </tr> 
  <tr> 
   <td align="left">128</td> 
   <td align="left"><strong>Signal Exits</strong> 如果 Node 接收到致命信号，比如SIGKILL 或 SIGHUP，那么退出代码就是128 加信号代码。这是标准的 Unix 做法，退出信号代码放在高位。</td> 
  </tr> 
 </tbody> 
</table>

##### 12.8.3 Process 属性 #####

Process 提供了很多有用的属性，便于我们更好的控制系统的交互：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号.</th> 
   <th align="left">属性 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>stdout</strong> 标准输出流。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>stderr</strong> 标准错误流。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>stdin</strong> 标准输入流。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>argv</strong> argv 属性返回一个数组，由命令行执行脚本时的各个参数组成。它的第一个成员总是node，第二个成员是脚本文件名，其余成员是脚本文件的参数。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><strong>execPath</strong> 返回执行当前脚本的 Node 二进制文件的绝对路径。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><strong>execArgv</strong> 返回一个数组，成员是命令行下执行脚本时，在Node可执行文件与脚本文件之间的命令行参数。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><strong>env</strong> 返回一个对象，成员为当前 shell 的环境变量</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><strong>exitCode</strong> 进程退出时的代码，如果进程优通过 process.exit() 退出，不需要指定退出码。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><strong>version</strong> Node 的版本，比如v0.10.18。</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><strong>versions</strong> 一个属性，包含了 node 的版本和依赖.</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><strong>config</strong> 一个包含用来编译当前 node 执行文件的 javascript 配置选项的对象。它与运行 ./configure 脚本生成的 “config.gypi” 文件相同。</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><strong>pid</strong> 当前进程的进程号。</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><strong>title</strong> 进程名，默认值为"node"，可以自定义该值。</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><strong>arch</strong> 当前 CPU 的架构：‘arm’、‘ia32’ 或者 ‘x64’。</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left"><strong>platform</strong> 运行程序所在的平台系统 ‘darwin’, ‘freebsd’, ‘linux’, ‘sunos’ 或 ‘win32’</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left"><strong>mainModule</strong> require.main 的备选方法。不同点，如果主模块在运行时改变，require.main可能会继续返回老的模块。可以认为，这两者引用了同一个模块。</td> 
  </tr> 
 </tbody> 
</table>

###### 12.8.3.1 实例 ######

创建文件 main.js ，代码如下所示：

// 输出到终端
    process.stdout.write("Hello World!" + "\n");
    
    // 通过参数读取
    process.argv.forEach(function(val, index, array) {
        
       console.log(index + ': ' + val);
    });
    
    // 获取执行路径
    console.log(process.execPath);
    
    
    // 平台信息
    console.log(process.platform);

执行 main.js 文件，代码如下所示:

$ node main.js
    Hello World!
    0: node
    1: /web/www/node/main.js
    /usr/local/node/0.10.36/bin/node
    darwin

##### 12.8.4 方法参考手册 #####

Process 提供了很多有用的方法，便于我们更好的控制系统的交互：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">方法 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>abort()</strong> 这将导致 node 触发 abort 事件。会让 node 退出并生成一个核心文件。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>chdir(directory)</strong> 改变当前工作进程的目录，如果操作失败抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>cwd()</strong> 返回当前进程的工作目录</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>exit([code])</strong> 使用指定的 code 结束进程。如果忽略，将会使用 code 0。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><strong>getgid()</strong> 获取进程的群组标识（参见 getgid(2)）。获取到的是群组的数字 id，而不是名字。 注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><strong>setgid(id)</strong> 设置进程的群组标识（参见 setgid(2)）。可以接收数字 ID 或者群组名。如果指定了群组名，会阻塞等待解析为数字 ID 。 注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><strong>getuid()</strong> 获取进程的用户标识(参见 getuid(2))。这是数字的用户 id，不是用户名。 注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><strong>setuid(id)</strong> 设置进程的用户标识（参见setuid(2)）。接收数字 ID或字符串名字。如果指定了群组名，会阻塞等待解析为数字 ID 。 注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><strong>getgroups()</strong> 返回进程的群组 ID 数组。POSIX 系统没有保证一定有，但是 node.js 保证有。 注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><strong>setgroups(groups)</strong> 设置进程的群组 ID。这是授权操作，所以你需要有 root 权限，或者有 CAP_SETGID 能力。 注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><strong>initgroups(user, extra_group)</strong> 读取 /etc/group ，并初始化群组访问列表，使用成员所在的所有群组。这是授权操作，所以你需要有 root 权限，或者有 CAP_SETGID 能力。 注意：这个函数仅在 POSIX 平台上可用(例如，非Windows 和 Android)。</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><strong>kill(pid[, signal])</strong> 发送信号给进程. pid 是进程id，并且 signal 是发送的信号的字符串描述。信号名是字符串，比如 ‘SIGINT’ 或 ‘SIGHUP’。如果忽略，信号会是 ‘SIGTERM’。</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><strong>memoryUsage()</strong> 返回一个对象，描述了 Node 进程所用的内存状况，单位为字节。</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><strong>nextTick(callback)</strong> 一旦当前事件循环结束，调用回调函数。</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left"><strong>umask([mask])</strong> 设置或读取进程文件的掩码。子进程从父进程继承掩码。如果mask 参数有效，返回旧的掩码。否则，返回当前掩码。</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left"><strong>uptime()</strong> 返回 Node 已经运行的秒数。</td> 
  </tr> 
  <tr> 
   <td align="left">17</td> 
   <td align="left"><strong>hrtime()</strong> 返回当前进程的高分辨时间，形式为 [seconds, nanoseconds]数组。它是相对于过去的任意事件。该值与日期无关，因此不受时钟漂移的影响。主要用途是可以通过精确的时间间隔，来衡量程序的性能。 你可以将之前的结果传递给当前的 process.hrtime() ，会返回两者间的时间差，用来基准和测量时间间隔。</td> 
  </tr> 
 </tbody> 
</table>

###### 12.8.4.1 实例 ######

创建文件 main.js ，代码如下所示：

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

执行 main.js 文件，代码如下所示:

$ node main.js
    当前目录: /web/com/runoob/nodejs
    当前版本: v0.10.36
    { rss: 12541952, heapTotal: 4083456, heapUsed: 2157056 }

### 13. Node.js 常用工具 ###

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

使用方法如下：

const util = require('util');

#### 13.1 util.callbackify ####

**util.callbackify(original)** 将 `async` 异步函数（或者一个返回值为 `Promise` 的函数）转换成遵循异常优先的回调风格的函数，例如将 `(err, value) => ...` 回调作为最后一个参数。 在回调函数中，第一个参数为拒绝的原因（如果 `Promise` 解决，则为 `null`），第二个参数则是解决的值。

##### 13.1.1 实例 #####

以上代码输出结果为：

hello world

回调函数是异步执行的，并且有异常堆栈错误追踪。 如果回调函数抛出一个异常，进程会触发一个 ‘uncaughtException’ 异常，如果没有被捕获，进程将会退出。

null 在回调函数中作为一个参数有其特殊的意义，如果回调函数的首个参数为 Promise 拒绝的原因且带有返回值，且值可以转换成布尔值 false，这个值会被封装在 Error 对象里，可以通过属性 reason 获取。

function fn() {
        
      return Promise.reject(null);
    }
    const callbackFunction = util.callbackify(fn);
    
    callbackFunction((err, ret) => {
        
      // 当 Promise 被以 `null` 拒绝时，它被包装为 Error 并且原始值存储在 `reason` 中。
      err && err.hasOwnProperty('reason') && err.reason === null;  // true
    });

original 为 async 异步函数。该函数返回传统回调函数。

#### 13.2 util.inherits ####

**util.inherits(constructor, superConstructor)** 是一个实现对象间原型继承的函数。

JavaScript 的面向对象特性是基于原型的，与常见的基于类的不同。JavaScript 没有提供对象继承的语言级别特性，而是通过原型复制来实现的。

在这里我们只介绍 util.inherits 的用法，示例如下：

我们定义了一个基础对象 Base 和一个继承自 Base 的 Sub，Base 有三个在构造函数内定义的属性和一个原型中定义的函数，通过util.inherits 实现继承。运行结果如下：

base 
    Hello base 
    { name: 'base', base: 1991, sayHello: [Function] } 
    sub 
    { name: 'sub' }

\*\*注意：\*\*Sub 仅仅继承了Base 在原型中定义的函数，而构造函数内部创造的 base 属性和 sayHello 函数都没有被 Sub 继承。

同时，在原型中定义的属性不会被 console.log 作 为对象的属性输出。如果我们去掉 objSub.sayHello(); 这行的注释，将会看到：

node.js:201 
    throw e; // process.nextTick error, or 'error' event on first tick 
    ^ 
    TypeError: Object #<Sub> has no method 'sayHello' 
    at Object.<anonymous> (/home/byvoid/utilinherits.js:29:8) 
    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)

#### 13.3 util.inspect ####

**util.inspect(object,\[showHidden\],\[depth\],\[colors\])** 是一个将任意对象转换为字符串的方法，通常用于调试和错误输出。它至少接受一个参数 object，即要转换的对象。

showHidden 是一个可选参数，如果值为 true，将会输出更多隐藏信息。

depth 表示最大递归的层数，如果对象很复杂，你可以指定层数以控制输出信息的多少。如果不指定depth，默认会递归 2 层，指定为 null 表示将不限递归层数完整遍历对象。 如果 colors 值为 true，输出格式将会以 ANSI 颜色编码，通常用于在终端显示更漂亮的效果。

特别要指出的是，util.inspect 并不会简单地直接把对象转换为字符串，即使该对象定义了 toString 方法也不会调用。

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

运行结果是：

Person { name: 'byvoid', toString: [Function] }
    Person {
      name: 'byvoid',
      toString: 
       { [Function]
         [length]: 0,
         [name]: '',
         [arguments]: null,
         [caller]: null,
         [prototype]: { [constructor]: [Circular] } } }

#### 13.4 util.isArray(object) ####

如果给定的参数 “object” 是一个数组返回 true，否则返回 false。

var util = require('util');
    
    util.isArray([])
      // true
    util.isArray(new Array)
      // true
    util.isArray({
        })
      // false

#### 13.5 util.isRegExp(object) ####

如果给定的参数 “object” 是一个正则表达式返回true，否则返回false。

var util = require('util');
    
    util.isRegExp(/some regexp/)
      // true
    util.isRegExp(new RegExp('another regexp'))
      // true
    util.isRegExp({
        })
      // false

#### 13.6 util.isDate(object) ####

如果给定的参数 “object” 是一个日期返回true，否则返回false。

var util = require('util');
    
    util.isDate(new Date())
      // true
    util.isDate(Date())
      // false (without 'new' returns a String)
    util.isDate({
        })
      // false

更多详情可以访问 [http://nodejs.org/api/util.html][http_nodejs.org_api_util.html] 了解详细内容。

### 14. Node.js 文件系统 ###

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

var fs = require("fs")

#### 14.1 异步和同步 ####

Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 fs.readFile() 和同步的 fs.readFileSync()。

异步的方法函数最后一个参数为回调函数，回调函数的第一个参数包含了错误信息(error)。

建议大家使用异步方法，比起同步，异步方法性能更高，速度更快，而且没有阻塞。

##### 14.1.1 实例 #####

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

菜鸟教程官网地址：www.runoob.com
    文件读取实例

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

以上代码执行结果如下：

$ node file.js 
    同步读取: 菜鸟教程官网地址：www.runoob.com
    文件读取实例
    
    程序执行完毕。
    异步读取: 菜鸟教程官网地址：www.runoob.com
    文件读取实例

接下来，让我们来具体了解下 Node.js 文件系统的方法。

#### 14.2 打开文件 ####

##### 14.2.1 语法 #####

以下为在异步模式下打开文件的语法格式：

fs.open(path, flags[, mode], callback)

##### 14.2.2 参数 #####

参数使用说明如下：

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

flags 参数可以是以下值：

<table> 
 <thead> 
  <tr> 
   <th align="left">Flag</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">r</td> 
   <td align="left">以读取模式打开文件。如果文件不存在抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">r+</td> 
   <td align="left">以读写模式打开文件。如果文件不存在抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">rs</td> 
   <td align="left">以同步的方式读取文件。</td> 
  </tr> 
  <tr> 
   <td align="left">rs+</td> 
   <td align="left">以同步的方式读取和写入文件。</td> 
  </tr> 
  <tr> 
   <td align="left">w</td> 
   <td align="left">以写入模式打开文件，如果文件不存在则创建。</td> 
  </tr> 
  <tr> 
   <td align="left">wx</td> 
   <td align="left">类似 ‘w’，但是如果文件路径存在，则文件写入失败。</td> 
  </tr> 
  <tr> 
   <td align="left">w+</td> 
   <td align="left">以读写模式打开文件，如果文件不存在则创建。</td> 
  </tr> 
  <tr> 
   <td align="left">wx+</td> 
   <td align="left">类似 ‘w+’， 但是如果文件路径存在，则文件读写失败。</td> 
  </tr> 
  <tr> 
   <td align="left">a</td> 
   <td align="left">以追加模式打开文件，如果文件不存在则创建。</td> 
  </tr> 
  <tr> 
   <td align="left">ax</td> 
   <td align="left">类似 ‘a’， 但是如果文件路径存在，则文件追加失败。</td> 
  </tr> 
  <tr> 
   <td align="left">a+</td> 
   <td align="left">以读取追加模式打开文件，如果文件不存在则创建。</td> 
  </tr> 
  <tr> 
   <td align="left">ax+</td> 
   <td align="left">类似 ‘a+’， 但是如果文件路径存在，则文件读取追加失败。</td> 
  </tr> 
 </tbody> 
</table>

##### 14.2.3 实例 #####

接下来我们创建 file.js 文件，并打开 input.txt 文件进行读写，代码如下所示：

var fs = require("fs");
    
    // 异步打开文件
    console.log("准备打开文件！");
    fs.open('input.txt', 'r+', function(err, fd) {
        
       if (err) {
        
           return console.error(err);
       }
      console.log("文件打开成功！");     
    });

以上代码执行结果如下：

$ node file.js 
    准备打开文件！
    文件打开成功！

#### 14.3 获取文件信息 ####

##### 14.3.1 语法 #####

以下为通过异步模式获取文件信息的语法格式：

fs.stat(path, callback)

##### 14.3.2 参数 #####

参数使用说明如下：

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

fs.stat(path)执行后，会将stats类的实例返回给其回调函数。可以通过stats类中的提供方法判断文件的相关属性。例如判断是否为文件：

var fs = require('fs');
    
    fs.stat('/Users/liuht/code/itbilu/demo/fs.js', function (err, stats) {
        
        console.log(stats.isFile());         //true
    })

stats类中的方法有：

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">stats.isFile()</td> 
   <td align="left">如果是文件返回 true，否则返回 false。</td> 
  </tr> 
  <tr> 
   <td align="left">stats.isDirectory()</td> 
   <td align="left">如果是目录返回 true，否则返回 false。</td> 
  </tr> 
  <tr> 
   <td align="left">stats.isBlockDevice()</td> 
   <td align="left">如果是块设备返回 true，否则返回 false。</td> 
  </tr> 
  <tr> 
   <td align="left">stats.isCharacterDevice()</td> 
   <td align="left">如果是字符设备返回 true，否则返回 false。</td> 
  </tr> 
  <tr> 
   <td align="left">stats.isSymbolicLink()</td> 
   <td align="left">如果是软链接返回 true，否则返回 false。</td> 
  </tr> 
  <tr> 
   <td align="left">stats.isFIFO()</td> 
   <td align="left">如果是FIFO，返回true，否则返回 false。FIFO是UNIX中的一种特殊类型的命令管道。</td> 
  </tr> 
  <tr> 
   <td align="left">stats.isSocket()</td> 
   <td align="left">如果是 Socket 返回 true，否则返回 false。</td> 
  </tr> 
 </tbody> 
</table>

##### 14.3.3 实例 #####

接下来我们创建 file.js 文件，代码如下所示：

var fs = require("fs");
    
    console.log("准备打开文件！");
    fs.stat('input.txt', function (err, stats) {
        
       if (err) {
        
           return console.error(err);
       }
       console.log(stats);
       console.log("读取文件信息成功！");
       
       // 检测文件类型
       console.log("是否为文件(isFile) ? " + stats.isFile());
       console.log("是否为目录(isDirectory) ? " + stats.isDirectory());    
    });

以上代码执行结果如下：

$ node file.js 
    准备打开文件！
    { dev: 16777220,
      mode: 33188,
      nlink: 1,
      uid: 501,
      gid: 20,
      rdev: 0,
      blksize: 4096,
      ino: 40333161,
      size: 61,
      blocks: 8,
      atime: Mon Sep 07 2015 17:43:55 GMT+0800 (CST),
      mtime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST),
      ctime: Mon Sep 07 2015 17:22:35 GMT+0800 (CST) }
    读取文件信息成功！
    是否为文件(isFile) ? true
    是否为目录(isDirectory) ? false

#### 14.4 写入文件 ####

##### 14.4.1 语法 #####

以下为异步模式下写入文件的语法格式：

fs.writeFile(file, data[, options], callback)

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

##### 14.4.2 参数 #####

参数使用说明如下：

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

##### 14.4.3 实例 #####

接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备写入文件
    数据写入成功！
    --------我是分割线-------------
    读取写入的数据！
    异步读取文件数据: 我是通过fs.writeFile 写入文件的内容

#### 14.5 读取文件 ####

##### 14.5.1 语法 #####

以下为异步模式下读取文件的语法格式：

fs.read(fd, buffer, offset, length, position, callback)

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

##### 14.5.2 参数 #####

参数使用说明如下：

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

##### 14.5.3 实例 #####

input.txt 文件内容为：

菜鸟教程官网地址：www.runoob.com

接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备打开已存在的文件！
    文件打开成功！
    准备读取文件：
    42  字节被读取
    菜鸟教程官网地址：www.runoob.com

#### 14.6 关闭文件 ####

##### 14.6.1 语法 #####

以下为异步模式下关闭文件的语法格式：

fs.close(fd, callback)

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

##### 14.6.2 参数 #####

参数使用说明如下：

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

##### 14.6.3 实例 #####

input.txt 文件内容为：

菜鸟教程官网地址：www.runoob.com

接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备打开文件！
    文件打开成功！
    准备读取文件！
    菜鸟教程官网地址：www.runoob.com
    文件关闭成功

#### 14.7 截取文件 ####

##### 14.7.1 语法 #####

以下为异步模式下截取文件的语法格式：

fs.ftruncate(fd, len, callback)

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

##### 14.7.2 参数 #####

参数使用说明如下：

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

##### 14.7.3 实例 #####

input.txt 文件内容为：

site:www.runoob.com

接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备打开文件！
    文件打开成功！
    截取10字节内的文件内容，超出部分将被去除。
    文件截取成功。
    读取相同的文件
    site:www.r
    文件关闭成功

#### 14.8 删除文件 ####

##### 14.8.1 语法 #####

以下为删除文件的语法格式：

fs.unlink(path, callback)

##### 14.8.2 参数 #####

参数使用说明如下：

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

##### 14.8.3 实例 #####

input.txt 文件内容为：

site:www.runoob.com

接下来我们创建 file.js 文件，代码如下所示：

var fs = require("fs");
    
    console.log("准备删除文件！");
    fs.unlink('input.txt', function(err) {
        
       if (err) {
        
           return console.error(err);
       }
       console.log("文件删除成功！");
    });

以上代码执行结果如下：

$ node file.js 
    准备删除文件！
    文件删除成功！

再去查看 input.txt 文件，发现已经不存在了。

#### 14.9 创建目录 ####

##### 14.9.1 语法 #####

以下为创建目录的语法格式：

fs.mkdir(path[, options], callback)

##### 14.9.2 参数 #####

参数使用说明如下：

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

##### 14.9.3 实例 #####

接下来我们创建 file.js 文件，代码如下所示：

var fs = require("fs");
    // tmp 目录必须存在
    console.log("创建目录 /tmp/test/");
    fs.mkdir("/tmp/test/",function(err){
        
       if (err) {
        
           return console.error(err);
       }
       console.log("目录创建成功。");
    });

以上代码执行结果如下：

$ node file.js 
    创建目录 /tmp/test/
    目录创建成功。

可以添加 recursive: true 参数，不管创建的目录 /tmp 和 /tmp/a 是否存在：

fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
      if (err) throw err;
    });

#### 14.10 读取目录 ####

##### 14.10.1 语法 #####

以下为读取目录的语法格式：

fs.readdir(path, callback)

##### 14.10.2 参数 #####

参数使用说明如下：

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

##### 14.10.3 实例 #####

接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    查看 /tmp 目录
    input.out
    output.out
    test
    test.txt

#### 14.11 删除目录 ####

##### 14.11.1 语法 #####

以下为删除目录的语法格式：

fs.rmdir(path, callback)

##### 14.11.2 参数 #####

参数使用说明如下：

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

##### 14.11.3 实例 #####

接下来我们创建 file.js 文件，代码如下所示：

以上代码执行结果如下：

$ node file.js 
    准备删除目录 /tmp/test
    读取 /tmp 目录
    ……

#### 14.12 文件模块方法参考手册 ####

以下为 Node.js 文件模块相同的方法列表：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">方法 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>fs.rename(oldPath, newPath, callback)</strong> 异步 rename().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>fs.ftruncate(fd, len, callback)</strong> 异步 ftruncate().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>fs.ftruncateSync(fd, len)</strong> 同步 ftruncate()</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>fs.truncate(path, len, callback)</strong> 异步 truncate().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><strong>fs.truncateSync(path, len)</strong> 同步 truncate()</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><strong>fs.chown(path, uid, gid, callback)</strong> 异步 chown().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><strong>fs.chownSync(path, uid, gid)</strong> 同步 chown()</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><strong>fs.fchown(fd, uid, gid, callback)</strong> 异步 fchown().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><strong>fs.fchownSync(fd, uid, gid)</strong> 同步 fchown()</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><strong>fs.lchown(path, uid, gid, callback)</strong> 异步 lchown().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><strong>fs.lchownSync(path, uid, gid)</strong> 同步 lchown()</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><strong>fs.chmod(path, mode, callback)</strong> 异步 chmod().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><strong>fs.chmodSync(path, mode)</strong> 同步 chmod().</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><strong>fs.fchmod(fd, mode, callback)</strong> 异步 fchmod().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left"><strong>fs.fchmodSync(fd, mode)</strong> 同步 fchmod().</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left"><strong>fs.lchmod(path, mode, callback)</strong> 异步 lchmod().回调函数没有参数，但可能抛出异常。Only available on Mac OS X.</td> 
  </tr> 
  <tr> 
   <td align="left">17</td> 
   <td align="left"><strong>fs.lchmodSync(path, mode)</strong> 同步 lchmod().</td> 
  </tr> 
  <tr> 
   <td align="left">18</td> 
   <td align="left"><strong>fs.stat(path, callback)</strong> 异步 stat(). 回调函数有两个参数 err, stats，stats 是 fs.Stats 对象。</td> 
  </tr> 
  <tr> 
   <td align="left">19</td> 
   <td align="left"><strong>fs.lstat(path, callback)</strong> 异步 lstat(). 回调函数有两个参数 err, stats，stats 是 fs.Stats 对象。</td> 
  </tr> 
  <tr> 
   <td align="left">20</td> 
   <td align="left"><strong>fs.fstat(fd, callback)</strong> 异步 fstat(). 回调函数有两个参数 err, stats，stats 是 fs.Stats 对象。</td> 
  </tr> 
  <tr> 
   <td align="left">21</td> 
   <td align="left"><strong>fs.statSync(path)</strong> 同步 stat(). 返回 fs.Stats 的实例。</td> 
  </tr> 
  <tr> 
   <td align="left">22</td> 
   <td align="left"><strong>fs.lstatSync(path)</strong> 同步 lstat(). 返回 fs.Stats 的实例。</td> 
  </tr> 
  <tr> 
   <td align="left">23</td> 
   <td align="left"><strong>fs.fstatSync(fd)</strong> 同步 fstat(). 返回 fs.Stats 的实例。</td> 
  </tr> 
  <tr> 
   <td align="left">24</td> 
   <td align="left"><strong>fs.link(srcpath, dstpath, callback)</strong> 异步 link().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">25</td> 
   <td align="left"><strong>fs.linkSync(srcpath, dstpath)</strong> 同步 link().</td> 
  </tr> 
  <tr> 
   <td align="left">26</td> 
   <td align="left"><strong>fs.symlink(srcpath, dstpath[, type], callback)</strong> 异步 symlink().回调函数没有参数，但可能抛出异常。 type 参数可以设置为 ‘dir’, ‘file’, 或 ‘junction’ (默认为 ‘file’) 。</td> 
  </tr> 
  <tr> 
   <td align="left">27</td> 
   <td align="left"><strong>fs.symlinkSync(srcpath, dstpath[, type])</strong> 同步 symlink().</td> 
  </tr> 
  <tr> 
   <td align="left">28</td> 
   <td align="left"><strong>fs.readlink(path, callback)</strong> 异步 readlink(). 回调函数有两个参数 err, linkString。</td> 
  </tr> 
  <tr> 
   <td align="left">29</td> 
   <td align="left"><strong>fs.realpath(path[, cache], callback)</strong> 异步 realpath(). 回调函数有两个参数 err, resolvedPath。</td> 
  </tr> 
  <tr> 
   <td align="left">30</td> 
   <td align="left"><strong>fs.realpathSync(path[, cache])</strong> 同步 realpath()。返回绝对路径。</td> 
  </tr> 
  <tr> 
   <td align="left">31</td> 
   <td align="left"><strong>fs.unlink(path, callback)</strong> 异步 unlink().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">32</td> 
   <td align="left"><strong>fs.unlinkSync(path)</strong> 同步 unlink().</td> 
  </tr> 
  <tr> 
   <td align="left">33</td> 
   <td align="left"><strong>fs.rmdir(path, callback)</strong> 异步 rmdir().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">34</td> 
   <td align="left"><strong>fs.rmdirSync(path)</strong> 同步 rmdir().</td> 
  </tr> 
  <tr> 
   <td align="left">35</td> 
   <td align="left"><strong>fs.mkdir(path[, mode], callback)</strong> S异步 mkdir(2).回调函数没有参数，但可能抛出异常。 访问权限默认为 0777。</td> 
  </tr> 
  <tr> 
   <td align="left">36</td> 
   <td align="left"><strong>fs.mkdirSync(path[, mode])</strong> 同步 mkdir().</td> 
  </tr> 
  <tr> 
   <td align="left">37</td> 
   <td align="left"><strong>fs.readdir(path, callback)</strong> 异步 readdir(3). 读取目录的内容。</td> 
  </tr> 
  <tr> 
   <td align="left">38</td> 
   <td align="left"><strong>fs.readdirSync(path)</strong> 同步 readdir().返回文件数组列表。</td> 
  </tr> 
  <tr> 
   <td align="left">39</td> 
   <td align="left"><strong>fs.close(fd, callback)</strong> 异步 close().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">40</td> 
   <td align="left"><strong>fs.closeSync(fd)</strong> 同步 close().</td> 
  </tr> 
  <tr> 
   <td align="left">41</td> 
   <td align="left"><strong>fs.open(path, flags[, mode], callback)</strong> 异步打开文件。</td> 
  </tr> 
  <tr> 
   <td align="left">42</td> 
   <td align="left"><strong>fs.openSync(path, flags[, mode])</strong> 同步 version of fs.open().</td> 
  </tr> 
  <tr> 
   <td align="left">43</td> 
   <td align="left"><strong>fs.utimes(path, atime, mtime, callback)</strong></td> 
  </tr> 
  <tr> 
   <td align="left">44</td> 
   <td align="left"><strong>fs.utimesSync(path, atime, mtime)</strong> 修改文件时间戳，文件通过指定的文件路径。</td> 
  </tr> 
  <tr> 
   <td align="left">45</td> 
   <td align="left"><strong>fs.futimes(fd, atime, mtime, callback)</strong></td> 
  </tr> 
  <tr> 
   <td align="left">46</td> 
   <td align="left"><strong>fs.futimesSync(fd, atime, mtime)</strong> 修改文件时间戳，通过文件描述符指定。</td> 
  </tr> 
  <tr> 
   <td align="left">47</td> 
   <td align="left"><strong>fs.fsync(fd, callback)</strong> 异步 fsync.回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
  <tr> 
   <td align="left">48</td> 
   <td align="left"><strong>fs.fsyncSync(fd)</strong> 同步 fsync.</td> 
  </tr> 
  <tr> 
   <td align="left">49</td> 
   <td align="left"><strong>fs.write(fd, buffer, offset, length[, position], callback)</strong> 将缓冲区内容写入到通过文件描述符指定的文件。</td> 
  </tr> 
  <tr> 
   <td align="left">50</td> 
   <td align="left"><strong>fs.write(fd, data[, position[, encoding]], callback)</strong> 通过文件描述符 fd 写入文件内容。</td> 
  </tr> 
  <tr> 
   <td align="left">51</td> 
   <td align="left"><strong>fs.writeSync(fd, buffer, offset, length[, position])</strong> 同步版的 fs.write()。</td> 
  </tr> 
  <tr> 
   <td align="left">52</td> 
   <td align="left"><strong>fs.writeSync(fd, data[, position[, encoding]])</strong> 同步版的 fs.write().</td> 
  </tr> 
  <tr> 
   <td align="left">53</td> 
   <td align="left"><strong>fs.read(fd, buffer, offset, length, position, callback)</strong> 通过文件描述符 fd 读取文件内容。</td> 
  </tr> 
  <tr> 
   <td align="left">54</td> 
   <td align="left"><strong>fs.readSync(fd, buffer, offset, length, position)</strong> 同步版的 fs.read.</td> 
  </tr> 
  <tr> 
   <td align="left">55</td> 
   <td align="left"><strong>fs.readFile(filename[, options], callback)</strong> 异步读取文件内容。</td> 
  </tr> 
  <tr> 
   <td align="left">56</td> 
   <td align="left"><strong>fs.readFileSync(filename[, options])</strong></td> 
  </tr> 
  <tr> 
   <td align="left">57</td> 
   <td align="left"><strong>fs.writeFile(filename, data[, options], callback)</strong> 异步写入文件内容。</td> 
  </tr> 
  <tr> 
   <td align="left">58</td> 
   <td align="left"><strong>fs.writeFileSync(filename, data[, options])</strong> 同步版的 fs.writeFile。</td> 
  </tr> 
  <tr> 
   <td align="left">59</td> 
   <td align="left"><strong>fs.appendFile(filename, data[, options], callback)</strong> 异步追加文件内容。</td> 
  </tr> 
  <tr> 
   <td align="left">60</td> 
   <td align="left"><strong>fs.appendFileSync(filename, data[, options])</strong> The 同步 version of fs.appendFile.</td> 
  </tr> 
  <tr> 
   <td align="left">61</td> 
   <td align="left"><strong>fs.watchFile(filename[, options], listener)</strong> 查看文件的修改。</td> 
  </tr> 
  <tr> 
   <td align="left">62</td> 
   <td align="left"><strong>fs.unwatchFile(filename[, listener])</strong> 停止查看 filename 的修改。</td> 
  </tr> 
  <tr> 
   <td align="left">63</td> 
   <td align="left"><strong>fs.watch(filename[, options][, listener])</strong> 查看 filename 的修改，filename 可以是文件或目录。返回 fs.FSWatcher 对象。</td> 
  </tr> 
  <tr> 
   <td align="left">64</td> 
   <td align="left"><strong>fs.exists(path, callback)</strong> 检测给定的路径是否存在。</td> 
  </tr> 
  <tr> 
   <td align="left">65</td> 
   <td align="left"><strong>fs.existsSync(path)</strong> 同步版的 fs.exists.</td> 
  </tr> 
  <tr> 
   <td align="left">66</td> 
   <td align="left"><strong>fs.access(path[, mode], callback)</strong> 测试指定路径用户权限。</td> 
  </tr> 
  <tr> 
   <td align="left">67</td> 
   <td align="left"><strong>fs.accessSync(path[, mode])</strong> 同步版的 fs.access。</td> 
  </tr> 
  <tr> 
   <td align="left">68</td> 
   <td align="left"><strong>fs.createReadStream(path[, options])</strong> 返回ReadStream 对象。</td> 
  </tr> 
  <tr> 
   <td align="left">69</td> 
   <td align="left"><strong>fs.createWriteStream(path[, options])</strong> 返回 WriteStream 对象。</td> 
  </tr> 
  <tr> 
   <td align="left">70</td> 
   <td align="left"><strong>fs.symlink(srcpath, dstpath[, type], callback)</strong> 异步 symlink().回调函数没有参数，但可能抛出异常。</td> 
  </tr> 
 </tbody> 
</table>

更多内容，请查看官网文件模块描述：[File System][]。

### 15. Node.js GET/POST请求 ###

在很多场景中，我们的服务器都需要跟用户的浏览器打交道，如表单提交。

表单提交到服务器一般都使用 GET/POST 请求。

#### 15.1 获取GET请求内容 ####

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

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

##### 15.1.1 实例 #####

在浏览器中访问 **http://localhost:3000/user?name=菜鸟教程&url=www.runoob.com** 然后查看返回结果:

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

##### 15.1.2 获取 URL 的参数 #####

我们可以使用 url.parse 方法来解析 URL 中的参数，代码如下：

###### 15.1.2.1 实例 ######

var http = require('http');
    var url = require('url');
    var util = require('util');
     
    http.createServer(function(req, res){
        
        res.writeHead(200, {
        'Content-Type': 'text/plain'});
     
        // 解析 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);

在浏览器中访问 **http://localhost:3000/user?name=菜鸟教程&url=www.runoob.com** 然后查看返回结果:

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

#### 15.2 获取 POST 请求内容 ####

POST 请求的内容全部的都在请求体中，http.ServerRequest 并没有一个属性内容为请求体，原因是等待请求体传输可能是一件耗时的工作。

比如上传文件，而很多时候我们可能并不需要理会请求体的内容，恶意的POST请求会大大消耗服务器的资源，所以 node.js 默认是不会解析请求体的，当你需要的时候，需要手动来做。

##### 15.2.1 基本语法结构说明 #####

以下实例表单通过 POST 提交并输出数据：

![在这里插入图片描述][42845a1e76c94c778723a4494821cd66.gif_pic_center]

### 16. Node.js 工具模块 ###

在 Node.js 模块库中有很多好用的模块。接下来我们为大家介绍几种常用模块的使用：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">模块名 &amp; 描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><a href="https://www.runoob.com/nodejs/nodejs-os-module.html" rel="nofollow"><strong>OS 模块</strong></a> 提供基本的系统操作函数。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><a href="https://www.runoob.com/nodejs/nodejs-path-module.html" rel="nofollow"><strong>Path 模块</strong></a> 提供了处理和转换文件路径的工具。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><a href="https://www.runoob.com/nodejs/nodejs-net-module.html" rel="nofollow"><strong>Net 模块</strong></a> 用于底层的网络通信。提供了服务端和客户端的的操作。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><a href="https://www.runoob.com/nodejs/nodejs-dns-module.html" rel="nofollow"><strong>DNS 模块</strong></a> 用于解析域名。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><a href="https://www.runoob.com/nodejs/nodejs-domain-module.html" rel="nofollow"><strong>Domain 模块</strong></a> 简化异步代码的异常处理，可以捕捉处理try catch无法捕捉的。</td> 
  </tr> 
 </tbody> 
</table>

### 17. Node.js Web 模块 ###

#### 17.1 什么是 Web 服务器？ ####

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

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

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

#### 17.2 Web 应用架构 ####

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

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

#### 17.3 使用 Node 创建 Web 服务器 ####

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

var http = require('http');

以下是演示一个最基本的 HTTP 服务器架构(使用 8080 端口)，创建 server.js 文件，代码如下所示：

接下来我们在该目录下创建一个 index.html 文件，代码如下：

<!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <title>菜鸟教程(runoob.com)</title>
    </head>
    <body>
        <h1>我的第一个标题</h1>
        <p>我的第一个段落。</p>
    </body>
    </html>

执行 server.js 文件：

$ node server.js
    Server running at http://127.0.0.1:8080/

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

执行 server.js 的控制台输出信息如下：

Server running at http://127.0.0.1:8080/
    Request for /index.html received.     #  客户端请求信息

#### 17.4 使用 Node 创建 Web 客户端 ####

Node 创建 Web 客户端需要引入 http 模块，创建 client.js 文件，代码如下所示：

**新开一个终端**，执行 client.js 文件，输出结果如下：

$ node  client.js 
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="utf-8">
    <title>菜鸟教程(runoob.com)</title>
    </head>
    <body>
        <h1>我的第一个标题</h1>
        <p>我的第一个段落。</p>
    </body>
    </html>

执行 server.js 的控制台输出信息如下：

Server running at http://127.0.0.1:8080/
    Request for /index.html received.   # 客户端请求信息

### 18. Node.js Express 框架 ###

#### 18.1 Express 简介 ####

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

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

Express 框架核心特性：

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

#### 18.2 安装 Express ####

安装 Express 并将其保存到依赖列表中：

$ cnpm install express --save

以上命令会将 Express 框架安装在当前目录的 **node\_modules** 目录中， **node\_modules** 目录下会自动创建 express 目录。以下几个重要的模块是需要与 express 框架一起安装的：

*  **body-parser** \- node.js 中间件，用于处理 JSON, Raw, Text 和 URL 编码的数据。
 *  **cookie-parser** \- 这就是一个解析Cookie的工具。通过req.cookies可以取到传过来的cookie，并把它们转成对象。
 *  **multer** \- node.js 中间件，用于处理 enctype=“multipart/form-data”（设置表单的MIME编码）的表单数据。

$ cnpm install body-parser --save
    $ cnpm install cookie-parser --save
    $ cnpm install multer --save

安装完后，我们可以查看下 express 使用的版本号：

$ cnpm list express
    /data/www/node
    └── express@4.15.2  -> /Users/tianqixin/www/node/node_modules/.4.15.2@express

#### 18.3 第一个 Express 框架实例 ####

接下来我们使用 Express 框架来输出 “Hello World”。

以下实例中我们引入了 express 模块，并在客户端发起请求后，响应 “Hello World” 字符串。

创建 express\_demo.js 文件，代码如下所示：

// express_demo.js 文件代码：
    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)
     
    })

执行以上代码：

$ node express_demo.js 
    应用实例，访问地址为 http://0.0.0.0:8081

在浏览器中访问 http://127.0.0.1:8081，结果如下图所示：

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

#### 18.4 请求和响应 ####

Express 应用使用回调函数的参数： **request** 和 **response** 对象来处理请求和响应的数据。

app.get('/', function (req, res) {
        
       // --
    })

**request** 和 **response** 对象的具体介绍：

**Request 对象** \- request 对象表示 HTTP 请求，包含了请求查询字符串，参数，内容，HTTP 头部等属性。常见属性有：

1.  req.app：当callback为外部文件时，用req.app访问express的实例
2.  req.baseUrl：获取路由当前安装的URL路径
3.  req.body / req.cookies：获得「请求主体」/ Cookies
4.  req.fresh / req.stale：判断请求是否还「新鲜」
5.  req.hostname / req.ip：获取主机名和IP地址
6.  req.originalUrl：获取原始请求URL
7.  req.params：获取路由的parameters
8.  req.path：获取请求路径
9.  req.protocol：获取协议类型
10. req.query：获取URL的查询参数串
11. req.route：获取当前匹配的路由
12. req.subdomains：获取子域名
13. req.accepts()：检查可接受的请求的文档类型
14. req.acceptsCharsets / req.acceptsEncodings / req.acceptsLanguages：返回指定字符集的第一个可接受字符编码
15. req.get()：获取指定的HTTP请求头
16. req.is()：判断请求头Content-Type的MIME类型

**Response 对象** \- response 对象表示 HTTP 响应，即在接收到请求时向客户端发送的 HTTP 响应数据。常见属性有：

1.  res.app：同req.app一样
2.  res.append()：追加指定HTTP头
3.  res.set()在res.append()后将重置之前设置的头
4.  res.cookie(name，value \[，option\])：设置Cookie
5.  opition: domain / expires / httpOnly / maxAge / path / secure / signed
6.  res.clearCookie()：清除Cookie
7.  res.download()：传送指定路径的文件
8.  res.get()：返回指定的HTTP头
9.  res.json()：传送JSON响应
10. res.jsonp()：传送JSONP响应
11. res.location()：只设置响应的Location HTTP头，不设置状态码或者close response
12. res.redirect()：设置响应的Location HTTP头，并且设置状态码302
13. res.render(view,\[locals\],callback)：渲染一个view，同时向callback传递渲染后的字符串，如果在渲染过程中有错误发生next(err)将会被自动调用。callback将会被传入一个可能发生的错误以及渲染后的页面，这样就不会自动输出了。
14. res.send()：传送HTTP响应
15. res.sendFile(path \[，options\] \[，fn\])：传送指定路径的文件 -会自动根据文件extension设定Content-Type
16. res.set()：设置HTTP头，传入object可以一次设置多个头
17. res.status()：设置HTTP状态码
18. res.type()：设置Content-Type的MIME类型

#### 18.5 路由 ####

我们已经了解了 HTTP 请求的基本应用，而路由决定了由谁(指定脚本)去响应客户端请求。

在HTTP请求中，我们可以通过路由提取出请求的URL以及GET/POST参数。

接下来我们扩展 Hello World，添加一些功能来处理更多类型的 HTTP 请求。

创建 express\_demo2.js 文件，代码如下所示：

// express_demo2.js 文件代码：
    var express = require('express');
    var app = express();
     
    //  主页输出 "Hello World"
    app.get('/', function (req, res) {
        
       console.log("主页 GET 请求");
       res.send('Hello GET');
    })
     
     
    //  POST 请求
    app.post('/', function (req, res) {
        
       console.log("主页 POST 请求");
       res.send('Hello POST');
    })
     
    //  /del_user 页面响应
    app.get('/del_user', function (req, res) {
        
       console.log("/del_user 响应 DELETE 请求");
       res.send('删除页面');
    })
     
    //  /list_user 页面 GET 请求
    app.get('/list_user', function (req, res) {
        
       console.log("/list_user GET 请求");
       res.send('用户列表页面');
    })
     
    // 对页面 abcd, abxcd, ab123cd, 等响应 GET 请求
    app.get('/ab*cd', function(req, res) {
           
       console.log("/ab*cd GET 请求");
       res.send('正则匹配');
    })
     
     
    var server = app.listen(8081, function () {
        
     
      var host = server.address().address
      var port = server.address().port
     
      console.log("应用实例，访问地址为 http://%s:%s", host, port)
     
    })

执行以上代码：

$ node express_demo2.js 
    应用实例，访问地址为 http://0.0.0.0:8081

接下来你可以尝试访问 http://127.0.0.1:8081 不同的地址，查看效果。

在浏览器中访问 http://127.0.0.1:8081/list\_user，结果如下图所示：

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

在浏览器中访问 http://127.0.0.1:8081/abcd，结果如下图所示：

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

在浏览器中访问 http://127.0.0.1:8081/abcdefg，结果如下图所示：

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

#### 18.6 静态文件 ####

Express 提供了内置的中间件 **express.static** 来设置静态文件如：图片， CSS, JavaScript 等。

你可以使用 **express.static** 中间件来设置静态文件路径。例如，如果你将图片， CSS, JavaScript 文件放在 public 目录下，你可以这么写：

app.use('/public', express.static('public'));

我们可以到 public/images 目录下放些图片,如下所示：

node_modules
    server.js
    public/
    public/images
    public/images/logo.png

让我们再修改下 “Hello World” 应用添加处理静态文件的功能。

创建 express\_demo3.js 文件，代码如下所示：

// express_demo3.js 文件代码：
    var express = require('express');
    var app = express();
     
    app.use('/public', express.static('public'));
     
    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)
     
    })

执行以上代码：

$ node express_demo3.js 
    应用实例，访问地址为 http://0.0.0.0:8081

执行以上代码：

在浏览器中访问 http://127.0.0.1:8081/public/images/logo.png（本实例采用了菜鸟教程的 logo），结果如下图所示：

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

#### 18.7 GET 方法 ####

以下实例演示了在表单中通过 GET 方法提交两个参数，我们可以使用 server.js 文件内的 **process\_get** 路由器来处理输入：

// index.html 文件代码：
    <html>
    <body>
    <form action="http://127.0.0.1:8081/process_get" method="GET">
    First Name: <input type="text" name="first_name">  <br>
     
    Last Name: <input type="text" name="last_name">
    <input type="submit" value="Submit">
    </form>
    </body>
    </html>

// server.js 文件代码：
    var express = require('express');
    var app = express();
     
    app.use('/public', express.static('public'));
     
    app.get('/index.html', function (req, res) {
        
       res.sendFile( __dirname + "/" + "index.html" );
    })
     
    app.get('/process_get', function (req, res) {
        
     
       // 输出 JSON 格式
       var response = {
        
           "first_name":req.query.first_name,
           "last_name":req.query.last_name
       };
       console.log(response);
       res.end(JSON.stringify(response));
    })
     
    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/index.html，如图所示：

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

#### 18.8 POST 方法 ####

以下实例演示了在表单中通过 POST 方法提交两个参数，我们可以使用 server.js 文件内的 **process\_post** 路由器来处理输入：

// index.html 文件代码：
    <html>
    <body>
    <form action="http://127.0.0.1:8081/process_post" method="POST">
    First Name: <input type="text" name="first_name">  <br>
     
    Last Name: <input type="text" name="last_name">
    <input type="submit" value="Submit">
    </form>
    </body>
    </html>

// server.js 文件代码：
    var express = require('express');
    var app = express();
    var bodyParser = require('body-parser');
     
    // 创建 application/x-www-form-urlencoded 编码解析
    var urlencodedParser = bodyParser.urlencoded({
         extended: false })
     
    app.use('/public', express.static('public'));
     
    app.get('/index.html', function (req, res) {
        
       res.sendFile( __dirname + "/" + "index.html" );
    })
     
    app.post('/process_post', urlencodedParser, function (req, res) {
        
     
       // 输出 JSON 格式
       var response = {
        
           "first_name":req.body.first_name,
           "last_name":req.body.last_name
       };
       console.log(response);
       res.end(JSON.stringify(response));
    })
     
    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/index.html，如图所示：

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

现在你可以向表单输入数据，并提交，如下演示：

![在这里插入图片描述][b14fab1638e446b19a860d8aa65a95a6.gif_pic_center]

#### 18.9 文件上传 ####

以下我们创建一个用于上传文件的表单，使用 POST 方法，表单 enctype 属性设置为 multipart/form-data。

// index.html 文件代码：
    <html>
    <head>
    <title>文件上传表单</title>
    </head>
    <body>
    <h3>文件上传：</h3>
    选择一个文件上传: <br />
    <form action="/file_upload" method="post" enctype="multipart/form-data">
    <input type="file" name="image" size="50" />
    <br />
    <input type="submit" value="上传文件" />
    </form>
    </body>
    </html>

// server.js 文件代码：
    var express = require('express');
    var app = express();
    var fs = require("fs");
     
    var bodyParser = require('body-parser');
    var multer  = require('multer');
     
    app.use('/public', express.static('public'));
    app.use(bodyParser.urlencoded({
         extended: false }));
    app.use(multer({
         dest: '/tmp/'}).array('image'));
     
    app.get('/index.html', function (req, res) {
        
       res.sendFile( __dirname + "/" + "index.html" );
    })
     
    app.post('/file_upload', function (req, res) {
        
     
       console.log(req.files[0]);  // 上传的文件信息
     
       var des_file = __dirname + "/" + req.files[0].originalname;
       fs.readFile( req.files[0].path, function (err, data) {
        
            fs.writeFile(des_file, data, function (err) {
        
             if( err ){
        
                  console.log( err );
             }else{
        
                   response = {
        
                       message:'File uploaded successfully', 
                       filename:req.files[0].originalname
                  };
              }
              console.log( response );
              res.end( JSON.stringify( response ) );
           });
       });
    })
     
    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/index.html，如图所示：

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

现在你可以向表单输入数据，并提交，如下演示：

![在这里插入图片描述][8e795c93452549d49bb350d7f1a28d95.gif_pic_center]

#### 18.10 Cookie 管理 ####

我们可以使用中间件向 Node.js 服务器发送 cookie 信息，以下代码输出了客户端发送的 cookie 信息：

// express_cookie.js 文件代码：
    var express      = require('express')
    var cookieParser = require('cookie-parser')
    var util = require('util');
     
    var app = express()
    app.use(cookieParser())
     
    app.get('/', function(req, res) {
        
        console.log("Cookies: " + util.inspect(req.cookies));
    })
     
    app.listen(8081)

执行以上代码：

$ node express_cookie.js

现在你可以访问 http://127.0.0.1:8081 并查看终端信息的输出，如下演示：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C28HGgbx-1666506326078)(Node.js%20%E6%95%99%E7%A8%8B.assets/nodejs-gif9-166591712176635.gif)\]

#### 18.11 相关资料 ####

*  Express官网： [http://expressjs.com/][http_expressjs.com]
 *  Express4.x API 中文版： [Express4.x API Chinese][]
 *  Express4.x API：[http://expressjs.com/zh-cn/4x/api.html][http_expressjs.com_zh-cn_4x_api.html]

### 19. Node.js RESTful API ###

#### 19.1 什么是 REST？ ####

REST即表述性状态传递（英文：Representational State Transfer，简称REST）是Roy Fielding博士在2000年他的博士论文中提出来的一种软件架构风格。

表述性状态转移是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是RESTful。需要注意的是，REST是设计风格而不是标准。REST通常基于使用HTTP，URI，和XML（标准通用标记语言下的一个子集）以及HTML（标准通用标记语言下的一个应用）这些现有的广泛流行的协议和标准。REST 通常使用 JSON 数据格式。

##### 19.1.1 HTTP 方法 #####

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

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

#### 19.2 RESTful Web Services ####

Web service是一个平台独立的，低耦合的，自包含的、基于可编程的web的应用程序，可使用开放的XML（标准通用标记语言下的一个子集）标准来描述、发布、发现、协调和配置这些应用程序，用于开发分布式的互操作的应用程序。

基于 REST 架构的 Web Services 即是 RESTful。

由于轻量级以及通过 HTTP 直接传输数据的特性，Web 服务的 RESTful 方法已经成为最常见的替代方法。可以使用各种语言（比如 Java 程序、Perl、Ruby、Python、PHP 和 Javascript\[包括 Ajax\]）实现客户端。

RESTful Web 服务通常可以通过自动客户端或代表用户的应用程序访问。但是，这种服务的简便性让用户能够与之直接交互，使用它们的 Web 浏览器构建一个 GET URL 并读取返回的内容。

更多介绍，可以查看：[RESTful 架构详解][RESTful]

#### 19.3 创建 RESTful ####

首先，创建一个 json 数据资源文件 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：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">URI</th> 
   <th align="left">HTTP 方法</th> 
   <th align="left">发送内容</th> 
   <th align="left">结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">listUsers</td> 
   <td align="left">GET</td> 
   <td align="left">空</td> 
   <td align="left">显示所有用户列表</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left">addUser</td> 
   <td align="left">POST</td> 
   <td align="left">JSON 字符串</td> 
   <td align="left">添加新用户</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left">deleteUser</td> 
   <td align="left">DELETE</td> 
   <td align="left">JSON 字符串</td> 
   <td align="left">删除用户</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left">:id</td> 
   <td align="left">GET</td> 
   <td align="left">空</td> 
   <td align="left">显示用户详细信息</td> 
  </tr> 
 </tbody> 
</table>

##### 19.3.1 获取用户列表 #####

以下代码，我们创建了 RESTful API **listUsers**，用于读取用户的信息列表， server.js 文件代码如下所示：

接下来执行以下命令：

$ node server.js 
    应用实例，访问地址为 http://0.0.0.0:8081

在浏览器中访问 http://127.0.0.1:8081/listUsers，结果如下所示：

##### 19.3.2 添加用户 #####

以下代码，我们创建了 RESTful API **addUser**， 用于添加新的用户数据，server.js 文件代码如下所示：

接下来执行以下命令：

$ 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 } 
    }

##### 19.3.3 显示用户详情 #####

以下代码，我们创建了 RESTful API **:id（用户id）**， 用于读取指定用户的详细信息，server.js 文件代码如下所示：

接下来执行以下命令：

$ node server.js 
    应用实例，访问地址为 http://0.0.0.0:8081

在浏览器中访问 http://127.0.0.1:8081/2，结果如下所示：

{
        
       "name":"suresh",
       "password":"password2",
       "profession":"librarian",
       "id":2
    }

##### 19.3.4 删除用户 #####

以下代码，我们创建了 RESTful API **deleteUser**， 用于删除指定用户的详细信息，以下实例中，用户 id 为 2，server.js 文件代码如下所示：

接下来执行以下命令：

$ 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 } 
    }

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

#### 20.1 exec() 方法 ####

child\_process.exec 使用子进程执行命令，缓存子进程的输出，并将子进程的输出以回调函数参数的形式返回。

语法如下所示：

child_process.exec(command[, options], callback)

##### 20.1.1 参数 #####

参数说明如下：

**command：** 字符串， 将要运行的命令，参数使用空格隔开

**options ：对象，可以是：**

*  cwd ，字符串，子进程的当前工作目录
 *  env，对象 环境变量键值对
 *  encoding ，字符串，字符编码（默认： ‘utf8’）
 *  shell ，字符串，将要执行命令的 Shell（默认: 在 UNIX 中为`/bin/sh`， 在 Windows 中为`cmd.exe`， Shell 应当能识别 `-c`开关在 UNIX 中，或 `/s /c` 在 Windows 中。 在Windows 中，命令行解析应当能兼容`cmd.exe`）
 *  timeout，数字，超时时间（默认： 0）
 *  maxBuffer，数字， 在 stdout 或 stderr 中允许存在的最大缓冲（二进制），如果超出那么子进程将会被杀死 （默认: 200\*1024）
 *  killSignal ，字符串，结束信号（默认：‘SIGTERM’）
 *  uid，数字，设置用户进程的 ID
 *  gid，数字，设置进程组的 ID

\*\*callback ：\*\*回调函数，包含三个参数error, stdout 和 stderr。

exec() 方法返回最大的缓冲区，并等待进程结束，一次性返回缓冲区的内容。

##### 20.1.2 实例 #####

让我们创建两个 js 文件 support.js 和 master.js。

// support.js 文件代码：
    console.log("进程 " + process.argv[2] + " 执行。" );

// master.js 文件代码：
    const fs = require('fs');
    const child_process = require('child_process');
     
    for(var i=0; i<3; i++) {
        
        var workerProcess = child_process.exec('node support.js '+i, function (error, stdout, stderr) {
        
            if (error) {
        
                console.log(error.stack);
                console.log('Error code: '+error.code);
                console.log('Signal received: '+error.signal);
            }
            console.log('stdout: ' + stdout);
            console.log('stderr: ' + stderr);
        });
     
        workerProcess.on('exit', function (code) {
        
            console.log('子进程已退出，退出码 '+code);
        });
    }

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

$ node master.js 
    子进程已退出，退出码 0
    stdout: 进程 1 执行。
    
    stderr: 
    子进程已退出，退出码 0
    stdout: 进程 0 执行。
    
    stderr: 
    子进程已退出，退出码 0
    stdout: 进程 2 执行。
    
    stderr:

#### 20.2 spawn() 方法 ####

child\_process.spawn 使用指定的命令行参数创建新进程，语法格式如下：

child_process.spawn(command[, args][, options])

##### 20.2.1 参数 #####

参数说明如下：

**command：** 将要运行的命令

**args：** Array 字符串参数数组

**options Object**

*  cwd String 子进程的当前工作目录
 *  env Object 环境变量键值对
 *  stdio Array|String 子进程的 stdio 配置
 *  detached Boolean 这个子进程将会变成进程组的领导
 *  uid Number 设置用户进程的 ID
 *  gid Number 设置进程组的 ID

spawn() 方法返回流 (stdout & stderr)，在进程返回大量数据时使用。进程一旦开始执行时 spawn() 就开始接收响应。

##### 20.2.2 实例 #####

让我们创建两个 js 文件 support.js 和 master.js。

// support.js 文件代码：
    console.log("进程 " + process.argv[2] + " 执行。" );

// master.js 文件代码：
    const fs = require('fs');
    const child_process = require('child_process');
     
    for(var i=0; i<3; i++) {
        
       var workerProcess = child_process.spawn('node', ['support.js', i]);
     
       workerProcess.stdout.on('data', function (data) {
        
          console.log('stdout: ' + data);
       });
     
       workerProcess.stderr.on('data', function (data) {
        
          console.log('stderr: ' + data);
       });
     
       workerProcess.on('close', function (code) {
        
          console.log('子进程已退出，退出码 '+code);
       });
    }

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

$ node master.js stdout: 进程 0 执行。
    
    子进程已退出，退出码 0
    stdout: 进程 1 执行。
    
    子进程已退出，退出码 0
    stdout: 进程 2 执行。
    
    子进程已退出，退出码 0

#### 20.3 fork 方法 ####

child\_process.fork 是 spawn() 方法的特殊形式，用于创建进程，语法格式如下：

child_process.fork(modulePath[, args][, options])

##### 20.3.1 参数 #####

参数说明如下：

**modulePath**： String，将要在子进程中运行的模块

**args**： Array 字符串参数数组

**options**：Object

*  cwd String 子进程的当前工作目录
 *  env Object 环境变量键值对
 *  execPath String 创建子进程的可执行文件
 *  execArgv Array 子进程的可执行文件的字符串参数数组（默认： process.execArgv）
 *  silent Boolean 如果为`true`，子进程的`stdin`，`stdout`和`stderr`将会被关联至父进程，否则，它们将会从父进程中继承。（默认为：`false`）
 *  uid Number 设置用户进程的 ID
 *  gid Number 设置进程组的 ID

返回的对象除了拥有ChildProcess实例的所有方法，还有一个内建的通信信道。

##### 20.3.2 实例 #####

让我们创建两个 js 文件 support.js 和 master.js。

// support.js 文件代码：
    console.log("进程 " + process.argv[2] + " 执行。" );

// master.js 文件代码：
    const fs = require('fs');
    const child_process = require('child_process');
     
    for(var i=0; i<3; i++) {
        
       var worker_process = child_process.fork("support.js", [i]);    
     
       worker_process.on('close', function (code) {
        
          console.log('子进程已退出，退出码 ' + code);
       });
    }

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

$ node master.js 
    进程 0 执行。
    子进程已退出，退出码 0
    进程 1 执行。
    子进程已退出，退出码 0
    进程 2 执行。
    子进程已退出，退出码 0

### 21. Node.js JXcore 打包 ###

Node.js 是一个开放源代码、跨平台的、用于服务器端和网络应用的运行环境。

JXcore 是一个支持多线程的 Node.js 发行版本，基本不需要对你现有的代码做任何改动就可以直接线程安全地以多线程运行。

这篇文章主要是要向大家介绍 JXcore 的打包功能。

#### 21.1 JXcore 安装 ####

下载 JXcore 安装包，并解压，在解压的的目录下提供了 jx 二进制文件命令，接下来我们主要使用这个命令。

##### 21.1.1 步骤1、下载 #####

下载 JXcore 安装包 https://github.com/jxcore/jxcore-release，你需要根据你自己的系统环境来下载安装包。

1、Window 平台下载：[Download(Windows x64 (V8))][Download_Windows x64 _V8]。

2、Linux/OSX 安装命令：

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

如果权限不足，可以使用以下命令：

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

以上步骤如果操作正确，使用以下命令，会输出版本号信息：

$ jx --version
    v0.10.32

#### 21.2 包代码 ####

例如，我们的 Node.js 项目包含以下几个文件，其中 index.js 是主文件：

drwxr-xr-x  2 root root  4096 Nov 13 12:42 images
    -rwxr-xr-x  1 root root 30457 Mar  6 12:19 index.htm
    -rwxr-xr-x  1 root root 30452 Mar  1 12:54 index.js
    drwxr-xr-x 23 root root  4096 Jan 15 03:48 node_modules
    drwxr-xr-x  2 root root  4096 Mar 21 06:10 scripts
    drwxr-xr-x  2 root root  4096 Feb 15 11:56 style

接下来我们使用 **jx** 命令打包以上项目，并指定 index.js 为 Node.js 项目的主文件：

$ jx package index.js index

以上命令执行成功，会生成以下两个文件：

*  **index.jxp** 这是一个中间件文件，包含了需要编译的完整项目信息。
 *  **index.jx** 这是一个完整包信息的二进制文件，可运行在客户端上。

#### 21.3 载入 JX 文件 ####

Node.js 的项目运行：

$ node index.js command_line_arguments

使用 JXcore 编译后，我们可以使用以下命令来执行生成的 jx 二进制文件：

$ jx index.jx command_line_arguments

--------------------

更多 JXcore 安装参考：https://github.com/jxcore/jxcore/blob/master/doc/INSTALLATION.md。

更多 JXcore 功能特性你可以参考官网：https://github.com/jxcore/jxcore。

### 22. Node.js 连接 MySQL ###

本章节我们将为大家介绍如何使用 Node.js 来连接 MySQL，并对数据库进行操作。

如果你还没有 MySQL 的基本知识，可以参考我们的教程：[MySQL 教程][MySQL]。

本教程使用到的 Websites 表 SQL 文件：[websites.sql][]。

#### 22.1 安装驱动 ####

本教程使用了[淘宝定制的 cnpm 命令][cnpm]进行安装：

$ cnpm install mysql

#### 22.2 连接数据库 ####

在以下实例中根据你的实际配置修改数据库用户名、及密码及数据库名：

// test.js 文件代码：
    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);
    });

执行以下命令输出结果为：

$ node test.js
    The solution is: 2

#### 22.3 数据库连接参数说明 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">参数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">host</td> 
   <td align="left">主机地址 （默认：localhost）</td> 
  </tr> 
  <tr> 
   <td align="left">user</td> 
   <td align="left">用户名</td> 
  </tr> 
  <tr> 
   <td align="left">password</td> 
   <td align="left">密码</td> 
  </tr> 
  <tr> 
   <td align="left">port</td> 
   <td align="left">端口号 （默认：3306）</td> 
  </tr> 
  <tr> 
   <td align="left">database</td> 
   <td align="left">数据库名</td> 
  </tr> 
  <tr> 
   <td align="left">charset</td> 
   <td align="left">连接字符集（默认：‘UTF8_GENERAL_CI’，注意字符集的字母都要大写）</td> 
  </tr> 
  <tr> 
   <td align="left">localAddress</td> 
   <td align="left">此IP用于TCP连接（可选）</td> 
  </tr> 
  <tr> 
   <td align="left">socketPath</td> 
   <td align="left">连接到unix域路径，当使用 host 和 port 时会被忽略</td> 
  </tr> 
  <tr> 
   <td align="left">timezone</td> 
   <td align="left">时区（默认：‘local’）</td> 
  </tr> 
  <tr> 
   <td align="left">connectTimeout</td> 
   <td align="left">连接超时（默认：不限制；单位：毫秒）</td> 
  </tr> 
  <tr> 
   <td align="left">stringifyObjects</td> 
   <td align="left">是否序列化对象</td> 
  </tr> 
  <tr> 
   <td align="left">typeCast</td> 
   <td align="left">是否将列值转化为本地JavaScript类型值 （默认：true）</td> 
  </tr> 
  <tr> 
   <td align="left">queryFormat</td> 
   <td align="left">自定义query语句格式化方法</td> 
  </tr> 
  <tr> 
   <td align="left">supportBigNumbers</td> 
   <td align="left">数据库支持bigint或decimal类型列时，需要设此option为true （默认：false）</td> 
  </tr> 
  <tr> 
   <td align="left">bigNumberStrings</td> 
   <td align="left">supportBigNumbers和bigNumberStrings启用 强制bigint或decimal列以JavaScript字符串类型返回（默认：false）</td> 
  </tr> 
  <tr> 
   <td align="left">dateStrings</td> 
   <td align="left">强制timestamp,datetime,data类型以字符串类型返回，而不是JavaScript Date类型（默认：false）</td> 
  </tr> 
  <tr> 
   <td align="left">debug</td> 
   <td align="left">开启调试（默认：false）</td> 
  </tr> 
  <tr> 
   <td align="left">multipleStatements</td> 
   <td align="left">是否许一个query中有多个MySQL语句 （默认：false）</td> 
  </tr> 
  <tr> 
   <td align="left">flags</td> 
   <td align="left">用于修改连接标志</td> 
  </tr> 
  <tr> 
   <td align="left">ssl</td> 
   <td align="left">使用ssl参数（与crypto.createCredenitals参数格式一至）或一个包含ssl配置文件名称的字符串，目前只捆绑Amazon RDS的配置文件</td> 
  </tr> 
 </tbody> 
</table>

更多说明可参见：https://github.com/mysqljs/mysql

#### 22.4 数据库操作( CURD ) ####

在进行数据库操作前，你需要将本站提供的 Websites 表 SQL 文件[websites.sql][] 导入到你的 MySQL 数据库中。

本教程测试的 MySQL 用户名为 root，密码为 123456，数据库为 test，你需要根据自己配置情况修改。

##### 22.4.1 查询数据 #####

将上面我们提供的 SQL 文件导入数据库后，执行以下代码即可查询出数据：

执行以下命令输出就结果为：

$ node test.js
    --------------------------SELECT----------------------------
    [ RowDataPacket {
        id: 1,
        name: 'Google',
        url: 'https://www.google.cm/',
        alexa: 1,
        country: 'USA' },
      RowDataPacket {
        id: 2,
        name: '淘宝',
        url: 'https://www.taobao.com/',
        alexa: 13,
        country: 'CN' },
      RowDataPacket {
        id: 3,
        name: '菜鸟教程',
        url: 'http://www.runoob.com/',
        alexa: 4689,
        country: 'CN' },
      RowDataPacket {
        id: 4,
        name: '微博',
        url: 'http://weibo.com/',
        alexa: 20,
        country: 'CN' },
      RowDataPacket {
        id: 5,
        name: 'Facebook',
        url: 'https://www.facebook.com/',
        alexa: 3,
        country: 'USA' } ]
    ------------------------------------------------------------

##### 22.4.2 插入数据 #####

我们可以向数据表 websties 插入数据：

执行以下命令输出就结果为：

$ node test.js
    --------------------------INSERT----------------------------
    INSERT ID: OkPacket {
      fieldCount: 0,
      affectedRows: 1,
      insertId: 6,
      serverStatus: 2,
      warningCount: 0,
      message: '',
      protocol41: true,
      changedRows: 0 }
    -----------------------------------------------------------------

执行成功后，查看数据表，即可以看到添加的数据：

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

##### 22.4.3 更新数据 #####

我们也可以对数据库的数据进行修改：

执行以下命令输出就结果为：

--------------------------UPDATE----------------------------
    UPDATE affectedRows 1
    -----------------------------------------------------------------

执行成功后，查看数据表，即可以看到更新的数据：

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

##### 22.4.4 删除数据 #####

我们可以使用以下代码来删除 id 为 6 的数据:

执行以下命令输出就结果为：

--------------------------DELETE----------------------------
    DELETE affectedRows 1
    -----------------------------------------------------------------

执行成功后，查看数据表，即可以看到 id=6 的数据已被删除：

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

[de264f2a79ba4c5285a1125051346b28.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/27418792c51a4194baf29bdba40b2f10.png
[76494a03f8874babbc0b904891dee950.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7803bee33cb44aaa94977a06a5246780.png
[Link 1]: https://npmjs.org/doc/files/package.json.html#dependencies
[npmjs.org_doc]: https://npmjs.org/doc/
[Link 2]: https://baijiahao.baidu.com/s?id=1694911077228884017&wfr=spider&for=pc
[7506f34d973f466198645c340e6d6145.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/900bb7862d1f4f6cbdf91d73bfd313dd.png
[JSON.stringify]: https://www.runoob.com/js/javascript-json-stringify.html
[e0c0f0f15a7747c0ad75218155d3d947.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/857d9f938b6b421bb67e8c87d54e0eb3.png
[5c37d0879ed24f12963ffda500cbbe25.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/61d85e3f51f44d75b3fa217ccf83dc58.png
[8509213157574b93af9f08795afd11cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/b66c12129c7a444eb875c82cd1b77c08.png
[http_nodejs.org_api_util.html]: https://nodejs.org/api/util.html
[File System]: https://nodejs.org/api/fs.html#fs_fs_rename_oldpath_newpath_callback
[44cbea52a2f24f89b8e8f6b4a849f653.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/529dc6d2a4b2439cadb67003e53da936.png
[b47129b8ece7417691054645c3e95987.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ee8699843825492e9416f915c10bd89e.png
[42845a1e76c94c778723a4494821cd66.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e12a98d1309b4dd081c48d07271b39ed.gif
[5f6bff565dc04539be67580f6eaaab62.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3238bbb573954829b9a818d451e9abcd.png
[64a312eec72246638e0e6553482ef307.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/98ebce866ca548f48d9c57ef4c00edd2.png
[5657d170206a419aa8c0a0f1c0c1e9df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/4a34b33eae634bf99a0342bd4ff945e0.png
[a81ae38ceafe4582803ad886b5ff6ab3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6baeb5d076904b1c8c9202504173f42d.png
[16c49d4c376241a2bf43384e2dd0c077.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/1c32537868004e57a78cfd88cf1cdb89.png
[59ef806553bf46df9f665468fa063dce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/35dd2ab9e1f74c4fbec3fbfddffbd411.png
[77479f8a7a4a40c89b2f03d5dd8c502c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d62c9022cb604d8ba6408aa02c239019.png
[e39e2b7829a44916b7f11cbb72d35686.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d09b9e1291b44e44a9c10b288b825886.png
[49cc3dfcd1de4629bbd51c80f8ce9ac4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/cd4d9bece8aa475490a41e2745190733.png
[b14fab1638e446b19a860d8aa65a95a6.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/0e7b4f4733244889813d486c4b2f3e5c.gif
[bb81a3de765a482d9d3ac638ea784ca0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/be2321ccd6bd4b5b9c36e8917094326c.png
[8e795c93452549d49bb350d7f1a28d95.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/0b11da711b3844a3b4772b9c8e37120c.gif
[http_expressjs.com]: https://expressjs.com/
[Express4.x API Chinese]: https://www.runoob.com/w3cnote/express-4-x-api.html
[http_expressjs.com_zh-cn_4x_api.html]: https://expressjs.com/zh-cn/4x/api.html
[RESTful]: https://www.runoob.com/w3cnote/restful-architecture.html
[Download_Windows x64 _V8]: https://raw.githubusercontent.com/jxcore/jxcore-release/master/0311/jx_win64v8.zip
[MySQL]: https://www.runoob.com/mysql/mysql-tutorial.html
[websites.sql]: https://static.runoob.com/download/websites.sql
[cnpm]: https://www.runoob.com/nodejs/nodejs-npm.html#taobaonpm
[5798c80598f34f829a75a3bde2e8a6a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c635bc5cb84744d382969ef760f0a32d.png
[513910f68c21412ebe78f36be2e5cea2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5169ba11c23d45d9b9ea32249b07eeec.png
[c8f40782b60945faa65734587a127b2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6087816e535a43edac39fa17d3cf4a36.png