一、Node根底概念

1.1 Node是什么

Node.js 是一个开源与跨平台的 JavaScript 运行时环境。在浏览器外运行 V8 JavaScript 引擎（Google Chrome 的内核），利用事件驱动、非阻塞和异步输入输出模型等技术进步性能。咱们能够了解为：Node.js 就是一个服务器端的、非阻塞式I/O的、事件驱动的JavaScript运行环境。

了解Node，有几个根底的概念：非阻塞异步和事件驱动。

非阻塞异步： Nodejs采纳了非阻塞型I/O机制，在做I/O操作的时候不会造成任何的阻塞，当实现之后，以工夫的模式告诉执行操作。例如，在执行了拜访数据库的代码之后，将立刻转而执行其前面的代码，把数据库返回后果的解决代码放在回调函数中，从而进步了程序的执行效率。
事件驱动： 事件驱动就是当进来一个新的申请的时，申请将会被压入一个事件队列中，而后通过一个循环来检测队列中的事件状态变动，如果检测到有状态变动的事件，那么就执行该事件对应的解决代码，个别都是回调函数。比方，读取一个文件，文件读取结束后，就会触发对应的状态，而后通过对应的回调函数来进行解决。

1.2 Node的利用场景及存在的毛病

1.2.1 优缺点

Node.js适宜用于I/O密集型利用，值的是利用在运行极限时，CPU占用率依然比拟低，大部分工夫是在做 I/O硬盘内存读写操作。毛病如下：

不适宜CPU密集型利用
只反对单核CPU，不能充分利用CPU
可靠性低，一旦代码某个环节解体，整个零碎都解体

对于第三点，罕用的解决方案是，应用Nnigx反向代理，开多个过程绑定多个端口，或者开多个过程监听同一个端口。

1.2.1 利用场景

在相熟了Nodejs的长处和弊病后，咱们能够看到它适宜以下的利用场景：

长于I/O，不长于计算。因为Nodejs是一个单线程，如果计算（同步）太多，则会阻塞这个线程。
大量并发的I/O，应用程序外部并不需要进行非常复杂的解决。
与 WeSocket 配合，开发长连贯的实时交互应用程序。

具体的应用场景如下：

用户表单收集零碎、后盾管理系统、实时交互零碎、考试零碎、联网软件、高并发量的web应用程序。
基于web、canvas等多人联网游戏。
基于web的多人实时聊天客户端、聊天室、图文直播。
单页面浏览器应用程序。
操作数据库、为前端和挪动端提供基于json的API。

二、Node全副对象

在浏览器 JavaScript 中，window 是全局对象，而 Nodejs 中的全局对象则是 global。

在NodeJS里，是不可能在最外层定义一个变量，因为所有的用户代码都是以后模块的，只在以后模块里可用，但能够通过exports对象的应用将其传递给模块内部。所以，在NodeJS中，用var申明的变量并不属于全局的变量，只在以后模块失效。像上述的global全局对象则在全局作用域中，任何全局变量、函数、对象都是该对象的一个属性值。

2.1 常见全局对象

Node常见的全局对象有如下一些：

Class:Buffer
process
console
clearInterval、setInterval
clearTimeout、setTimeout
global

Class:Buffer
Class:Buffer能够用来解决二进制以及非Unicode编码的数据，在Buffer类实例化中存储了原始数据。Buffer相似于一个整数数组，在V8堆原始存储空间给它调配了内存，一旦创立了Buffer实例，则无奈扭转大小。

process
process示意过程对象，提供无关以后过程的信息和管制。包含在执行node程序的过程中，如果须要传递参数，咱们想要获取这个参数须要在process内置对象中。比方，咱们有如下一个文件：

process.argv.forEach((val, index) => {   console.log(`${index}: ${val}`);});

当咱们须要启动一个过程时，能够应用上面的命令：

 node index.js 参数...

console
console次要用来打印stdout和stderr，最罕用的比方日志输入：console.log。清空控制台的命令为：console.clear。如果须要打印函数的调用栈，能够应用命令console.trace。

clearInterval、setInterval
setInterval用于设置定时器，语法格局如下：

setInterval(callback, delay[, ...args])

clearInterval则用于革除定时器，callback每delay毫秒反复执行一次。

clearTimeout、setTimeout

和setInterval一样，setTimeout次要用于设置延时器，而clearTimeout则用于革除设置的延时器。

global
global是一个全局命名空间对象，后面讲到的process、console、setTimeout等能够放到global中，例如：

console.log(process === global.process)     //输入true

2.2 模块中的全局对象

除了零碎提供的全局对象外，还有一些只是在模块中呈现，看起来像全局变量，如下所示：

__dirname
__filename
exports
module
require

__dirname
__dirname次要用于获取以后文件所在的门路，不包含前面的文件名。比方，在/Users/mjr 中运行 node example.js，打印后果如下：

console.log(__dirname);         // 打印: /Users/mjr

__filename
__filename用于获取以后文件所在的门路和文件名称，包含前面的文件名称。比方，在/Users/mjr 中运行 node example.js，打印的后果如下：

console.log(__filename);// 打印: /Users/mjr/example.js

exports
module.exports 用于导出一个指定模块所的内容，而后也能够应用require() 拜访外面的内容。

exports.name = name;exports.age = age;exports.sayHello = sayHello;

require
require次要用于引入模块、 JSON、或本地文件，能够从 node_modules 引入模块。能够应用相对路径引入本地模块或JSON文件，门路会依据__dirname定义的目录名或当前工作目录进行解决。

三、谈谈对process的了解

3.1 基本概念

咱们晓得，过程计算机系统进行资源分配和调度的根本单位，是操作系统构造的根底，是线程的容器。当咱们启动一个js文件，理论就是开启了一个服务过程，每个过程都领有本人的独立空间地址、数据栈，像另一个过程无法访问以后过程的变量、数据结构，只有数据通信后，过程之间才能够数据共享。

process 对象是Node的一个全局变量，提供了无关以后 Node.js 过程的信息并对其进行管制。
因为JavaScript是一个单线程语言，所以通过node xxx启动一个文件后，只有一条主线程。

3.2 罕用属性和办法

process的常见属性如下：

process.env：环境变量，例如通过 `process.env.NODE_ENV 获取不同环境我的项目配置信息
process.nextTick：这个在谈及 EventLoop 时常常为会提到
process.pid：获取以后过程id
process.ppid：以后过程对应的父过程
process.cwd()：获取以后过程工作目录
process.platform：获取以后过程运行的操作系统平台
process.uptime()：以后过程已运行工夫，例如：pm2 守护过程的 uptime 值
过程事件： process.on(‘uncaughtException’,cb) 捕捉异样信息、 process.on(‘exit’,cb）过程推出监听
三个规范流： process.stdout 规范输入、 process.stdin 规范输出、 process.stderr 规范谬误输入
process.title：用于指定过程名称，有的时候须要给过程指定一个名称

四、谈谈你对fs模块的了解

4.1 fs是什么

fs（filesystem）是文件系统模块，该模块提供本地文件的读写能力，基本上是POSIX文件操作命令的简略包装。能够说，所有与文件的操作都是通过fs外围模块来实现的。

应用之前，须要先导入fs模块，如下：

const fs = require('fs');

4.2 文件基础知识

在计算机中，有对于文件的基础知识有如下一些：

权限位 mode
标识位 flag
文件形容为 fd

4.2.1 权限位 mode

针对文件所有者、文件所属组、其余用户进行权限调配，其中类型又分成读、写和执行，具备权限位4、2、1，不具备权限为0。如在linux查看文件权限位的命令如下：

drwxr-xr-x 1 PandaShen 197121 0 Jun 28 14:41 core-rw-r--r-- 1 PandaShen 197121 293 Jun 23 17:44 index.md

在结尾前十位中，d为文件夹，-为文件，后九位就代表以后用户、用户所属组和其余用户的权限位，按每三位划分，别离代表读（r）、写（w）和执行（x），- 代表没有以后位对应的权限。

4.2.2 标识位

标识位代表着对文件的操作形式，如可读、可写、即可读又可写等等，如下表所示：

4.2.3 文件形容 fd

操作系统会为每个关上的文件调配一个名为文件描述符的数值标识，文件操作应用这些文件描述符来辨认与追踪每个特定的文件。

Window 零碎应用了一个不同但概念相似的机制来追踪资源，为不便用户，NodeJS 形象了不同操作系统间的差别，为所有关上的文件调配了数值的文件描述符。

在 NodeJS 中，每操作一个文件，文件描述符是递增的，文件描述符个别从 3 开始，因为后面有 0、1、2三个比拟非凡的描述符，别离代表 process.stdin（规范输出）、process.stdout（规范输入）和 process.stderr（谬误输入）。

4.3 罕用办法

因为fs模块次要是操作文件的，所以常见的文件操作方法有如下一些：

文件读取
文件写入
文件追加写入
文件拷贝
创立目录

4.3.1 文件读取

罕用的文件读取有readFileSync和readFile两个办法。其中，readFileSync示意同步读取，如下：

const fs = require("fs");let buf = fs.readFileSync("1.txt");let data = fs.readFileSync("1.txt", "utf8");console.log(buf); // <Buffer 48 65 6c 6c 6f>console.log(data); // Hello

第一个参数为读取文件的门路或文件描述符。
第二个参数为 options，默认值为 null，其中有 encoding（编码，默认为 null）和 flag（标识位，默认为 r），也可间接传入 encoding。

readFile为异步读取办法， readFile 与 readFileSync 的前两个参数雷同，最初一个参数为回调函数，函数内有两个参数 err（谬误）和 data（数据），该办法没有返回值，回调函数在读取文件胜利后执行。

const fs = require("fs");fs.readFile("1.txt", "utf8", (err, data) => {   if(!err){       console.log(data);         // Hello   }});

4.3.2 文件写入

文件写入须要用到writeFileSync和writeFile两个办法。writeFileSync示意同步写入，如下所示。

const fs = require("fs");fs.writeFileSync("2.txt", "Hello world");let data = fs.readFileSync("2.txt", "utf8");console.log(data); // Hello world

第一个参数为写入文件的门路或文件描述符。
第二个参数为写入的数据，类型为 String 或 Buffer。
第三个参数为 options，默认值为 null，其中有 encoding（编码，默认为 utf8）、 flag（标识位，默认为 w）和 mode（权限位，默认为 0o666），也可间接传入 encoding。

writeFile示意异步写入，writeFile 与 writeFileSync 的前三个参数雷同，最初一个参数为回调函数，函数内有一个参数 err（谬误），回调函数在文件写入数据胜利后执行。

const fs = require("fs");fs.writeFile("2.txt", "Hello world", err => {    if (!err) {        fs.readFile("2.txt", "utf8", (err, data) => {            console.log(data);       // Hello world        });    }});

4.3.3 文件追加写入

文件追加写入须要用到appendFileSync和appendFile两个办法。appendFileSync示意同步写入，如下。

const fs = require("fs");fs.appendFileSync("3.txt", " world");let data = fs.readFileSync("3.txt", "utf8");

第一个参数为写入文件的门路或文件描述符。
第二个参数为写入的数据，类型为 String 或 Buffer。
第三个参数为 options，默认值为 null，其中有 encoding（编码，默认为 utf8）、 flag（标识位，默认为 a）和 mode（权限位，默认为 0o666），也可间接传入 encoding。

appendFile示意异步追加写入，办法 appendFile 与 appendFileSync 的前三个参数雷同，最初一个参数为回调函数，函数内有一个参数 err（谬误），回调函数在文件追加写入数据胜利后执行，如下所示。

const fs = require("fs");fs.appendFile("3.txt", " world", err => {    if (!err) {        fs.readFile("3.txt", "utf8", (err, data) => {            console.log(data); // Hello world        });    }});

4.3.4 创立目录

创立目录次要有mkdirSync和mkdir两个办法。其中，mkdirSync为同步创立，参数为一个目录的门路，没有返回值，在创立目录的过程中，必须保障传入的门路后面的文件目录都存在，否则会抛出异样。

// 假如曾经有了 a 文件夹和 a 下的 b 文件夹fs.mkdirSync("a/b/c")

mkdir为异步创立，第二个参数为回调函数，如下所示。

fs.mkdir("a/b/c", err => {    if (!err) console.log("创立胜利");});

五、谈谈你对Stream 的了解

5.1 基本概念

流（Stream）是一种数据传输的伎俩，是一种端到端信息替换的形式，而且是有程序的，是逐块读取数据、解决内容，用于程序读取输出或写入输入。在Node中，Stream分成三局部：source、dest、pipe。

其中，在source和dest之间有一个连贯的管道pipe，它的根本语法是source.pipe(dest)，source和dest就是通过pipe连贯，让数据从source流向dest，如下图所示：

5.2 流的分类

在Node，流能够分成四个品种：

可写流：可写入数据的流，例如 fs.createWriteStream() 能够应用流将数据写入文件。
可读流：可读取数据的流，例如fs.createReadStream() 能够从文件读取内容。
双工流：既可读又可写的流，例如 net.Socket。
转换流：能够在数据写入和读取时批改或转换数据的流。例如，在文件压缩操作中，能够向文件写入压缩数据，并从文件中读取解压数据。

在Node的HTTP服务器模块中，request 是可读流，response 是可写流。对于fs 模块来说，能同时解决可读和可写文件流可读流和可写流都是单向的，比拟容易了解。而Socket是双向的，可读可写。

5.2.1 双工流

在Node中，比拟的常见的全双工通信就是websocket，因为发送方和接受方都是各自独立的办法，发送和接管都没有任何关系。

根本的应用办法如下：

const { Duplex } = require('stream');const myDuplex = new Duplex({  read(size) {    // ...  },  write(chunk, encoding, callback) {    // ...  }});

5.3 应用场景

流的常见应用场景有：

get申请返回文件给客户端
文件操作
一些打包工具的底层操作

5.3.1 网络申请

流一个常见的应用场景就是网络申请，比方应用stream流返回文件，res也是一个stream对象，通过pipe管道将文件数据返回。

const server = http.createServer(function (req, res) {    const method = req.method;      // get 申请    if (method === 'GET') {         const fileName = path.resolve(__dirname, 'data.txt');        let stream = fs.createReadStream(fileName);        stream.pipe(res);       }});server.listen(8080);

5.3.2 文件操作

文件的读取也是流操作，创立一个可读数据流readStream，一个可写数据流writeStream，通过pipe管道把数据流转过来。

const fs = require('fs')const path = require('path')// 两个文件名const fileName1 = path.resolve(__dirname, 'data.txt')const fileName2 = path.resolve(__dirname, 'data-bak.txt')// 读取文件的 stream 对象const readStream = fs.createReadStream(fileName1)// 写入文件的 stream 对象const writeStream = fs.createWriteStream(fileName2)// 通过 pipe执行拷贝，数据流转readStream.pipe(writeStream)// 数据读取实现监听，即拷贝实现readStream.on('end', function () {    console.log('拷贝实现')})

另外，一些打包工具，Webpack和Vite等都波及很多流的操作。

六、事件循环机制

6.1 什么是浏览器事件循环

Node.js 在主线程里保护了一个事件队列，当接到申请后，就将该申请作为一个事件放入这个队列中，而后持续接管其余申请。当主线程闲暇时(没有申请接入时)，就开始循环事件队列，查看队列中是否有要解决的事件，这时要分两种状况：如果是非 I/O 工作，就亲自解决，并通过回调函数返回到下层调用；如果是 I/O 工作，就从线程池中拿出一个线程来解决这个事件，并指定回调函数，而后持续循环队列中的其余事件。

当线程中的 I/O 工作实现当前，就执行指定的回调函数，并把这个实现的事件放到事件队列的尾部，期待事件循环，当主线程再次循环到该事件时，就间接解决并返回给下层调用。这个过程就叫事件循环 (Event Loop)，其运行原理如下图所示。

从左到右，从上到下，Node.js 被分为了四层，别离是应用层、V8引擎层、Node API层和 LIBUV层。

应用层：即 JavaScript 交互层，常见的就是 Node.js 的模块，比方 http，fs
V8引擎层：即利用 V8 引擎来解析JavaScript 语法，进而和上层 API 交互
Node API层：为下层模块提供零碎调用，个别是由 C 语言来实现，和操作系统进行交互。
LIBUV层：是跨平台的底层封装，实现了事件循环、文件操作等，是 Node.js 实现异步的外围。

在Node中，咱们所说的事件循环是基于libuv实现的，libuv是一个多平台的专一于异步IO的库。上图的EVENT_QUEUE 给人看起来只有一个队列，但事实上EventLoop存在6个阶段，每个阶段都有对应的一个先进先出的回调队列。

6.2 事件循环的六个阶段

事件循环一共能够分成了六个阶段，如下图所示。

timers阶段：此阶段次要执行timer（setTimeout、setInterval）的回调。
I/O事件回调阶段(I/O callbacks)：执行提早到下一个循环迭代的 I/O 回调，即上一轮循环中未被执行的一些I/O回调。
闲置阶段(idle、prepare)：仅零碎外部应用。
轮询阶段(poll)：检索新的 I/O 事件;执行与 I/O 相干的回调（简直所有状况下，除了敞开的回调函数，那些由计时器和 setImmediate() 调度的之外），其余状况 node 将在适当的时候在此阻塞。
查看阶段(check)：setImmediate() 回调函数在这里执行
敞开事件回调阶段(close callback)：一些敞开的回调函数，如：socket.on('close', ...)

每个阶段对应一个队列，当事件循环进入某个阶段时, 将会在该阶段内执行回调，直到队列耗尽或者回调的最大数量已执行, 那么将进入下一个解决阶段，如下图所示。

七、EventEmitter

7.1 基本概念

前文说过，Node采纳了事件驱动机制，而EventEmitter 就是Node实现事件驱动的根底。在EventEmitter的根底上，Node 简直所有的模块都继承了这个类，这些模块领有了本人的事件，能够绑定、触发监听器，实现了异步操作。

Node.js 外面的许多对象都会散发事件，比方 fs.readStream 对象会在文件被关上的时候触发一个事件，这些产生事件的对象都是 events.EventEmitter 的实例，用于将一个或多个函数绑定到命名事件上。

7.2 根本应用

Node的events模块只提供了一个EventEmitter类，这个类实现了Node异步事件驱动架构的基本模式：观察者模式。

在这种模式中，被观察者(主体)保护着一组其余对象派来(注册)的观察者，有新的对象对主体感兴趣就注册观察者，不感兴趣就勾销订阅，主体有更新会顺次告诉观察者，应用形式如下。

const EventEmitter = require('events')class MyEmitter extends EventEmitter {}const myEmitter = new MyEmitter()function callback() {    console.log('触发了event事件！')}myEmitter.on('event', callback)myEmitter.emit('event')myEmitter.removeListener('event', callback);

在下面的代码中，咱们通过实例对象的on办法注册一个名为event的事件，通过emit办法触发该事件，而removeListener用于勾销事件的监听。

除了下面介绍的一些办法外，其余罕用的办法还有如下一些：

emitter.addListener/on(eventName, listener) ：增加类型为 eventName 的监听事件到事件数组尾部。
emitter.prependListener(eventName, listener)：增加类型为 eventName 的监听事件到事件数组头部。
emitter.emit(eventName[, ...args])：触发类型为 eventName 的监听事件。
emitter.removeListener/off(eventName, listener)：移除类型为 eventName 的监听事件。
emitter.once(eventName, listener)：增加类型为 eventName 的监听事件，当前只能执行一次并删除。
emitter.removeAllListeners([eventName])：移除全副类型为 eventName 的监听事件。

7.3 实现原理

EventEmitter其实是一个构造函数，外部存在一个蕴含所有事件的对象。

class EventEmitter {    constructor() {        this.events = {};    }}

其中，events寄存的监听事件的函数的构造如下：

{  "event1": [f1,f2,f3]，  "event2": [f4,f5]，  ...}

而后，开始一步步实现实例办法，首先是emit，第一个参数为事件的类型，第二个参数开始为触发事件函数的参数，实现如下：

emit(type, ...args) {    this.events[type].forEach((item) => {        Reflect.apply(item, this, args);    });}

实现了emit办法之后，而后顺次实现on、addListener、prependListener这三个实例办法，它们都是增加事件监听触发函数的。

on(type, handler) {    if (!this.events[type]) {        this.events[type] = [];    }    this.events[type].push(handler);}addListener(type,handler){    this.on(type,handler)}prependListener(type, handler) {    if (!this.events[type]) {        this.events[type] = [];    }    this.events[type].unshift(handler);}

移除事件监听，能够应用办法removeListener/on。

removeListener(type, handler) {    if (!this.events[type]) {        return;    }    this.events[type] = this.events[type].filter(item => item !== handler);}off(type,handler){    this.removeListener(type,handler)}

实现once办法，再传入事件监听处理函数的时候进行封装，利用闭包的个性保护以后状态，通过fired属性值判断事件函数是否执行过。

once(type, handler) {    this.on(type, this._onceWrap(type, handler, this));  }  _onceWrap(type, handler, target) {    const state = { fired: false, handler, type , target};    const wrapFn = this._onceWrapper.bind(state);    state.wrapFn = wrapFn;    return wrapFn;  }  _onceWrapper(...args) {    if (!this.fired) {      this.fired = true;      Reflect.apply(this.handler, this.target, args);      this.target.off(this.type, this.wrapFn);    } }

上面是实现的测试代码：

class EventEmitter {    constructor() {        this.events = {};    }    on(type, handler) {        if (!this.events[type]) {            this.events[type] = [];        }        this.events[type].push(handler);    }    addListener(type,handler){        this.on(type,handler)    }    prependListener(type, handler) {        if (!this.events[type]) {            this.events[type] = [];        }        this.events[type].unshift(handler);    }    removeListener(type, handler) {        if (!this.events[type]) {            return;        }        this.events[type] = this.events[type].filter(item => item !== handler);    }    off(type,handler){        this.removeListener(type,handler)    }    emit(type, ...args) {        this.events[type].forEach((item) => {            Reflect.apply(item, this, args);        });    }    once(type, handler) {        this.on(type, this._onceWrap(type, handler, this));    }    _onceWrap(type, handler, target) {        const state = { fired: false, handler, type , target};        const wrapFn = this._onceWrapper.bind(state);        state.wrapFn = wrapFn;        return wrapFn;    }    _onceWrapper(...args) {        if (!this.fired) {            this.fired = true;            Reflect.apply(this.handler, this.target, args);            this.target.off(this.type, this.wrapFn);        }    }}

八、中间件

8.1 基本概念

中间件（Middleware）是介于利用零碎和系统软件之间的一类软件，它应用系统软件所提供的根底服务（性能），连接网络上利用零碎的各个局部或不同的利用，可能达到资源共享、性能共享的目标。
在Node中，中间件次要是指封装http申请细节解决的办法。例如，在express、koa等web框架中，中间件的实质为一个回调函数，参数蕴含申请对象、响应对象和执行下一个中间件的函数，架构示意图如下。

通常，在这些中间件函数中，咱们能够执行业务逻辑代码，批改申请和响应对象、返回响应数据等操作。

8.2 koa

Koa是基于Node以后比拟风行的web框架，自身反对的性能并不多，性能都能够通过中间件拓展实现。 Koa 并没有捆绑任何中间件，而是提供了一套优雅的办法，帮忙开发者疾速而欢快地编写服务端应用程序。

Koa 中间件采纳的是洋葱圈模型，每次执行下一个中间件都传入两个参数：

ctx ：封装了request 和 response 的变量
next ：进入下一个要执行的中间件的函数

通过后面的介绍，咱们晓得了Koa 中间件实质上就是一个函数，能够是 async 函数，也能够是一般函数。上面就针对koa进行中间件的封装：

// async 函数app.use(async (ctx, next) => {  const start = Date.now();  await next();  const ms = Date.now() - start;  console.log(`${ctx.method} ${ctx.url} - ${ms}ms`);});// 一般函数app.use((ctx, next) => {  const start = Date.now();  return next().then(() => {    const ms = Date.now() - start;    console.log(`${ctx.method} ${ctx.url} - ${ms}ms`);  });});

当然，咱们还能够通过中间件封装http申请过程中几个罕用的性能：

token校验

module.exports = (options) => async (ctx, next) {  try {    // 获取 token    const token = ctx.header.authorization    if (token) {      try {          // verify 函数验证 token，并获取用户相干信息          await verify(token)      } catch (err) {        console.log(err)      }    }    // 进入下一个中间件    await next()  } catch (err) {    console.log(err)  }}

日志模块

const fs = require('fs')module.exports = (options) => async (ctx, next) => {  const startTime = Date.now()  const requestTime = new Date()  await next()  const ms = Date.now() - startTime;  let logout = `${ctx.request.ip} -- ${requestTime} -- ${ctx.method} -- ${ctx.url} -- ${ms}ms`;  // 输入日志文件  fs.appendFileSync('./log.txt', logout + '\n')}

Koa存在很多第三方的中间件，如koa-bodyparser、koa-static等。

8.3 Koa中间件

koa-bodyparser
koa-bodyparser 中间件是将咱们的 post 申请和表单提交的查问字符串转换成对象，并挂在 ctx.request.body 上，不便咱们在其余中间件或接口处取值。

// 文件：my-koa-bodyparser.jsconst querystring = require("querystring");module.exports = function bodyParser() {    return async (ctx, next) => {        await new Promise((resolve, reject) => {            // 存储数据的数组            let dataArr = [];            // 接收数据            ctx.req.on("data", data => dataArr.push(data));            // 整合数据并应用 Promise 胜利            ctx.req.on("end", () => {                // 获取申请数据的类型 json 或表单                let contentType = ctx.get("Content-Type");                // 获取数据 Buffer 格局                let data = Buffer.concat(dataArr).toString();                if (contentType === "application/x-www-form-urlencoded") {                    // 如果是表单提交，则将查问字符串转换成对象赋值给 ctx.request.body                    ctx.request.body = querystring.parse(data);                } else if (contentType === "applaction/json") {                    // 如果是 json，则将字符串格局的对象转换成对象赋值给 ctx.request.body                    ctx.request.body = JSON.parse(data);                }                // 执行胜利的回调                resolve();            });        });        // 持续向下执行        await next();    };};

koa-static
koa-static 中间件的作用是在服务器接到申请时，帮咱们解决动态文件，比方。

const fs = require("fs");const path = require("path");const mime = require("mime");const { promisify } = require("util");// 将 stat 和 access 转换成 Promiseconst stat = promisify(fs.stat);const access = promisify(fs.access)module.exports = function (dir) {    return async (ctx, next) => {        // 将拜访的路由解决成绝对路径，这里要应用 join 因为有可能是 /        let realPath = path.join(dir, ctx.path);        try {            // 获取 stat 对象            let statObj = await stat(realPath);            // 如果是文件，则设置文件类型并间接响应内容，否则当作文件夹寻找 index.html            if (statObj.isFile()) {                ctx.set("Content-Type", `${mime.getType()};charset=utf8`);                ctx.body = fs.createReadStream(realPath);            } else {                let filename = path.join(realPath, "index.html");                // 如果不存在该文件则执行 catch 中的 next 交给其余中间件解决                await access(filename);                // 存在设置文件类型并响应内容                ctx.set("Content-Type", "text/html;charset=utf8");                ctx.body = fs.createReadStream(filename);            }        } catch (e) {            await next();        }    }}

总的来说，在实现中间件时候，单个中间件应该足够简略，职责繁多，中间件的代码编写应该高效，必要的时候通过缓存反复获取数据。

九、如何设计并实现JWT鉴权

9.1 JWT是什么

JWT（JSON Web Token），实质就是一个字符串书写标准，作用是用来在用户和服务器之间传递安全可靠的，如下图。

在目前前后端拆散的开发过程中，应用token鉴权机制用于身份验证是最常见的计划，流程如下：

服务器当验证用户账号和明码正确的时候，给用户颁发一个令牌，这个令牌作为后续用户拜访一些接口的凭证。
后续拜访会依据这个令牌判断用户时候有权限进行拜访。
Token，分成了三局部，头部（Header）、载荷（Payload）、签名（Signature），并以.进行拼接。其中头部和载荷都是以JSON格局存放数据，只是进行了编码，示意图如下。
9.1.1 header
每个JWT都会带有头部信息，这里次要申明应用的算法。申明算法的字段名为alg，同时还有一个typ的字段，默认JWT即可。以下示例中算法为HS256：

{  "alg": "HS256",  "typ": "JWT" }

因为JWT是字符串，所以咱们还须要对以上内容进行Base64编码，编码后字符串如下：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

9.1.2 payload

载荷即音讯体，这里会寄存理论的内容，也就是Token的数据申明，例如用户的id和name，默认状况下也会携带令牌的签发工夫iat，通过还能够设置过期工夫，如下：

{  "sub": "1234567890",  "name": "John Doe",  "iat": 1516239022}

同样进行Base64编码后，字符串如下：

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ

9.1.3 Signature

签名是对头部和载荷内容进行签名，个别状况，设置一个secretKey，对前两个的后果进行HMACSHA25算法，公式如下：

Signature = HMACSHA256(base64Url(header)+.+base64Url(payload),secretKey)

因而，就算后面两局部数据被篡改，只有服务器加密用的密钥没有泄露，失去的签名必定和之前的签名也是不统一的。

9.2 设计实现

通常，Token的应用分成了两局部：生成token和校验token。

生成token：登录胜利的时候，颁发token。
验证token：拜访某些资源或者接口时，验证token。

9.2.1 生成 token

借助第三方库jsonwebtoken，通过jsonwebtoken 的 sign 办法生成一个 token。sign有三个参数：

第一个参数指的是 Payload。
第二个是秘钥，服务端特有。
第三个参数是 option，能够定义 token 过期工夫。

上面是一个前端生成token的例子：

const crypto = require("crypto"),  jwt = require("jsonwebtoken");// TODO:应用数据库// 这里应该是用数据库存储，这里只是演示用let userList = [];class UserController {  // 用户登录  static async login(ctx) {    const data = ctx.request.body;    if (!data.name || !data.password) {      return ctx.body = {        code: "000002",         message: "参数不非法"      }    }    const result = userList.find(item => item.name === data.name && item.password === crypto.createHash('md5').update(data.password).digest('hex'))    if (result) {      // 生成token      const token = jwt.sign(          {          name: result.name        },        "test_token", // secret        { expiresIn: 60 * 60 } // 过期工夫：60 * 60 s      );      return ctx.body = {        code: "0",        message: "登录胜利",        data: {          token        }      };    } else {      return ctx.body = {        code: "000002",        message: "用户名或明码谬误"      };    }  }}module.exports = UserController;

在前端接管到token后，个别状况会通过localStorage进行缓存，而后将token放到HTTP 申请头Authorization 中，对于Authorization 的设置，后面须要加上 Bearer ，留神前面带有空格，如下。

axios.interceptors.request.use(config => {  const token = localStorage.getItem('token');  config.headers.common['Authorization'] = 'Bearer ' + token; // 注意这里的 Authorization  return config;})

9.2.2 校验token

首先，咱们须要应用 koa-jwt 中间件进行验证，形式比较简单，在路由跳转前校验即可，如下。

app.use(koajwt({  secret: 'test_token'}).unless({    // 配置白名单  path: [/\/api\/register/, /\/api\/login/]}))

应用koa-jwt中间件进行校验时，须要留神以下几点：

secret 必须和 sign 时候保持一致。
能够通过 unless 配置接口白名单，也就是哪些 URL 能够不必通过校验，像登陆/注册都能够不必校验。
校验的中间件须要放在须要校验的路由后面，无奈对后面的 URL 进行校验。

获取用户token信息的办法如下：

router.get('/api/userInfo',async (ctx,next) =>{    const authorization =  ctx.header.authorization // 获取jwt   const token = authorization.replace('Beraer ','')     const result = jwt.verify(token,'test_token')   ctx.body = result}

留神：上述的HMA256加密算法为单秘钥的模式，一旦泄露结果十分的危险。

在分布式系统中，每个子系统都要获取到秘钥，那么这个子系统依据该秘钥能够公布和验证令牌，但有些服务器只须要验证令牌。这时候能够采纳非对称加密，利用私钥公布令牌，公钥验证令牌，加密算法能够抉择RS256等非对称算法。

除此之外，JWT鉴权还须要留神以下几点：

payload局部仅仅是进行简略编码，所以只能用于存储逻辑必须的非敏感信息。
须要爱护好加密密钥，一旦泄露结果不堪设想。
为防止token被劫持，最好应用https协定。

十、Node性能监控与优化

10.1 Node优化点

Node作为一门服务端语言，性能方面尤为重要，其掂量指标个别有如下几点：

CPU
内存
I/O
网络

10.1.1 CPU

对于CPU的指标，次要关注如下两点：

CPU负载：在某个时间段内，占用以及期待CPU的过程总数。
CPU使用率：CPU工夫占用情况，等于 1 - 闲暇CPU工夫(idle time) / CPU总工夫。

这两个指标都是用来评估零碎以后CPU的忙碌水平的量化指标。Node利用个别不会耗费很多的CPU，如果CPU占用率高，则表明利用存在很多同步操作，导致异步工作回调被阻塞。

10.1.2 内存指标

内存是一个非常容易量化的指标。内存占用率是评判一个零碎的内存瓶颈的常见指标。对于Node来说，外部内存堆栈的应用状态也是一个能够量化的指标，能够应用上面的代码来获取内存的相干数据：

// /app/lib/memory.jsconst os = require('os');// 获取以后Node内存堆栈状况const { rss, heapUsed, heapTotal } = process.memoryUsage();// 获取零碎闲暇内存const sysFree = os.freemem();// 获取零碎总内存const sysTotal = os.totalmem();module.exports = {  memory: () => {    return {      sys: 1 - sysFree / sysTotal,  // 零碎内存占用率      heap: heapUsed / headTotal,   // Node堆内存占用率      node: rss / sysTotal,         // Node占用零碎内存的比例    }  }}

rss：示意node过程占用的内存总量。
heapTotal：示意堆内存的总量。
heapUsed：理论堆内存的使用量。
external ：内部程序的内存使用量，蕴含Node外围的C++程序的内存使用量。

在Node中，一个过程的最大内存容量为1.5GB，因而在理论应用时请正当管制内存的应用。

10.13 磁盘 I/O

硬盘的 IO 开销是十分低廉的，硬盘 IO 破费的 CPU 时钟周期是内存的 164000 倍。内存 IO 比磁盘 IO 快十分多，所以应用内存缓存数据是无效的优化办法。罕用的工具如 redis、memcached 等。

并且，并不是所有数据都须要缓存，拜访频率高，生成代价比拟高的才思考是否缓存，也就是说影响你性能瓶颈的思考去缓存，并且而且缓存还有缓存雪崩、缓存穿透等问题要解决。

10.2 如何监控

对于性能方面的监控，个别状况都须要借助工具来实现，比方Easy-Monitor、阿里Node性能平台等。

这里采纳Easy-Monitor 2.0，其是轻量级的 Node.js 我的项目内核性能监控 + 剖析工具，在默认模式下，只须要在我的项目入口文件 require 一次，无需改变任何业务代码即可开启内核级别的性能监控剖析。

Easy-Monitor 的应用也比较简单，在我的项目入口文件中依照如下形式引入。

const easyMonitor = require('easy-monitor');easyMonitor('项目名称');

关上你的浏览器，拜访 http://localhost:12333 ，即可看到过程界面，更具体的内容请参考官网

10.3 Node性能优化

对于Node的性能优化的形式有如下几个：

应用最新版本Node.js
正确应用流 Stream
代码层面优化
内存治理优化

10.3.1 应用最新版本Node.js

每个版本的性能晋升次要来自于两个方面：

V8 的版本更新
Node.js 外部代码的更新优化

10.3.2 正确应用流

在Node中，很多对象都实现了流，对于一个大文件能够通过流的模式发送，不须要将其齐全读入内存。

const http = require('http');const fs = require('fs');// 谬误形式http.createServer(function (req, res) {    fs.readFile(__dirname + '/data.txt', function (err, data) {        res.end(data);    });});// 正确形式http.createServer(function (req, res) {    const stream = fs.createReadStream(__dirname + '/data.txt');    stream.pipe(res);});

10.3.3 代码层面优化

合并查问，将屡次查问合并一次，缩小数据库的查问次数。

// 谬误形式for user_id in userIds      let account = user_account.findOne(user_id)// 正确形式const user_account_map = {}   // 留神这个对象将会耗费大量内存。user_account.find(user_id in user_ids).forEach(account){    user_account_map[account.user_id] =  account}for user_id in userIds     var account = user_account_map[user_id]

10.3.4 内存治理优化

在 V8 中，次要将内存分为新生代和老生代两代：

新生代：对象的存活工夫较短。新生对象或只通过一次垃圾回收的对象。
老生代：对象存活工夫较长。经验过一次或屡次垃圾回收的对象。

若新生代内存空间不够，间接调配到老生代。通过缩小内存占用，能够进步服务器的性能。如果有内存泄露，也会导致大量的对象存储到老生代中，服务器性能会大大降低，比方上面的例子。

const buffer = fs.readFileSync(__dirname + '/source/index.htm');app.use(    mount('/', async (ctx) => {        ctx.status = 200;        ctx.type = 'html';        ctx.body = buffer;        leak.push(fs.readFileSync(__dirname + '/source/index.htm'));    }));const leak = [];

当leak的内存十分大的时候，就有可能造成内存泄露，该当防止这样的操作。

缩小内存应用，能够显著的进步服务性能。而节俭内存最好的形式是应用池，其将频用、可复用对象存储起来，缩小创立和销毁操作。例如有个图片申请接口，每次申请，都须要用到类。若每次都须要从新new这些类，并不是很适合，在大量申请时，频繁创立和销毁这些类，造成内存抖动。而应用对象池的机制，对这种频繁须要创立和销毁的对象保留在一个对象池中，从而防止重读的初始化操作，从而进步框架的性能。