NodeJS基础

Node.js 简称 Node，是一个可以使 JavaScript 运行在服务器端的开发平台。

JavaScript 本是一种 Web 前端语言，Node.js 让 JavaScript 成为服务器端脚本语言。

Node.js 选择 JavaScript 作为实现语言的原因：

• JavaScript满足CommonJS标准，符合事件驱动，用户较多且门槛较低；

• Chrome 的 V8 引擎具有出色的性能。

Node.js 将 V8 引擎封装起来，作为服务器运行平台，以执行 JavasScript 编写的后端脚本程序。

• Node.js 运行时环境包含执行 JavaScript 程序所需的一切条件。该引擎会将 JavaScript 代码转换为更快的机器码。

  

  Figure 1. Node.js与Java运行时环境对比

• Node.js 进一步提升 JavaScript 的能力，使 JavaScript 可以访问文件、读取数据库、访问进程，从而胜任后端任务。

• Node.js 的最大优点是开发人员可以在客户端和服务器端编写 JavaScript，打通了前后端。

• Node.js 发展迅速，目前已成为 JavaScript 服务器端运行平台的事实标准。

• Node.js是跨平台的，能运行在Windows、macOS和Linux平台上。

• Node.js除了自己的标准类库之外，还可使用大量的第三方模块系统来实现代码的分享和重用。

• 与其他后端脚本语言不同的是，Node.js内置了处理网络请求和响应的函数库，也就是自备了HTTP服务器，所以不需要额外部署HTTP服务器。

  

  Figure 2. Node.js与PHP对HTTP请求的处理

• 非阻塞I/O 又称异步式 I/O，是 Node.js 的重要特点。

• 阻塞I/O是指线程在执行过程中遇到I/O操作时，操作系统会撤销该线程的CPU控制权，使其暂停执行，处于等待状态，同时将资源转让给其他线程。

• 非阻塞I/O是指当线程遇到I/O操作时，不会以阻塞方式等待I/O操作完成或数据返回，而只是将I/O请求转发给操作系统，继续执行下一条指令。

• 非阻塞I/O是一种异步方式的I/O，与事件驱动密不可分。

• 事件驱动以事件为中心，Node.js将每一个任务都当成事件来处理。Node.js在执行过程中会维护一个事件队列，需执行的每个任务都会加入事件队列并提供一个包含处理结果的回调函数。

• 在事件驱动模型中，会生成一个事件循环线程来监听事件，不断地检查是否有未处理的事件。

• Node.js 的异步机制是基于事件的，所有磁盘I/O、网络通信、数据库查询事件都以非阻塞的方式请求，返回的结果由事件循环线程来处理。

• Node.js的应用程序是单进程、单线程的，但是通过事件和回调支持并发，性能变得非常高。

• 在阻塞模式下，一个线程只能处理一项任务，要想提高吞吐量必须使用多线程。

• 在非阻塞模式下，线程不会被I/O操作阻塞，该线程所使用的CPU核心利用率永远是100%，I/O操作以事件的方式通知操作系统。

• Node.js在主线程中维护一个事件队列，当接收到请求后，就将该请求作为一个事件放入该队列中，然后继续接收其他请求。

• Node.js内部通过线程池来完成非阻塞I/O操作，Node.js的单线程是指对JavaScript层面的任务处理是单线程的，而Node.js本身是一个多线程平台。

• REST API：REST API是一种前后端分离的应用程序架构。

• 单页Web应用：加载单个HTML页面，并在用户与应用程序交互时动态更新该页面的Web应用程序。

• 统一Web应用的UI层：Node.js是面向服务的架构，其能够更好地实现前后端的依赖分离，可以将所有的关键业务逻辑都封装成REST API，UI层只需要考虑如何用这些API构建具体的应用。

• 准实时系统：如聊天系统、微博系统、博客系统的准实时社交系统，特点是轻量级、高流量，没有复杂的计算逻辑。

• 游戏服务器：程序员不必使用C语言就能开发游戏的服务器程序。

• 微服务架构：Node.js也可用于实现基于微服务架构的应用。

• 数据加密和解密。

• 数据压缩和解压。

• 模板渲染。

下载可执行文件 .msi 双击安装: https://nodejs.org/dist/v18.13.0/node-v18.13.0.pkg

• Installing Node.js via binary archive: https://github.com/nodejs/help/wiki/Installation#how-to-install-nodejs-via-binary-archive-on-linux

• Installing Node.js via package manager: https://nodejs.org/en/download/package-manager/#debian-and-ubuntu-based-linux-distributions

  ubuntu system

  $ sudo apt install nodejs
  $ sudo apt install nodejs:i386  # 老计算机
  $ node -v
  $ sudo apt install npm
  $ npm -v

nvm 支持全平台的 Node 版本管理 https://github.com/nvm-sh/nvm

Windows system: https://github.com/coreybutler/nvm-windows

REPL: Read Eval Print Loop

• 功能——JavaScript脚本的简单调试

• 主要执行的操作

  • 读取用户输入，解析输入的JavaScript数据结构并将其存储在内存中。

  • 执行输入的数据结构，打印（输出）结果。

  • 循环操作以上步骤直到用户按下两次<Ctrl>+<C>组合键。

• 进入命令行界面，执行 node 命令即可启动Node终端，出现“>”提示符表示进入REPL命令行交互界面。

  举例输入 2 * 6

Download Visual Studio Code: https://code.visualstudio.com/download

#clean src/ch01/helloworld.js

const http = require('http');  // (1)
const httpServer = http.createServer(function (req, res) {  // (2)
  res.writeHead(200, {'Content-Type': 'text/plain'});  // (3)
  res.end("Hello World!\n");  // (4)
});
httpServer.listen(8080, function () {  // (5)
  console.log("服务器正在8080端口上监听!");  // (6)
});

测试程序

1. 使用 node 命令运行程序

   $ node xxx.js

   • 运行当前目录下的 index.js 脚本文件，可以使用点号代替

     $ node .

   • 选项-e（--eval）表示直接执行某语句：

1. 使用 npm 命令运行程序

   这需要依赖当前目录下的配置文件 package.json。package.json 是 CommonJS 规定的用于描述包的文件。例如，当前目录下的 package.json 包含如下内容:

   {
     "scripts":{
       "start": "node demo.js",
       "test": "node test.js"
     }
   }

   其中 scripts 属性定义要执行的脚本

   • 在当前目录下执行npm start命令就相当于执行node demo.js 命令;

   • 执行 npm test 命令就相当于执行 node test.js命令。

     这种方式可以为不同的环境(如测试、生产)指定不同的 Node.js 程序。

2. 使用 nodemon 监视文件改动并自动重启程序

   $ npm i nodemon -g
   $ nodemon xxx.js

3. 在 Visual Studio Code 中运行程序

   在 vscode 中打开一个终端窗口，运行命令

   $ node xxx.js

#clean src/ch01/package.json

1. 使用日志工具进行调试

   • 使用console.log()方法检查变量或字符串的值，记录脚本调用的函数，或记录来自第三方服务的响应。

   • 使用console.warn()或console.error()方法记录警告或错误信息。

2. 使用 Node.js 内置调试器

   Node.js内置一个进程外的调试实用程序，可通过V8检查器和内置调试客户端访问。

   1. 调试之前先将 debudder; 语句插入到脚本的源代码，以在代码中的该位置启用断点。

      global.x = 5;
      setTimeout(() => {   //此处用到的回调函数的形式是箭头函数，() =>相当于function()
        debugger;  // (1)
        console.log('world');
      }, 1000);
      console.log('hello');

      1. 插入 debugger 语句

   2. 执行 node 命令时加上 inspect 参数，指定要调试的脚本的路径。

      $ node inspect debugdemo.js
      调试操作如下：

      < Debugger listening on ws://127.0.0.1:9229/bf92c68e-26b6-44cb-bc75-f5f812fb4c0b
      < For help, see: https://nodejs.org/en/docs/inspector
      <
      < Debugger attached.
      <
       ok
      Break on start in debugdemo.js:1
      > 1 global.x = 5;
        2 setTimeout(() => {   //此处用到的回调函数的形式是箭头函数，() =>相当于function()
        3   debugger;
      debug> cont // (1)
      < hello
      <
      break in debugdemo.js:3
        1 global.x = 5;
        2 setTimeout(() => {   //此处用到的回调函数的形式是箭头函数，() =>相当于function()
      > 3   debugger;
        4   console.log('world');
        5 }, 1000);
      debug> next  // (2)
      break in debugdemo.js:4
        2 setTimeout(() => {   //此处用到的回调函数的形式是箭头函数，() =>相当于function()
        3   debugger;
      > 4   console.log('world');
        5 }, 1000);
        6 console.log('hello');
      debug> repl  // (3)
      Press Ctrl+C to leave debug repl
      > x
      5
      > .exit

      1. cont 继续执行

      2. next 下一步

      3. repl 交互模式

      4. exit 退出调试

      Note	其中代码行号前面的 > 符号表示程序暂停的位置。

3. 在 Visual Studio Code 中调试

   

   Figure 4. 执行调试
   

   Figure 5. 调试界面

#clean src/ch01/debugdemo.js

global.x = 5;
setTimeout(() => {   //此处用到的回调函数的形式是箭头函数，() =>相当于function()
  debugger;
  console.log('world');
}, 1000);
console.log('hello');

ES6 是目前的主流版本, Node.js 自 6.0 版本开始全面支持 ES6。目前的 Node.js 版本对 ES6 标准的支持率达 99%。可以使用 es-checker 包来检测当前 Node.js 版本对 ES6 的支持情况。

Node 的新版本也在逐渐提供对 ES 新标准的支持,尽管有的是部分支持。这里主要以 ES6 版本为例 JavaScript 语法。Node.js 对 ES 标准的支持得益于 V8 引擎，V8 引擎在发展的过程中一直紧追 ECMAScript 发布的脚步，使 Node,js 能及时采用 ECMAScript 的最新语法。

Node.js自7.6版本于开始就默认支持 async/await 异步编程。

• 方式一：Node.js REPL交互式运行环境

  $ node

  Welcome to Node.js v17.9.0.
  Type ".help" for more information.
  > .help
  .break    Sometimes you get stuck, this gets you out
  .clear    Alias for .break
  .editor   Enter editor mode
  .exit     Exit the REPL
  .help     Print this help message
  .load     Load JS from a file into the REPL session
  .save     Save all evaluated commands in this REPL session to a file
  
  Press Ctrl+C to abort current expression, Ctrl+D to exit the REPL
  >

• 方式二：浏览器控制台

  打开浏览器 Ctrl + Shift + c 可快捷进入开发模式， 再点击 Console 标签

JavaScript 语法的基本规则与 Java 语言类似，严格区分大小写。JavaScript 是解释型语言,程序(脚本)由 JavaScript 引擎解释执行。

1. 语句

   • JavaScript每条语句都以分号“;”结束。（非强制但推荐）

   • 一行代码可包含多条语句。（不推荐）

   • 一行语句太长，则可以使用续行符“\”进行换行。

2. 语句块

   • 语句块是一组语句的集合，作为一个整体使用大括号“{}”封装。

   • 语句块可以嵌套，形成层级结构。

3. 注释

   行注释

   // 我是单独一行注释
   console.log("Hello World!"); // 我是行注释
   块注释

   /* 块注释开始
      块注释结束 */

1. 变量命名

   • JavaScript 的变量可以是任意数据类型。

   • 变量名可以是大小写英文字母、数字、符号“$”或“_”的任意组合，但不能以数字开头。

   • 变量名不能是 javascript 的关键字（如 for、if、while）等。

2. 变量的声明与赋值

   • 弱类型的编程语言，所有数据类型都可以用 var 关键字声明。在定义变量时无须指定变量类型。

     var hello; // 声明一个名为hello的变量，此时该变量的值为undefined，表示未定义

   • 使用等号对变量进行赋值，可以将任意数据类型赋值给变量。

     hello='我是个字符串'; // 此时变量的值为“我是个字符串”

   • 可以在声明变量的同时对变量进行赋值。

   • 可以反复赋值同一个变量。

3. 变量提升

   • 变量可以在声明之前使用，值为 undefined

• ES6 用 let 关键字改变这种行为，变量一定要在声明之后使用，否则会报错。

1. 变量泄露

   • 用来计数的循环变量使用 var 关键字声明后会泄露为全局变量。

• 改用let关键字来声明循环变量避免变量泄露。

  1. 全局作用域和函数作用域

• ES5中只有全局作用域（顶层作用域）和函数作用域。

1. 块级作用域与let关键字

   • ES6引入块级作用域，使用let关键字声明的变量只能在当前块级作用域中使用。

1. 使用const关键字声明只读常量

   const PI = 3.1415;

数值 Number

字符串 String

布尔值 Boolean

数组 Array

对象 Object

let numproperty = 'num';
var myObj = {
  isobj: true,
  [numproperty]: [1,2,3],
  ['des'+'cription']: '我是个对象'
};
myObj[numproperty];    // [1,2,3]
myObj['num'];          // [1,2,3]
myObj['description'];  // "我是个对象"

符号 Symbol

let welcome = Symbol();  // 自动产生一个值
let myObj = {};
myObj[welcome] = '欢迎光临';  // (1)
let myObj = { [welcome]: '欢迎光临' };  // (2)
let myObj = {};
Object.defineProperty(myObj, welcome, { value: '欢迎光临' });  // (3)

映射 Map

const myMap = new Map([
  ['name',  "王刚"],
  ['title', "博士"]
]);
myMap.get("name");   // 返回“王刚”
myMap.get("title");  // 返回“博士”

集合 Set

map.forEach(function (value, key, map) ...};

set.forEach(function (element, sameElement, set) ..}

JavaScript 默认情况下按顺序执行每一条语句， 直到脚本文件结束，一条路走到底， 也就是线性地执行语句列，这是最基本的顺序结构。

JavaScript 还提供分支结构和循环结构以进行流程控制

• 分支结构好比有多条岔路可以选择;

• 循环结构类似于一段路来来回回地反复走。

分支结构

循环结构

函数可以将一个复杂功能划分成若干模块，让程序结构更加清晰，代码重复利用率更高。

函数声明

函数调用及参数

匿名函数

var sumAge = function (x,y) {
  return  x + y;
};

箭头函数

var f = x => x;

var f = function (x) {
  return x;
};

var sumAge = (x, y) => x + y;

var sumAge = function (x,y) {
  return  x + y;
};

var f = () => 20;

var f = function () { return 20 };

var diffAge = (x, y) => {
  var diff = x - y;
  return Math.abs(diff);
}

var diffAge = function (x,y) {
    var diff = x - y;
    return Math.abs(diff);
}

高阶函数

function diffAge(m, n, abs) {
  return abs(m-n);
}
diffAge(19, 22, Math.abs);  // 相差 3 岁

var arr = [100, 120, -10, 2];
arr.sort(function (m, n) {
  if (m < n) {
    return -1;
  }
  if (m > n) {
    return 1;
  }
  return 0;
});  // [ -10, 2, 100, 120 ]

闭包

var basePrice = 10.00;       // 起步价
var baseMiles = 3.00;        // 起步里程

function taxiPrice(unitPrice, mileAge) {
  function totalPrice() {   //计算总费用 ；这是定义在一个函数内部的函数
    if ( mileAge > baseMiles) {   //超过起步里程
      return  unitPrice * mileAge;  //单价与里程相乘
    }
    else{                    //在起步里程内
      return basePrice;
    }
  }
  return totalPrice();
}
taxiPrice(2.00, 6.00);  // 打车费用12.00

ES6 的写法更像面向对象编程的语法。

1. 定义一个类 Visitor

2. constructor 是构造方法

3. this 代表实例对象本身

4. 定义方法时前面不用加 function 关键字

5. 实例化对象时直接使用 new，跟构造函数的用法完全一致

• 在大多数 ES5 实现中，每一个对象都有 __proto__ 属性，指向对应的构造函数的 prototype 属性

• 而类同时有 prototype 属性和 __proto__ 属性，因此同时存在两条继承链:子类的 __proto__ 属性表示构造函数的继承，总是指向父类;子类 prototype 属性的 __proto__ 属性，表示方法的继承，总是指向父类的 prototype 属性。

ES6 类可以通过 exends 关键字实现继承，这比 ES5 通过修改原型链实现继承更清晰和方便。

类相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前加上 static 关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就是静态方法。父类的静态方法,可以被子类继承。

早期的 JavaScript 并不强制要求声明变量，如果一个变量没有声明就被使用, 那么该变量就自动被作为全局变量，这会导致在同一网页的不同 JavaScript 文件中如果使用相同的变量名，可能造成变量之间的冲突，产生错误结果。而使用 var 关键字的变量就不是全局变量，其作用域被限制在声明该变量的函数体内。这样不同的函数体内同名变量不会产生冲突。ECMA 从 ES5 版本开始增加严格模式(Strict Mode)，要求指定代码在严格条件下执行，强制要求变置在声明之后使用，不能使用未声明的变量。

1. 使用严格模式

   严格模式通过在脚本或函数的头部添加以下语句来声明。

   'use strict';

   • 在文件第 1 行使用这个声明，表示整个脚本文件都执行严格模式;

   • 在函数第 1 行使用该声明，这个函数内部使用严格模式。

     Note

     严格模式声明语句只是一个字符串, 不支持严格模式的 JavaScript 引擎会将它作为一个字符串语句执行，而支持严格模式的 js 引擎将开启严格模式来运行 js 代码。 严格模式消除代码运行的一些不安全之处以保证代码的安全运行，提高编译器效率以提高运行速度。 严格模式禁用了一些可能在未来版本中定义的语法，从而体现了 JavaScript 向更合理、更安全、 更严谨的方向发展。 浏览器 Intenet Explorer 10+、Firefox4+、. Chrome 13+、Safari5.1+ 和 Opera12+ 都支持严格模式。 ES6的模块自动采用严格模式，无论是否声明都会使用严格模式。 在Node.js中，建议在所有脚本文件中加入严格模式声明，也可以给 node 命令加上选项 --use_ strict 来默认启用严格模式。

2. 严格模式的主要限制

   • 变量必须声明后使用。

   • 不能出现两个命名参数同名的情况，否则报错。

   • 不能使用with语句。

   • 不能对只读属性赋值，否则报错。

   • 不能使用前缀0表示八进制数，否则报错。

   • 不能删除不可删除的属性，否则报错。

   • 不能删除变量，只能删除属性。

   • eval关键字不会在它的外层作用域引入变量。

   • eval和arguments不能被重新赋值。

   • 不能使用 arguments.callee 和 arguments.caller 属性。

   • 禁止this关键字指向全局对象。

   • 不能使用 fn.caller 和 fn.arguments 属性获取函数调用的堆栈。

   • 增加了保留字（如 protected、static 和 interface）。

1. 代码格式

   • 每行代码应小于 80个字符。如果代码较长，应尽量换行。

   • 使用UNIX风格的换行，每行以软回车“\n” 结束，不使用Windows的硬回车"nr" 换行符。通过Git工具提交代码时Git会自动将换行符转换为UNIX风格。

   • 行末无空白。

   • 每条JavaScript语句应该以分号结束。

   • 缩进使用2个半角空格或4个半角空格，而不使用Tab键。

   • 每行仅声明一个变量，而不要声明多个变量。

   • 字符串尽量使用单引号。

   • 符号“{”应在行末，表示代码块的开始，符号“}”应在行首，表示代码块的结束。

   • 适当的空白行可以大大提高代码的可阅读性，可以使代码逻辑更清晰易懂。

2. 命名规范

   • 变量推荐使用小驼峰命名法。

   • 常量名建议全部大写。

   • 函数也采用小驼峰命名法，建议前缀部分为动词。

   • 类和构造函数采用大驼峰命名法，同时建议前缀部分为名词。

   • 文件命名尽量采用下划线分割单词。

   • 类的公共属性和方法与上述变量和函数的命名方法一样。类的私有属性和方法建议前缀为下划线。

   • 文件命名时尽量采用下划线分割单词。

3. 函数

   • 函数的实现代码尽可能短小精悍，便于阅读。

   • 避免多余的else语句，尽早执行retum语句。

   • 尽可能为闭包命名，便于调试跟踪。

   • 不要嵌套闭包。

   • 使用方法链时，每行仅调用一个方法，并使用缩进表明方法的并列关系。

4. 注释

   • 注释要尽量简单、清晰明了，同时注重注释的意义。

   • 尽可能从更高层次说明代码的功能。

   • 尽可能使用英文注释。 当然书写中文注释也是无可厚非的。

回调函数是作为另外一个函数(主函数)的参数传递给该主函数,然后在该主函数体的某个位置执行的函数，这就涉及在一个函数中调用另外个函数。

1. 主函数，参数列表中的 callback 是一个回调函数

2. 调用回调函数

3. 回调函数

4. 执行主函数

使用 Node.js 程序读取文件有两种方式。

• 一种是同步操作，只有读取操作结束之后才能进行后面的命令，这种方式称为阻塞。

• 另一种是异步方式，可以一边读取文件，一边执行其他命令，这种方式又称为非阻塞。

非阻塞方式基于回调函数，允许并行执行操作，操作结果会在事件发生时由回调函数处理，因此程序无须等待某个操作的结果就能继续下一步操作。这就大大提高了 Node.js 的性能，使其可以处理大量的并发请求。

Node.js 异步方式读取文件的方法如下:

• 其中参数 file 是文件路径名或文件描述符;

• 参数 options 可以用来指定字符编码;

• callback 是个回调函数，它有 err 和 data 两个参数，err 返回错误信息，data 返回读取的文件内容。

下面以一个异步读取文件内容的例子来说明回调函数的使用。

• 首先在当前目录下准备一个名为 demo.txt 的文本文件(以UTF-8编码格式保存)。

• 然后新建一个名为 test_callback.js 的文件，并以 UTF-8 编码格式保存。

• 运行文件 node test_callback.js

  Node程序已经执行结束!
  周董好久没有发新歌了，左盼右盼，终于等来了《说好不哭》

#clean src/ch02/demo.txt

#clean src/ch02/test_callback.js

const fs = require("fs");  // (1)

fs.readFile('demo.txt', function (err, data) {  // (2)
    if (err) return console.error(err);  // (3)
    console.log(data.toString());   // (4)
});
console.log("Node程序已经执行结束!");  // (5)

在事件驱动模型中，会生成一个主循环(事件循环)来监听事件。Node.js 中几乎所有事件机制都是使用观察员模式实现的。Node.js 单线程类似进入一个 while(true) 循环结构的事件循环，注册到每个异步事件上的回调函数相当于个观察员，如果观察员观察到事件发生就调用该回调函数，直到没有事件时观察员退出循环。

以 Web 应用程序为例，当 Web 服务接收到请求时，就将请求交给操作系统内核处理，然后去服务下一个 Web 请求。当一个请求完成时，其结果被放回处理队列，当该结果到达队列开头时，它就被返回给用户。这个模型非常高效，可扩展性强，因为 Web 服务一直接受请求而不用等待任何读写操作。

事件循环尽可能地将相应的操作转给操作系统内核处理，从而让单线程的 JavaScript 程序支持非阻塞 I/O 操作。目前主流的内核都是多线程的，它们可以同时在后台执行多个操作。当其中的某个操作完成时，内核就会通知 Node.js 将与其相关的回调函数添加到轮询队列中并最终得到执行。

Node.js 启动后，它会初始化事件循环，处理提供的输入脚本，该脚本可以进行异步 API 调用、定 时器，或者调用 process.nextTick() 方法，然后开始处理事件循环。下图展示了事件循环的操作顺序，其中每个方框代表事件循环的一个阶段，共有 6 个阶段。

事件循环的每个阶段都会维持一个先进先出的可执行回调函数的队列。这个队列类似于买票排队，排在前面的人买完票就从队列中退出来了。通常情况下当事件循环进入某个阶段时，它将执行这个阶段特有的任何操作，然后执行该阶段的队列中的回调，直到队列结束，或者回调数达到最大限制。当该队列结束或达到回调限制，事件循环将移动到下一阶段继续处理，循环往复。

由于事件循环中任一操作都可能调度更多的操作，并且在轮询阶段处理的新事件会加入内核的队列，轮询事件被处理时会有新的轮询事件加入。这样，处理时间较长的回调任务会导致轮询阶段的时间超过了定时器的阈值。事件循环的各个阶段说明如下。

1. 定时器(timers)：定时器的用途是让指定的回调函数在某个阈值后会被执行。定时器的回调会在指定的时间后尽快得到执行，然而，操作系统的调度或者其他回调的执行可能会延迟该回调的执行。本阶段执行 setTimeout() 和 setInterval() 方法调度的回调函数。

2. 待定回调(pending callbacks)：执行已被延迟到下一个循环迭代的 I/O 回调函数。

3. 空闲和准备(idle, prepare)：仅在系统内部使用。

4. 轮询(poll)：轮询阶段有两个主要功能，一是执行已到时间的定时器脚本，二是处理轮询队列中的事件。一旦轮询队列空闲，事件循环会查找已到时间的定时器。如果找到，事件循环就回到定时器阶段执行回调。Node.js 将在此阶段根据实际情况进行阻塞操作。

5. 检查(check)：这个阶段允许回调函数在轮询阶段完成后立即被执行。如果轮询阶段空闲，并且存在已经被 setImmediate() 方法加入队列的回调函数，事件循环会进入检测阶段而不是在轮询阶段等待。

6. 关闭回调(close callbacks)：执行一些关闭的回调函数，如 socket.on('close',…​)。例如，一个 Socket (套接字)忽然关闭，close 事件将会在此阶段触发。否则这类事件会通过 process.nextTick() 方法触发。

在事件循环执行过程中，Nodejs 检查循环是否有需要等待的非阻塞 I/O 或定时器，如果没有则彻底结束事件循环。

Node.js 不是在各个线程中为每个请求执行所有的任务，而是把任务添加到事件队列中，然后由一个单独的线程运行一个事件循环，将任务从事件队列中提取出来。事件循环获取事件队列中头部的任务，执行该任务，再找到下一个任务。当执行到长期运行或有阻塞 I/O 的代码时，它不是直接调用函数，而是将函数与一个要在此函数完成后执行的回调函数一起添加到事件队列中。当 Node.js 事件队列中的所有事件都被完成时，Node.js 应用程序终止。阻塞 I/O 停止当前线程的执行并等待响应，直到收到响应线程执行才能继续。Node.js 使用事件回调来避免对阻塞 I/O 的等待。事件回调的关键就是事件轮询。

在 Node.js 中，异步的 I/O 操作在完成时都会发送一个事件到事件从列中。Node.js 中的许多对象也会分发事件，如 net.Server 对象会在毎次有新的连接时分发一个事件，fs.readStream 对象会在文件被打开时分发一个事件。这些产生事件的对象都是 event.EventEmitter 类的实例。

events 模块是 Node.js 的核心，Node.js 中大部分的模块都继承自 events 模块，events 模块只提供了一个EventEmitter 对象。EventEmitter 本质上是观察者模式的实现，这种模式定义了对象间的一种一对多的关系，让多个观察者同时监听某一个对象，当一个对象发生改变时，所有依赖于它的对象都将得到通知。Node.js 大多数情况下不会直接使用 EventEmitter 对象，而是在对象中继承它。只要是支持事件响应的 Node.js 核心模块(如fs、net、 http)，都是 EventEmitter 类的子类。

事件的监听与触发实例

const EventEmitter = require('events');  // (1)
const myEmitter = new EventEmitter.EventEmitter();  // (2)
myEmitter.on('seen', () => {  // (3)(5)
  console.log('报告，有人来了');
});
myEmitter.emit('seen');  // (4)

报告，有人来了

为一个事件注册多个监听器

const EventEmitter = require('events').EventEmitter;  // (1)
var event = new EventEmitter();   // (2)

event.on('seen', function(who) {  // (3)
    console.log('报告，来人是一位', who);
});
event.on('seen', function() {  // (4)
    console.log('欢迎光临！');
});
event.emit('seen', '女士');  // (5)

报告，来人是一位 女士
欢迎光临！

处理 error 事件

const events = require("events");
const emitter = new events.EventEmitter();
emitter.emit("error") ;

__filename 指向当前正在执行的脚本文件名。

__dirname 指向当前运行的脚本所在的目录。

console 模块提供了一个简单的调试控制台，类似于 Web 浏览器提供的 JavaScript 控制台。该模块导出两个特定的组件：

• 全局 console 实例

• Console 类

全局 console 实例

console.log('hello world');          // 打印hello world到标准输出流
console.log('hello %s', 'world');    // 打印hello world到标准输出流

console.error(new Error('错误信息')); // 打印 [Error: 错误信息] 到标准错误流

const name = 'Robert';
console.warn(`Danger ${name}! Danger!`);  // 打印 Danger Robert! Danger!到标准错误流

> node nodejs/src/ch02/console.js
hello world
hello world
Error: 错误信息
    at Object.<anonymous> (/Users/swot/learning/nodejs/src/ch02/console.js:6:15)
    at Module._compile (node:internal/modules/cjs/loader:1099:14)
    at Object.Module._extensions..js (node:internal/modules/cjs/loader:1153:10)
    at Module.load (node:internal/modules/cjs/loader:975:32)
    at Function.Module._load (node:internal/modules/cjs/loader:822:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
    at node:internal/main/run_main_module:17:47
Danger Robert! Danger!

Console 类

const { Console } = require('console');
// 或者
const { Console } = console;

new Console(process.stdout, process.stderr);

// 下面 4 行代码还没学，先不用管
var fs = require("fs");
const { Console } = require('console');
const output = fs.createWriteStream('./stdout.log');
const errorOutput = fs.createWriteStream('./stderr.log');

const logger = new Console(output, errorOutput);  // (1)

// 像 console 一样使用 logger
const count = 5;
logger.log('count: %d', count);  // (2)
logger.error(new Error("错误信息"));  // (3)
const name = "Swot";
logger.warn(`Danger ${name}! Danger!`)  // (4)

count: 5

Error: 错误信息
    at Object.<anonymous> (/Users/swot/learning/nodejs/src/ch02/Console_class.js:13:14)
    at Module._compile (node:internal/modules/cjs/loader:1099:14)
    at Object.Module._extensions..js (node:internal/modules/cjs/loader:1153:10)
    at Module.load (node:internal/modules/cjs/loader:975:32)
    at Function.Module._load (node:internal/modules/cjs/loader:822:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
    at node:internal/main/run_main_module:17:47
Danger Swot! Danger!

process 对象是一个全局变量，其提供有关当前 Node.js 进程的信息井对其进行控制。作为一个全局变量，它始终可供 Node.Js 应用程序使用，无须加载 process 模块。它通常用于编写本地命令行程序。

进程事件

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

程序开始执行
程序执行结束
退出码为: 0

退出状态码

process 对象的属性

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);  // 平台信息

Hello World!
0: /usr/local/Cellar/nvm/0.39.0/versions/node/v17.9.0/bin/node
1: /Users/swot/learning/nodejs/src/ch02/process_attr.js
/usr/local/Cellar/nvm/0.39.0/versions/node/v17.9.0/bin/node
darwin

Hello World!
0: /usr/local/Cellar/nvm/0.39.0/versions/node/v17.9.0/bin/node
1: /Users/swot/learning/nodejs/src/ch02/process_attr.js
2: a
3: b
4: c
/usr/local/Cellar/nvm/0.39.0/versions/node/v17.9.0/bin/node
darwin

process 对象的方法

console.log('当前目录: ' + process.cwd());  // 输出当前目录

console.log('当前版本: ' + process.version);  // 输出当前版本

console.log(process.memoryUsage());  // 输出内存使用情况

当前目录: /Users/swot/learning/nodejs/src/ch02
当前版本: v17.9.0
{
  rss: 25812992,
  heapTotal: 5283840,
  heapUsed: 4542016,
  external: 459236,
  arrayBuffers: 11166
}

Node.js 中的定时器在一段时间后会调用给定的函数。何时调用定时器函数取决于用来创建定时器的方法及 Node.js 事件循环正在执行的其他工作。

基本用法 setTimeout(callback, delay[, …​args])

例如，下面的代码将在 1 秒后输出提示信息，之后定时器就不再起作用。

基本用法 setInterval(callback, delay[, …​args])

例如，下面的代码将在 1 秒之后输出提示信息，之后定时器每隔 1 秒就重复输出提示信息，除非使用 clearlnterval() 方法取消该定时器或者终止程序。

基本用法 setImmediate(callback[, …​args])

1. 出现这种情况的原因是：setImmediate 将其中的函数作为宏任务，放到 C++ 一个线程中去执行，然后将其放入任务队列中。所以不会影响主线程的执行。

分别用 clearTimeout()、clearInterval() 和 clearImmediate() 方法取消相应定时器，防止该定时器触发。

Node.js 内置两个有关定时器的类 Timeout 和 Immediate，可用于创建相应的对象。

• Timeout 对象在内部创建，并由 setTimeout() 或 setInterval() 方法返回，可以传递给 clearTimeout() 或 clearInterval() 以取消定时器。

• Immediate 对象也在内部创建，并由 setImmediate() 方法返回。它可以传递给 clearImmediate() 以取消即时定时器。

setImmediate() 和 setTimeout() 类似，但由于它们的调用时机不同，所以行为也不相同。

• setlmmediate() 在当前轮询阶段完成后执行脚本

• setTimeout() 在指定周期的最小阈值后调度脚本运行

#clean src/ch02/timeout_vs_immediate0.js

console.log('outer');

// EventLoop: timers
setTimeout(() => {  // (1)(7)
  setTimeout(() => {  // (2)
    console.log('setTimeout');
  }, 0);
  setImmediate(() => {  // (3)
    console.log('setImmediate');
  });
}, 0);  // (4)
// EventLoop: pending callbacks
// EventLoop: idle, prepare
// EventLoop: poll
// EventLoop: check   (5)
// EventLoop: close callbacks (6)

outer
setImmediate
setTimeout

#clean src/ch02/timeout_vs_immediate1.js

console.log("outer");  // (1)

setTimeout(() => {
  console.log('setTimeout');
}, 0);  // (2)

setImmediate(() => {  // (3)
  console.log('setImmediate');
});
// (4)

outer
setTimeout
setImmediate

outer
setImmediate
setTimeout

#clean src/ch02/timeout_vs_immediate2.js

var fs = require('fs')

// EventLoop: timers
// EventLoop: pending callbacks
// EventLoop: idle, prepare
// EventLoop: poll
fs.readFile(__filename, () => {  // (1)
  setTimeout(() => {  // (2)
    console.log('setTimeout');
  }, 0);
  setImmediate(() => {  // (3)
    console.log('setImmediate');
  });
});
// EventLoop: check
// EventLoop: close callbacks

setImmediate
setTimeout

process.nextTick() 是一个特殊的异步 API，他不属于任何的 Event Loop 阶段。事实上 Node 在遇到这个 API 时，Event Loop 根本就不会继续进行，会马上停下来执行 process.nextTick()，这个执行完后才会继续 Event Loop。我们写个例子来看下：

#clean src/ch02/nextTick_vs_setImmediate.js

var fs = require('fs')

// EventLoop: timers
// EventLoop: pending callbacks
// EventLoop: idle, prepare
// EventLoop: poll
fs.readFile(__filename, () => {  // (1)
  setTimeout(() => {  // (2)
    console.log('setTimeout');  // (7)
  }, 0);
  setImmediate(() => {  // (3)
    console.log('setImmediate');  // (5)
    process.nextTick(() => {
      console.log('nextTick 2');  // (6)
    });
  });
  process.nextTick(() => {  // (4)
    console.log('nextTick 1');
  });
// EventLoop: check
// EventLoop: close callbacks
});

nextTick 1
setImmediate
nextTick 2
setTimeout

• 可以将Buffer视为一种用来处理二进制数据的数据类型。

• Buffer类的实例（即对象）类似于整数数组，但实例对应于固定大小的原始内存分配，其大小在创建时被确定且无法更改。

• Buffer 类位于全局作用域中，因此无须使用 require() 方法加载相应的模块。

Buffer实例创建使用 Buffer.from()、Buffer.alloc() 或 Buffer.allocUnsafe() 方法。

创建一个包含数组 [0x1, 0x2, 0x3] 的 Buffer 实例

const buf1 = Buffer.from([1, 2, 3]);

创建一个包含 UTF-8 字节 [0x74, 0xc3, 0xa9, 0x73, 0x74] 的 Buffer实例

const buf2 = Buffer.from('tést');

创建一个包含 Latin-1 字节 [0x74, 0xe9, 0x73, 0x74] 的 Buffer实例

const buf3 = Buffer.from('tést', 'latin1');

创建一个长度为 10、且用零填充的 Buffer实例

const buf4 = Buffer.alloc(10);

创建一个长度为 10、且用 0x1 填充的 Buffer实例

const buf5 = Buffer.alloc(10, 1);

创建一个长度为 10、且未初始化的 Buffer实例

const buf6 = Buffer.allocUnsafe(10);

• Buffer实例一般用于表示编码字符的序列，如UTF-8、UCS2(UTF-16)、Base64 或十六进制编码的数据。

• 在文件操作和网络操作中，如果没有显式声明编码格式，返回数据的默认类型为 Buffer。

• 通过使用显式字符编码将 Buffer 实例与 JavaScript 字符串相互转换。

• 在创建 Buffer 实例时指定存入字符串的字符编码

  • const buf = Buffer.from('hello world', 'ascii');

• 将已创建的 Buffer 实例转换成字符串的语法

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

下面是一个简单的例子:

Node.js 目前支持的字符编码如下：

• ascii: 仅适用于 7 位 ASCII 数据。此编码速度很快，如果设置这种编码，将从数据中删除高位。

• utf8: 多字节编码的 Unicode 字符。许多网页和文档都使用这种编码格式。

• utf16le: 2个或4个字节，小字节序编码的 Unicode 字符。支持代理对(U+10000 至 U+10FFFF)。 ucs2是它的别名。

• base64: Base6编码。

• latin1: 一种将 Buffer 编码成单字节编码字符串的方法。binary 是 latin1 的别名。

• hex: 将每个字节编码成两个十六进制的字符。

#clean src/ch02/buf_to_json.js

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);
console.log(json);  // (1)

const copy = JSON.parse (json, (key, value) => {
  console.log('key:', key)
  console.log('value:', value)
  console.log('value.type:', value.type)
  console.log('value.data:', value.data)
  return value && value.type === 'Buffer'
      ? Buffer.from(value.data)
      : value;
});
console.log(copy);  // (2)

... 前面的输出内容都没用，省略
key:
value: {type: 'Buffer', data: Array(5)}
value.type: Buffer
value.data: (5) [1, 2, 3, 4, 5]

Buffer 写入实例

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

const buf = Buffer.alloc(256);
const len = buf.write('\u00bd + \u00bc = \u00be', 0);
console.log(`${len} 个字节: ${buf.toString('utf8', 0, len)}`);
// 输出: 12 个字节: ½ + ¼ = ¾

Buffer 读取实例

const buf = Buffer.from([-1, 5]);
console.log(buf.readInt8(0));// 输出结果: -1
console.log(buf.readInt8(1));// 输出结果: 5
console.log(buf.readInt8(2));// 抛出异常 ERR_OUT_OF_RANGE（超出范围）

Buffer 实例合并

Buffer.concat (list[, totalLength])

const buf1 = Buffer.alloc(5);
const buf2 = Buffer.alloc(7);
const totalLength = buf1.length + buf2.length;
const bufA = Buffer.concat([buf1, buf2], totalLength);
console.log(bufA);  // <Buffer 00 00 00 00 00 00 00 00 00 00 00 00>

Buffer 实例复制

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

Buffer 实例切片

buf.slice(start[, end]])

流可以看作是某段时间内从一个点移动到另一个点的数据序列，就像水从一根管子的一端流到另-端。 Node.js中的流用于管理和处理数据，可以使用流完成对大量数据的操作以及逐段处理的操作。在 Node.js 异步处理数据的基础上，流将要传输的数据处理成“块”(chunk) 连续传输，这样就可使用较低的内存消耗获得较高的性能提升。

流是 Node.js 中处理流式数据的抽象接口。Node.js 提供了多种流对象，例如 HTTP 服务器的请求和process.stdout 都是流的实例。流可以是可读的、可写的，或者可读可写的。所有流都是 EventEmitter 类的实例。stream 模块用于构建实现了流接口的对象，使用时需要导入，方法如下:

stream 模块主要用于开发人员创建新类型的流实例。几乎所有的 Node.js 应用程序都在某种程度上使用了流。应用程序只需写入数据到流，或者从流消费数据，并不需要直接实现流的接口，通常也不需要直接加载 stream 模块。本节给出的示例代码没有直接实现流的接口，而是直接利用 fs 模块内置的文件操作流接口。

流的基本类型：

• 可写流（Writable）

• 可读流（Readable）

• 双工流（Duplex）

• 转换流（Transform）

流的实现类型

• 普通的流：基于字符串和 Buffer（或 Uint8Array）工作

• 对象模式的流：使用其他类型的 JavaScript 值工作

可写流和可读流都会在内部的缓冲器中存储数据， 可缓冲的数据大小取决于传入流构造函数的 highWaterMark 选项（相当于水位线）。

双工流和转换流都是可读又可写的，各自维护着两个相互独立的内部缓冲器用于读取和写入。在维护数据流时，读取和写入两端可以各自独立地工作。

可读流是对提供数据的来源的一种抽象。所有可读流都实现了 stream.Readable 类定义的接口。

可读流有两种模式：流动（Flowing）和暂停（Paused）。

所有可读流一开始都处于暂停模式，之后可以通过以下方式切换到流动模式。

• 添加 data 事件处理函数。

• 调用 stream.resume() 方法

• 调用 stream.pipe() 方法

可读流也可以通过以下方式切换回暂停模式。

• 如果没有管道目标，则调用 stream.pause() 方法。

• 如果有管道目标，则移除所有管道目标。调用 stream.unpipe() 方法可以移除多个管道目标。

stream.Readable 类定义的主要事件

• data：当有数据可读时被触发。

• end：没有更多的数据可读时被触发。

• error：当接收过程中发生错误时被触发。

• readable：当流中有数据可供读取时被触发。当到达流数据的尽头时，readable 事件也会被触发,但是在 end 事件之前被触发。

• close: 当流或其底层资源被关闭时被触发。这表明不会再触发其他事件，也不会再发生操作。

stream.Readable 类定义的主要方法

• readable.read([size])：从内部缓冲区拉取并返回数据（默认返回是 Buffer 对象），size 指定要读取的数据的字节数。如果没在可读的数据，则返回 null。它只对处于暂停模式的可读流调用。

• readable.pause()：使流动模式的流停止触发data事件，并切换出流动模式。任何可用的数据都会保留在内部缓存中。

• readable.resume()：将被暂停的可读流恢复触发 data 事件，并将流切换到流动模式。

• readable.setEncoding(encoding)：为从可读流读取的数据设置字符编码。

下面是可读流操作的例子

#clean src/ch02/test_readablestream.js

const fs = require('fs')

var readStream=fs.createReadStream('demo.txt');  // (1)

var str='';
readStream.on('data',function(chunk){  // (2)
    str+=chunk;
})
readStream.on('end',function(chunk){  // (3)
    console.log(str);
})
readStream.on('error',function(err){  // (4)
    console.log(err);
})

周董好久没有发新歌了，左盼右盼，终于等来了《说好不哭》

可写流是对数据被写入的目的地的一种抽象。所有可写流都实现了 stream.Writable 类定义的接口。

stream.Writable 类定义的主要事件如下：

• close: 当流或其底层资源被关闭时被触发。不是所有可写流都会触发该事件。

• drain: 如果调用stream.wite(chunk)方法返回false,则当可以继续写入数据到流时会触发该事件。

• error: 写入数据发生错误时被触发。当触发该事件时，流还未被关闭。

• finish: 调用 stream.end() 方法且缓冲数据都已传给底层系统之后被触发。

• pipe: 当在可读流上调用 stream.pipe() 方法时被触发。

• unpipe: 当在可读流上调用 stream.unpipe() 方法时被触发。

stream.Witable类定义的主要方法是

• writable.write(chunk[, encoding][, callback])。这个方法写入数据到流，并在数据被完全处理之后调用回调函数。

下面给出一个可写流操作的例子。

#clean src/ch02/test_writablestream.js

const fs = require('fs')

var str = '这是测试可写流的数据，保存起来';
var writerStream = fs.createWriteStream('output.txt');  // (1)

writerStream.write(str,'UTF8');  // (2)
writerStream.end();  // (3)

// 处理流事件
writerStream.on('finish', function() {
    console.log('写入完成!');
});
writerStream.on('error', function(err){
    console.log('写入失败');
});

写入完成!

这是测试可写流的数据，保存起来

通常要将从一个流中获取的数据传递到另外一个流中，这可以通过管道操作机制实现。可读流提供的 readable.pipe() 方法在可读流与可写流之间架起桥梁，使数据可以通过管道由可读流进入可写流。该方法的语法如下:

• 参数 destination 指定数据写入的目标

• options 用于设选项，其中 end 指定当读取结束时是否终止写入，默认为 true。

• 该方法返回目标可写流，如果该方法返回的目标可写流是双工流或转换流，则可以形成管道链。

下面的代码将可读流的所有数据通过管道推送到file.txt 文件:

可以在单个可读流上绑定多个可写流。readable.pipe()会返回目标流的引用，这样就可以对流进行链式管道操作。下面给出一段示例代码:

默认情况下，当来源可读流触发 end 事件时，目标可写流也会调用 stream.end() 结束写入。如果禁用这种默认行为，end 选项应设为 false，这样目标流就会保持打开状态，例如:

如果可读流发生错误，目标可写流不会自动关闭，因此需要手动关闭所有流以避免内存泄漏。

还有一个 readable.unpipe() 方法用于解绑之前使用 stream.pipe() 方法绑定的可写流， 它有一个参数 destination,用于指定要移除管道的可写流。

• 如果没有指定该参数，则解绑所有管道。

• 如果指定 destination 参数，但它并没有建立管道，则不起作用。

• Node.js将可重用代码封装在各种模块中，减少应用程序的代码量，提高开发效率和代码的可读性。

• 模块打包代码的方式不会改变全局作用域，开发人员可以在被载入的模块文件中选择要对外暴露的方法和变量。

• 模块可以发布到npm仓库中与他人共享。

• 开发人员可以使用来自npm仓库的第三方模块,而不必担心某个模块会覆盖其他模块的变量和方法。

主流的 JavaScript 模块规范有两种，分别是 AMD 和 CommonJS。

AMD 规范要求异步加载模块，允许指定回调函数，并在回调函数中执行操作。对于浏览器环境，要从服务器端加载模块，必须采用非同步模式，因此浏览器端般采用 AMD规范。

CommonJS 规范要求同步加载模块，也就是说，只有模块加载完成，才能执行后面的操作。CommonJS 是服务器端广泛使用的模块化机制。Node.js 主要用于服务器端编程，模块文件一般保存于本地磁盘，加载速度较快，因而无须考虑非同步加载的方式，所以选择 CommonJS 规范。

按照 CommonJS 规范要求，模块必须通过 module.exports 对象导出对外暴露的变量或接口，通过 require() 方法将其他模块的输出加载到当前模块作用域中。

在 Node.js 模块系统中，每个文件都被视为独立的模块，有目己的作用域，其变量、方法等都对其他文件不可见的。当然，模块也可以是包含一个或多个文件的目录。

模块可以是一个包含 exports 对象属性定义的文件，这些属性可以是任意类型的数据，比如字符串、对象和方法。可将 exports 看作是 module. exports 的简单引用形式。通过在 exports 对象上指定额外的属性，可以将方法和对象等添加到模块的根部。例如，创建一个名为 hello.js 的文件，添加代码来定义模块。

#clean src/ch03/moduledef/hello_exports_method.js

var show_day = new Array('星期一','星期二','星期三','星期四','星期五','星期六','星期日');
var nowTime = new Date();
var day = nowTime.getDay();

exports.sayHello = function(name) {
  console.log('你好！' + name);
  console.log('今天是' + show_day[day-1]);
};

使用上述模块要用到 Node.js 的 require() 方法,该方法以要使用的模块的文件路径为参数。Node.js 找到该模块文件并加载其内容。这里创建一个名为 index.js 的文件，通过添加代码来导入模块。

#clean src/ch03/moduledef/index_require_hello_exports_method.js

var hello = require('./hello_exports_method');  // (1)
hello.sayHello('小王');  // (2)

你好！小王
今天是星期三  // (3)

在 Node.js 中，exports 是模块公开的接口，require() 方法用于从外部获取一个模块的接口，即所获取模块的 exports 对象。

如果希望模块成为某个对象的导出，则应将要导出的对象赋值给 module.exports 属性。

如果将要导出的对象赋值给 exports 对象，则会简单地重新绑定本地的 exports 变量。

• 使用 module.exports 对象可以对外提供 单个交量、方法或者对象。

  • 下面 hello_module_exports_method.js 导出了单个方法

• 使用 module.exports 对象可以对外提供 多个变量和方法。

  var baseSalary = 3000.00;  // 基本工资
  var getSalary = function (bonus) {  // 计算工资
    return baseSalary + bonus;  // 基本工资加资金
  };
  module.exports.baseSalary = baseSalary;  // (1)
  module.exports.getSalary = getSalary;  // (2)

  导出了一个变量和一个方法：

  1. 导出 baseSalary 变量

  2. 导出 getSalary 方法

• 使用 module.exports 导出一个对象

  • 下面 hello_module_exports_object.js 导出单个对象（Hello 大写了，我们称为类）

在每个模块内部，module 对象代表当前模块。它的 exports 属性是对外的接口，将模块的接口对模块外部暴露。

其他文件加载该模块，实际上就是读取 module.exports 属性。

#clean src/ch03/moduledef/hello_module_exports_method.js

var show_day = new Array('星期一','星期二','星期三','星期四','星期五','星期六','星期日');
var nowTime = new Date();
var day = nowTime.getDay();

var sayHello = function(name) {
  console.log('你好！' + name);
  console.log('今天是' + show_day[day-1]);
};
module.exports.sayHello = sayHello;

#clean src/ch03/moduledef/index_require_hello_module_exports_method.js

var hello = require('./hello_module_exports_method');  // (1)
hello.sayHello('小王');  // (2)

你好！小王
今天是星期三  // (3)

#clean src/ch03/moduledef/hello_module_exports_object.js

var show_day = new Array('星期一','星期二','星期三','星期四','星期五','星期六','星期日');
var nowTime = new Date();
var day = nowTime.getDay();

function Hello (name) {  // (1)
  this.name = name;
  this.sayHello = function () {
    console.log('你好！' + this.name);
    console.log('今天是' + show_day[day-1]);
  };
};
module.exports = Hello;  // (2)

#clean src/ch03/moduledef/index_require_hello_module_exports_object.js

var Hello = require('./hello_module_exports_object');
var hello = new Hello('小张');   // 此处需要实例化类
hello.sayHello();