mirror of
https://github.com/apachecn/eloquent-js-3e-zh.git
synced 2025-05-31 00:57:25 +00:00
595 lines
35 KiB
Markdown
595 lines
35 KiB
Markdown
## 二十、Node.js
|
||
|
||
> A student asked ‘The programmers of old used only simple machines and no programming languages, yet they made beautiful programs. Why do we use complicated machines and programming languages?’. Fu-Tzu replied ‘The builders of old used only sticks and clay, yet they made beautiful huts.’
|
||
>
|
||
> Master Yuan-Ma, The Book of Programming
|
||
|
||
到目前为止，我们已经使用了 JavaScript 语言，并将其运用于单一的浏览器环境中。本章和下一章将会大致介绍Node.js，该程序可以让读者将你的JavaScirpt技能运用于浏览器之外。读者可以运用Node.js构建应用程序，实现简单的命令行工具和复杂动态HTTP服务器。
|
||
|
||
这些章节旨在告诉你建立Node.js的主要概念，并向你提供信息，使你可以采用Nodejs编写一些实用程序。它们并不是这个平台的完整的介绍。
|
||
|
||
如果你想要运行本章中的代码，需要安装 Node.js 10 或更高版本。 为此，请访问 [nodejs.org](https://nodejs.org)，并按照用于你的操作系统的安装说明进行操作。 您也可以在那里找到 Node.js 的更多文档。
|
||
|
||
### 20.1 背景
|
||
|
||
编写通过网络通信的系统时，一个更困难的问题是管理输入输出，即向/从网络和硬盘读写数据。到处移动数据会耗费时间，而调度这些任务的技巧会使得系统在相应用户或网络请求时产生巨大的性能差异。
|
||
|
||
在这样的程序中，异步编程通常是有帮助的。 它允许程序同时向/从多个设备发送和接收数据，而无需复杂的线程管理和同步。
|
||
|
||
Node最初是为了使异步编程简单方便而设计的。 JavaScript 很好地适应了像 Node 这样的系统。 它是少数几种没有内置输入和输出方式的编程语言之一。 因此，JavaScript 可以适应 Node 的相当古怪的输入和输出方法，而不会产生两个不一致的接口。 在 2009 年设计 Node 时，人们已经在浏览器中进行基于回调的编程，所以该语言的社区用于异步编程风格。
|
||
|
||
### 20.3 node命令
|
||
|
||
在系统中安装完Node.js后，Node.js会提供一个名为node的程序，该程序用于执行JavaScript文件。假设你有一个文件hello.js，该文件会包含以下代码。
|
||
|
||
```js
|
||
let message = "Hello world";
|
||
console.log(message);
|
||
```
|
||
|
||
读者可以仿照下面这种方式通过命令行执行程序。
|
||
|
||
```
|
||
$ node hello.js
|
||
Hello world
|
||
```
|
||
|
||
Node中的console.log方法与浏览器中所做的类似，都用于打印文本片段。但在Node中，该方法不会将文本显示在浏览器的JavaScript控制台中，而显示在标准输出流中。从命令行运行`node`时，这意味着您会在终端中看到记录的值。
|
||
|
||
若你执行node时不附带任何参数，node会给出提示符，读者可以输入JavaScript代码并立即看到执行结果。
|
||
|
||
```js
|
||
$ node
|
||
> 1 + 1
|
||
2
|
||
> [-1, -2, -3].map(Math.abs)
|
||
[1, 2, 3]
|
||
> process.exit(0)
|
||
$
|
||
```
|
||
|
||
绑定process类似于console绑定，是Node中的全局绑定。该绑定提供了多种方式来监听并操作当前程序。该绑定中的exit方法可以结束进程并赋予一个退出状态码，告知启动node的程序（在本例中时命令行shell），当前程序是成功完成（代码为0），还是遇到了错误（其他代码）。
|
||
|
||
读者可以读取process.argv来获取传递给脚本的命令行参数，该绑定是一个字符串数组。请注意该数组包括了node命令和脚本名称，因此实际的参数从索引2处开始。若showargv.js只包含一条console.log（process.argv）语句，你可以这样执行该脚本。
|
||
|
||
```
|
||
$ node showargv.js one --and two
|
||
["node", "/tmp/showargv.js", "one", "--and", "two"]
|
||
```
|
||
|
||
所有标准JavaScript全局绑定，比如Array、Math以及JSON也都存在于Node环境中。而与浏览器相关的功能，比如document与alert则不存在。
|
||
|
||
### 20.4 模块
|
||
|
||
除了前文提到的一些绑定，比如console和process，Node在全局作用域中添加了很少绑定。如果你需要访问其他的内建功能，可以通过system模块获取。
|
||
|
||
第10章中描述了基于require函数的CommonJS模块系统。该系统是Node的内建模块，用于在程序中装载任何东西，从内建模块，到下载的包，再到普通文件都可以。
|
||
|
||
调用require时，Node会将给定的字符串解析为可加载的实际文件。路径名若以“/”、“./”或“../”开头，则解析为相对于当前模块的路径，其中“./”表示当前路径，“../”表示当前路径的上一级路径，而“/”则表示文件系统根路径。因此若你访问从文件/tmp/robot/robot.js访问“./graph”，Node会尝试加载文件/tmp/robot/graph.js。
|
||
|
||
`.js`扩展名可能会被忽略，如果这样的文件存在，Node 会添加它。 如果所需的路径指向一个目录，则 Node 将尝试加载该目录中名为`index.js`的文件。
|
||
|
||
当一个看起来不像是相对路径或绝对路径的字符串被赋给`require`时，按照假设，它引用了内置模块，或者安装在`node_modules`目录中模块。 例如，`require("fs")`会向你提供 Node 内置的文件系统模块。 而`require("robot")`可能会尝试加载`node_modules/robot/`中的库。 安装这种库的一种常见方法是使用 NPM，我们稍后讲讲它。
|
||
|
||
我们来建立由两个文件组成的小项目。 第一个称为`main.js`，并定义了一个脚本，可以从命令行调用来反转字符串。
|
||
|
||
```js
|
||
const {reverse} = require("./reverse");
|
||
|
||
// Index 2 holds the first actual command-line argument
|
||
let argument = process.argv[2];
|
||
|
||
console.log(reverse(argument));
|
||
```
|
||
|
||
文件reverse.js中定义了一个库，用于截取字符串，这个命令行工具，以及其他需要直接访问字符串反转函数的脚本，都可以调用该库。
|
||
|
||
```js
|
||
exports.reverse = function(string) {
|
||
return Array.from(string).reverse().join("");
|
||
};
|
||
```
|
||
|
||
请记住，将属性添加到`exports`，会将它们添加到模块的接口。 由于 Node.js 将文件视为 CommonJS 模块，因此`main.js`可以从`reverse.js`获取导出的`reverse`函数。
|
||
|
||
我们可以看到我们的工具执行结果如下所示。
|
||
|
||
```
|
||
$ node main.js JavaScript
|
||
tpircSavaJ
|
||
```
|
||
|
||
### 20.5 使用NPM安装
|
||
|
||
第十章中介绍的NPM，是一个JavaScript模块的在线仓库，其中大部分模块是专门为Node编写的。当你在计算机上安装Node时，你就会获得一个名为npm的程序，提供了访问该仓库的简易接口。
|
||
|
||
它的主要用途是下载软件包。 我们在第十章中看到了`ini`包。 我们可以使用 NPM 在我们的计算机上获取并安装该软件包。
|
||
|
||
```
|
||
$ npm install ini
|
||
npm WARN enoent ENOENT: no such file or directory,
|
||
open '/tmp/package.json'
|
||
+ ini@1.3.5
|
||
added 1 package in 0.552s
|
||
$ node
|
||
> const {parse} = require("ini");
|
||
> parse("x = 1\ny = 2");
|
||
{ x: '1', y: '2' }
|
||
```
|
||
|
||
运行`npm install`后，NPM 将创建一个名为`node_modules`的目录。 该目录内有一个包含库的`ini`目录。 您可以打开它并查看代码。 当我们调用`require("ini")`时，加载这个库，我们可以调用它的`parse`属性来解析配置文件。
|
||
|
||
默认情况下，NPM 在当前目录下安装软件包，而不是在中央位置。 如果您习惯于其他软件包管理器，这可能看起来很不寻常，但它具有优势 - 它使每个应用程序完全控制它所安装的软件包，并且使其在删除应用程序时，更易于管理版本和清理。
|
||
|
||
## 包文件
|
||
|
||
在`npm install`例子中，你可以看到`package.json`文件不存在的警告。 建议为每个项目创建一个文件，手动或通过运行`npm init`。 它包含该项目的一些信息，例如其名称和版本，并列出其依赖项。
|
||
|
||
来自第七章的机器人模拟，在第十章中模块化，它可能有一个`package.json`文件，如下所示：
|
||
|
||
```json
|
||
{
|
||
"author": "Marijn Haverbeke",
|
||
"name": "eloquent-javascript-robot",
|
||
"description": "Simulation of a package-delivery robot",
|
||
"version": "1.0.0",
|
||
"main": "run.js",
|
||
"dependencies": {
|
||
"dijkstrajs": "^1.0.1",
|
||
"random-item": "^1.0.0"
|
||
},
|
||
"license": "ISC"
|
||
}
|
||
```
|
||
|
||
当你运行`npm install`而没有指定安装包时，NPM 将安装`package.json`中列出的依赖项。 当你安装一个没有列为依赖项的特定包时，NPM会将它添加到`package.json`中。
|
||
|
||
## 版本
|
||
|
||
也许有些出乎意料，figlet.text并不是简单地返回一个组成巨大字母的字符串，而会接受一个回调函数，并将结果传递给该函数。该函数也会向回调函数传递第二个参数即error，在发生一些错误时用该参数保存一个错误对象，若一切正常则为null。
|
||
|
||
这在Node代码中是常见模式。使用figlet渲染字符需要读取包含字符形状的文件，而在Node中读取文件是一个异步操作，因此figlet.text无法立即返回结果。在某种程度上，异步性是具有传染性的。每个调用异步函数的函数都会变成一个异步函数。
|
||
|
||
NPM并不只是npm install那么简单，该工具会读取package.json文件，该文件包含了以JSON格式编码的程序或库的信息（比如依赖于哪些库）。在包含该文件的目录下执行nmp install，会自动安装所有的依赖，还包括依赖的依赖。NPM工具也可用来将库发布到NPM在线包仓库中，这样其他人就可以查找、下载并使用它们。
|
||
|
||
本书不会继续深入探究NPM的使用细节。请读者自行参考[http://npmjs.org/](http://npmjs.org/)进一步阅读文档，也可以在该网站中轻松地搜索库。
|
||
|
||
### 20.6 文件系统模块
|
||
|
||
在Node中最常用的内建模块就是“fs”（表示Filesystem，文件系统）模块。该模块提供了处理文件和目录的函数。
|
||
|
||
例如，有个函数名为readFile，该函数读取文件并调用回调函数，并将文件内容传递给回调函数。
|
||
|
||
```js
|
||
var fs = require("fs");
|
||
fs.readFile("file.txt", "utf8", function(error, text) {
|
||
if (error)
|
||
throw error;
|
||
console.log("The file contained:", text);
|
||
});
|
||
```
|
||
|
||
readFile的第二个参数表示字符编码，用于将文件解码成字符串。将文本编码成二进制数据有许多方式，但现代系统中最为普遍的是使用UTF-8编码文本，因此除非有特殊原因确信文件使用了别的编码，否则读取文件时使用“utf-8”是一种较为安全的方式。若你不传递任何编码，Node会认为你需要解析二进制数据，因此会返回一个Buffer对象而非字符串。该对象类似于数组，每个元素是文件中字节对应的数字。
|
||
|
||
```js
|
||
var fs = require("fs");
|
||
fs.readFile("file.txt", function(error, buffer) {
|
||
if (error)
|
||
throw error;
|
||
console.log("The file contained", buffer.length, "bytes.",
|
||
"The first byte is:", buffer[0]);
|
||
});
|
||
```
|
||
|
||
有一个名为writeFile的函数与其类似，用于将文件写到磁盘上。
|
||
|
||
```js
|
||
var fs = require("fs");
|
||
fs.writeFile("graffiti.txt", "Node was here", function(err) {
|
||
if (err)
|
||
console.log("Failed to write file:", err);
|
||
else
|
||
console.log("File written.");
|
||
});
|
||
```
|
||
|
||
这里我们不需要制定编码，因为如果我们调用writeFile时传递的是字符串而非Buffer对象，则writeFile会使用默认编码（即UTF-8）来输出文本。
|
||
|
||
“fs”模块也包含了其他实用函数，其中readdir函数用于将目录中的文件以字符串数组的方式返回，stat函数用于获取文件信息，rename函数用于重命名文件，unlink用于删除文件等。
|
||
|
||
相关细节请参见[http://nodejs.org/](http://nodejs.org/)中的文档。
|
||
|
||
fs模块中的许多函数都有异步与同步的两种变体。例如，函数readFile的同步版本名为readFileSync。
|
||
|
||
```js
|
||
var fs = require("fs");
|
||
console.log(fs.readFileSync("file.txt", "utf8"));
|
||
```
|
||
|
||
使用同步函数较为节省代码，在简单的脚本中非常实用（不需要异步I/O提供的额外速度提升）。但需要注意的是当执行同步操作时，程序会完全停止。若程序需要对用户或网络上的其他机器做出响应，可能因为同步I/O而产生令人厌烦的延迟。
|
||
|
||
### 20.7 HTTP模块
|
||
|
||
另一个主要模块名为"http"。该模块提供了执行HTTP服务和产生HTTP请求的功能。
|
||
|
||
启动一个简单的HTTP服务器只需要以下代码。
|
||
|
||
```js
|
||
var http = require("http");
|
||
var server = http.createServer(function(request, response) {
|
||
response.writeHead(200, {"Content-Type": "text/html"});
|
||
response.write("<h1>Hello!</h1><p>You asked for <code>" +
|
||
request.url + "</code></p>");
|
||
response.end();
|
||
});
|
||
server.listen(8000);
|
||
```
|
||
|
||
若你在自己的机器上执行该脚本，你可以打开网页浏览器，并访问[http://localhost：8000/hello](http://localhost%EF%BC%9A8000/hello)，就会向你的服务器发出一个请求。服务器会响应一个简单的HTML页面。
|
||
|
||
每次客户端尝试连接服务器时，服务器都会调用传递给createServer函数的参数。request和response绑定都是对象，分别表示输入数据和输出数据。request包含请求信息，例如该对象的url属性表示请求的URL。
|
||
|
||
你需要调用response对象的方法以将一些数据发回客户端。第一个函数调用（writeHead）会输出响应头（参见第17章）。你需要向该函数传递状态码（本例中200表示成功）和一个对象，该对象包含头部信息的值。本例中我们告诉客户端我们送回的是HTML文档。
|
||
|
||
接下来使用response.write来发送响应体（文档自身）。若你想一段一段地发送相应信息，可以多次调用该方法，在合适的时候会将数据发送到客户端。最后调用response.end发送相应结束信号。
|
||
|
||
调用server.listen会使服务器在8000端口上开始等待请求。这就是与服务器通信时，需要连接localhost：8000，而不是localhost（这样将会使用默认端口，即80）的原因。
|
||
|
||
这类Node脚本不会自动结束，因为它会永远等待下一个事件（在本例中是网络连接），所以需要按Ctrl-C来停止脚本。
|
||
|
||
一个真实的Web服务器需要做的事情比上面的示例多得多。其差别在于我们需要根据请求的方法（method属性），来判断客户端尝试执行的动作，并根据请求的URL来找出动作处理的资源。本章随后会介绍更高级的服务器。
|
||
|
||
你可以使用http模块的request函数来充当一个HTTP客户端。
|
||
|
||
```js
|
||
var http = require("http");
|
||
var request = http.request({
|
||
hostname: "eloquentjavascript.net",
|
||
path: "/20_node.html",
|
||
method: "GET",
|
||
headers: {Accept: "text/html"}
|
||
}, function(response) {
|
||
console.log("Server responded with status code",
|
||
response.statusCode);
|
||
});
|
||
request.end();
|
||
```
|
||
|
||
request函数的第一个参数是请求配置，告知Node需要访问的服务器、服务器请求地址、使用的方法等信息。第二个参数是响应开始时的回调函数。该回调函数会接受一个参数，用于检查相应信息，例如获取状态码。
|
||
|
||
和在服务器中看到的response对象一样，request返回的对象允许我们使用write方法多次发送数据，并使用end方法结束发送。本例中并没有使用wirte方法，因为GET请求的请求体中无法包含数据。
|
||
|
||
Node提供了名为https的包，用于发送安全的HTTP（HTTPS）请求，其中包含了自己的request函数，与http.request类似。
|
||
|
||
### 20.8 流
|
||
|
||
我们在HTTP中看过两个可写流的例子，即服务器可以向response对象中写入数据，而http.request返回的请求对象也可以写入数据。
|
||
|
||
可写流是Node接口中广泛使用的概念。所有的可写流都有一个write方法，你可以传递字符串或Buffer对象。可写流的end方法用于关闭流，如果给定一个参数，该方法会在关闭流前输出指定的一段数据。这两个方法都可以使用一个回调函数作为额外参数，当写入数据或关闭流完成后，会调用用户指定的回调函数。
|
||
|
||
我们也可以使用fs.createWriteStream建立一个指向本地文件的输出流。你可以调用该方法返回的结果对象的write方法，每次向文件中写入一段数据，而不是像fs.writeFile那样一次性写入所有数据。
|
||
|
||
可读流则略为复杂。传递给HTTP服务器回调函数的request绑定，以及传递给HTTP客户端回调函数的response对象都是可读流（服务器读取请求并写入响应，而客户端则先写入请求，然后读取响应）。读取流需要使用事件处理器，而不是方法。
|
||
|
||
Node中发出的事件都有一个on方法，类似浏览器中的addEventListener方法。该方法接受一个事件名和一个函数，并将函数注册到事件上，接下来每当指定事件发生时，都会调用注册的函数。
|
||
|
||
可读流有data事件和end事件。data事件在每次数据到来时触发，end事件在流结束时触发。该模型适用于“流”数据，这类数据可以立即处理，即使整个文档的数据没有到位。我们可以使用fs.createReadStream函数创建一个可读流，来读取本地文件。
|
||
|
||
下面的代码创建了一个服务器并读取请求体，然后将读取到的数据全部转换成大写，并使用流写回客户端。
|
||
|
||
```js
|
||
var http = require("http");
|
||
http.createServer(function(request, response) {
|
||
response.writeHead(200, {"Content-Type": "text/plain"});
|
||
request.on("data", function(chunk) {
|
||
response.write(chunk.toString().toUpperCase());
|
||
});
|
||
request.on("end", function() {
|
||
response.end();
|
||
});
|
||
}).listen(8000);
|
||
```
|
||
|
||
传递给data处理函数的chunk绑定是一个二进制Buffer对象，我们可以使用toString将其转换成字符串，该方法会使用默认编码（UTF-8）解码二进制数据。
|
||
|
||
下面是另一段代码，当我们执行上面的服务（将字母转换成大写）时，这段代码会向服务器发送一个请求并输出获取到的响应数据：
|
||
|
||
```js
|
||
var http = require("http");
|
||
var request = http.request({
|
||
hostname: "localhost",
|
||
port: 8000,
|
||
method: "POST"
|
||
}, function(response) {
|
||
response.on("data", function(chunk) {
|
||
process.stdout.write(chunk.toString());
|
||
});
|
||
});
|
||
request.end("Hello server");
|
||
```
|
||
|
||
该示例代码向process.stdout（进程的标准输出流，也是一个可写流）中写入数据，而不使用console.log，因为console.log函数会在输出的每段文本后加上额外的换行符，在这里不太合适。
|
||
|
||
### 20.9 简单的文件服务器
|
||
|
||
让我们将新学习的HTTP服务器和文件系统的知识结合起来，并建立起两者之间的桥梁：使用HTTP服务允许客户远程访问文件系统。这个服务有许多用处，它允许网络应用程序存储并共享数据或使得一组人可以共享访问一批文件。
|
||
|
||
当我们将文件当作HTTP资源时，可以将HTTP的GET、PUT和DELETE方法分别看成读取、写入和删除文件。我们将请求中的路径解释成请求指向的文件路径。
|
||
|
||
我们可能不希望共享整个文件系统，因此我们将这些路径解释成以服务器工作路径（即启动服务器的路径）为起点的相对路径。若从/home/marijn/public（或Windows下的C：\Users\marijn\public）启动服务器，那么对/file.txt的请求应该指向/home/marijn/public/file.txt（或C：\Users\marijn\public\file.txt）。
|
||
|
||
我们将一段段地构建程序，使用名为methods的对象来存储处理多种HTTP方法的函数。
|
||
|
||
```js
|
||
var http = require("http"), fs = require("fs");
|
||
|
||
var methods = Object.create(null);
|
||
|
||
http.createServer(function(request, response) {
|
||
function respond(code, body, type) {
|
||
if (!type) type = "text/plain";
|
||
response.writeHead(code, {"Content-Type": type});
|
||
if (body && body.pipe)
|
||
body.pipe(response);
|
||
else
|
||
response.end(body);
|
||
}
|
||
if (request.method in methods)
|
||
methods[request.method](urlToPath(request.url),
|
||
respond, request);
|
||
else
|
||
respond(405, "Method " + request.method +
|
||
" not allowed.");
|
||
}).listen(8000);
|
||
```
|
||
|
||
这样启动服务器之后，服务器永远只会产生405错误响应，该代码表示服务器无法处理特定的方法。
|
||
|
||
函数respond被传递给处理不同方法的函数，作为请求结束时的回调函数。该方法接受三个参数，第一个是状态码，第二个是响应体，第三个是可选的内容类型。若传递的响应体是一个可读流，该对象有一个pipe方法，用于将可读流转发到可写流中。若不是可读流，我们假定它是null（没有响应体）或一个字符串，我们将字符串直接传递给响应的end方法。
|
||
|
||
为了从请求的URL中获取路径，urlToPath函数使用了Node内建的url模块来解析URL。我们取出parse函数返回值中的pathname属性（结果类似于/file.txt），并进行解码，去除%20这类转义代码，并加上一个句号作为前缀，以产生相对于当前目录的路径。
|
||
|
||
```js
|
||
function urlToPath(url) {
|
||
var path = require("url").parse(url).pathname;
|
||
return "." + decodeURIComponent(path);
|
||
}
|
||
```
|
||
|
||
若你担心urlToPath函数的安全性，那么你是正确的。我们将会在习题中回过头来看这个问题。
|
||
|
||
我们来创建GET方法，在读取目录时返回文件列表，在读取普通文件时返回文件内容。
|
||
|
||
一个棘手的问题是我们返回文件内容时添加的Content-Type头应该是什么类型。因为这些文件可以是任何内容，我们的服务器无法简单地对所有文件返回相同的类型。但NPM可以帮助我们完成该任务。mime包（以text/plain这种方式表示的内容类型名为MIME类型）可以获取大量文件扩展名的正确类型。
|
||
|
||
若你在服务器脚本所在目录中执行以下npm命令，你可以使用require（“mime”）来获取库。
|
||
|
||
```
|
||
$ npm install mime@1.4.0
|
||
npm http GET https://registry.npmjs.org/mime
|
||
npm http 304 https://registry.npmjs.org/mime
|
||
mime@1.4.0 node_modules/mime
|
||
```
|
||
|
||
当请求文件不存在时，应该返回的正确HTTP错误代码是404。我们使用fs.stat（查询文件信息）来找出特定文件是否存在以及是否是一个目录。
|
||
|
||
```js
|
||
methods.GET = function(path, respond) {
|
||
fs.stat(path, function(error, stats) {
|
||
if (error && error.code == "ENOENT")
|
||
respond(404, "File not found");
|
||
else if (error)
|
||
respond(500, error.toString());
|
||
else if (stats.isDirectory())
|
||
fs.readdir(path, function(error, files) {
|
||
if (error)
|
||
respond(500, error.toString());
|
||
else
|
||
respond(200, files.join("\n"));
|
||
});
|
||
else
|
||
respond(200, fs.createReadStream(path),
|
||
require("mime").lookup(path));
|
||
});
|
||
};
|
||
```
|
||
|
||
因为fs.stat访问磁盘需要耗费一些时间，因此该函数是异步的。当文件不存在时，fs.stat会传递一个错误对象（包含code属性，值为“ENOENT”）给回调函数。若Node为不同类型的错误定义了不同的Error子类型，那是非常好的，但现在不存在这种类型。
|
||
|
||
我们只能在这里使用晦涩难懂的，源于Unix的错误代码。
|
||
|
||
发生任何无法预料的错误时，我们统一返回状态代码500，表示服务器中存在问题，与以4开头的错误代码（比如404，一般指的是错误请求）相对应。在某些情况下这个错误代码可能不完全准确，但对于小型示例程序而言，这已经足够好了。
|
||
|
||
由fs.stat返回的stats对象告知我们关于文件的一系列信息，比如文件大小（size属性）和修改日期（mtime属性）。这里我们想知道的是该文件是一个目录还是普通文件，isDirectory方法可以告诉我们答案。
|
||
|
||
我们使用fs.readdir来读取目录中的文件列表，并将其返回给用户。对于普通文件，我们使用fs.createReadStream创建一个可读流，并将其传递给respond对象，同时使用mime模块根据文件名获取内容类型并传递给respond。
|
||
|
||
处理DELETE请求的代码就稍显简单了。
|
||
|
||
```js
|
||
methods.DELETE = function(path, respond) {
|
||
fs.stat(path, function(error, stats) {
|
||
if (error && error.code == "ENOENT")
|
||
respond(204);
|
||
else if (error)
|
||
respond(500, error.toString());
|
||
else if (stats.isDirectory())
|
||
fs.rmdir(path, respondErrorOrNothing(respond));
|
||
else
|
||
fs.unlink(path, respondErrorOrNothing(respond));
|
||
});
|
||
};
|
||
```
|
||
|
||
这里删除不存在的文件会返回204状态码，而不是错误，对此读者可能感到疑惑。当删除不存在的文件时，你可以认为我们已经完成了请求的任务。HTTP标准鼓励人们采用幂等的请求，这意味着无论多少次应用请求都不会产生不同结果。
|
||
|
||
```js
|
||
function respondErrorOrNothing(respond) {
|
||
return function(error) {
|
||
if (error)
|
||
respond(500, error.toString());
|
||
else
|
||
respond(204);
|
||
};
|
||
}
|
||
```
|
||
|
||
若HTTP响应不包含任何数据，我们可以用状态码204（无内容）来表示这种情况。因为我们需要提供回调函数来报告错误或在某些不同情况下返回204响应，因此我编写了函数respondErrorOrNothing来创建一个回调函数。
|
||
|
||
下面是PUT请求的处理函数。
|
||
|
||
```js
|
||
methods.PUT = function(path, respond, request) {
|
||
var outStream = fs.createWriteStream(path);
|
||
outStream.on("error", function(error) {
|
||
respond(500, error.toString());
|
||
});
|
||
outStream.on("finish", function() {
|
||
respond(204);
|
||
});
|
||
request.pipe(outStream);
|
||
};
|
||
```
|
||
|
||
这里我们不需要检查文件是否存在，若存在只需覆盖即可。我们再次使用pipe来将可读流中的数据移动到可写流中，在本例中是将请求的数据移动到文件中。若流创建失败，则触发error事件，并在我们的响应中报告错误。当数据成功传输后，pipe会关闭两个流，并触发可写流的finish事件。当该事件发生后我们采用204响应向客户端报告任务成功完成。
|
||
|
||
完整的服务器脚本可以从[http://eloquentjavascript.net/code/file_server.js](http://eloquentjavascript.net/code/file_server.js)获取。读者可以下载该脚本并使用Node启动你自己的文件服务器。当然你可以修改并扩展该脚本，以完成本章的习题或进行实验。
|
||
|
||
命令行工具curl在类Unix系统中得到广泛使用，可用于产生HTTP请求。接下来的会话用于简单测试我们的服务器。这里需要注意，-x用于设置请求方法，-d用于包含请求体。
|
||
|
||
```
|
||
$ curl http://localhost:8000/file.txt
|
||
File not found
|
||
$ curl -X PUT -d hello http://localhost:8000/file.txt
|
||
$ curl http://localhost:8000/file.txt
|
||
hello
|
||
$ curl -X DELETE http://localhost:8000/file.txt
|
||
$ curl http://localhost:8000/file.txt
|
||
File not found
|
||
```
|
||
|
||
由于file.txt一开始不存在，因此第一请求失败。而PUT请求则创建文件，因此我们看到下一个请求可以成功获取该文件。在使用DELETE请求删除该文件后，第三次GET请求再次找不到该文件。
|
||
|
||
### 20.10 错误处理
|
||
|
||
在文件服务器代码中，有6个位置我们显式传递异常，我们不知道如何处理异常。因为异常不会直接传播到回调函数中而是使用参数传递给回调函数，因此我们不得不每次都显式处理这些异常。这完全抵消了异常处理的优势，换言之，我们无法将错误处理集中到一起。
|
||
|
||
当一些代码在系统中抛出一个异常会发生什么？由于我们并未使用任何的try块，因此exception会直接传播到调用栈顶部。在Node中，这会导致程序停止运行并输出异常信息（包括堆栈轨迹）到程序的标准错误流中。
|
||
|
||
这就意味着我们的服务器在服务器代码内遇到任何问题都会崩溃，而相对的，异步问题会通过参数传递给回调函数。若我们想要处理所有在请求处理中引发的异常，为了确保我们可以发送响应，我们需要在每个回调函数中添加try/catch块。
|
||
|
||
这是无法工作的。许多Node程序都尽可能少使用异常，如果没有这种假设，当引发异常时，由于程序无法处理这些异常，正常的结果就是程序崩溃。
|
||
|
||
另一种方法是使用Promise，第17章中已经有过介绍。Promise可以捕捉由回调函数引发的异常，并将其作为错误向外层传播。我们可以在Node中加载promise库，并使用其管理异步控制。几乎没有Node库集成了promise，但包裹这些异常对象太烦琐了。而NPM提供了优秀的promise模块，包含一个名为denodeify的函数，用于将诸如fs.readFile之类的异步函数转换成返回promise的函数。
|
||
|
||
```js
|
||
var Promise = require("promise");
|
||
var fs = require("fs");
|
||
|
||
var readFile = Promise.denodeify(fs.readFile);
|
||
readFile("file.txt", "utf8").then(function(content) {
|
||
console.log("The file contained: " + content);
|
||
}, function(error) {
|
||
console.log("Failed to read file: " + error);
|
||
});
|
||
```
|
||
|
||
为了进行比较，我基于promise编写了另一个版本的文件服务器，该文件服务器可以从[http://eloquentjavascript.net/code/file_server_promises.js](http://eloquentjavascript.net/code/file_server_promises.js)获取。由于现在函数可以直接返回其结果，而不必要调用回调函数，因此代码变得稍微优雅一点，而异常处理路径也变成隐式处理，而非显式处理。
|
||
|
||
这里列举出几行基于promise的文件服务器代码，展示两种程序设计风格的差别。
|
||
|
||
代码中使用的fsp对象使用Promise.denodeify包裹fs中的一系列函数，提供了promise风格的变体。方法处理器返回的对象包含code和body属性，是promise链中的最终结果，我们用其判断应该向客户端发送何种响应。
|
||
|
||
```js
|
||
methods.GET = function(path) {
|
||
return inspectPath(path).then(function(stats) {
|
||
if (!stats) // Does not exist
|
||
return {code: 404, body: "File not found"};
|
||
else if (stats.isDirectory())
|
||
return fsp.readdir(path).then(function(files) {
|
||
return {code: 200, body: files.join("\n")};
|
||
});
|
||
else
|
||
return {code: 200,
|
||
type: require("mime").lookup(path),
|
||
body: fs.createReadStream(path)};
|
||
});
|
||
};
|
||
|
||
function inspectPath(path) {
|
||
return fsp.stat(path).then(null, function(error) {
|
||
if (error.code == "ENOENT") return null;
|
||
else throw error;
|
||
});
|
||
}
|
||
```
|
||
|
||
inspectPath函数是对fs.stat函数的简单包装，用于处理找不到文件的情况。在这种情况下，我们将错误信息替换为成功（null），其他的错误依然继续传播。当这些处理器中返回的promise失败，HTTP服务器会响应500错误状态码。
|
||
|
||
### 20.11 本章小结
|
||
|
||
Node是一种优雅直接的系统，可以让我们在非浏览器环境中执行JavaScript。Node最初的设计意图是完成网络任务，扮演网络中的节点。但同时也能用来执行任何脚本任务，如果你觉得编写JavaScript代码是一件惬意的事情，那么使用Node来自动完成每天的任务是非常不错的。
|
||
|
||
NPM为你所能想到的功能（当然还有相当多你想不到的）提供了库，你可以通过执行简单的命令，获取并安装这些库。Node也附带了许多内建模块，包括fs模块（处理文件系统）、http模块（执行HTTP服务器并生成HTTP请求）。
|
||
|
||
Node中的所有输入输出都是异步的，除非你明确使用函数的同步变体，比如fs.readFileSync。使用者提供回调函数，Node会在适当的时候调用回调函数（比如I/O请求结束时）。
|
||
|
||
### 20.12 习题
|
||
|
||
#### 20.12.1 再次设定内容属性
|
||
|
||
在第17章中，第一个习题是向[http://eloquentjavascript.net/author/](http://eloquentjavascript.net/author/)发送一些请求，通过传递不同的Accept头来请求不同类型的内容。
|
||
|
||
请使用Node的http.request函数再次完成该习题。至少需要请求以下几类媒体类型：text/plain、text/html和application/json。你可以直接给定一个对象表示请求头部，该对象通过http.request的第一个参数的headers属性传递。
|
||
|
||
输出每个请求的响应内容。
|
||
|
||
#### 20.12.2 修复漏洞
|
||
|
||
我非常喜欢在自己的机器上运行本章定义的文件服务器，这样我可以很容易地远程访问某些在/home/marijn/public中的文件。随后的一天，我发现有人获取了我存储在浏览器中的所有密码。
|
||
|
||
发生了什么？
|
||
|
||
你可能还不太清楚，让我们回想一下urlToPath函数，该函数定义如下。
|
||
|
||
```js
|
||
function urlToPath(url) {
|
||
var path = require("url").parse(url).pathname;
|
||
return "." + decodeURIComponent(path);
|
||
}
|
||
```
|
||
|
||
现在思考一下，传递给fs函数的路径可以是个相对路径，包含“../”来访问上级目录。当客户端使用如下所示的URL向服务器发送请求，会发生什么？
|
||
|
||
```
|
||
http://myhostname:8000/../.config/config/google-chrome/Default/Web%20Data
|
||
http://myhostname:8000/../.ssh/id_dsa
|
||
http://myhostname:8000/../../../etc/passwd
|
||
```
|
||
|
||
修改urlToPath来解决该问题。请考虑Node在Windows上的运行情况，而Windows同时允许以斜杠和反斜杠作为目录分隔符。
|
||
|
||
同时也考虑一下，如果你在互联网上执行了没有充分考虑安全问题的系统而别人可以利用系统漏洞在你的机器上做一些危险的事情。
|
||
|
||
#### 20.12.3 创建目录
|
||
|
||
尽管DELETE方法可以删除目录（使用了fs.rmdir），但文件服务器现在没有提供创建目录的方式。
|
||
|
||
为了添加对MKCOL方法的支持，读者可以调用fs.mkdir来创建目录。MKCOL并不是基本的HTTP方法，但其确实存在，且与我们的意图相同。该方法定义在WebDAV标准中，WebDAV制定了一系列的HTTP扩展，以适用于修改资源，而不仅仅是读取资源。
|
||
|
||
#### 20.12.4 网络上的公共空间
|
||
|
||
由于文件服务器提供了任何类型的文件服务，甚至只要包含正确的Content-Type头部，你可以使用其提供网站服务。由于该服务允许每个人删除或替换文件，因此这是一类非常有趣的网站：任何人只要使用正确的HTTP请求，都可以修改、截取并破坏文件。但这仍然是一个网站。
|
||
|
||
请编写一个基础的HTML页面，包含一个简单的JavaScript文件。将该文件放在文件服务器的数据目录下，并在你的浏览器中打开这些文件。
|
||
|
||
接下来，作为进阶练习或是周末作业，将你迄今为止在本书中学习到的内容整合起来，构建一个对用户友好的界面，在网站内部修改网站。
|
||
|
||
使用一个HTML表单（第18章）编辑网站内部资源，运行用户通过第17章中描述的HTTP请求更新服务器软件。
|
||
|
||
刚开始的时候，该页面仅允许用户编辑单个文件，然后进行修改，允许选择想要编辑的文件。向文件服务器发送请求时，若URL是一个目录，服务器会返回该目录下的文件列表，你可以利用该特性实现你的网页。
|
||
|
||
不要直接编辑文件服务器的代码，如果你犯了什么错误，很有可能就破坏了你的代码。相反，将你的代码保存在公共访问目录之外，测试时再将其拷贝到公共目录中。
|
||
|
||
若你可以使用因特网直接连接你的计算机，而且没有防火墙、路由器或其他任何会干涉两台机器之间连接的设备，你可以邀请你的朋友使用你的网站。为了检查一下，你可以访问[http://whatismyip.com/](http://whatismyip.com/)，复制网站显示的IP地址到你浏览器的地址栏中，并在其后添加：8000以选择正确端口。若这样可以访问你的网站，说明网络上的任何人都可以访问你的网站。
|