node知识点(包括一些简单的运用)

1.命令行窗口(小黑屏)、cmd窗口、终端、shell

​

​ -开始菜单 —>运行—>CMD–>回车

——常用的指令：

​ dir 列出当前目录下的所有文件

​ cd 目录名 进入到指定的目录

​ md 目录名 创建一个文件夹(madir 文件夹名)

​ rd 目录名 删除一个文件名 (remove 文件夹名)

​ 去某个盘：盘符 : 比如 去E盘 e:

​ 1.使用tab键在终端可以快速补全文件名(前提是写一个在文件名中的开头字符)

​ 2.使用esc键，能够快速清空当前输入的命令。

​ 3.输入cls命令能够清空终端

-目录

​ . 表示当前的目录

​ … 表示上一级目录

​

——环境变量(windows系统中变量)

​ path

​ E:\软件\python\python\Scripts;

​ E:\软件\python\python;

​ E:\软件\python\Scripts;

​ E:\软件\python;

%USERPROFILE%\AppData\Local\Microsoft\WindowsApps;

​ D:\VsCode\VsCode\Microsoft VS Code\bin;%WebStorm%;

C:\Users\Administrator\AppData\Roaming\npm;

​ %CATALINA_HOME%\lib;

–当我们在命令行窗口打开一个文件，或调用一个程序时，系统会首先去当前目录下寻找文件或程序，如果找到了则直接打开，如果没有找到则依次到环境变量path的路径中寻找，如果没有找到则报错

–所以我们可以将一些经常需要访问的程序和文件的路径添加到path中，这样我们就可以在任意位置访问这些文件和程序了。

2.进程和线程

进程：

​ -进程负责为程序提供程序运行提供的必备的环境

​ -进程相当于工厂中的车间

​

线程：

​ -线程是计算机的最小计算单位，线程负责执行保存到进程中的程序

​ -线程就相当于工厂中的工人

单线程：

​ js是单线程的

多线程：

传统的服务器都是多线程的

​ -每进来一个请求，就创建一个线程去处理请求

-Node 的服务是单线程的

​ -Node处理请求时时单线程 ，但是在后台拥有一个I/O线程池

3.Node的学习路径：

​ JavaScript基础语法+Node.js内置API模块(fs、path、http等)+第三方API 模块(express,mysql )

4.node的介绍

node.js
- node是一款对ES标准实现的JS引擎
- 通过node可以使js在服务器中运行
- node就是一款使用js编写的web服务器
- node底层是使用c++的编写的
- node的中js引擎使用的chrome的v8引擎
- node的特点：
1.非阻塞、异步的I/O
2.事件和回调函数
3.单线程（主线程单线程，后台I/O线程池）
4.跨平台

- 模块化
	- ES5中没有原生支持模块化，我们只能通过script标签引入js文件来实现模块化
	- 在node中为了对模块管理，引入了CommonJS规范
		
		- 模块的引用
			- 使用 require()函数来引入一个模块
			- 例子：
				var 变量 = require("模块的标识");
			
		- 模块的定义
			- 在node中一个js文件就是一个模块
			- 默认情况下在js文件中编写的内容，都是运行在一个独立的函数中，
				外部的模块无法访问
			- 导出变量和函数
				- 使用 exports 
					- 例子：
						exports.属性 = 属性值;
						exports.方法 = 函数;
						
				- 使用module.exports
					- 例子：
						module.exports.属性 = 属性值;
						module.exports.方法 = 函数;
						module.exports = {};
		
		- 模块的标识
			- 模块的标识就是模块的名字或路径
				我们node通过模块的标识来寻找模块的
				对于核心模块（npm中下载的模块），直接使用模块的名字对其进行引入
					var fs = require("fs");
					var express = require("express");
					
				对于自定义的文件模块，需要通过文件的路径来对模块进行引入
					路径可以是绝对路径，如果是相对路径必须以./或 ../开头
					var router = require("./router");

​
​ - npm的命令
​ - npm -v 查看npm的版本
​ - npm version 查看所有模块的版本
​ - npm search 包名 搜索包
​ - npm install / i 包名 安装包
​ - npm remove / r 包名 删除包
​ - npm install 包名 --save 安装包并添加到依赖中 *****
​ - npm install 下载当前项目所依赖的包
​ - npm install 包名 -g 全局安装包（全局安装的包一般都是一些工具）

5.package和文件系统

	node
- 包（package）
	- 将多个模块组合为一个完整的功能，就是一个包
	- 包结构
		bin
			- 二进制的可执行文件，一般都是一些工具包中才有
		lib
			- js文件
		doc
			- 文档
		test
			- 测试代码
		package.json
			- 包的描述文件
			
	- package.json	
		- 它是一个json格式的文件，在它里面保存了包各种相关的信息
			name 包名
			version 版本
			dependencies 依赖
			main 包的主要的文件
			bin 可执行文件
			
- npm（Node Package Manager node的包管理器）
	- 通过npm可以对node中的包进行上传、下载、搜索等操作
	- npm会在安装完node以后，自动安装
	- npm的常用指令
		npm -v 查看npm的版本
		npm version 查看所有模块的版本
		npm init 初始化项目（创建package.json）
		npm i/install 包名 安装指定的包
		npm i/install 包名 --save 安装指定的包并添加依赖
		npm i/install 包名 -g 全局安装（一般都是一些工具）
		npm i/install 安装当前项目所依赖的包
		npm s/search 包名 搜索包	
		npm r/remove 包名 删除一个包

文件系统（File System）
- Buffer（缓冲区）
- Buffer和数组的结构的非常类似，Buffer是用来存储二进制数据的
- Buffer的方法
- Buffer.from(字符串)
- 将一个字符串中内容保存到一个buffer中
- buf.toString()
- 将buffer转换为一个字符串
- Buffer.alloc(size)
- 创建一个指定大小的buffer对象
- Buffer.allocUnsafe(size)
- 创建一个指定大小的buffer对象，可以包含敏感数据

- fs模块
	- 在Node通过fs模块来对系统中的文件进行操作，fs模块是node中已经继承好了，不需要在使用npm下载，直接引入即可
	- 引入fs
		var fs = require("fs");
	- fs模块中的大部分操作都提供了两种方法，同步方法和异步方法
		同步方法带sync
		异步方法没有sync，都需要回调函数
		
	- 写入文件
		1.同步写入
		2.异步写入
		3.简单写入
		4.流式写入
		
	- 读取文件
		1.同步读取
		2.异步读取
		3.简单读取
		4.流式读取
		
	- 方法
		- 打开文件
			fs.open(path, flags[, mode], callback)
			fs.openSync(path, flags[, mode])
			
		- 读写文件
			fs.write(fd, string[, position[, encoding]], callback)
			fs.writeSync(fd, string[, position[, encoding]])
			
			fs.read(fd, buffer, offset, length, position, callback)
			fs.readSync(fd, buffer, offset, length, position)
			
		- 关闭文件
			fs.close(fd,callback)
			fs.closeSync(fd);
			
		- 简单文件读取和写入
			fs.writeFile(file, data[, options], callback)
			fs.writeFileSync(file, data[, options])
			
			fs.readFile(path[, options], callback)
			fs.readFileSync(path[, options])

​
​ - 流式文件读取和写入
​ - 流式读取和写入适用于一些比较大的文件
​ fs.createWriteStream(path[, options])
​ fs.createReadStream(path[, options])

​
​
​
​
​
​
​
​

6.fs文件系统模块

1.fs模块是Node官方提供，用来操作文件的模块，它提供了一系列的方法和属性，用来满足用户对文件的操作需求

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

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

如果需要在JavaScript代码中使用fs模块来操作文件，则需要使用如下的方式先导入它：

​ const fs=require(‘fs’);

2.fs.readFile()方法，可以读取指定文件中的内容，语法格式如下：

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

​ 参数解读：

• 参数一：必选参数，字符串，表示文件的路径。
• 参数二:可选参数，表示以什么编码格式来读取文件。
• 参数三：必须参数，文件读取完成后，通过回调函数拿到读取的结果。

例子：

//1.导入fs模块，来操作文件
const fs=require('fs');
//2.调用fs.readFile()方法读取文件
//参数1：读取文件的存放路径
//参数2：读取文件时候采用的编码格式，一般默认指定utf8
//参数3：回调函数，拿到读取失败和成功的结果 err,dataStr
fs.readFile("./files/1.txt","utf-8",function(err,dataStr){
​        //打印失败的结果
​        console.log(err);  
​         //如果读取成功，则err值为null
​         //如果读取失败，则err的值为错误对象，datStr的值为undefined
​        console.log('------');
​        //打印成功的结果
​        console.log(dataStr);
})

如何判断文件是否读取成功

​ 可以判断err对象是否为null，从而知晓文件读取的结果

​ 例子：

//导入模块
const fs=require('fs');
fs.readFile("./files/1.txt",'utf-8',(err,dataStr)=>{
​        if(err){
​            return console.log("读取文件失败"+err.message);
​        }
​        console.log("读取文件成功！"+dataStr);
})

3.fs.writeFile()方法可以向指定的文件中写入内容，语法格式如下：

​ 1.参数解答：

​ 参数一：必须参数，需要指定一个文件路径的字符串，表格文件存放路径。

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

​ 参数三：可选参数，表示已什么格式写入文件内容，默认值是utf8

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

​ 实例：

	//1.导入fs文件系统模块

const fs=require('fs');

//调用fs.writeFile()方式写入文件内容

/* 

参数1：表示文件存放的路径(默认以utf-8为格式)

参数2：表示要写入的内容

参数3：回调函数
*/
fs.writeFile("./files/2.txt","abcd",err=>{
   
​    //2.1 如果文件写入成功，则err的值等于null
​    //2.2 如果文件写入失败，则err的值等于一个错误对象
​    console.log(err);
})

2.判断文件是否写入成功

const fs=require('fs');
fs.writeFile("./files/3.txt","ok123",err=>{
​    //2.1 如果文件写入成功，则err的值等于null
​    //2.2 如果文件写入失败，则err的值等于一个错误对象
​    //console.log(err);
​    //可以判断err是否为null，从而知晓文件写入的结果
​    if(err){
​        return console.log("文件写入失败！"+err.message);
​    }
​    console.log("文件写入成功！");
})

3.整理成绩案列：

//导入fs模块
const fs=require("fs")
//2.调用fs.readFile()来读取文件的内容
fs.readFile("./files/成绩.txt","utf-8",(err,dataStr)=>{
​    //3.判断是否读取成功
​    if(err){
​        return console.log("文件读取失败！",err.message);
​    }
​    // console.log("读取文件成功！"+dataStr);
​    //4.1先把成绩的数据，按照空格进行分割
​    const arrOld=dataStr.split(' ');
​    //console.log(arrOld);
​    //4.2循环分割后的数组，对每一项数据，进行字符串的替换操作
​    const arrNew=[];
​    arrOld.forEach(item => {
​        arrNew.push(item.replace('=',':'));
​    });
​    //console.log(arrNew);
​    //4.3把数组中的每一项，进行合并，得到一个新的字符串
​    const newStr =arrNew.join('\r\n');
​    // console.log(newStr);
​    //5.调用fs.writeFile()方法，把处理完毕的成绩写入到新的文件中
​    fs.writeFile('./files/成绩-ok.txt',newStr,err=>{
​        if(err){
​            console.log("成绩写入失败！",+err.message);
​        }
​        console.log("成绩写入成功！");
​    })
})

4.fs模块-路径动态拼接的问题

在使用 fs 模块操作文件时，如果提供的操作路径是以 ./ 或 …/ 开头的相对路径时，很容易出现路径动态拼接错误的问题。
原因：代码在运行的时候，会以执行 node 命令时所处的目录，动态拼接出被操作文件的完整路径。
解决方案：在使用 fs 模块操作文件时，直接提供完整的路径，不要提供 ./ 或 …/ 开头的相对路径，从而防止路径动态拼接的问题。

//出现路径拼接问题，是因为提供了./或../开头的相对路径
//如果要解决这个问题，可以直接提供一个完整的文件存放路径就行
//问题，移值性非常差
fs.readFile('E:\\学习笔记图像\\web_Study\\Node_Study\\study_01\\files\\1.txt','utf8',(err,dataStr)=>{
​    if(err){
​        return console.log('读取失败！',+err.message);
​    }
​    console.log('读取文件成功'+dataStr);
})

解决办法：使用__dirname处理

//__dirname 表示当前文件所处的目录
// console.log(__dirname);
fs.readFile(__dirname+'/files/1.txt','utf8',(err,dataStr)=>{
​    if(err){
​        return console.log('读取失败！',+err.message);
​    }
​    console.log('读取文件成功'+dataStr);
})

7.path路径模块

7.1 什么是path路径模块

path 模块是 Node.js 官方提供的、用来处理路径的模块。它提供了一系列的方法和属性，用来满足用户对路径的处理需求。
例如：
path.join() 方法，用来将多个路径片段拼接成一个完整的路径字符串
path.basename() 方法，用来从路径字符串中，将文件名解析出来

如果要在 JavaScript 代码中，使用 path 模块来处理路径，则需要使用如下的方式先导入它：

const path=require(“path”)

7.2 path路径拼接

path.join()代码示例

使用path.join方法，可以把多个路径片段拼接成完整的路径字符串。语法格式如下：

path.join([…paths])

参数解读：

…paths 路径片段的序列

返回值：

例子：
const fs = require('fs');
const path=require('path');
//注意：  ../会抵消前面的路径
// const pathStr=path.join('/a','/b/c','./d','e')
// console.log(pathStr);   //\a\b\c\d\e
fs.readFile(path.join(__dirname,'./files/1.txt'),'utf8',function(err,dataStr){
​    if(err){
​        return console.log(err.message);
​    }
​    console.log(dataStr);
})

注意：今后凡是涉及到路径拼接的操作，都要使用 path.join() 方法进行处理。不要直接使用 + 进行字符串的拼接。

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 nameWithoutExit=path.basename(fpath,'.html');
console.log(nameWithoutExit);       //输出 index

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

8.综合案列-时钟案例

1.案例要实现的功能

将素材目录下的 index.html 页面，拆分成三个文件，分别是：
index.css
index.js
index.html
并且将拆分出来的 3 个文件，存放到 clock 目录中。

2.案例的实现步骤

创建两个正则表达式，分别用来匹配

3.案例注意的两个问题

1.fs.writeFile() 方法只能用来创建文件，不能用来创建路径
2.重复调用 fs.writeFile() 写入同一个文件，新写入的内容会覆盖之前的旧内容

实现代码：

//1.1导入fs模块
 const fs=require('fs');
 //1.2导入path模块
 const path=require('path');
 //1.3定义正则表达式，分别匹配<style></style>和<script></script>标签
 const regStyle=/<style>[\s\S]*<\/style>/
 const regScript=/<script>[\s\S]*<\/script>/
 //2.1调用fs.readFile()方法读取文件、
 fs.readFile(path.join(__dirname,'../素材/index.html'),'utf8',function(err,dataStr){
​     //2.2 读取html文件失败
​     if(err)
​     return console.log("读取html文件失败"+err.message);
​     //2.3 读取文件成功后，调用对应的三个方法，分别解出css,js,html文件 
​        removeCss(dataStr);
​        resolveJS(dataStr);
​        resolveHtml(dataStr);
 })
 //3.1 定义处理css的样式的方法
 function removeCss(htmlStr){
​     //3.2 使用正则提取需要的内容
​     const r1=regStyle.exec(htmlStr);
​    // console.log(r1);
​    //替换<style>和</style>标签
   const newCss= r1[0].replace('<style>','').replace("</style>","");
//    console.log(newCss);
​    //3.4 调用fs.writeFile()方法，将提取的样式，写入到clock目录中index.css的文件里面
​    fs.writeFile(path.join(__dirname,'./clock/index.css'),newCss,function(err){
​        if(err) return console.log('写入css样式失败！'+err.message);
​         console.log("写入样式文件成功！");
​    })
}
//4.1 定义处理js脚本的方法
function resolveJS(htmlStr){
​    //4.2通过正则，提取对应的<script></script>标签内容
​     const r2=regScript.exec(htmlStr);
​     //4.3 将提取出来的内容进一步处理
​     const newJS=r2[0].replace('<script>','').replace('</script>','')
​     //4.4 将处理的结果写入clock目录中的index.js文件里面
​     fs.writeFile(path.join(__dirname,'./clock/index.js'),newJS,function(err){
​         if(err){
​             return console.log("写入JavaScript脚本失败！"+err.message);
​         }
​         console.log("写入js脚本成功！");
​     })
​     
​     
}
//5.1 定义处理html结构的方法
function resolveHtml(htmlStr){
​    //5.2 将字符串调用replace方法，把内嵌的style和script标签，替换为外联的link和script标签 
   const newHtml= htmlStr.replace(regStyle,'<link rel="stylesheet" href="./index.css"/>').replace(regScript,'<script src="./index.js"></script>');
​    //5.3 写入index.html这个文件
​    fs.writeFile(path.join(__dirname,'./clock/index.html'),newHtml,function(err){
​        if(err) return console.log("写入html文件失败！"+err.message)
​        console.log("写入html页面成功！");
​    })
}

9.http模块

1.什么是 http 模块

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

如果要希望使用 http 模块创建 Web 服务器，则需要先导入它：

const http=require(‘http’)；

2.http的作用：

服务器和普通电脑的区别在于，服务器上安装了 web 服务器软件，例如：IIS、Apache 等。通过安装这些服务器软件，就能把一台普通的电脑变成一台 web 服务器。
在 Node.js 中，我们不需要使用 IIS、Apache 等这些第三方 web 服务器软件。因为我们可以基于 Node.js 提供的 http 模块，通过几行简单的代码，就能轻松的手写一个服务器软件，从而对外提供 web 服务。

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，它们都代表我们自己的这台电脑，在使用效果上没有任何区别。

3.端口号

计算机中的端口号，就好像是现实生活中的门牌号一样。通过门牌号，外卖小哥可以在整栋大楼众多的房间中，准确把外卖送到你的手中。
同样的道理，在一台电脑中，可以运行成百上千个 web 服务。每个 web 服务都对应一个唯一的端口号。客户端发送过来的网络请求，通过端口号，可以被准确地交给对应的 web 服务进行处理。

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

4.使用http模块创建最基本的web服务器

1.创建 web 服务器的基本步骤

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

代码实现：
//1.导入 http 模块
const http=require('http');
//2.创建 web 服务器实例
//调用 http.createServer() 方法，即可快速创建一个 web 服务器实例：
const server=http.createServer();
//3.为服务器实例绑定 request 事件，监听客户端的请求
//使用服务器实例的 .on方法为服务器绑定一个request事件
server.on('request',(req,res)=>{
​    //只要服务器接收到了客户端的请求，就会调用通过 server.on() 为服务器绑定的 request 事件处理函数。
​    console.log('Someone visit our web server');
})
//4.启动服务器
//调用sever.listen(端口号,cb回调),方法，即可启动web服务器
server.listen(8080,()=>{
​    console.log('sever running  at http://127.0.0.1:8080');
})

2.req请求对象

只要服务器接收到了客户端的请求，就会调用通过 server.on() 为服务器绑定的 request 事件处理函数。
如果想在事件处理函数中，访问与客户端相关的数据或属性，可以使用如下的方式：

const http=require('http');
const server=http.createServer();
// req 是请求对象，包含了与客户端相关的数据和属性
server.on('request',req=>{
​    //req.url 是客户端请求的URL地址
​    const url=req.url;
​    //req.method 是客户端请求的method类型
​    const method=req.method;
​    const str=`Your request url is ${url},and request method is ${method}`;
​    console.log(str);
})
server.listen(80,()=>{
​    console.log('sever ruuning at http://127.0.0.1');
})

3.res响应对象

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

const http=require('http');
const server=http.createServer();
// req 是请求对象，包含了与客户端相关的数据和属性
server.on('request',(req,res)=>{
​    //req.url 是客户端请求的URL地址
​    const url=req.url;
​    //req.method 是客户端请求的method类型
​    const method=req.method;
​    const str=`Your request url is ${url},and request method is ${method}`;
​    console.log(str);
​    //调用res.end()方法向客户端响应一些内容
​    res.end(str)
})
server.listen(80,()=>{
​    console.log('sever ruuning at http://127.0.0.1');
})

4.解决中文乱码的问题

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

const http=require('http');
const server=http.createServer();
server.on('request',(req,res)=>{
​    //定义一个字符串，包含中文内容的内容
​    const str = `您请求的URL地址是${req.url},请求的method类型为${req.method}`;
​    //调用res.setHeader()方法，设置Content-Type响应头，解决中文乱码问题
​    res.setHeader("Content-Type","text/html;charset=utf-8");
​    //res.end()将内容响应给客户端
​    res.end(str);
})
server.listen(80,()=>{
​    console.log('server running at http://127.0.0.1')
})

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

实现：

const http=require('http');
const server=http.createServer();
server.on('request',(req,res)=>{
​    //1.获取请求的 url 地址
​    const url=req.url;
   // 2.设置默认的响应内容为 404 Not found
   let content="<h3>404 NOT found</h3>"
   // 3.判断用户请求的是否为 / 或 /index.html 首页
​    // 4.判断用户请求的是否为 /about.html 关于页面
   if(url==='/'||url==='/index.html'){
​       content='<h3>首页</h3>'
   }else if (url==='/about.html'){
​       content='<h3>关于页面</h3>'
   }
   // 5.设置 Content-Type 响应头，防止中文乱码
   res.setHeader("Content-Type","text/html;charset=utf-8");
   // 6.使用 res.end() 把内容响应给客户端
   res.end(content);
​    console.log('server running at http://127.0.0.1')
})

6.实现 clock 时钟的 web 服务器案例

//1.1 导入http模块
const http=require('http');
 //1.2 导入fs模块
const fs=require("fs");
 //1.3 导入path模块
const path=require("path");
//2.1 创建web服务器
const server=http.createServer();
//2.2 监听web服务器的request事件
server.on('request',(req,res)=>{
   //3.1获取到客户端请求的url地址
   const url=req.url;
   //  /clock/index.html
   //  /clock/index.css
   //  /clock/index.js
   //3.2把请求的url地址映射成具体文件的存放路径
​    //const fpath=path.join(__dirname,url);//此方法需要用户手动加前面的路径
​    //5.1 预定义一个空白的文件路径    (优化资源的请求路径)
​    let fpath="";
​    if(url==='/'){
​        fpath=path.join(__dirname,'./clock/index.html');
​    }else{
​        // /index.html
​        // /index.css
​        // /index.js
​        fpath=path.join(__dirname,'/clock',url);
​    }
​    //4.1 根据映射过来的文件路径读取文件的内容
​    fs.readFile(fpath,'utf8',(err,dataStr)=>{
​        //4.2 读取失败，向客户端响应固定的错误消息
​        if(err) return res.end("404 NOT found");
​        //4.3 读取成功，将读取成功的内容，响应给客户端
​        res.end(dataStr);
​    })
})
 //2.3 启动服务器
 server.listen(80,()=>{
​     console.log("server running at http://127.0.0.1")
 })

10.模块化

1.模块化的基本概念

​ 1.模块化是指解决一个复杂问题时，自顶向下逐层把系统划分成若干模块的过程。对于整个系统来说，模块是可组合、分解和更换的单元。

​ 2.编程领域中的模块化:就是遵守固定的规则，把一个大文件拆成独立并互相依赖的多个小模块。

​ 3.把代码进行模块化拆分的好处：
​ 提高了代码的复用性
​ 提高了代码的可维护性
​ 可以实现按需加载

2.模块化规范

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

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

3.Node.js中的模块化

​ 分类：

​ Node.js 中根据模块来源的不同，将模块分为了 3 大类，分别是：
​ 内置模块（内置模块是由 Node.js 官方提供的，例如 fs、path、http 等）
​ 自定义模块（用户创建的每个 .js 文件，都是自定义模块）
​ 第三方模块（由第三方开发出来的模块，并非官方提供的内置模块，也不是用户创建的自定义模块，使用前需要先下载）

4.加载模块

​ 使用强大的 require() 方法，可以加载需要的内置模块、用户自定义模块、第三方模块进行使用。例如：

注意：使用 require() 方法加载其它模块时，会执行被加载模块中的代码。在使用require加载用户自定义模块期间，可以省略.js的后缀名

5.Node.js中的模块作用域

​ 1.什么叫模块作用域

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

​ 例如：

注意：

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

​ 2.向外共享模块作用域中的成员

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

​ 2.module.exports 对象:在自定义模块中，可以使用 module.exports 对象，将模块内的成员共享出去，供外界使用。外界用 require() 方法导入自定义模块时，得到的就是 module.exports 所指向的对象。一个自定义模块中，默认情况下module.exports为空对象。

​ 3.共享成员时的注意点:使用 require() 方法导入模块时，导入的结果，永远以 module.exports 指向的对象为准。

​ 4.exports 对象：由于 module.exports 单词写起来比较复杂，为了简化向外共享成员的代码，Node 提供了 exports 对象。默认情况下，exports 和 module.exports 指向同一个对象。最终共享的结果，还是以 module.exports 指向的对象为准。

​ 注意：

​ 时刻谨记，require() 模块时，得到的永远是 module.exports 指向的对象：为了防止混乱，建议大家不要在同一个模块中同时使用 exports 和 module.exports

6.Node.js 中的模块化规范

Node.js 遵循了 CommonJS 模块化规范，CommonJS 规定了模块的特性和各模块之间如何相互依赖。
CommonJS 规定：
每个模块内部，module 变量代表当前模块。
module 变量是一个对象，它的 exports 属性（即 module.exports）是对外的接口。
加载某个模块，其实是加载该模块的 module.exports 属性。require() 方法用于加载模块。

11.npm与包

​ 解释：Node.js 中的第三方模块又叫做包。不同于 Node.js 中的内置模块与自定义模块，包是由第三方个人或团队开发出来的，免费供所有人使用。
​ 注意：Node.js 中的包都是免费且开源的，不需要付费即可免费下载使用。

1.为什么需要包：

​ 由于 Node.js 的内置模块仅提供了一些底层的 API，导致在基于内置模块进行项目开发的时，效率很低。
包是基于内置模块封装出来的，提供了更高级、更方便的 API，极大的提高了开发效率。
包和内置模块之间的关系，类似于 jQuery 和 浏览器内置 API 之间的关系。

搜索和下载包：

​ 从 https://www.npmjs.com/ 网站上搜索自己所需要的包。
​ 从 https://registry.npmjs.org/ 服务器上下载自己需要的包。

2.npm的例子----格式化时间

​ 1.传统格式化的时间例子：

代码：

//1.定义格式化时间的方法
function dateFormat(dtStr){
​    const dt=new Date(dtStr); 
​    const y=dt.getFullYear();
​    const m=padZero(dt.getMonth()+1);
​    const d=padZero(dt.getDate());
​    const hh=padZero(dt.getHours());
​    const mm=padZero(dt.getMinutes());
​    const ss=padZero(dt.getSeconds());
​    return `${y}-${m}-${d}-${hh}-${mm}-${ss}`

}

//定义补零函数
function padZero(n){

​    return  n>9 ? n:'0'+n
}
//暴露出去，分享成员
module.exports={
​    dateFormat
}

//导入自定义的格式化时间模块
const  Time=require('./06_dataFormat');
//调用方法，进行时间的格式化
const dt=new Date();
//console.log(dt);
const newDt=Time.dateFormat(dt);
console.log(newDt);

2.格式化时间的高级做法

​ 使用 npm 包管理工具，在项目中安装格式化时间的包 moment
​ 使用 require() 导入格式化时间的包
​ 参考 moment 的官方 API 文档对时间进行格式化

代码：
//1.导入需要的包
//注意：导入的名称，就是装包时候的名称
const moment=require('moment');
const dt=moment().format('YYYY-MM-DD HH:mm:ss')
console.log(dt);

​ 1.npm install 包的完整名称

​ 2.简写形式：npm i 完整的包名称

3.npm与包

​ 3.1.node_modules 文件夹用来存放所有已安装到项目中的包。require() 导入第三方包时，就是从这个目录中查找并加载包。
​ 3.2.package-lock.json 配置文件用来记录 node_modules 目录下的每一个包的下载信息，例如包的名字、版本号、下载地址等。

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

​ 3.4.如何记录项目中安装了哪些包

​ 在项目根目录中，创建一个叫做 package.json 的配置文件，即可用来记录项目中安装了哪些包。从而方便剔除 node_modules 目录之后，在团队成员之间共享项目的源代码。

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

​ 3.5.快速创建package.json:

​ npm 包管理工具提供了一个快捷命令，可以在执行命令时所处的目录中，快速创建 package.json 这个包管理: npm init -y

​ 注意：

​ 上述命令只能在英文的目录下成功运行！所以，项目文件夹的名称一定要使用英文命名，不要使用中文，不能出现空格。
​ 运行 npm install 命令安装包的时候，npm 包管理工具会自动把包的名称和版本号，记录到 package.json 中。

​ 3.6.dependencies 节点

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

​ 3.7.一次性安装所有的包：可以运行npm install 命令（或npm i）一次性安装所有的依赖包：执行npm install命令时，npm包管理工具会先读取package.json的 dependencies节点,读取到记录的所有依赖名称和版本号之后，npm包管理工具会把这些包一次性下载到项目中。

​ 3.8.卸载包：

​ 可以运行npm uninstall命令来卸载指定的包。npm install 具体的包名

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

​ 3.9.devDependencies 节点

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

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

​ 3.10.解决下包速度慢的问题

​ *切换 npm 的下包镜像源： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8IRZ43OQ-1675571807689)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1661742152534.png)]

​ *nrm工具

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

3.11 包的分类

​ 使用 npm 包管理工具下载的包，共分为两大类，分别是：
​ *项目包

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

​ 项目包又分为两类，分别是：
​ 开发依赖包（被记录到 devDependencies 节点中的包，只在开发期间会用到）
​ 核心依赖包（被记录到 dependencies 节点中的包，在开发期间和项目上线之后都会用到）

​ *全局包

​ 在执行 npm install 命令时，如果提供了 -g 参数，则会把包安装为全局包。
​ 全局包会被安装到 C:\Users\用户目录\AppData\Roaming\npm\node_modules 目录下。

注意：

​ 只有工具性质的包，才有全局安装的必要性。因为它们提供了好用的终端命令。
​ 判断某个包是否需要全局安装后才能使用，可以参考官方提供的使用说明即可。

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

​ 3.12 规范包结构：

​ 一个规范的包，它的组成结构，必须符合以下 3 点要求：
​ 包必须以单独的目录而存在
​ 包的顶级目录下要必须包含 package.json 这个包管理配置文件
​ package.json 中必须包含 name，version，main 这三个属性，分别代表包的名字、版本号、包的入口。 规范约束参考网址：https://yarnpkg.com/zh-Hans/docs/package-json

4.开发属于自己的包

​ 1.明确自己要的功能

​ 2.初始化包的基本结构

​ 2.1新建 itheima-tools 文件夹，作为包的根目录
​ 在 itheima-tools 文件夹中，新建如下三个文件：
​ package.json （包管理配置文件）
​ index.js （包的入口文件）
​ README.md （包的说明文档）

​ 2.2初始化package.json

​ 2.3 在 index.js 中定义格式化时间的方法

​ 2.4在 index.js 中定义转义 HTML 的方法

​
2.5 在 index.js 中定义还原 HTML 的方法

2.6 将不同的功能进行划分

​ 将格式化时间的功能，拆分到 src -> dateFormat.js 中
​ 将处理 HTML 字符串的功能，拆分到 src -> htmlEscape.js 中
​ 在 index.js 中，导入两个模块，得到需要向外共享的方法
​ 在 index.js 中，使用 module.exports 把对应的方法共享出去

2. 7 编写包的说明文档

   ​ 包根目录中的 README.md 文件，是包的使用说明文档。通过它，我们可以事先把包的使用说明，以 markdown 的格式写出来，方便用户参考。README 文件中具体写什么内容，没有强制性的要求；只要能够清晰地把包的作用、用法、注意事项等描述清楚即可。我们所创建的这个包的 README.md 文档中，会包含以下 6 项内容：安装方式、导入方式、格式化时间、转义 HTML 中的特殊字符、还原 HTML 中的特殊字符、开源协议。

5.发布自己的包到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 上发布没有意义的包！

​

6.模块的加载机制

​ 1.内置模块的加载机制

​ 内置模块是由 Node.js 官方提供的模块，内置模块的加载优先级最高。
​ 例如，require(‘fs’) 始终返回内置的 fs 模块，即使在 node_modules 目录下有名字相同的包也叫做 fs。

​ 2.自定义模块的加载机制

​ 使用 require() 加载自定义模块时，必须指定以 ./ 或 …/ 开头的路径标识符。在加载自定义模块时，如果没 有指定 ./ 或 …/ 这样的路径标识符，则 node 会把它当作内置模块或第三方模块进行加载。

​ 同时，在使用 require() 导入自定义模块时，如果省略了文件的扩展名，则 Node.js 会按顺序分别尝试加载以下的文件：
​ 按照确切的文件名进行加载
​ 补全 .js 扩展名进行加载
​ 补全 .json 扩展名进行加载
​ 补全 .node 扩展名进行加载
​ 加载失败，终端报错

3.第三方模块的加载机制

​ 如果传递给 require() 的模块标识符不是一个内置模块，也没有以 ‘./’ 或 ‘…/’ 开头，则 Node.js 会从当前模块的父目录开始，尝试从 /node_modules 文件夹中加载第三方模块。如果没有找到对应的第三方模块，则移动到再上一层父目录中，进行加载，直到文件系统的根目录。
例如，假设在 ‘C:\Users\itheima\project\foo.js’ 文件里调用了 require(‘tools’)，则 Node.js 会按以下顺序查找：
C:\Users\itheima\project\node_modules\tools
C:\Users\itheima\node_modules\tools
C:\Users\node_modules\tools
C:\node_modules\tools

4.目录作为模块

​ 当把目录作为模块标识符，传递给 require() 进行加载的时候，有三种加载方式：
在被加载的目录下查找一个叫做 package.json 的文件，并寻找 main 属性，作为 require() 加载的入口
如果目录里没有 package.json 文件，或者 main 入口不存在或无法解析，则 Node.js 将会试图加载目录下的 index.js 文件。如果以上两步都失败了，则 Node.js 会在终端打印错误消息，报告模块的缺失：Error: Cannot find module ‘xxx’

12.express的笔记

1.express的基本使用

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

安装：

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

创建基本的服务器：

监听 GET 请求：通过 app.get() 方法，可以监听客户端的 GET 请求，具体的语法格式如下：

监听 POST 请求：通过 app.post() 方法，可以监听客户端的 POST 请求，具体的语法格式如下：

把内容响应给客户端：通过 res.send() 方法，可以把处理好的内容，发送给客户端 例子：

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

获取 URL 中的动态参数:通过 req.params 对象，可以访问到 URL 中，通过 : 匹配到的动态参数：(可以有多个动态参数)

2.托管静态资源

​ express 提供了一个非常好用的函数，叫做 express.static()，通过它，我们可以非常方便地创建一个静态资源服务器，例如，通过如下代码就可以将 public 目录下的图片、CSS 文件、JavaScript 文件对外开放访问了：可以访问 public 目录中的所有文件了

注意：Express 在指定的静态目录中查找文件，并对外提供资源的访问路径。因此，存放静态文件的目录名不会出现在 URL 中。

2.1托管多个静态资源目录

​ 如果要托管多个静态资源目录，请多次调用 express.static() 函数，访问静态资源文件时，express.static() 函数会根据目录的添加顺序查找所需的文件。

3.挂载路径前缀

​ 如果希望在托管的静态资源访问路径之前，挂载路径前缀，则可以使用如下的方式：现在，你就可以通过带有 /public 前缀地址来访问 public 目录中的文件了：
​ http://localhost:3000/public/images/kitten.jpg
​ http://localhost:3000/public/css/style.css
​ http://localhost:3000/public/js/app.js

4.nodemon

**使用的作用：**在编写调试 Node.js 项目的时候，如果修改了项目的代码，则需要频繁的手动 close 掉，然后再重新启动，非常繁琐。现在，我们可以使用 nodemon（https://www.npmjs.com/package/nodemon） 这个工具，它能够监听项目文件的变动，当代码被修改后，nodemon 会自动帮我们重启项目，极大方便了开发和调试。

**安装：**在终端中，运行如下命令，即可将 nodemon 安装为全局可用的工具：

使用 nodemon

​ 当基于 Node.js 编写了一个网站应用的时候，传统的方式，是运行 node app.js 命令，来启动项目。这样做的坏处是：代码被修改之后，需要手动重启项目。现在，我们可以将 node 命令替换为 nodemon 命令，使用 nodemon app.js 来启动项目。这样做的好处是：代码被修改之后，会被 nodemon 监听到，从而实现自动重启项目的效果。

5.express路由

​ 5.1 路由的概念

​ 在 Express 中，路由指的是客户端的请求与服务器处理函数之间的映射关系。Express 中的路由分 3 部分组成，分别是请求的类型、请求的 URL 地址、处理函数，格式如下：

​ 5.2 路由的匹配过程

​ 每当一个请求到达服务器之后，需要先经过路由的匹配，只有匹配成功之后，才会调用对应的处理函数。在匹配时，会按照路由的顺序进行匹配，如果请求类型和请求的 URL 同时匹配成功，则 Express 会将这次请求，转交给对应的 function 函数进行处理。

​ 注意：*按照定义的先后顺序进行匹配
​ *请求类型和请求的URL同时匹配成功，才会调用对应的处理函数。

​ 5.3 路由的使用–最简单的用法：

​ 在 Express 中使用路由最简单的方式，就是把路由挂载到 app 上，示例代码如下：

​ 5.4 模块化路由

​ 为了方便对路由进行模块化的管理，Express 不建议将路由直接挂载到 app 上，而是推荐将路由抽离为单独的模块。
​ 将路由抽离为单独模块的步骤如下：
​ *创建路由模块对应的 .js 文件
​ *调用 express.Router() 函数创建路由对象
​ *向路由对象上挂载具体的路由
​ *使用 module.exports 向外共享路由对象
​ *使用 app.use() 函数注册路由模块

创键路由模块例子：

注册路由模块：app.use()函数的作用就是来注册全局中间件

添加路由前缀：

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

6.Express的中间件

​ 1.中间件调用流程：当一个请求到达 Express 的服务器之后，可以连续调用多个中间件，从而对这次请求进行预处理。如图所示。

​ 2.express中间件的格式：Express 的中间件，本质上就是一个 function 处理函数，Express 中间件的格式如下： 注意：中间件函数的形参列表中，必须包含 next 参数。而路由处理函数中只包含 req 和 res。

​ 3.express的中间件next的作用：next 函数是实现多个中间件连续调用的关键，它表示把流转关系转交给下一个中间件或路由。图例如下：

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

​ 5.全局生效的中间件

​ 客户端发起的任何请求，到达服务器之后，都会触发的中间件，叫做全局生效的中间件。
通过调用 app.use(中间件函数)，即可定义一个全局生效的中间件；如下所示：

全局中间件的简化形式：

可以定义多个全局中间件：可以使用 app.use() 连续定义多个全局中间件。客户端请求到达服务器之后，会按照中间件定义的先后顺序依次进行调用，示例代码如下：

6.局部生效的中间件：不使用 app.use() 定义的中间件，叫做局部生效的中间件，示例代码如下：

​

定义多个局部中间件：

中间件的注意事项：

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

​ 6.1 中间件的分类：分为5大类：

• 应用级别的中间件

• 路由级别的中间件

• 错误级别的中间件

• Express 内置的中间件

• 第三方的中间件

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

  ​ 绑定到 express.Router() 实例上的中间件，叫做路由级别的中间件。它的用法和应用级别中间件没有任何区别。只不过，应用级别中间件是绑定到 app 实例上，路由级别中间件绑定到 router 实例上，代码例子：
  

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

格式：错误级别中间件的 function 处理函数中，必须有 4 个形参，形参顺序从前到后，分别是 (err, req, res, next)。 注意：错误级别的中间件，必须注册在所有路由之后。如下所示。

*Express 内置的中间件

​ 自 Express 4.16.0 版本开始，Express 内置了 3 个常用的中间件，极大的提高了 Express 项目的开发效率和体验：
express.static 快速托管静态资源的内置中间件，例如： HTML 文件、图片、CSS 样式等（无兼容性）
​ express.json 解析 JSON 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）在服务器中，可以使用req.body这个属性来接收客户端发送过来的请求体数据，默认情况下，如果不配置解析表单数据的中间件，则req.body默认等于undefined
​ express.urlencoded 解析 URL-encoded 格式的请求体数据，使用req.body进行接收（有兼容性，仅在 4.16.0+ 版本中可用）

***第三方的中间件：**非 Express 官方内置的，而是由第三方开发出来的中间件，叫做第三方中间件。在项目中，大家可以按需下载并配置第三方中间件，从而提高项目的开发效率。
例如：在 express@4.16.0 之前的版本中，经常使用 body-parser 这个第三方中间件，来解析请求体表单数据。使用步骤如下：
*运行 npm install body-parser 安装中间件
*使用 require 导入中间件
*调用 app.use() 注册并使用中间件

​ 6.2 自定义中间件：

*使用 app.use() 来定义全局生效的中间件

*监听 req 的 data 事件：在中间件中，需要监听 req 对象的 data 事件，来获取客户端发送到服务器的数据。
如果数据量比较大，无法一次性发送完毕，则客户端会把数据切割后，分批发送到服务器。所以 data 事件可能会触发多次，每一次触发 data 事件时，获取到数据只是完整数据的一部分，需要手动对接收到的数据进行拼接。

*监听 req 的 end 事件:当请求体数据接收完毕之后，会自动触发 req 的 end 事件。
因此，我们可以在 req 的 end 事件中，拿到并处理完整的请求体数据。

*使用 querystring 模块解析请求体数据:Node.js 内置了一个 querystring 模块，专门用来处理查询字符串。通过这个模块提供的 parse() 函数，可以轻松把查询字符串，解析成对象的格式

*将解析出来的数据对象挂载为 req.body:上游的中间件和下游的中间件及路由之间，共享同一份 req 和 res。因此，我们可以将解析出来的数据，挂载为 req 的自定义属性，命名为 req.body，供下游使用。示例代码如下：

*将自定义中间件封装为模块:为了优化代码的结构，我们可以把自定义的中间件函数，封装为独立的模块，

7.使用expres编写接口

7.1 创建基本的服务器

7.2 创建 API 路由模块

7.3 编写get接口：在路由模块中编写

7.4 编写post接口：

**注意：**如果要获取 URL-encoded 格式的请求体数据，必须配置中间件

7.5CORS 跨域资源共享

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

​ 解决接口跨域问题的方案主要有两种：
CORS（主流的解决方案，推荐使用）
​ JSONP（有缺陷的解决方案：只支持 GET 请求)

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

​ 运行 npm install cors 安装中间件
​ 使用 const cors = require(‘cors’) 导入中间件
​ 在路由之前调用 app.use(cors()) 配置中间件

cros的注意事项：

​ *CORS 主要在服务器端进行配置。客户端浏览器无须做任何额外的配置，即可请求开启了 CORS 的接口。
​ *CORS 在浏览器中有兼容性。只有支持 XMLHttpRequest Level2 的浏览器，才能正常访问开启了 CORS 的服务端接口（例如：IE10+、Chrome4+、FireFox3.5+）

​

7.6 CORS 响应头部 - Access-Control-Allow-Origin：

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

​ 其中，origin 参数的值指定了允许访问该资源的外域 URL。
例如，下面的字段值将只允许来自 http://itcast.cn 的请求：

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

7.7 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 对额外的请求头进行声明，否则这次请求会失败！

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

​ 默认情况下，CORS 仅支持客户端发起 GET、POST、HEAD 请求。
如果客户端希望通过 PUT、DELETE 等方式请求服务器的资源，则需要在服务器端，通过 Access-Control-Alow-Methods来指明实际请求所允许使用的 HTTP 方法。

7.9 CORS请求的分类:

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

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

​ 请求方式：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）

​ **7.9.2 预检请求：**只要符合以下任何一个条件的请求，都需要进行预检请求：
请求方式为 GET、POST、HEAD 之外的请求 Method 类型
​ 请求头中包含自定义头部字段
向服务器发送了 application/json 格式的数据

​ 在浏览器与服务器正式通信之前，浏览器会先发送 OPTION 请求进行预检，以获知服务器是否允许该实际请求，所以这一次的 OPTION 请求称为“预检请求”。服务器成功响应预检请求后，才会发送真正的请求，并且携带真实数据。

7.10 简单请求和预检请求的区别：

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

7.11 JSONP 接口：

浏览器端通过

​ 特点： JSONP 不属于真正的 Ajax 请求，因为它没有使用 XMLHttpRequest 这个对象。
​ JSONP 仅支持 GET 请求，不支持 POST、PUT、DELETE 等请求。

​ 创建 JSONP 接口的注意事项：如果项目中已经配置了 CORS 跨域资源共享，为了防止冲突，必须在配置 CORS 中间件之前声明 JSONP 的接口。否则 JSONP 接口会被处理成开启了 CORS 的接口。示例代码如下：

​ 实现 JSONP 接口的步骤：

​ 获取客户端发送过来的回调函数的名字
​ 得到要通过 JSONP 形式发送给客户端的数据
​ 根据前两步得到的数据，拼接出一个函数调用的字符串
​ 把上一步拼接得到的字符串，响应给客户端的

​ 实现 JSONP 接口的具体代码

​ 在网页中使用 jQuery 发起 JSONP 请求

​ 调用 $.ajax(从而发起 JSONP 请求，示例代码如下：) 函数，提供 JSONP 的配置选项，

​

13.在项目中操作MySQL

数据库的基本知识
语法：
SELECT 语句用于从表中查询数据。执行的结果被存储在一个结果表中（称为结果集）。语法格式如下：

我们希望从 users 表中选取所有的列，可以使用符号 * 取代列的名称，示例如下：

INSERT INTO 语句用于向数据表中插入新的数据行，语法格式如下：

向 users 表中，插入一条 username 为 tony stark，password 为 098123 的用户数据，示例如下：

Update 语句用于修改表中的数据。语法格式如下：
把 users 表中 id 为 7 的用户密码，更新为 888888。示例如下：

把 users 表中 id 为 2 的用户密码和用户状态，分别更新为 admin123 和 1。示例如下：

DELETE 语句用于删除表中的行。语法格式如下：

从 users 表中，删除 id 为 4 的用户，示例如下：

SQL 的 WHERE 子句：
WHERE 子句用于限定选择的标准。在 SELECT、UPDATE、DELETE 语句中，皆可使用 WHERE 子句来限定选择的标准。

可在 WHERE 子句中使用的运算符“

WHERE 子句示例
可以通过 WHERE 子句来限定 SELECT 的查询条件：

SQL 的 AND 和 OR 运算符：
AND 和 OR 可在 WHERE 子语句中把两个或多个条件结合起来。
AND 表示必须同时满足多个条件，相当于 JavaScript 中的 && 运算符，例如 if (a !== 10 && a !== 20)
OR 表示只要满足任意一个条件即可，相当于 JavaScript 中的 || 运算符，例如 if(a !== 10 || a !== 20)

AND 运算符示例

OR 运算符示例：
使用 OR 来显示所有 status 为 1，或者 username 为 zs 的用户：

SQL 的 ORDER BY 子句：
ORDER BY 语句用于根据指定的列对结果集进行排序。
ORDER BY 语句默认按照升序对记录进行排序。
如果您希望按照降序对记录进行排序，可以使用 DESC 关键字。
对 users 表中的数据，按照 status 字段进行升序排序，示例如下：

对 users 表中的数据，按照 id 字段进行降序排序，示例如下：

ORDER BY 子句 – 多重排序：
对 users 表中的数据，先按照 status 字段进行降序排序，再按照 username 的字母顺序，进行升序排序，示例如下：

COUNT(*) 函数用于返回查询结果的总数据条数，语法格式如下：

查询 users 表中 status 为 0 的总数据条数：

使用 AS 为列设置别名：
如果希望给查询出来的列名称设置别名，可以使用 AS 关键字，示例如下：

1.在项目中操作数据库的步骤

​ *1.1安装操作 MySQL 数据库的第三方模块（mysql）：

​ mysql 模块是托管于 npm 上的第三方模块。它提供了在 Node.js 项目中连接和操作 MySQL 数据库的能力。想要在项目中使用它，需要先运行如下命令，将 mysql 安装为项目的依赖包：npm i mysql

​ 1.2在使用 mysql 模块操作 MySQL 数据库之前，必须先对 mysql 模块进行必要的配置:

1.3 测试 mysql 模块能否正常工作:调用 db.query() 函数,指定要执行的 sql 语句,通过回调函数拿到执行的结果

2.通过 mysql 模块连接到 MySQL 数据库

3.通过 mysql 模块执行 SQL 语句

3.1 查询数据（查询user表中的所有用户信息）

		代码：//查询user表中的所有数据
​    	const sqlStr="select * from user";
  		 db.query(sqlStr,(err,results)=>{
​        //查询数据失败
​       	if(err) return console.log(err.message);
​        	//查询成功，返回数据
​        	//注意：如果执行的是select查询语句，则执行的结果是数组
​       	 console.log(results);
​   	 })					
​							

3.2插入数据

（向user表中添加数据，其中username为Spider-Man ,password为pcc123）

		//向user表中添加数据，其中username为Spider-Man ,password为pcc123
​    const user={username:'Spider-Man',password:'pcc123'}
​    //定义执行的SQL语句 其中？ 为占位符
​    const sqlStr='insert into user (username,password) values(?, ?)';
​    //执行SQL语句
​    db.query(sqlStr,[user.username,user.password],(err,results)=>{
​            //执行SQL语句失败了
​            if(err) return console.log(err.message);
​            //执行成功了
​            //注意：如果执行的是insert into 语句，则results是一个对象
​            //可以通过affectRows属性来判断是否插入数据成功
​            if(results.affectedRows===1){
​                console.log("插入数据成功！");
​            }
​    })

3.3 插入数据的快捷方式：

向表中新增数据时，如果数据对象的每个属性和数据表的字段一一对应，则可以通过如下方式快速插入数据：

3.4 更新数据

​ **更新数据的便捷方式:**更新表数据时，如果数据对象的每个属性和数据表的字段一一对应，则可以通过如下方式快速更新表数据：

3.5 删除数据：

在删除数据时，推荐根据 id 这样的唯一标识，来删除对应的数据。

//删除数据的操作
//删除id为5的用户
const sqlStr='delete from users where id=?';
db.query(sqlStr,5,(err,results)=>{
    if(err) return console.log(err.message)
    //注意：执行delete语句之后，结果也是一个对象，也包含affectedRow属性
    if(results.affectedRows===1){
        console.log('删除数据成功！！')
    }
})

​ 标记删除：使用 DELETE 语句，会把真正的把数据从表中删除掉。为了保险起见，推荐使用标记删除的形式，来模拟删除的动作。所谓的标记删除，就是在表中设置类似于 status 这样的状态字段，来标记当前这条数据是否被删除。当用户执行了删除的动作时，我们并没有执行 DELETE 语句把数据删除掉，而是执行了 UPDATE 语句，将这条数据对应的 status 字段标记为删除即可。

14.前后端的身份认证

1.1 Web的开发模式

​ 目前主流的 Web 开发模式有两种，分别是：
​ *基于服务端渲染的传统 Web 开发模式。

​ 服务端渲染的概念：服务器发送给客户端的 HTML 页面，是在服务器通过字符串的拼接，动态生成的。因此，客户端不需要使用 Ajax 这样的技术额外请求页面的数据。代码示例如下：

​ 服务端渲染的优缺点：

​ 优点：
​ 前端耗时少。因为服务器端负责动态生成 HTML 内容，浏览器只需要直接渲染页面即可。尤其是移动端，更省电。
​ 有利于SEO。因为服务器端响应的是完整的 HTML 页面内容，所以爬虫更容易爬取获得信息，更有利于 SEO。

​ 缺点：
占用服务器端资源。即服务器端完成 HTML 页面内容的拼接，如果请求较多，会对服务器造成一定的访问压力。
​ 不利于前后端分离，开发效率低。使用服务器端渲染，则无法进行分工合作，尤其对于前端复杂度高的项目，不利于项目高效开发。

​ *基于前后端分离的新型 Web 开发模式。

​ 前后端分离的概念：前后端分离的开发模式，依赖于 Ajax 技术的广泛应用。简而言之，前后端分离的 Web 开发模式，就是后端只负责提供 API 接口，前端使用 Ajax 调用接口的开发模式。

​ 前后端分离的优缺点：

​ 优点：
​ 开发体验好。前端专注于 UI 页面的开发，后端专注于api 的开发，且前端有更多的选择性。
用户体验好。Ajax 技术的广泛应用，极大的提高了用户的体验，可以轻松实现页面的局部刷新。
减轻了服务器端的渲染压力。因为页面最终是在每个用户的浏览器中生成的。

​ 缺点：
​ 不利于 SEO。因为完整的 HTML 页面需要在客户端动态拼接完成，所以爬虫对无法爬取页面的有效信息。（解决方案：利用 Vue、React 等前端框架的 SSR （server side render）技术能够很好的解决 SEO 问题！）

1.2 身份认证：

​ 身份认证（Authentication）又称“身份验证”、“鉴权”，是指通过一定的手段，完成对用户身份的确认。在 Web 开发中，也涉及到用户身份的认证，例如：各大网站的手机验证码登录、邮箱密码登录、二维码登录等。

1.3 不同开发模式下的身份认证

​ 对于服务端渲染和前后端分离这两种开发模式来说，分别有着不同的身份认证方案：

• 服务端渲染推荐使用 Session 认证机制
• 前后端分离推荐使用 JWT 认证机制

1.4 Session 认证机制

​ Cookie:

​ Cookie 是存储在用户浏览器中的一段不超过 4 KB 的字符串。它由一个名称（Name）、一个值（Value）和其它几个用于控制 Cookie 有效期、安全性、使用范围的可选属性组成。
不同域名下的 Cookie 各自独立，每当客户端发起请求时，会自动把当前域名下所有未过期的 Cookie 一同发送到服务器。
​ Cookie的几大特性：
​ 自动发送
​ 域名独立
​ 过期时限
​ 4KB 限制

1.5 Cookie 在身份认证中的作用

​ 客户端第一次请求服务器的时候，服务器通过响应头的形式，向客户端发送一个身份认证的 Cookie，客户端会自动将 Cookie 保存在浏览器中。
​ 随后，当客户端浏览器每次请求服务器的时候，浏览器会自动将身份认证相关的 Cookie，通过请求头的形式发送给服务器，服务器即可验明客户端的身份。

​ Cookie 不具有安全性:由于 Cookie 是存储在浏览器中的，而且浏览器也提供了读写 Cookie 的 API，因此 Cookie 很容易被伪造，不具有安全性。因此不建议服务器将重要的隐私数据，通过 Cookie 的形式发送给浏览器。千万不要使用 Cookie 存储重要且隐私的数据！比如用户的身份信息、密码等。

1.6.Session 的工作原理

1.7 在 Express 中使用 Session 认证

​ **1.安装express-session 中间件：***在 Express 项目中，只需要安装 express-session 中间件，即可在项目中使用 Session 认证：npm i express-session 命令即可安装

​ 2.配置 express-session 中间件

​ express-session 中间件安装成功后，需要通过 app.use() 来注册 session 中间件，示例代码如下：

​ 3.向 session 中存数据:当 express-session 中间件配置成功后，即可通过 req.session 来访问和使用 session 对象，从而存储用户的关键信息：

​ 4.从 session 中取数据:

​ 可以直接从 req.session 对象上获取之前存储的数据，示例代码如下：

​ 5. 清空 session:调用 req.session.destroy() 函数，即可清空服务器保存的 session 信息。

15.JWT 认证机制

1.了解 Session 认证的局限性

​ Session 认证机制需要配合 Cookie 才能实现。由于 Cookie 默认不支持跨域访问，所以，当涉及到前端跨域请求后端接口的时候，需要做很多额外的配置，才能实现跨域 Session 认证。

​ 注意：
​ *当前端请求后端接口不存在跨域问题的时候，推荐使用 Session 身份认证机制。
​ *当前端需要跨域请求后端接口的时候，不推荐使用 Session 身份认证机制，推荐使用 JWT 认证机制。

2.含义：JWT

​ JWT（英文全称：JSON Web Token）是目前最流行的跨域认证解决方案。

3.JWT 的工作原理

​ 用户的信息通过 Token 字符串的形式，保存在客户端浏览器中。服务器通过还原 Token 字符串的形式来认证用户的身份。

4.JWT 的组成部分

​ JWT 通常由三部分组成，分别是 Header（头部）、Payload（有效荷载）、Signature（签名）。
三者之间使用英文的“.”分隔，格式如下：

下面是 JWT 字符串的示例：

​ 4.1JWT 的三个部分各自代表的含义

​ JWT 的三个组成部分，从前到后分别是 Header、Payload、Signature。
​ 其中：
​ Payload 部分才是真正的用户信息，它是用户信息经过加密之后生成的字符串。
​ Header 和 Signature 是安全性相关的部分，只是为了保证 Token 的安全性

5.JWT 的使用方式

​ 客户端收到服务器返回的 JWT 之后，通常会将它储存在 localStorage 或 sessionStorage 中。
此后，客户端每次与服务器通信，都要带上这个 JWT 的字符串，从而进行身份认证。推荐的做法是把 JWT 放在 HTTP 请求头的 Authorization 字段中，格式如下：

6.在 Express 中使用 JWT

​ 1.安装 JWT 相关的包

​ 运行如下命令，安装如下两个 JWT 相关的包：

​ 其中：
​ jsonwebtoken 用于生成 JWT 字符串
​ express-jwt 用于将 JWT 字符串解析还原成 JSON 对象

​ 2.导入 JWT 相关的包

​ 使用 require() 函数，分别导入 JWT 相关的两个包：

3.定义 secret 密钥

​ 为了保证 JWT 字符串的安全性，防止 JWT 字符串在网络传输过程中被别人破解，我们需要专门定义一个用于加密和解密的 secret 密钥：
​ 当生成 JWT 字符串的时候，需要使用 secret 密钥对用户的信息进行加密，最终得到加密好的 JWT 字符串
​ 当把 JWT 字符串解析还原成 JSON 对象的时候，需要使用 secret 密钥进行解密（注意：密钥可以自己定义，越复杂越好）

4.在登录成功后生成 JWT 字符串

​ 调用 jsonwebtoken 包提供的 sign() 方法，将用户的信息加密成 JWT 字符串，响应给客户端：
·
5.将 JWT 字符串还原为 JSON 对象

​ 客户端每次在访问那些有权限接口的时候，都需要主动通过请求头中的 Authorization 字段，将 Token 字符串发送到服务器进行身份认证。此时，服务器可以通过 express-jwt 这个中间件，自动将客户端发送过来的 Token 解析还原成 JSON 对象：

6.捕获解析 JWT 失败后产生的错误

​ 当使用 express-jwt 解析 Token 字符串时，如果客户端发送过来的 Token 字符串过期或不合法，会产生一个解析失败的错误，影响项目的正常运行。我们可以通过 Express 的错误中间件，捕获这个错误并进行相关的处理，示例代码如下：