NodeJS 入门笔记

发表于 更新于 分类于 阅读次数：

上学期曾在 NodeJS 的门槛前匆匆一瞥而不得入，暑假终于有大块的时间一次入门。这篇笔记以 七天学会NodeJS 为主干，辅以廖雪峰 JavaScript 教程中相关内容以及其他渠道的一些知识整理而成。内容主要是脑图，一部分细碎知识点和代码以文字呈现。

在学习 NodeJS 过程中，感觉对软件工程基础课程的融会贯通有了更深的理解。作为 JavaScript 的服务器端环境，NodeJS 操作文件、操作进程等功能和上学期的 Unix 课程有着较高的相通性。可惜我 Unix 没有好好听过。网络操作的内容则和 HTTP 以及 Socket 协议的知识紧密联系，这些大概在大三下学期的计算机网络课程中。到时要督促自己按时到勤认真听课了。

虽然总觉得大学授课的水平参差不齐，课程内容可能重要性也分三六九等，但是回头才发现全面的知识体系对今后学习的帮助，不管哪方面知识都是可以迁移的。说实话 whu iss 的专业课安排还是比较科学的（不过学长说计算机网络有点晚，应该放到大三上学期）。希望自己珍惜在学校的最后一年多的时间，不管是学业还是别的方面，不要留太多遗憾。

更新记录：

  • 17.08.30 根据《深入浅出 Node.js》的笔记，对”NodeJS 应用领域及特点”部分进行文字补充。
  • 17.09.02 根据《深入浅出 Node.js》的笔记，对”模块”部分进行文字补充。

NodeJS 应用领域及特点

Node.js+概念一览.png

设计高性能 Web 服务器的要点：事件驱动、非阻塞 I/O。

Node 从 Ryan Dahl 一开始设想的 Web 服务器，发展成一个强制不共享任何资源的单线程、单进程系统，包含十分适宜网络的库，为构建大型分布式应用程序提供基础设施的网络应用平台。

Node 与浏览器的异同

Chrome 浏览器除了 V8 作为 JavaScript 引擎外，还有一个 WebKit 布局引擎。

Node 的结构和 Chrome 十分相似，都是基于事件驱动的异步架构。浏览器通过事件驱动来服务界面上的交互，Node 通过事件驱动来服务 I/O。

Node 的特点

异步 I/O

事件与回调函数

事件的编程方式具有轻量级、松耦合、只关注事务点等优势，但是在多个异步任务的场景下，各事件之间各自独立，如何协作是一个问题。

单线程

保持了 JS 在浏览器中单线程的特点。在 Node 中，JS 与其余线程无法共享状态。

好处：

  1. 不用在意状态同步问题；
  2. 没有死锁；
  3. 没有线程上下文交换带来的性能开销；

弱点：

  1. 无法利用多核 CPU；
  2. 错误会引起整个应用退出，应用的健壮性值得考验；
  3. 大量计算占用 COU 导致无法继续调用异步 I/O。

浏览器端，Web Workers 能够创建工作线程进行计算。为了不阻塞主线程，工作线程采用消息传递的方式来传递运行结果，使得工作线程不能访问主线程的 UI。

Node 采用同样的思路解决单线程中大计算量的问题：child_process。通过将计算分发到各个子进程，可以将大量计算分解掉，然后再通过进程之间的事件消息传递结果。

子进程的出现，意味着 Node 可以从容应对单线程在健壮性和无法利用多核 CPU 方面的问题。

跨平台

操作系统与 Node 上层模块之间构建了一层平台层架构，即libuv。

Node 的应用场景

I/O 密集型

Node 面向网络且擅长并行 I/O，能够有效组织更多的硬件资源。

I/O 密集的优势在于Node 利用事件循环的处理能力（而非为每一个服务启动一个线程），资源占用极少。

不擅长 CPU 密集型业务？

由于 JavaScript 单线程的原因，如果有长时间运行的计算（比如大循环），将导致 CPU 时间片不能释放，使得后续 I/O 无法发起。适当调整和分解大型运算任务能使运算适时释放，不阻塞 I/O 调用的发起。

与遗留系统和平共处

可以将稳定的旧有系统作为后端接口与中间件，而让 Node 将该数据源作为数据接口，发挥异步并行的优势。

分布式应用

模块

模块.png

使用模块的好处

  1. 大大提高代码的可维护性；
  2. 可以随时引用；
  3. 避免函数名和变量名冲突；

CommonJS 规范

CommonJS 主要是在 Node 服务器端的规范。意义在于将类聚的方法与变量限定在私有的作用域中，使得用户完全不必考虑变量污染。

CommonJS 对模块的定义主要分为模块引用、模块定义、模块标识三个部分：

模块引用

一个模块要引用其他模块暴露的变量，用var foo = require('module_name')就拿到了引用模块的变量。

模块定义

上下文提供了 exports 对象用于导出当前模块的方法或者变量，并且它是唯一的出口。

在模块中，还存在一个 module 对象，代表模块自身，而 exports 是 module 的属性。

一个模块要对外暴露变量（函数也是变量），可以用module.exports = variable;。

模块标识

即传递给require()方法的参数。

模块实现

在 Node 中引入模块，需要经历如下三个步骤：

  1. 路径分析
  2. 文件定位
  3. 编译执行

在 Node 中，模块分为 Node 提供的核心模块和用户编写的文件模块。

核心模块部分在 Node 源代码的编译过程中，编译进了二进制执行文件。在 Node 进程启动时，部分核心模块就直接加载进内存中。因此可以省略文件定位和编译执行两个步骤，且在路径分析中优先判断，加载速度最快。

文件模块在运动时动态加载，需要完整的路径分析、文件定位、编译执行过程，速度比核心模块慢。

优先从缓存加载

模块加载会有缓存，且其根据绝对路径识别。因此同样的模块名放在不同的路径之中多次 require 不会重新加载。

Node 对引入过的模块都会以编译和执行后的对象的形式进行缓存。核心模块和文件模块都采用缓存优先进行二次加载，核心模块的缓存检查先于文件模块。

路径分析和文件定位

模块路径是 Node 在定位文件模块的具体文件时制定的查找策略，具体表现为一个路径组成的数组。

其生成规则为从当前文件目录下的 node_modules 目录开始，沿路径向上逐级递归，直到根目录下的 node_modules 目录。

Node 在当前目录下查找 package.json，通过JSON.parse()解析出包描述对象，从中取出main属性制定的文件名进行定位。

模块编译

  • .js 文件。通过 fs 模块同步读取文件后编译执行。
  • .node 文件。这是用 C/C++ 编写的扩展文件，通过dlopen()方法加载最后编译生成的文件。
  • .json 文件。通过 fs 模块同步读取文件后，用JSON.parse()解析返回结果。
  • 其余扩展名。它们都被当作 .js 文件载入。

每一个编译成功的模块都会将其文件路径作为索引缓存在 Module._cache 对象上，以提高二次引入的性能。

如果要达成 require 引入一个类的效果，请赋值给 module.exports 对象。

前后端共用模块

浏览器端的 JavaScript 需要经历从同一个服务器端分发到多个客户端执行，瓶颈在于带宽；而服务器端 JavaScript 则是相同的代码需要多次执行，瓶颈在于 CPU 和内存等资源。

CommonJS 是同步加载的，在服务器端模块文件一般存放在本地，再加上有缓存，加载速度很快。而在浏览器端就可能导致“假死”，因此浏览器端采用另一种异步加载方式 - AMD（Asynchronous Module Definition，异步模块定义）规范。

1
2
3
4
5
6
7
define(function(){
  var exports = {}
  exports.sayHello = function() {
    alert('Hello from module: ' + module.id)
  }
  return exports
})

可以看到 AMD 的模块定义与 Node 模块相似，不同之处在于 AMD 模块需要用define来明确定义一个模块，而在 Node 实现中是隐式包装的；以及内容需要通过返回的方式实现导出。

想要进一步了解，可参考 Javascript模块化编程（二）：AMD规范 - 阮一峰的网络日志。

深入了解模块原理

Node.js 的“模块”功能利用了 JavaScript 函数式编程的特性，通过闭包实现。

代码的组织和部署

代码的组织和部署.png

包描述文件中的部分属性

  • maintainers。包维护者列表，npm 通过该属性进行权限认证。
  • bin。将包作为命令行工具使用，需配置好 bin 字段，通过npm install package_name -g命令将脚本添加到执行路径中。之后可以在命令行中直接执行。例如："bin": { "express": "./bin/express" }

全局模式安装

-g将一个包安装为全局可用的可执行命令。通过全局模式安装的所有模块包都被安装进了一个统一的目录下，这个目录可以通过如下方式推算出来：

1
path.resolve(process.execPath, '..', '..', 'lib', 'node_modules');

基本模块

基本模块.png

Node.js 内置的常用模块是为了实现基本的服务器功能，底层代码是用 C/C++ 在 Node.js 运行环境中实现。

global

Node.js 环境中唯一的全局变量。

process

代表当前 Node.js 进程。

判断 JavaScript 执行环境

1
2
3
4
5
if(typeof(window) === 'undefined'){
    console.log('node.js');
} else {
    console.log('browser');
}

文件操作

文件操作.png

不同系统下路径的标准化

标准化之后的路径里的斜杠在 Windows 系统下是\，而在 Linux 系统下是/。如果想保证任何系统下都使用/作为路径分隔符的话，需要用.replace(/\\/g, '/')再替换一下标准路径。

遍历目录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// 同步遍历获取某一文件夹下的所有文件，用 callback 处理
function travel(dir, callback){
  fs.readdirSync(dir).forEach((file) => {
    var pathname = path.join(dir, file);

    if(fs.statSync(pathname).isDirectory()){
      travel(pathname, callback)；
    } else {
      callback(pathname);
    }
  })
}

// 异步遍历
function travel(dir, callback, finish){
  fs.readdir(dir, (err, files) => {
    (function next(i){
      if(i < files.length) {
        var pathname = path.join(dir, files[i]);

        fs.stat(pathname, (err, stats) => {
          if(stats.isDirectory()){
            travel(pathname, callback, () => {
              next(i + 1);
            });
          } else {
            callback(pathname, () => {
              next(i + 1);
            })
          }
        });
      } else {
        finish && finish();
      }
    })(0);
  })
}

网络操作

网络操作.png

监听端口的权限问题

在 Linux 系统下，监听 1024 以下端口需要 root 权限。因此，如果想监听 80 或 443 端口的话，需要使用 sudo 命令启动程序。

URL 的完整组成

1
2
3
4
5
6
7
8
9
                           href
 -----------------------------------------------------------------
                            host              path
                      --------------- ----------------------------
 http: // user:pass @ host.com : 8080 /p/a/t/h ?query=string #hash
 -----    ---------   --------   ---- -------- ------------- -----
protocol     auth     hostname   port pathname     search     hash
                                                ------------
                                                   query

网络操作常见问题

  • 问： 为什么通过headers对象访问到的 HTTP 请求头或响应头字段不是驼峰的？

    答： 从规范上讲，HTTP 请求头和响应头字段都应该是驼峰的。但现实中不是每个 HTTP 服务端或客户端程序都严格遵循规范，所以 NodeJS 在处理从别的客户端或服务端收到的头字段时，都统一地转换为了小写字母格式，以便开发者能使用统一的方式来访问头字段，例如headers['content-length']。

  • 问： 为什么http模块创建的 HTTP 服务器返回的响应是chunked传输方式的？

    答： 因为默认情况下，使用.writeHead方法写入响应头后，允许使用.write方法写入任意长度的响应体数据，并使用.end方法结束一个响应。由于响应体数据长度不确定，因此 NodeJS 自动在响应头里添加了Transfer-Encoding: chunked字段，并采用chunked传输方式。但是当响应体数据长度确定时，可使用.writeHead方法在响应头里加上Content-Length字段，这样做之后 NodeJS 就不会自动添加Transfer-Encoding字段和使用chunked传输方式。

  • 问： 为什么使用http模块发起 HTTP 客户端请求时，有时候会发生socket hang up错误？

    答： 发起客户端 HTTP 请求前需要先创建一个客户端。http模块提供了一个全局客户端http.globalAgent，可以让我们使用.request或.get方法时不用手动创建客户端。但是全局客户端默认只允许5个并发 Socket 连接，当某一个时刻 HTTP 客户端请求创建过多，超过这个数字时，就会发生socket hang up错误。解决方法也很简单，通过http.globalAgent.maxSockets属性把这个数字改大些即可。另外，https模块遇到这个问题时也一样通过https.globalAgent.maxSockets属性来处理。

进程操作

进程管理.png

降权

1
2
3
4
5
6
7
8
9
// 降权
http.createServer(callback).listen(80, () => {
  var env = process.env,
      uid = parseInt(env['SUDO_UID'] || process.getuid(), 10);
      gid = parseInt(env['SUDO_GID'] || process.getgid(), 10);

  process.setgid(gid);
  process.setuid(uid);
})

注意点：

  1. 如果是通过sudo获取 root 权限的，运行程序的用户的 UID 和 GID 保存在环境变量SUDO_UID和SUDO_GID里边。如果是通过chmod +s方式获取 root 权限的，运行程序的用户的 UID 和 GID 可直接通过process.getuid和process.getgid方法获取。

  2. process.setuid和process.setgid方法只接受number类型的参数。

  3. 降权时必须先降 GID 再降 UID，否则顺序反过来的话就没权限更改程序的 GID 了。

进程间通讯

如果父子进程都是 NodeJS 进程，就可以通过 IPC（进程间通讯）双向传递数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/* parent.js */
// 在 options.stdio 字段中通过 ipc 开启一条 IPC 通道
var child = child_process.spawn('node', ['child.js'], {
  stdio: [0, 1, 2, 'ipc']
});

child.on('message', (msg) => {
  console.log(msg);
})

// 给子进程发送消息
child.send({ hello: 'hello' });

/* child.js */
process.on('message', (msg) => {
  msg.hello = msg.hello.toUpperCase();
  process.send(msg);
})

数据在传递过程中，会先在发送端使用JSON.stringify方法序列化，再在接收端使用JSON.parse方法反序列化。

守护进程

1
2
3
4
5
6
7
8
9
10
11
12
13
// 守护子进程
/* daemon.js */
function spawn(mainModule){
  var worker = child_process.spawn('node', [mainModule]);

  worker.on('exit', (code) => {
    if(code !== 0){
      spawn(mainModule);
    }
  });
}

spawn('worker.js');

异步编程

异步编程.png

domain 捕获异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
function async(request, callback){
  // Do something
  asyncA(request, (data) => {
    // Do something
    asyncB(request, (data) => {
      // Do something
      asyncC(request, (data) => {
        // Do something
        callback(data);
      })
    })
  })
}

http.createServer((request, response) => {
  var d = domain.create();

  d.on('error', () => {
    response.writeHead(500);
    response.end();
  });

  d.run(() => {
    async(request, (data) => {
      response.writeHead(200);
      response.end(data);
    })
  })
})

陷阱

使用uncaughtException或domain捕获异常，代码执行路径里涉及到了 C/C++ 部分的代码时，如果不能确定是否会导致内存泄漏等问题，最好在处理完异常后重启程序比较妥当。而使用try语句捕获异常时一般捕获到的都是 JS 本身的异常，不用担心上述问题。

结语

NodeJS 的学习其实主要分为三块：

  1. JavaScript 语言本身。要学会借助 ECMAScript 规范 加深自己的理解。
  2. NodeJS 的 API。要熟悉官方 API 文档，主要是熟悉 NodeJS 提供的功能以及知道该查询文档的哪块地方。不推荐死记硬背，因为新版本会更改和弃用部分 API。
  3. 生态圈中的各种三方库。要学习检索、过滤、去其糟粕取其精华，利用但不迷信。

而在 NodeJS 开发时，首先要有一个全局的设计，再再实现的过程中对之间忽略掉的细节进行设计上的改进，为二次迭代做准备。

参考资料

除开文章开头提到的资料，结语部分参考了 当我们学习 Node.js 时，我们在学习什么？。

下一步学习

  1. 《Node.js 包教不包会》 by alsotang
  2. 《深入浅出Node.js》
  3. 自己撸个爬虫