node基础入门、npm与包、Express中间件

1 Node.js 简介

Node.js 是基于 CHrome V8 引擎的 JavaScript 运行环境。

浏览器是 JavaScript 的前端运行环境；

Node.js 是 JavaScript 的后端运行环境；

Node.js 中无法调用 DOM 和 BOM等浏览器内置的API。

浏览器中的 JavaScript 学习路径：
JavaScript 基础语法 + 浏览器内置 API（DOM + BOM） + 第三方库（jQuery、art-template 等）

Node.js 的学习路径：
JavaScript 基础语法 + Node.js 内置 API 模块（fs、path、http等）+ 第三方 API 模块（express、mysql 等）

2 fs 文件系统模块

2.1 什么是 fs 文件系统模块

fs 模块 是 Node.js 官方提供、用来操作文件的模块，提供了一系列的方法和属性。

例如：

fs.readFile() 方法，用来读取指定文件中的内容

fs.writeFile() 方法，用来向指定的文件写入内容

引入 fs ：

const fs = require('fs');

2.2 读取指定文件中的内容

1 fs.readFile() 语法格式。

fs.readFile( path[,options], callback);

参数解读： 被中括号[]包起来的参数，即是可选参数。

参数1：必选参数，字符串，表示文件的路径。

参数2：可选参数，表示以什么编码格式来读取文件。

参数3：必选参数，文件读取完成后，通过回调函数拿到读取的结果。

2 fs.readFile() 实例代码。

以 utf8 的编码格式，读取指定文件内容，并打印 err 和 dataStr 的值。

// 1 引入 fs 模块
const fs = require("fs");

// 2 调用 fs.readFile() 方法读取文件
fs.readFile("./files/1.txt", "utf8", (err, res) => {
    
    
  console.log("err", err); // 失败的结果
  console.log("res", res); // 成功的返回值
});

// 如果读取成功，则 err 的值为 null
// 如果读取失败，则 err 的值为 错误对象，res 的值为 undefined

2.3 向指定的文件中写入内容

1 fs.writeFile() 语法格式。

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

参数解读：

参数1：必选参数，需要指定一个文件路径的字符串，表示文件的存放路径。（如果路径对应的文件不存在，即 会创建一个新文件写入内容。）

参数2：必选参数，表示要写入的内容。

参数3：可选参数，表示以什么格式写入文件内容，默认值是 utf8。

参数4：必选参数，文件写入完成后的回调函数

2 fs.writeFile() 示例代码。

// 1 引入 fs 模块
const fs = require("fs");

// 2 调用 fs.writeFile() 方法读取文件
fs.writeFile("./files/2.txt", "222txt内容", (err) => {
    
    
  console.log("err", err);
});

// 如果写入成功，则 err 的值等于 null  
// 如果写入失败，则 err 的值等于一个 错误对象

2.4 案例

读取文件，处理数据，写入文件。

// 1 引入 fs 模块
const fs = require("fs");

// 2 调用 fs.readFile() 方法读取文件
fs.readFile("./files/成绩.txt", "utf8", (err, res) => {
    
    
  // 3 判断是否读取成功
  if (err) {
    
    
    return console.log("读取文件失败！", err);
  }

  // 4 读取文件成功后
  // 4.1 先把成绩的数据，按照空格进行分割
  const data = res.split(" ");

  // 4.2 将 = 替换 ：
  const data2 = data.map((item) => item.replace("=", "："));

  // 4.3 再将新数组中的每一项，进行合并，得到新的字符串 \r\n 表示换行的意思
  const str = data2.join("\r\n");

  //   5 调用 fs.writeFile() 方法，把处理完的数据写入到新的文件中
  fs.writeFile("./files/成绩2.txt", str, (err) => {
    
    
    if (err) {
    
    
      return console.log("写入文件失败！", err);
    }
    console.log("写入成功！");
  });
});

2.5 fs 模块 - 路径动态拼接问题

在使用 fs 模块操作文件时，如果提供的操作路径是以 ./ 或 …/ 开头的相对路径时，很容易出现路径动态拼接错误的问题。

原因：代码在运行的时候，会以执行 node 命令时所处的目录，动态拼接出被操作文件的完整路径。

解决方案：在使用 fs 模块操作文件时，直接提供完整的路径，不要提供 ./ 或 …/ 开头的相对路径，从而防止路径动态拼接的问题。

即是从盘符开始写。

const fs = require("fs");

fs.readFile("C:\\Users\\blank\\Desktop\\2022node\\代码笔记\\files\\1.txt", "utf8", (err, res) => {
    
    
  console.log("err", err);
  console.log("res", res);
});

缺点：移植性比较差，不利于维护。

更优方案： __dirname 表示当前文件所处的目录。

const fs = require("fs");

fs.readFile(__dirname + "/files/1.txt", "utf8", (err, res) => {
    
    
  console.log("err", err);
  console.log("res", res);
});

---

3 path 路径模块

3.1 什么是 path 路径模块

path 模块是 Node.js 官方提供的、用来处理路径的模块。它提供了一系列的方法和属性，用来满足用户对路径的处理需求。

例如：

path.join() 方法，用来将多个路径片段拼接成一个完整的路径字符串

path.basename() 方法，用来从路径字符串中，将文件名解析出来

引入 path 模块：

const path = require('path');

3.2 路径拼接 path.join()

path.join() 方法可以将多个路径片段拼接位完整的路径字符串。

语法格式：

path.join([...paths]);

参数解读：

…paths 路径片段的序列，可以任意多个

返回值：

代码实例：

const path = require("path");
const fs = require("fs");

// 注意：../ 会抵消前面的路径
const pathStr = path.join("/a", "/b/c", "../", "./d", "e");
console.log(pathStr); // 一组 "../" 即抵消前面一个路径 \a\b\d\e

const pathStr2 = path.join("/a", "/b/c", "../../", "./d", "e");
console.log(pathStr2); // 两组 "../" 即抵消前面两个个路径 \a\d\e

// fs.readFile(__dirname + "./files/1.txt", "utf8", (err, res) => {
    
    

fs.readFile(path.join(__dirname, "/files/1.txt"), "utf8", (err, res) => {
    
    
  console.log("err", err);
  console.log("res", res);
});

3.3 获取路径中的文件名 path.basename()

path.basename()可以获取路径中的最后一部分，经常通过这个方法获取路径中的文件名。

语法格式如下：

path.basename(path[, ext]);

参数解读：

path 必选参数，表示一个路径的字符串

ext 可选参数，表示文件扩展名。如果传入第二个参数，即返回值不包括扩展名

返回: 表示路径中的最后一部分

代码实例：

const path = require("path");

// 定义文件的存放路径
const fpath = '/a/b/c/index.html'

const fullName = path.basename(fpath);
console.log('包含扩展名',fullName); // 包含扩展名 index.html

const nameWithoutExt = path.basename(fpath,'.html');
console.log('不包含扩展名',nameWithoutExt); // 不包含扩展名 index

3.4 获取路径中的扩展名 path.extname()

path.extname() 方法，可以获取路径中的扩展名部分。

语法格式如下：

path.extname(path)

参数解读：

path 必选参数，表示一个路径的字符串

返回: 返回得到的扩展名字符串

实例代码：

const path = require("path");

// 定义文件的存放路径
const fpath = '/a/b/c/index.html'

const fext = path.extname(fpath);
console.log('文件扩展名',fext); // .html

3.5 综合案例

---

4 http 模块

4.1 什么是 http 模块

在网络节点中，负责消费资源的电脑，叫做客户端；
负责对外提供网络资源的电脑，叫做服务器。

http 模块 是 Node.js 官方提供的、用来 创建 web 服务器 的模块。通过 http 模块提供的 http.createServer() 方法，就能方便的把一台普通的电脑，变成一台 Web 服务器，从而对外提供 Web 资源服务。

导入 http 模块：

const http = require('http');

4.2 理解 http 模块的作用

服务器和普通电脑的区别在于，服务器上安装了 web 服务器软件，例如：IIS、Apache 等。通过安装这些服务器软件，就能把一台普通的电脑变成一台 web 服务器。

在 Node.js 中，我们不需要使用 IIS、Apache 等这些第三方 web 服务器软件。因为我们可以基于 Node.js 提供的
http 模块，通过几行简单的代码，就能轻松的手写一个服务器软件，从而对外提供 web 服务。

4.3 服务器相关的概念

1 IP 地址

IP 地址就是互联网上每台计算机的唯一地址， 因此 IP 地址具有唯一性。如果把“个人电脑”比作“一台电话”，那么“IP地址”就相当于“电话号码”，只有在知道对方 IP 地址的前提下，才能与对应的电脑之间进行数据通信。

IP 地址的格式：通常用“点分十进制”表示成（a.b.c.d）的形式，其中，a,b,c,d 都是 0~255 之间的十进制整数。例如：用点分十进表示的 IP地址（192.168.1.1）

注意：
① 互联网中每台 Web 服务器，都有自己的 IP 地址，例如：大家可以在 Windows 的终端中运行 ping www.baidu.com 命令，即可查看到百度服务器的 IP 地址。

② 在开发期间，自己的电脑既是一台服务器，也是一个客户端，为了方便测试，可以在自己的浏览器中输入 127.0.0.1 这个IP 地址，就能把自己的电脑当做一台服务器进行访问了。

2 域名和域名服务器

尽管 IP 地址能够唯一地标记网络上的计算机，但IP地址是一长串数字，不直观，而且不便于记忆，于是人们又发明了另一套字符型的地址方案，即所谓的域名（Domain Name）地址。

IP地址和域名是一一对应的关系，这份对应关系存放在一种叫做域名服务器(DNS，Domain name server)的电脑中。使用者只需通过好记的域名访问对应的服务器即可，对应的转换工作由域名服务器实现。因此，域名服务器就是提供 IP 地址和域名之间的转换服务的服务器。

注意：
① 单纯使用 IP 地址，互联网中的电脑也能够正常工作。但是有了域名的加持，能让互联网的世界变得更加方便。
② 在开发测试期间， 127.0.0.1 对应的域名是 localhost，它们都代表我们自己的这台电脑，在使用效果上没有任何区别。（ 127.0.0.1 === localhost ）

3 端口号

计算机中的端口号，就好像是现实生活中的门牌号一样。通过门牌号，外卖小哥可以在整栋大楼众多的房间中，准确把外卖送到你的手中。

同样的道理，在一台电脑中，可以运行成百上千个 web 服务。每个 web 服务都对应一个唯一的端口号。客户端发送过来的网络请求，通过端口号，可以被准确地交给对应的 web 服务进行处理。

注意：
① 每个端口号不能同时被多个 web 服务占用。
② 在实际应用中，URL 中的 80 端口可以被省略。

4.4 创建 web 服务器

1 基本步骤：

① 导入 http 模块
② 创建 web 服务器实例
③ 为服务器实例绑定 request 事件，监听客户端的请求
④ 启动服务器

// 1 导入 http 模块
const http = require("http");

// 2 创建 web 服务器实例
const server = http.createServer();

// 3 为服务器实例绑定 request 事件，监听客户端的请求
server.on("request", function (req, res) {
    
    
  console.log("Someone visit our web server.");
});

// 4 启动服务器
server.listen(8080, function () {
    
    
  console.log("server runing at http://127.0.0.1:8080");
});

2 req 请求对象

只要服务器接收到了客户端的请求，就会调用通过 server.on() 为服务器绑定的 request 事件处理函数。

如果想在事件处理函数中，访问与客户端相关的数据或属性，可以使用如下的方式：

// req 是请求对象，包含了与客户端相关的数据和属性
server.on("request", (req) => {
    
    
  const {
    
     url, method } = req;
  console.log('客户端请求的 URL 地址',url);
  console.log('客户端的 method 请求类型',method);
});

3 res 响应对象

在服务器的 request 事件处理函数中，如果想访问与服务器相关的数据或属性，可以使用如下的方式：

res.end()

server.on("request", (req, res) => {
    
    
  const {
    
     url, method } = req;
  const str = `客户端请求的URL地址为：${
      
      url}，客户端的请求类型为：${
      
      method}。`;
  
  res.end(str); // res.end() 方法的作用：向客户端发送指定的内容，并结束这次请求的处理过程。
});

4 解决中文乱码问题

当调用 res.end() 方法，向客户端发送中文内容的时候，会出现乱码问题，此时，需要手动设置内容的编码格式：

res.setHeader(“Content-Type”, “text/html; charset=utf-8”);

server.on("request", (req, res) => {
    
    
  const {
    
     url, method } = req;
  const str = `客户端请求的URL地址为：${
      
      url}，客户端的请求类型为：${
      
      method}。`;

  // 为了防止中文显示乱码的问题，需要设置响应头 Content-Type 的值为 text/html;charset=utf-8
  res.setHeader("Content-Type", "text/html; charset=utf-8"); // 固定写法
  res.end(str); 
});

5 根据不同的url响应不同的html内容

核心实现步骤：
① 获取请求的 url 地址
② 设置默认的响应内容为 404 Not found
③ 判断用户请求的是否为 / 或 /index.html 首页
④ 判断用户请求的是否为 /about.html 关于页面
⑤ 设置 Content-Type 响应头，防止中文乱码
⑥ 使用 res.end() 把内容响应给客户端

const http = require("http");
const server = http.createServer();

server.on("request", function (req, res) {
    
    
  // 1 获取请求的 url 地址
  const {
    
     url } = req;
  // 2 设置默认的内容为 404 Not Found
  let content = "<h1>404 Not Found!</h1>";

  // 3 根据 url 确定要显示的内容
  if (url === "/" || url === "/index.html") {
    
    
    content = "<h1>index页面</h1>";
  } else if (url === "/about.html") {
    
    
    content = "<h1>about页面</h1>";
  }

  res.setHeader("Content-Type", "text/html; charset=utf-8");
  res.end(content);
});

server.listen(80, function () {
    
    
  console.log("server runing at http://127.0.0.1");
});

---

5 模块化

5.1 模块化的概念

1 什么是模块化

编程领域中的模块化，就是遵守固定的规则，把一个大文件拆成独立并互相依赖的多个小模块。也就是把一个复杂问题才分成小模块进行处理。

把代码进行模块化拆分的好处：

提高了代码的复用性

提高了代码的可维护性

可以实现按需加载

2 模块化规范

模块化规范就是对代码进行模块化的拆分与组合时，需要遵守的那些规则。

例如：使用什么样的语法格式来引用模块、在模块中使用什么样的语法格式向外暴露成员

模块化规范的好处：

大家都遵守同样的模块化规范写代码，降低了沟通成本，极大方便了各个模块之间的相互调用，利人利己。

5.2 node.js 中的模块化

1 node.js 中模块化的分类

node.js 中根据模块来源的不同，将模块分为3类，分别是：

内置模块：由node.js官网提供的，例如fs、path、http 等

自定义模块：用户创建的每个.js文件，都是自定义模块

第三方模块：由第三方开发出来的模块，并非官方提供的内置模块，也不是用户创建的自定义模块，使用前需要先下载

2 加载模块

使用强大的 require() 方法，可以加载需要的各个模块进行使用。例如：

// 1 加载内置的 fs 模块
const fs = require('fs');

// 2 加载用户定义的自定义模块（需要通过路径） 
const custom = require('./custom.js');
const custom = require('./custom');//可以省略.js后缀名

// 3 加载第三方模块 
const moment = require('moment');

注意：使用 require() 方法加载其他模块时，会执行被加载模块中的代码。

3 node.js 中的模块作用域

和函数作用域类似，在自定义模块中定义的变量、方法等成员，只能在当前模块内被访问，这种模块级别的访问限制，叫做模块作用域。

模块作用域的好处：防止了全局变量污染的问题。

4 向外共享模块作用域中的成员

(1) module 对象

在每个.js自定义模块中都有一个module 对象，它里面存储了和当前模块有关的信息。

Module {
    
    
  id: '.',
  path: 'C:\\Users\\blank\\Desktop\\2022node\\代码笔记',
  exports: {
    
    },
  filename: 'C:\\Users\\blank\\Desktop\\2022node\\代码笔记\\10 module.js',
  loaded: false,
  children: [],
  paths: [
    'C:\\Users\\blank\\Desktop\\2022node\\代码笔记\\node_modules',
    'C:\\Users\\blank\\Desktop\\2022node\\node_modules',
    'C:\\Users\\blank\\Desktop\\node_modules',
    'C:\\Users\\blank\\node_modules',
    'C:\\Users\\node_modules',
    'C:\\node_modules'
  ]
}

(2) module.exports 对象

在自定义模块中，使用 module.exports 向外共享成员，供外界使用。默认 module.exports 等于一个空对象 。

外界用 require() 方法导入自定义模块时，得到的就是 module.exports 所指的对象。

自定义组件：

// 在一个自定义模块中，默认情况下，module.exports === {}

// 向 module.exports 对象上挂载 username 属性
module.exports.username = "小徐";

// 向 module.exports 对象上挂载 sayHello 方法
module.exports.sayHello = function () {
    
    
  console.log("Hello!");
};

const age = 24;
module.exports.age = age;

外界接收组件：

// 在外界使用 require 导入一个自定义的模块的时候，得到的成员就是，那个模块中
// 通过 module.exports 指向的那个对象

const zhidingyi = require("./11 自定义模块");

console.log(zhidingyi);// { username: '小徐', sayHello: [Function (anonymous)], age: 24 }

(3) 共享成员时的注意点

使用 require() 方法导入模块时，导入的结果，永远以 module.exports 指向的对象为准。

// 在一个自定义模块中，默认情况下，module.exports === {}

// 向 module.exports 对象上挂载 username 属性
module.exports.username = "小徐";

// 向 module.exports 对象上挂载 sayHello 方法
module.exports.sayHello = function () {
    
    
  console.log("Hello!");
};

const age = 24;
module.exports.age = age;

// 让 module.exports 指向一个全新的对象。
// 也就是在该文件中，最后输出的对象是下面最后指向的对象
module.exports = {
    
    
    nikename:'香香',
    sayHi(){
    
    
        console.log('Hi! xx');
    }
}

(4) exports 对象

由于 module.export 单词写起来比较复杂，为了简化向外共享的代码，node 提供了 exports 对象。

默认情况下，exports 和 module.exports 指向同一个对象。

最终共享的结果，还是以 module.exports 指向的对象为准。

module.exports.username = "小徐";

exports.username = "小徐";

// 二者作用相同

(5) exports 与 module.exports 使用误区

注意，require() 模块时，得到的永远是 module.exports 指向的对象。

export.username = 'xiaoxu';
module.exports = {
    
    
    gender: 'nan',
    age: 22
}

// 最终输出的对象是 
{
    
     
    gender: 'nan',
	age: 22
}

module.exports.username = 'xiaoxu';
export = {
    
    
    gender: 'nan',
    age: 22
}

// 最终输出的对象是 
{
    
     
    username: 'xiaoxu',
}

exports.username = 'xiaoxu';
module.exports.gender = 'nan';

// 最终输出的对象是 
{
    
     
    username: 'xiaoxu',
	gender: 'nan'
}

export = {
    
    
    username: 'xiaoxu',
    gender: 'nan',
}
module.exports = exports;
module.exports.age = 22

// 最终输出的对象是 
{
    
     
    username: 'xiaoxu',
	gender: 'nan',
    age: 22
}

注意： 为了防止混乱，尽量不要在 同一个模块中同时使用 exports 和 module.exports

5 node.js 中的模块化规范

node.js 遵循了 CommonJS 模块化规范，CommonJS 规定了模块的特性和各模块之间相互依赖。

CommonJS 规定：

(1) 每个模块内部，module 变量代表当前模块；

(2) module 变量是一个对象，它的 exports 属性（即是module.exports）是对外的接口；

(3) 加载某个模块，其实就是加载目标模块的 module.exports 属性。require() 方法用于加载模块。

---

6 npm 与 包

6.1 包

1 什么是包

node.js 中的第三方模块又叫做包。

2 包的来源

不同于 Node.js 中的内置模块与自定义模块，包是由第三方个人或团队开发出来的，免费供所有人使用。

注意：Node.js 中的包都是免费且开源的，不需要付费即可免费下载使用。

3 为什么需要包

由于 Node.js 的内置模块仅提供了一些底层的 API，导致在基于内置模块进行项目开发的时，效率很低。

包是基于内置模块封装出来的，提供了更高级、更方便的 API，极大的提高了开发效率。

包和内置模块之间的关系，类似于 jQuery 和 浏览器内置 API 之间的关系。

4 从哪里下载包

国外有一家 IT 公司，叫做 npm, Inc. 这家公司旗下有一个非常著名的网站： https://www.npmjs.com/ ，它是全球最大的包共享平台，你可以从这个网站上搜索到任何你需要的包，只要你有足够的耐心！

到目前位置，全球约 1100 多万的开发人员，通过这个包共享平台，开发并共享了超过 120 多万个包 供我们使用。

npm, Inc. 公司提供了一个地址为 https://registry.npmjs.org/ 的服务器，来对外共享所有的包，我们可以从这个服务器上下载自己所需要的包。

注意：

• 从 https://www.npmjs.com/ 网站上搜索自己所需要的包

• 从 https://registry.npmjs.org/ 服务器上下载自己需要的包

5 如何下载包

npm, Inc. 公司提供了一个包管理工具，我们可以使用这个包管理工具，从 https://registry.npmjs.org/ 服务器把需要的包下载到本地使用。

这个包管理工具的名字叫做 Node Package Manager（简称 npm 包管理工具），这个包管理工具随着 Node.js 的安装包一起被安装到了用户的电脑上。

大家可以在终端中执行 npm -v 命令，来查看自己电脑上所安装的 npm 包管理工具的版本号

6.2 npm

1 安装指定包的命令

npm install 包的完整名称

// 简写
npm i 包的完整名称

2 初次装包后多了哪些文件

初次装包完成后，在项目文件夹下多一个叫做 node_modules 的文件夹和 package-lock.json 的配置文件。

其中：

node_modules文件夹 用来存放所有已安装到项目中的包。require() 导入第三方包时，就是从这个目录中查找并加载包。

package-lock.json配置文件 用来记录 node_modules 目录下的每一个包的下载信息，例如包的名字、版本号、下载地址等。

注意：程序员不要手动修改 node_modules 或 package-lock.json 文件中的任何代码，npm 包管理工具会自动维护它们。

3 安装指定版本的包

默认情况下，使用 npm install 命令安装包的时候，会自动安装最新版本的包。如果需要安装指定版本的包，可以在包名之后，通过 @ 符号指定具体的版本，例如：

npm i moment@2.22.2

4 包的语义化版本规范

包的版本号是以“点分十进制”形式进行定义的，总共有三位数字，例如 2.24.0

其中每一位数字所代表的的含义如下：

第1位数字：大版本

第2位数字：功能版本

第3位数字：Bug修复版本

版本号提升的规则：只要前面的版本号增长了，则后面的版本号归零。

6.3 包管理配置文件

npm 规定，在项目根目录中，必须提供一个叫做 package.json 的包管理配置文件。

用来记录与项目有关的一些配置信息。例如：

• 项目的名称、版本号、描述等

• 项目中都用到了哪些包

• 哪些包只在开发期间会用到

• 那些包在开发和部署时都需要用到

1 多人协作的问题

多人协作时会遇到的问题：第三方包的体积过大，不方便团队成员之间共享项目源代码。

解决方案：共享时剔除node_modules

2 如何记录项目中安装了哪些包

在项目根目录中，创建一个叫做 package.json 的配置文件，即可用来记录项目中安装了哪些包。

从而方便剔除 node_modules 目录之后，在团队成员之间共享项目的源代码。

注意：今后在项目开发中，一定要把 node_modules 文件夹，添加到 .gitignore 忽略文件中。

3 快速创建 package.json

npm包管理工具提供了一个快捷命令，可以在执行命令时所处的目录中，快速创建 package.json
这个包管理配置文件：

// 作用：在执行命令所在目录中，快速新建 package.json 文件
npm init -y

// 执行该命令的时机，是在新建好项目文件夹的时候，不要开始写任何代码，第一步要做的任务就是执行该命令，而且这个命令在项目中只需要执行一次就够了，目的就是创建package.json文件。

注意：

• 上述命令只能在英文的目录下成功运行！所以，项目文件夹的名称一定要使用英文命名，不要使用中文，不能出现空格。

• 运行 npm install 命令安装包的时候，npm 包管理工具会自动把包的名称和版本号，记录到 package.json 中。

4 dependencies 节点

package.json文件中，有一个dependencies节点，专门用来记录您使用npminstall 命令安装了哪些包。

5 一次性安装所有的包

当我们拿到一个剔除了 node_modules 的项目之后，需要先把所有的包下载到项目中，才能将项目运行起来。

否则会报类似于下面的错误：

// 由于项目运行依赖于moment这个包，如果没有提前安装好这个包，就会报一下错误
Error: Cannot find module 'moment'

可以运行 npm install 命令（或 npmi）一次性安装所有的依赖包：

// 执行 npm install 命令时，npm 包管理工具会先读取 package.json 中的 dependencies 节点。
// 读取到记录的所有依赖包名称和版本号之后，npm 包管理工具会把这些包一次性下载到项目中。
npm install

6 卸载包

可以运行 npm uninstall 命令，来卸载指定的包：

// 使用 npm uninstall 具体的报名，来卸载包
npm uninstall moment

注意：npm uninstall 命令执行成功后，会把卸载的包，自动从 package.json 的 dependencies 中移除掉。

7 devDependcise 节点

如果某些包只在项目开发阶段会用到，在项目上线之后不会用到，则建议把这些包记录到 devDependencies 节点中。

与之对应的，如果某些包在开发和项目上线之后都需要用到，则建议把这些包记录到 dependencies 节点中。

您可以使用如下的命令，将包记录到 devDependencies 节点中：

// 安装指定的包，并记录到 devDependcise 节点中
npm i 报名 -D

// 注意：上述命令是简写形式，等价于下面完整的写法
npm  install 报名 --save-dev

6.4 解决下包速度慢的问题

1 为什么下包速度慢

在使用 npm 下包的时候，默认从国外的 https://registry.npmjs.org/ 服务器进行下载，此时，网络数据的传输需要经过漫长的海底光缆，因此下包速度会很慢。

扩展阅读 - 海底光缆：

• https://baike.baidu.com/item/%E6%B5%B7%E5%BA%95%E5%85%89%E7%BC%86/4107830](https://baike.baidu.com/item/海底光缆/4107830)

• https://baike.baidu.com/item/%E4%B8%AD%E7%BE%8E%E6%B5%B7%E5%BA%95%E5%85%89%E7%BC%86/10520363

• https://baike.baidu.com/item/APG/23647721?fr=aladdin

2 淘宝 NPM 镜像服务器

淘宝在国内搭建了一个服务器，专门把国外官方服务器上的包同步到国内的服务器，然后在国内提供下包的服务。从而极大的提高了下包的速度。

扩展：

镜像（Mirroring）是一种文件存储形式，一个磁盘上的数据在另一个磁盘上存在一个完全相同的副本即为镜像。

3 切换 npm 的下包镜像源

下包的镜像源，是指下包的服务器地址。

// 查看当前的下包镜像源
npm config get registry

// 将下包的镜像源切换为淘宝镜像源
npm config set registry=https://registry.npm.taobao.org/

4 nrm

为了更方便的切换下包的镜像源，我们可以安装 nrm 这个小工具，利用 nrm 提供的终端命令，可以快速查看和切换下包的镜像源。

// 通过 npm 包管理器，将 nrm 安装为全局可用的工具
npm i nrm -g

// 查看所有可用的镜像源
nrm ls

// 将下包的镜像源切换为 taobao 镜像
nrm use taobao

6.5 包的分类

使用 npm 包管理工具下载的包，共分为两大类，分别是：项目包、全局包。

1 项目包

那些被安装到项目的 node_modules 目录中的包，都是项目包。

项目包又分为两类，分别是：

• 开发依赖包（被记录到 devDependencies 节点中的包，只在开发期间会用到）

• 核心依赖包（被记录到 dependencies 节点中的包，在开发期间和项目上线之后都会用到）

npm i 包名 -D  	// 开发依赖包
npm i 包名		// 核心依赖包

2 全局包

在执行 npm install 命令时，如果提供了 -g 参数，则会把包安装为全局包。

全局包会被安装到 C:\Users\用户目录\AppData\Roaming\npm\node_modules 目录下。

npm i 包名 -g			// 安装指定的包到全局
npm uninstall 包名 -g	// 指定卸载全局安装的包

注意：

• 只有工具性质的包，才有全局安装的必要性。因为它们提供了好用的终端命令。

• 判断某个包是否需要全局安装后才能使用，可以参考官方提供的使用说明即可。

3 i5ting_toc

i5ting_toc 是一个可以把 md 文档转为 html 页面的小工具，使用步骤如下：

// 将 i5ting_toc 安装为全局包
npm install -g i5ting_toc

// 调用 i5ting_toc 轻松实现 md 转 HTML 的功能。-o 表示转换完成后自动在浏览器打开 
i5ting_toc -f 要转换的md文件的路径 -o

6.6 规范的包结构

在清楚了包的概念、以及如何下载和使用包之后，接下来，我们深入了解一下包的内部结构。

一个规范的包，它的组成结构，必须符合以下 3 点要求：

• ① 包必须以 单独的目录 而存在

• ② 包的顶级目录下要必须包含 package.json 这个包管理配置文件

• ③ package.json 中必须包含 name，version，main 这三个属性，分别代表包的名字、版本号、包的入口。

●

注意：以上 3 点要求是一个规范的包结构必须遵守的格式，关于更多的约束，可以参考如下网址：

https://yarnpkg.com/zh-Hans/docs/package-json

6.7 在npm发布包

1 注册 npm 账号

①访问 https://www.npmjs.com/ 网站，点击 sign up 按钮，进入注册用户界面

②填写账号相关的信息：Full Name、Public Email、Username、Password

③点击 Create an Account 按钮，注册账号

④登录邮箱，点击验证链接，进行账号的验证

2 登录 npm 账号

npm 账号注册完成后，可以在终端中执 npm login 命令，依次输入用户名、密码、邮箱后，即可登录成功。

**注意：**在运行 npm login 命令之前，必须先把下包的服务器地址切换为 npm 的官方服务器。否则会导致发布包失败！

3 把包发布到 npm 上

将终端切换到包的根目录之后，运行 npm publish 命令，即可将包发布到 npm 上（注意：包名不能雷同）。

4 删除已发布的包

运行 npm unpublish 包名 --force 命令，即可从 npm 删除已发布的包。

注意：

①npm unpublish 命令只能删除 72 小时以内发布的包

②npm unpublish 删除的包，在 24 小时内不允许重复发布

③发布包的时候要慎重，尽量不要往 npm 上发布没有意义的包！

---

7 模块的加载机制

7.1 优先从缓存中进行加载

模块在第一次加载后会被缓存。 这也意味着多次调用 require() 不会导致模块的代码被执行多次。

注意：不论是内置模块、用户自定义模块、还是第三方模块，它们都会优先从缓存中加载，从而提高模块的加载效率。

7.2 内置模块的加载机制

内置模块是由 Node.js 官方提供的模块，内置模块的加载优先级最高。

例如，require(‘fs’) 始终返回内置的 fs 模块，即使在 node_modules 目录下有名字相同的包也叫做 fs。

7.3 自定义模块的加载机制

使用 require() 加载自定义模块时，必须指定以 ./ 或 …/ 开头的路径标识符。

在加载自定义模块时，如果没有指定 ./ 或 …/ 这样的路径标识符，则 node 会把它当作内置模块或第三方模块进行加载。

同时，在使用 require() 导入自定义模块时，如果省略了文件的扩展名，

则 Node.js 会按顺序分别尝试加载以下的文件：

①按照确切的文件名进行加载

②补全 .js 扩展名进行加载

③补全 .json 扩展名进行加载

④补全 .node 扩展名进行加载

⑤加载失败，终端报错

7.4 第三方模块的加载机制

如果传递给 require() 的模块标识符不是一个内置模块，也没有以 ‘./’ 或 ‘…/’ 开头，则 Node.js 会从当前模块的父目录开始，尝试从 /node_modules 文件夹中加载第三方模块。

如果没有找到对应的第三方模块，则移动到再上一层父目录中，进行加载，直到文件系统的根目录。

例如，假设在 ‘C:\Users\xiaoxu\project\foo.js’ 文件里调用了 require(‘tools’)，则 Node.js 会按以下顺序查找：

① C:\Users\xiaoxu\project\node_modules\tools

② C:\Users\xiaoxu\node_modules\tools

③ C:\Users\node_modules\tools

④ C:\node_modules\tools

7.5 目录作为模块

当把目录作为模块标识符，传递给 require() 进行加载的时候，有三种加载方式：

①在被加载的目录下查找一个叫做 package.json 的文件，并寻找 main 属性，作为 require() 加载的入口

②如果目录里没有 package.json 文件，或者 main 入口不存在或无法解析，则 Node.js 将会试图加载目录下的 index.js 文件。

③如果以上两步都失败了，则 Node.js 会在终端打印错误消息，报告模块的缺失：Error: Cannot find module ‘xxx’

---

8 Express

8.1 Express 简介

1 什么是 Express

官方给出的概念：Express 是基于 Node.js 平台，快速、开放、极简的 Web 开发框架。

通俗的理解：Express 的作用和 Node.js 内置的 http 模块类似，是专门用来创建 Web 服务器的。

Express 的本质：就是一个 npm 上的第三方包，提供了快速创建 Web 服务器的便捷方法。

Express 的中文官网： http://www.expressjs.com.cn/

2 进一步理解 Express

思考：不使用 Express 能否创建 Web 服务器？

答案：能，使用 Node.js 提供的原生 http 模块即可。

思考：既生瑜何生亮（有了 http 内置模块，为什么还有用 Express）？

答案：http 内置模块用起来很复杂，开发效率低；Express 是基于内置的 http 模块进一步封装出来的，能够极大的提高开发效率。

思考：http 内置模块与 Express 是什么关系？

答案：类似于浏览器中 Web API 和 jQuery 的关系。后者是基于前者进一步封装出来的。

3 Express 能做什么

对于前端程序员来说，最常见的两种服务器，分别是：

• Web 网站服务器：专门对外提供 Web 网页资源的服务器。

• API 接口服务器：专门对外提供 API 接口的服务器。

使用 Express，我们 可以方便、快速的创建 Web 网站的服务器或 API 接口的服务器。

8.2 Express 的基本使用

1 安装

在项目所处的目录中，运行如下的终端命令，即可将 express 安装到项目中使用：

npm i express@4.17.1

2 创建基本的 Web 服务器

// 1 导入 express
const express = require('express')

// 2 创建 web 服务器
const app = express()

// 3 启动 web 服务器
app.listen(80,()=>{
    
    
    console.log('express server runing at http://127.0.0.1');
})

3 监听 GET 请求

app.get() 方法，可以监听客户端的 GET 请求。

语法格式：

// 参数1：客户端请求的 URL 地址
// 参数2：请求对应的处理函数
// req：请求对象（包含了与请求相关的属性与方法）
// res：响应对象（包含了与响应相关的属性与方法）

app.get('请求URL', (req, res) => {
    
    
    ... 处理函数
})

4 监听 POST 请求

app.post() 方法，可以监听客户端的 POST 请求。

语法格式：

// 参数1：客户端请求的 URL 地址
// 参数2：请求对应的处理函数
// req：请求对象（包含了与请求相关的属性与方法）
// res：响应对象（包含了与响应相关的属性与方法）

app.post('请求URL', (req, res) => {
    
    
    ... 处理函数
})

5 把内容响应给客户端

res.send()方法，可以把处理好的内容，发送给客户端。

app.get("/user", (req, res) => {
    
    
  // 调用 express 提供的 res.send() 方法，向客户端响应一个 JSON 对象
  res.send({
    
     name: "xiaoxu", age: 20 });
});

app.post("/user", (req, res) => {
    
    
  // 调用 express 提供的 res.send() 方法，向客户端响应一个 文本字符串
  res.send('请求成功');
});

6 获取 URL 中携带的查询参数

req.query 对象，可以访问客户端通过查询字符串的形式，发送到服务器的参数：

// req.query 默认是一个空对象
// 客户端使用 ?name=zs&age=20 这种查询字符串形式，发送到服务器的参数
// 可以通过 req.query 对象访问
// 例如：req.query.name  req.query.age

app.get("/", (req, res) => {
    
    
  console.log(req.query);
});

7 获取 URL 中的动态参数

req.params 对象，可以地方问到 URL 中，通过 : 匹配到的动态参数。

// req.params 默认是一个空对象
// 里面存放着通过 : 动态匹配到的参数值

app.get('/user/:id', (req, res) => {
    
    
  console.log(req.params); //{ id:1 }
})

// 注意：
// 其中冒号 : 是固定的，id不是固定的，可以是任意的，是匹配完成后参数的名称
// 动态参数可以有多个
app.get('/user/:id/:username', (req, res) => {
    
    
  console.log(req.params); // { id:1, username:'zs' }
})

8.3 托管静态资源

1 express.static()

express 提供了一个非常好用的函数，叫做 express.static()。

通过它，我们可以非常方便地创建一个静态资源服务器，例如，通过如下代码就可以将 public 目录下的图片、CSS文件、JavaScript文件对外开放访问了：

app.use(express.static('public'))

// 调用 app.use 这个函数，在函数中调用 express.static() 这个方法。
// 在这个方法中需要去指定哪个目录作为静态资源文件夹，进行共享向外托管。
// 指定 public 目录，即可访问 public 目录中的所有文件了。

现在，你就可以访问 public 目录中的所有文件了：

http://localhost:3000/images/bg.jpg

http://localhost:3000/css/style.css

http://localhost:3000/js/login.js

**注意：**Express 在指定的静态目录中查找文件，并对外提供资源的访问路径。

因此，存放静态文件的目录名不会出现在 URL 中。

2 托管多个静态资源目录

如果要托管多个静态资源目录，请多次调用 express.static() 函数：

app.use(express.static('public'))
app.use(express.static('public2'))

访问静态资源文件时，express.static() 函数会根据目录的添加顺序查找所需的文件。

3 挂载路径前缀

如果希望在托管的静态资源访问路径之前，挂载路径前缀，则可以使用如下的方式：

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

现在，你就可以通过带有 /public 前缀地址来访问 public 目录中的文件了：

http://localhost:3000/public/images/kitten.jpg

http://localhost:3000/public/css/style.css

http://localhost:3000/public/js/app.js

8.4 nodemon

1 为什么使用 nodemon

在编写调试 Node.js 项目的时候，如果修改了项目的代码，则需要频繁的手动 close 掉，然后再重新启动，非常繁琐。

现在，我们可以使用 nodemon（https://www.npmjs.com/package/nodemon） 这个工具，它能够监听项目文件的变动，当代码被修改后，nodemon 会自动帮我们重启项目，极大方便了开发和调试。

2 安装 nodemon

npm install -g nodemon

3 使用 nodemon

当基于 Node.js 编写了一个网站应用的时候，传统的方式，是运行 node app.js 命令，来启动项目。这样做的坏处是：代码被修改之后，需要手动重启项目。

现在，我们可以将 node 命令替换为 nodemon 命令，使用 nodemon app.js 来启动项目。这样做的好处是：

代码被修改之后，会被 nodemon 监听到，从而实现自动重启项目的效果。

node app.js

nodemon app.js

9 Express 路由

9.1 路由的概念

1 什么是路由

在 Express 中，路由指的是客户端的请求与服务器处理函数之间的映射关系。

2 路由的3个组成部分

Express 中的路由分 3 部分组成，分别是：请求的类型、请求的 URL 地址、处理函数。

格式如下：(类型与地址都与客户端有关)

app.METHOD(PATH, HANDLER)

METHOD	表示请求的类型		method
PATH	表示请求的地址 	path
HANDLER	处理函数		  handler

Express 中的路由例子：

// 匹配 get 请求，且请求 url 为 / 
app.get('/', function(req, res){
    
    
  res.send("hello world");  
})

// 匹配 post 请求，且请求 url 为 / 
app.post('/', function(req, res){
    
    
  res.send("hello world");  
})

3 路由的匹配过程

每当一个请求到达服务器之后，需要先经过路由的匹配，只有匹配成功之后，才会调用对应的处理函数。

在匹配时会按照路由的顺序进行匹配，如果请求类型和请求的url，同时匹配成功，则Express会将这次请求，转交给对应的function函数进行处理。

路由匹配的注意点 ：

• ① 按照定义的先后顺序进行匹配

• ② 请求类型和请求的URL同时匹配成功，才会调用对应的处理函数

9.2 路由的使用

1 最简单的用法

在 Express 中使用路由最简单的方式，就是把路由挂载到 app 上。

2 模块化路由

为了方便对路由进行模块化的管理，Express 不建议将路由直接挂载到 app 上，而是推荐将路由抽离为单独的模块。

将路由抽离为单独模块的步骤如下：

• ① 创建路由模块对应的 .js 文件

• ② 调用 express.Router() 函数创建路由对象

• ③ 向路由对象上挂载具体的路由

• ④ 使用 module.exports 向外共享路由对象

• ⑤ 使用 app.use() 函数注册路由模块

3 创建路由模块

（1）创建基本的服务器

const express = require("express");
const app = express();

app.listen(80, () => {
    
    
  console.log("http://127.0.0.1");
});

（2）创建路由模块

// 1 导入 express
const express = require("express");

// 2 创建路由对象
const router = express.Router();

// 3 挂载具体的路由
router.get("/user/list", (req, res) => {
    
    
  res.send("Get user list.");
});
router.post("/user/add", (req, res) => {
    
    
  res.send("Add new user.");
});

// 4 向外导出路由对象
module.exports = router;

4 注册路由模块

const express = require("express");
const app = express();

// 1 导入路由模块
const router = require("./router");

// 2 使用app.use() 注册路由模块
app.use(router);

app.listen(80, () => {
    
    
  console.log("http://127.0.0.1");
});

注意：app.use() 函数的作用是：注册全局中间件。

5 为路由模块添加前缀

类似于托管静态资源时，为静态资源统一挂载访问前缀一样，路由模块添加前缀的方式也非常简单 ：

app.use("api", router);
// 使用 app.use() 注册路由模块，并添加统一的访问前缀 /api

---

10 Express 中间件

10.1 中间件的概念

1 什么是中间件

中间件（Middleware），特指业务流程的中间处理环节。

2 例子

在处理污水的时候，一般都要经过三个处理环节，从而保证处理过后的废水，达到排放标准。

处理污水的这三个中间处理环节，就可以叫做中间件。中间件必须要有输入与输出。

3 Express 中间件的调用流程

当一个请求到达Express的服务器之后，可以连续调用多个中间件，从而对这次请求进行预处理。

4 Express 中间件的格式

Express的中间件，本质上就是一个function 处理函数，Express中间件的格式如下：

注意：中间件函数的形参列表中，必须包含 next 参数。而路由处理函数中只包含
req 和 res。

5 next 函数的作用

next 函数是实现多个中间件连续调用的关键，它表示把流转关系转交给下一个中间件或路由。

10.2 Express 中间件的初体验

1 定义中间件函数

定义一个最简单的中间件函数：

const express = require("express");
const app = express();

// 产量 mw 所指向的，就是一个中间件函数
const mw = function (req, res, next) {
    
    
  console.log("定义一个最简单的中间件函数");
  // 注意：当中间件的业务逻辑处理完毕后，必须调用 next() 函数
  // 表示把流转关系转交给下一个中间件或路由。
  next()
};

app.listen(80, () => {
    
    
  console.log("http://127.0.0.1");
});

2 全局生效的中间件

客户端发起的任何请求，到达服务器之后，都会触发的中间件，叫做全局生效的中间件。

通过调用 app.use(中间件函数)，即可定义一个全局生效的中间件，示例代码如下：

// 产量 mw 所指向的，就是一个中间件函数
const mw = function (req, res, next) {
    
    
  console.log("定义一个最简单的中间件函数");
  // 注意：当中间件的业务逻辑处理完毕后，必须调用 next() 函数
  // 表示把流转关系转交给下一个中间件或路由。
  next()
};

// 将 mw 注册为全局生效的中间件。
app.use(mw)

3 全局中间件的简化形式

之间在app.use中传入函数。

app.use((req, res, next) => {
    
    
  console.log("定义一个最简单的中间件函数");
  next();
});

4 中间件的作用

多个中间件之间，共享同一份 req 和 res。基于这样的特性，我们可以在上游的中间件中，统一为req或res对象添加自定义的属性或方法，供下游的中间件或路由进行使用。

app.use((req, res, next) => {
    
    
	// 获取到请求到达服务器的时间
    const time = Date.now();
    
    // req 对象，挂载自定义属性，从而把时间共享给后面的所有路由
    req.startTime = time

    next();
});

5 定义多个全局中间件

可以使用app.use()连续定义多个全局中间件。

客户端请求到达服务器之后，会按照中间件定义的先后顺序依次进行调用，示例代码如下：

6 局部生效的中间件

不使用 app.use() 定义的中间件，叫做局部生效的中间件。

示例代码如下：

const express = require("express"); // 导入 express 模块
const app = express(); // 创建 express 的服务器实例

// 1 定义中间件函数
const mw1 = (req, res, next) => {
    
    
  console.log("调用了局部生效的中间件");
  next();
};

// 2 创建路由
app.get("/", mw1, (req, res) => {
    
    
  // 该请求，会调用 mw1 中间件
  res.send("Home page.");
});
app.get("/user", (req, res) => {
    
    
  // 该请求不会调用 mw1 中间件
  res.send("User page.");
});

app.listen(80, () => {
    
    
  console.log("http://127.0.0.1");
});

7 定义多个局部中间件

可以在路由中，通过如下两种等价的方式，使用多个局部中间件：

// 一下两种写法是“完全等价”的，可以选择任意一种方式进行使用 
app.get("/", mw1, mw2, (req, res) => {
    
    
  res.send("Home page.");
});
app.get("/", [mw1, mw2], (req, res) => {
    
    
  res.send("Home page.");
});

8 了解中间件的5个使用注意事项

• ① 一定要在路由之前注册中间件
• ② 客户端发送过来的请求，可以连续调用多个中间件进行处理
• ③ 执行完中间件的业务代码之后，不要忘记调用 next() 函数
• ④ 为了防止代码逻辑混乱，调用 next() 函数后不要再写额外的代码
• ⑤ 连续调用多个中间件时，多个中间件之间，共享 req 和 res 对象

10.3 中间件的分类

Express 官方把常见的中间件用法，分成了 5 大类，分别是：

• ① 应用级别的中间件
• ② 路由级别的中间件
• ③ 错误级别的中间件
• ④ Express 内置的中间件
• ⑤ 第三方的中间件

1 应用级别的中间件

通过 app.use() 或 app.get() 或 app.post() ，绑定到 app 实例上的中间件，叫做应用级别的中间件，代码示例如下：

// 应用级别中间件（全局中间件）
app.use((req, res, next) => {
    
    
  next();
});

// 应用级别中间件（局部中间件）
app.get("/", mw1,(req, res) => {
    
    
  res.send("Home page.");
});

2 路由级别的中间件

绑定到 express.Router() 实例上的中间件，叫做路由级别的中间件。

它的用法和应用级别中间件没有任何区别。只不过，应用级别中间件是绑定到 app 实例上，路由级别中间件绑定到 router 实例上，代码示例如下：

const app = express()
const router = express.Router()

// 路由级别中间件
router.use((req, res, next) => {
    
    
    next()
})

app.use('/', router);

3 错误级别的中间件

**作用：**专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题。

**格式：**错误级别中间件的 function 处理函数中，必须有 4 个形参，形参顺序从前到后，分别是 (err, req, res, next)。

// 1 人为的制造错误
app.get('/', function(req, res){
    
    
  throw new Error('服务器内部发生了错误') // 抛出一个自定义的错误
  res.send('Home Page')
})

// 2 定义错误级别的中间件，捕获整个项目的异常错误，从而防止程序的崩溃
app.use((err, req, res, next) => {
    
    
  console.log('发生了错误！', err.message) // 在服务器答应错误消息 
  res.send('Error：', err.message) // 向客户响应错误相关的内容
})

**注意：**错误级别的中间件，必须注册在所有路由之后！

4 Express内置的中间件

自 Express 4.16.0 版本开始，Express 内置了 3 个常用的中间件，极大的提高了 Express 项目的开发效率和体验：

• ① express.static 快速托管静态资源的内置中间件，例如： HTML 文件、图片、CSS 样式等（无兼容性）
• ② express.json 解析 JSON 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）
• ③ express.urlencoded 解析 URL-encoded 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）

// 配置解析 application/json 格式数据的内置中间件
app.use(express.json());

// 配置解析 application/x-www-form-urlencoded 格式数据的内置中间件
app.use(express.urlencoded({
    
     extended: false}))

5 第三方的中间件

非 Express 官方内置的，而是由第三方开发出来的中间件，叫做第三方中间件。

在项目中，大家可以按需下载并配置第三方中间件，从而提高项目的开发效率。

例如：在 [email protected] 之前的版本中，经常使用 body-parser 这个第三方中间件，来解析请求体数据。使用步骤如下：

• ① 运行 npm install body-parser 安装中间件
• ② 使用 require 导入中间件
• ③ 调用 app.use() 注册并使用中间件

**注意：**Express 内置的 express.urlencoded 中间件，就是基于 body-parser 这个第三方中间件进一步封装出来的。

10.4 自定义中间件

https://www.bilibili.com/video/BV1a34y167AZ?p=49&vd_source=79669bc2885938b4485dee3a65450388

---

11 使用 Express 写接口

11.1 创建基本的服务器

// 导入 express 模块
const express = require("express");

// 创建 express 的服务器实例
const app = express();

// 调用 app.listen 方法，指定端口号并启动 web 服务器
app.listen(80, function () {
    
    
  console.log("Express server running at http://127.0.0.1");
});

11.2 创建 API 路由模块

apiRouter.js 路由模块

const express = require('express');

const router = express.Router();

// 在这里挂载路由

module.exports = router;

app.js 导入并注册路由模块

const express = require("express");
const app = express();


// 导入路由模块
const router = require("./apiRouter");

// 把路由模块，注册到 app 上
app.use("/api", router);


app.listen(80, function () {
    
    
  console.log("Express server running at http://127.0.0.1");
});

11.3 编写 get 接口

客户端通过查询字符串发送数据给服务端。

const express = require("express");
const router = express.Router();

// 在这里挂载路由
router.get("/get", (req, res) => {
    
    
  // 1 通过 req.query 获取客户端通过查询字符串，发送到服务器的数据
  const query = req.query;

  // 2 调用 res.send() 方法，向客户端响应处理的结果
  res.send({
    
    
    status: 0, // 0 表示处理成功，1 表示处理失败
    msg: "GET 请求成功！", // 状态的描述
    data: query, // 需要响应给客户端的具体数据
  });
});

module.exports = router;

11.4 编写 post 接口

客户端通过请求体传输数据给服务端。

const express = require("express");
const router = express.Router();

router.post("/post", (req, res) => {
    
    
  // 1 获取客户端通过请求体，发送到服务器的 URL-encoded 数据
  const body = req.body;

  // 2 调用 res.send() 方法，把数据响应给客户端
  res.send({
    
    
    status: 0, // 0 表示处理成功，1 表示处理失败
    msg: "POST 请求成功！", // 状态的描述
    data: body, // 需要响应给客户端的具体数据
  });
});

module.exports = router;

注意： 如果要获取 URL-encoded 格式的请求体数据，必须配置中间件，app.use(express.urlencoded({ extended: false }));。

如果不配置该中间件，就无法通过 req.body 获取请求体里面的数据。

11.5 CORS 跨域资源共享

1 接口的跨域问题

编写的 GET 和 POST接口，存在一个很严重的问题：不支持跨域请求。

解决接口跨域问题的方案主要有两种：

• ① CORS（主流的解决方案，推荐使用）

• ② JSONP（有缺陷的解决方案：只支持 GET 请求）

2 使用 cors 中间件解决跨域问题

cors 是 Express 的一个第三方中间件。通过安装和配置 cors 中间件，可以很方便地解决跨域问题。

使用步骤分为如下 3 步：

• ① 运行 npm install cors 安装中间件

• ② 使用 const cors = require(‘cors’) 导入中间件

• ③ 在路由之前调用 app.use(cors()) 配置中间件

// 一定要在路由之前，配置 cors 这个中间件，从而解决接口跨域的问题
const cors = require("cors");
app.use(cors());

// 导入 express 模块
const express = require("express");

// 创建 express 的服务器实例
const app = express();

// 配置解析表单数据的中间件
app.use(express.urlencoded({
    
     extended: false }));

// 一定要在路由之前，配置 cors 这个中间件，从而解决接口跨域的问题
const cors = require("cors");
app.use(cors());

// 导入路由模块
const router = require("./apiRouter");

// 把路由模块，注册到 app 上
app.use("/api", router);

// 调用 app.listen 方法，指定端口号并启动 web 服务器
app.listen(80, function () {
    
    
  console.log("Express server running at http://127.0.0.1");
});

3 什么是CORS

CORS （Cross-Origin Resource Sharing，跨域资源共享）由一系列 HTTP 响应头组成，这些 HTTP 响应头决定浏览器是否阻止前端 JS 代码跨域获取资源。

浏览器的同源安全策略默认会阻止网页“跨域”获取资源。但如果接口服务器配置了 CORS 相关的 HTTP 响应头，就可以解除浏览器端的跨域访问限制。

4 CORS 注意事项

• ①CORS 主要在服务器端进行配置。客户端浏览器无须做任何额外的配置，即可请求开启了 CORS 的接口。

• ②CORS 在浏览器中有兼容性。只有支持 XMLHttpRequest Level2 的浏览器，才能正常访问开启了 CORS 的服务端接口（例如：IE10+、Chrome4+、FireFox3.5+）。

5 CORS 响应头部 - Access-Control-Allow-Origin

响应头部中可以携带一个Access-Control-Allow-Origin字段，其语法如下:

Access-Control-Allow-Origin: <origin> | *
    
// 冒号前面为响应头的 名称
// 冒号后面是响应头的 值。值可以是一个具体的域名，也可以是一个星号

其中，origin 参数的值指定了允许访问该资源的外域 URL。

例如，下面的字段值将只允许来自 http://xxx.cn 的请求：

res.setHeader('Access-Control-Allow-Origin:', 'http://xxx.cn')
// 表示这个服务器只支持 这个http://xxx.cn网页下所有的跨域请求

如果指定了 Access-Control-Allow-Origin 字段的值为通配符 *，表示允许来自任何域的请求。

res.setHeader('Access-Control-Allow-Origin:', '*')

6 CORS 响应头部- Access-Control-Allow-Headers

默认情况下，CORS 仅支持客户端向服务器发送如下的 9 个请求头：

Accept、Accept-Language、Content-Language、DPR、Downlink、Save-Data、Viewport-Width、Width 、Content-Type （值仅限于 text/plain、multipart/form-data、application/x-www-form-urlencoded 三者之一）

如果客户端向服务器发送了额外的请求头信息，则需要在服务器端，通过 Access-Control-Allow-Headers 对额外的请求头进行声明，否则这次请求会失败！

// 允许客户端额外向服务器发送 Content-Type 请求头和 X-Custom-Header 请求头

// 注意：多个请求头之间使用英文的逗号进行分割
res.setHeader('Access-Control-Allow-Headers:', 'Content-Type, X-Custom-Header')

7 CORS 响应头部- Access-Control-Allow-Methods

默认情况下，CORS 仅支持客户端发起 GET、POST、HEAD 请求。

如果客户端希望通过 PUT、DELETE 等方式请求服务器的资源，则需要在服务器端，通过 Access-Control-Alow-Methods来指明实际请求所允许使用的 HTTP 方法。

示例代码如下：

// 只允许 POST、GET、DELETE、HEAD 请求方法
res.setHeader('Access-Control-Allow-Methods:', 'POST, GET, DELETE, HEAD')

// 允许所有的  HTTP 请求方法
res.setHeader('Access-Control-Allow-Methods:', '*')

8 CORS 请求的分类

客户端在请求 CORS 接口时，根据请求方式和请求头的不同，可以将 CORS 的请求分为两大类，分别是：

• ①简单请求

• ②预检请求

9 简单请求

同时满足以下两大条件的请求，就属于简单请求：

• ① 请求方式：GET、POST、HEAD 三者之一

• ② HTTP 头部信息不超过以下几种字段：无自定义头部字段、Accept、Accept-Language、Content-Language、DPR、Downlink、Save-Data、Viewport-Width、Width 、Content-Type（只有三个值application/x-www-form-urlencoded、multipart/form-data、text/plain）

10 预检请求

只要符合以下任何一个条件的请求，都需要进行预检请求：

• ① 请求方式为 GET、POST、HEAD 之外的请求 Method 类型

• ② 请求头中包含自定义头部字段

• ③ 向服务器发送了 application/json 格式的数据

在浏览器与服务器正式通信之前，浏览器会先发送 OPTION 请求进行预检，以获知服务器是否允许该实际请求，所以这一次的 OPTION 请求称为预检请求。

服务器成功响应预检请求后，才会发送真正的请求，并且携带真实数据。

11 简单请求与预检请求的区别

简单请求的特点：客户端与服务器之间只会发生一次请求。

预检请求的特点：客户端与服务器之间会发生两次请求，OPTION 预检请求成功之后，才会发起真正的请求。

11.6 JSONP 接口

1 JSONP 概念与特点

概念：浏览器端通过 <script> 标签的 src 属性，请求服务器上的数据，同时，服务器返回一个函数的调用。这种请求数据的方式叫做 JSONP。

特点：

• ① JSONP 不属于真正的 Ajax 请求，因为它没有使用 XMLHttpRequest 这个对象。

• ② JSONP 仅支持 GET 请求，不支持 POST、PUT、DELETE 等请求。

2 创建 JSONP 接口的注意事项

如果项目中已经配置了 CORS 跨域资源共享，为了防止冲突，必须在配置 CORS 中间件之前声明 JSONP 的接口。否则JSONP接口会被处理成开启了CORS的接口。

示例代码如下：

// 必须在配置 cors 中间件之前，配置 JSONP 的接口
app.get("api/jsonp", (req, res) => {
    
    
  // 定义jsonp接口的具体实现过程
});

// 一定要在路由之前，配置 cors 这个中间件，从而解决接口跨域的问题
const cors = require("cors");
app.use(cors());

3 实现 JSONP 接口

• ① 获取客户端发送过来的回调函数的名字

• ② 得到要通过 JSONP 形式发送给客户端的数据

• ③ 根据前两步得到的数据，拼接出一个函数调用的字符串

• ④ 把上一步拼接得到的字符串，响应给客户端的 <script> 标签进行解析执行

app.get("api/jsonp", (req, res) => {
    
    
  // 1 获取客户端发送过来的回调函数的名字
  const funcName = req.query.callback;

  // 2 得到要通过 jsonp 形式发送给客户端的数据
  const data = {
    
     naem: "zs", age: 20 };

  // 3 根据前两步得到的数据，拼接出一个函数调用的字符串
  const scriptStr = `${
      
      funcName}(${
      
      JSON.stringify(data)})`;

  // 4 把上一步拼接得到的字符串，响应给客户端的 <script> 标签进行解析执行
  res.send(scriptStr);
});

4 在网页中发起 JSONP 请求

---

望通过 PUT、DELETE 等方式请求服务器的资源，则需要在服务器端，通过 Access-Control-Alow-Methods来指明实际请求所允许使用的 HTTP 方法。

示例代码如下：

// 只允许 POST、GET、DELETE、HEAD 请求方法
res.setHeader('Access-Control-Allow-Methods:', 'POST, GET, DELETE, HEAD')

// 允许所有的  HTTP 请求方法
res.setHeader('Access-Control-Allow-Methods:', '*')

8 CORS 请求的分类

客户端在请求 CORS 接口时，根据请求方式和请求头的不同，可以将 CORS 的请求分为两大类，分别是：

• ①简单请求

• ②预检请求

9 简单请求

同时满足以下两大条件的请求，就属于简单请求：

• ① 请求方式：GET、POST、HEAD 三者之一

• ② HTTP 头部信息不超过以下几种字段：无自定义头部字段、Accept、Accept-Language、Content-Language、DPR、Downlink、Save-Data、Viewport-Width、Width 、Content-Type（只有三个值application/x-www-form-urlencoded、multipart/form-data、text/plain）

10 预检请求

只要符合以下任何一个条件的请求，都需要进行预检请求：

• ① 请求方式为 GET、POST、HEAD 之外的请求 Method 类型

• ② 请求头中包含自定义头部字段

• ③ 向服务器发送了 application/json 格式的数据

在浏览器与服务器正式通信之前，浏览器会先发送 OPTION 请求进行预检，以获知服务器是否允许该实际请求，所以这一次的 OPTION 请求称为预检请求。

服务器成功响应预检请求后，才会发送真正的请求，并且携带真实数据。

11 简单请求与预检请求的区别

简单请求的特点：客户端与服务器之间只会发生一次请求。

预检请求的特点：客户端与服务器之间会发生两次请求，OPTION 预检请求成功之后，才会发起真正的请求。

11.6 JSONP 接口

1 JSONP 概念与特点

概念：浏览器端通过 <script> 标签的 src 属性，请求服务器上的数据，同时，服务器返回一个函数的调用。这种请求数据的方式叫做 JSONP。

特点：

• ① JSONP 不属于真正的 Ajax 请求，因为它没有使用 XMLHttpRequest 这个对象。

• ② JSONP 仅支持 GET 请求，不支持 POST、PUT、DELETE 等请求。

2 创建 JSONP 接口的注意事项

如果项目中已经配置了 CORS 跨域资源共享，为了防止冲突，必须在配置 CORS 中间件之前声明 JSONP 的接口。否则JSONP接口会被处理成开启了CORS的接口。

示例代码如下：

// 必须在配置 cors 中间件之前，配置 JSONP 的接口
app.get("api/jsonp", (req, res) => {
    
    
  // 定义jsonp接口的具体实现过程
});

// 一定要在路由之前，配置 cors 这个中间件，从而解决接口跨域的问题
const cors = require("cors");
app.use(cors());

3 实现 JSONP 接口

• ① 获取客户端发送过来的回调函数的名字

• ② 得到要通过 JSONP 形式发送给客户端的数据

• ③ 根据前两步得到的数据，拼接出一个函数调用的字符串

• ④ 把上一步拼接得到的字符串，响应给客户端的 <script> 标签进行解析执行

app.get("api/jsonp", (req, res) => {
    
    
  // 1 获取客户端发送过来的回调函数的名字
  const funcName = req.query.callback;

  // 2 得到要通过 jsonp 形式发送给客户端的数据
  const data = {
    
     naem: "zs", age: 20 };

  // 3 根据前两步得到的数据，拼接出一个函数调用的字符串
  const scriptStr = `${
      
      funcName}(${
      
      JSON.stringify(data)})`;

  // 4 把上一步拼接得到的字符串，响应给客户端的 <script> 标签进行解析执行
  res.send(scriptStr);
});