什么是node.js
node.js是基于Chrome V8引擎的javaScrit运行环境
node.js中的javaScript运行环境
注意：
1.浏览器是javaScript的前端运行环境
2.Node.js是javaScript的后端运行环境
3.node.js中无法调取DOM和BOM等浏览器内置API
node.js可以做什么？
1.基于express框架，可以快速构建Web应用
2.基于Electron框架，可以构建跨平台的桌面应用
3.基于restify框架，可以快速构建API接口项目
4.读写和操作数据库，创建实用的命令行工具辅助前端开发，etc
nodejs的学习路径：
javaScript基础语法+node.js内置模块（fs,path,http等）+第三方API模块（express，mysql等）
node.js的内置模块
fs系统模块
fs是node.js官方提供的，用来操作文件的模块。它提供了一系列的方法和属性用来满足用户对文件的操作需求
1.fs.readFile()方法，用来读取指定文件的内容
2.fs.writeFile()方法，用来向指定的文件中写入内容
在js代码中使用fs模块(nodejs内置函数)
1.导入
const fs = require('fs')
1.读取指定文件内容
使用fs.readFile()读取指定文件的内容：
语法：
fs.readFile(path,option,callback)
参数解读：
1.path 必选参数，字符串，表示文件的路径
2.option 可选参数，表示使用什么编码格式来读取文件
3.callback 必选参数，文件读取后，通过回调函数拿到读取结果
示例：
const fs = require('fs') //导入fs模块
fs.readFile('./a.txt', 'utf8',function(err,dataStr){
console.log(err)
console.log(dataStr)
})
2.向指定模块中写入内容
fs.writeFile()的语法格式
使用fs.writeFile()方法写入
1.fs.writeFile(path,data,option,function)
参数解读：
参数1：path 必选参数，文件的路径
参数2：data 必选参数，表示要写入的内容
参数3：编码格式
参数4：回调函数 必选参数
实例：
const fs = require('fs')
fs.writeFile('./file/a.txt',"hello",function(err){
console.log(err)
})
*注意：
1.fs.writeFile() 方法只能用来创建文件，不能用来创建路径
2.重复调用fs.writeFile()写入同一个文件，新写入的文件内容会覆盖之前的旧内容
3.fs模块–路径动态拼接的问题
在使用fs 模块操作文件时，如果提供的操作路径是以/或../开头的相对路径时，很容易出现路径动态拼接错误的问题。
原因:代码在运行的时候，会以执行node 命令时所处的目录，动态拼接出被操作文件的完整路径。
解决这个问题：
1.提供一个完整的文件路径
2.不使用./ ../ 使用_dirname 表示当前文件所在的目录
//解决文件路径拼接问题
const fs = require('fs')
// __dirname 表示当前文件所处的目录
console.log(__dirname);
fs.readFile(__dirname+"/file/a.txt",'utf8',function(err, data) {
if (err){
return console.error(err)
}
console.log(data)
})
path路径模块
path模块是Node.js官方提供的，用来处理路径的模块，它提供了一系列的方法和属性，用来满足用户对路径的处理和需求
例如：
path.join()方法，用来将路径片段拼接成一个完整的路径字符串
path.basename()方法，用来从路径中将文件名解析出来
在js代码中使用fs模块(nodejs内置函数)
1.导入
const path = require('path')
路径拼接path.join()
path.join()方法。可以将多个路径片段拼接为完整的路径字符串
const pathStr = path.join('/a','/b/c','../','./d','e')
console.log(pathStr) // ../会抵消前面的一个路径 \a\b\d\e
const pathStr1 = path.join(__dirname,'/file/1.txt')
console.log(pathStr1) // 输出 当前文件所在目录 \file\1.txt
*涉及到路径一般使用path.join()进行路径的拼接
path.basename()的语法格式
使用path.basename()方法，可以获取路径中的最后一部分，经常通过这个方法获取路径中的文件名
path.basename(pth,ext)
path<String> 必选参数，表示一个路径的字符串
ext<String> 可选参数，表示文件的扩展名
返回<String> 表示路径中最后的一部分
获取路径中的扩展名
使用path.extname()方法，可以获取路径中扩展名部分，语法格式如下
path.extname(path)
path<String> 必选参数，表示一个路径的字符串
返回<String> 返回得到的扩展名字符串
http模块
1.什么是http模块
http模块是Node.js 官方提供的、用来创建web服务器的模块。通过 http模块提供的 http=createServer()方法
就能方便的把一台普通的电脑，变成一台Web 服务器，从而对外提供 Web资源服务。
2.如何使用http模块
1.首先导入 const http = require('http');
3.http模块的作用
在Node,js中，我们不需要使用lIS、Apache等这些第三方web服务器软件。因为我们可以基于Node.js 提供的http模块，通过几行简单的代码，就能轻松的手写一个服务器软件，从而对外提供web服务。
服务器相关的概念
1.IP地址
Ip地址就是互联网上每台计算机的唯一地址，因此IP地址具有唯一性。如果把"个人电脑"比作"一台电话"，那么"IP地址"就相当于"电话号码"只有在知道对方IP地址的前提下，才能与对应的电脑之间进行数据通信。
2.域名和域名服务器
尽管IРP地址能够唯一地标记网络上的计算机，但IP地址是一长串数字，不直观，而且不便于记忆，于是人们又发明了另一套字符型的地址方案，即所谓的域名(Domain Name)地址
IP地址和域名是一—对应的关系，这份对应关系存放在一种叫做域名服务器(DNS，Domain name server)的电脑中。使用者只需通过好记的域名访问对应的服务器即可，对应的转换工作由域名服务器实现。因此，域名服务器就是提供IР地址和域名之间的转换服务的服务器。
3.端口号
计算机中的端口号，就好像是现实生活中的门牌号一样。通过门牌号，外卖小哥可以在整栋大楼众多的房间中，准确把外卖送到你的手中。
同样的道理，在一台电脑中，可以运行成百上千个web服务。每个web服务都对应一个唯一的端口号。客户端发送过来的网络请求，通过端口号，可以被准确地交给对应的web 服务进行处理。
每个端口号只能被一个web服务使用
创建最基本的web服务器
1.创建web服务的基本步骤
1.导入http模块
const http = require('http');
2.创建web服务实例
通过http.creatServer()方法快速创建web服务实例
const server = http.createServer();
3.为服务器实例绑定request事件，建通客户端的请求
// 使用服务器实例 .on()方法，为服务器绑定一个request事件
server.on('request',(req,res)=>{
// 只要客户端来请求我们自己的服务器 就会触发 request事件 从而调用这个事件处理函数
console.log("Someone visit our web server")
})
4.启动服务
调用服务器实例的.listen()方法，即可启动当前的web服务实例：
//调用server。listen(端口号，cb回调方法) 即可启动web服务器
server.listen(80,()=>{
console.log('请访问 http://127.0.0.1:80')
})
2.req请求对象
只要服务器接收到客户端的请i去，就会调用server.on()为服务器绑定的request事件处理函数
如果想在事件处理函数中，访问与客户端相关的数据或属性，可以使用如下方式：
server.on('request',(req, res) => {
// req.url 是客户端请求的url地址
const url = req.url;
// req.method 是客户端请求的method类型
const method = req.method;
const str = `你请求的url:${url},请求方式是：${method}`;
console.log(str);
})
3.res响应对象
在服务器的request事件处理函数中，如果想访问服务器相关的数据或属性，可以使用如下的方式
server.on('request',(req, res) => {
// req.url 是客户端请求的url地址
const url = req.url;
// req.method 是客户端请求的method类型
const method = req.method;
const str = `你请求的url:${url},请求方式是：${method}`;
//为了防止中文显示乱码的问题，需要设置响应头Content-Type的值为 text/html; charset=utf-8
res.setHeader( 'Content-Type' ,'text/html; charset=utf-8 ')
//调用res.send向客户端响应一些内容
res.end(str)
})
*如果不设置相应头 res.end()返回中文会乱码
设置响应头：res.setHeader( 'Content-Type' ,'text/html; charset=utf-8 ')
根据不同的url地址响应不同的html内容
核心步骤：
1.获取请求的url地址
2.设置默认的响应内容 404 NOT Fount
3.判断用户请的是否为/或/index.html 首页
4.判断用户请求的是否为/about.html 页面
5.设置content-Type响应头，防止中文乱码
6.使用res.end把内容响应给客户端
模块化
编程领域中的模块化，就是遵守固定的规则，把一个大的文件查分成独立并且相互依赖的多个小模块
把代码进行模块化才分的好处：
1.提高代码的复用性
2.提高代码的可维护性
3.可以实现按需加载
模块化规范
模块化规范就是对模块化进行才分组合时需要遵守的规则
使用什么样的语法格式来引用模块？
在模块中使用什么样的语法格式向外暴露成员
模块化规范的好处：
大家遵守同样的模块化规范写代码，降低了沟通的成本，极大的方便了各模块之间的相互调用。
1.node.js中模块的分类
node.js根据模块的来源不同 ，将模块计划分为3大类，分别是：
1.内置模块（内置模块由nodejs官方提供的，例如：fs,path,http等）
2.自定义模块（用户创建的.js文件，都是自定义模块）
3.第三方模块（由第三方开发出来的模块，使用前需要下载）
2.加载模块
使用require()方法,可以加载内置模块，用户自定义模块，第三方模块进行使用
//1.加载内置模块
const fs = require('fs');
//2.加载自定义模块
const custom = require('./custom.js');
//3.加载第三方模块
const moment = require('moment');
*注意:
使用require方法加载其他模块时候，会执行被加载模块中的代码
在加载require加载用户模块期间，可以省略后缀名
3.node.js中模块作用域
什么式模块作用域
和作用域函数类似，在自定义模块中定义的变量，方法等成员，只能在当前模块内被访问，这种模块级别的访问限制叫做模块作用域
模块作用域的好处：
防止全局变量污染问题
4.向外共享模块作用域中的成员
1.module对象
在每个.js自定义模块中都有一个module对象，他里面存储了和当前模块有关的信息
打印module
Module {
id: '.',
path: 'E:\\student\\NODEJS\\04.模块化',
exports: {},
parent: null,
filename: 'E:\\student\\NODEJS\\04.模块化\\05.演示module对象.js',
loaded: false,
children: [],
paths: [
'E:\\student\\NODEJS\\04.模块化\\node_modules',
'E:\\student\\NODEJS\\node_modules',
'E:\\student\\node_modules',
'E:\\node_modules'
]
}
2.module.exports对象 默认为空对象
在自定义模块中，可以使用module.exports对象，将模块内的成员共享出去，供外界使用
外界用require()方法导入自定义模块时，得到的就是module.exports所指的对象
3.共享成员的注意点
使用require()方法导入模块时，导入的结果 永远以module.exports指向的对象为准
4.exports对象
由于module.expres写起来比较复杂，为了简化代码，提供了exports对象。默认情况下
exports和module.exports指向同一个对象，最终结果还是以module.exports指向的为准
*注意：为了防止混乱，建议不要再同一个模块中同时使用exports和module.expres
5.node.js中的模块化规范
node.js遵循了conmmonJS模块化规范，commonJS规定了模块的特性和各模块之间如何相互依赖
commonJS
1.每个模块内部，module变量代表当前模块
2.module变量是一个对象，它的exports属性（即module.exports）是对外接口
3.加载模块时候，其实加载该模块的module.exports属性。require()方法用于加载模块
npm与包
1.什么是包？
nodejs中的第三方模块又叫做包
2.包的来源
不同于node.js中内置模块和自定义模块，包是由第三方个人或团队开发出来的，免费供所有人使用
注意：Node.js中的包都是免费且开源的，不需要付费即可免费下载使用
3.为什么需要包？
由于node.js的内置模块仅仅提供了一些底层API,导致在基于模块进行项目开发时候，效率很低
包是基于内置模块封装出来的，提供了高级，更方便的API，极大的提高了开发效率
4.从哪里下载包
从https://www.npmjs.com/ 网站搜索自己所需要的包
5.如何下载包
npm 包管理器 安装node的时候自动安装了
6.在项目中装包的命令
npm install 包的完整名称
简写 npm i 包的完整名称
7.初次装包，文件里面多了哪些文件？
初次装包完成后，在项目文件夹下多了一个叫做 node_modules的文件夹和package-lock.json的配置文件
node modules文件夹用来存放所有已安装到项目中的包。require()导入第三方包时，就是从这个目录中查找并加载包。package-lockjson配置文件用来记录node_modules目录下的每一个包的下载信息，例如包的名字、版本号、下载地址等。
*注意:程序员不要手动修改node modules或package-lockjson文件中的任何代码，npm包管理工具会自动维护它们。
8.安装指定版本的包
默认情况下，使用npm install命令安装包的时候，会自动安装最新版本的包。如果需要安装指定版本的包，可以在包名之后，通过@符号指定具体的版本，例如:npm i [email protected]
9.包的语义化版本规范
包的版本号是以“点分十进制”形式进行定义的，总共有三位数字，例如2.24.0其中每一位数字所代表的的含义如下:
第1位数字:大版本
第2位数字:功能版本第3位数字:Bug修复版本
版本号提升的规则:只要前面的版本号增长了，则后面的版本号归零。
10.3.快速创建package.json
npm包管理工具提供了一个快捷命令，可以在执行命令时所处的目录中，快速创建package.json这个包管理配置文件:
//作用:在执行命令所处的目录中，快速新建package.json文件
npm init -y
注意:
上述命令只能在英文的目录下成功运行!所以，项目文件夹的名称一定要使用英文命名.不要使用中文，不能出现空格。
运行npm install 命令安装包的时候，npm包管理工具会自动把包的名称和版本号，记录到package.json中。
11.一次性安装所有的包
可以运行npm install命令(或npm i)一次性安装所有的依赖包:
1//执行npm install命令时，npm包管理工具会先读取package.json 中的 dependencies 节点
2//读取到记录的所有依赖包名称和版本号之后，npm包管理工具会把这些包一次性下载到项目中
3 npm install
12.卸载包
npm uninstall 包名
13.devDependencies节点
如果某些包只在项目开发阶段会用到，在项目上线之后不会用到，则建议把这些包记录到devDependencies节点中。
与之对应的，如果某些包在开发和项目上线之后都需要用到，则建议把这些包记录到dependencies 节点中。
您可以使用如下的命令，将包记录到devDependencies节点中:
1//安装指定的包，并记录到devDependencies节点中
2 npm i 包名-D
3//注意:上述命令是简写形式，等价于下面完整的写法:4 npm install 包名 --save-dev
14.解决下包速度慢的问题
1.为什么下包速度慢
在使用npm下包的时候，默认从国外的https://registry.npmjs.org/服务器进行下载，此时，网络数据的传输需要经过漫长的海底光缆，因此下包速度会很慢。
2.切换npm的下包镜像源
下包的镜像源，指的就是下包的服务器地址。
1#查看当前的下包镜像源
2 npm config get registry
3# 将下包的镜像源切换为淘宝镜像源
4 npm config set registry=https://registry.npm.taobao.org/
5 #检查镜像源是否下载成功
6 npm config get registry
3.nrm
为了更方便的切换下包的镜像源，我们可以安装nrm这个小工具，利用nrm 提供的终端命令，可以快速查看和切换下包的镜像源。
1 #通过npm包管理器，将 nrm安装为全局可用的工具2 npm i nrm -g
3#查看所有可用的镜像源
4 nrm ls
5#将下包的镜像源切换为taobao镜像6 nrm use taobao
express
Express简介
1.什么是Express
官方给出的概念:Express是基于Node.js 平台，快速、开放、极简的Web开发框架。
通俗的理解:Express的作用和Node.js内置的http模块类似，是专门用来创建Web服务器的。Express的本质:就是一个npm上的第三方包，提供了快速创建Web服务器的便捷方法。
Express的中文官网: http://www.expressis.com.cn/
Express 能做什么
对于前端程序员来说，最常见的两种服务器，分别是:
Web 网站服务器:专门对外提供Web 网页资源的服务器。API接口服务器:专门对外提供API接口的服务器。
使用Express，我们可以方便、快速的创建Web 网站的服务器或 API接口的服务器。
1.安装
在项目所处的目录中，运行如下的终端命令，即可将express安装到项目中使用:
1 npm i [email protected]
2.创建基本的Web服务器
1 // 1．导入express
2 const express = require( ' express ' )
3 // 2．创建web服务器
4 const app = express()
6 // 3．调用app.listen(端口号，启动成功后的回调函数)，启动服务器
7 app.listen(80，() =>{
console.log( ' express server running at http: //127.0.0.1')})
3.监听get请求
通过app.get( )方法，可以监听客户端的GET请求，语法如下：
1.参数1∶客户端请求的URL 地址
2.参数2:请求对应的处理函数
3.req:请求对象（(包含了与请求相关的属性与方法)
4.res:响应对象(包含了与响应相关的属性与方法)
5 app.get('请求URL',function(req,res) {/*处理函数*/ })
4.监听post请求
通过app.post( )方法，可以监听客户端的GET请求，语法如下：
1.参数1∶客户端请求的URL 地址
2.参数2:请求对应的处理函数
3.req:请求对象（(包含了与请求相关的属性与方法)
4.res:响应对象(包含了与响应相关的属性与方法)
5 app.post('请求URL',function(req,res) {/*处理函数*/ })
5.把内容响应给客户端
通过res.send)方法，可以把处理好的内容，发送给客户端:
app.get( ' /user ' , (req, res) =>{
向客户端发送JSON 对象
res.send({ name: 'zs '，age: 20，gender: '男'})
})
app.post( " /user'. (req,res) =>{
向客户端发送文本内容
res.send( '请求成功')
})
6.获取URL中携带的查询参数
通过req.query对象，可以访问到客户端通过查询字符串的形式，发送到服务器的参数:
app.get( '/'， (req，res) => {
//req.query 默认是一个空对象
//客户端使用?name=zs&age=20这种查询字符串形式，发送到服务器的参数，
//可以通过req.query对象访问到，例如:
// req.query.name req.query.age
console.log(req. query)
7.获取URL中的动态参数
通过req.params对象，可以访问到URL中，通过:匹配到的动态参数:
//URL地址中，可以通过:参数名的形式，匹配动态参数值
app.get( '/user/:id',(req,res) => {
//req.params 默认是一个空对象
//里面存放着通过:动态匹配到的参数值
console.log(req. params)
})
8.托管静态资源
1.express.static()
express提供了一个非常好用的函数，叫做express.static()，通过它，我们可以非常方便地创建一个静态资源服务器,例如，通过如下代码就可以将public目录下的图片、CSS文件JavaScript 文件对外开放访问了:
app.use(express.static('public'))
*如过不生效
const path = require('path');
app.use(express.static(path.join(__dirname, 'public')))
挂载路径前缀
如果希望在托管的静态资源访问路径之前，挂载路径前缀，则可以使用如下的方式:
app.use( '/public' , express.static( 'public' ))
现在，你就可以通过带有/public 前缀地址来访问public目录中的文件了:
express路由
1.Express中的路由
在Express 中，路由指的是客户端的请求与服务器处理函数之间的映射关系。
Express 中的路由分3部分组成，分别是请求的类型、请求的URL地址、处理函数，格式刻
app.METHOD(PATH,HANDLER)
2.Express中的路由的例子
匹配GET请求，且请求URL为/
app.get( '/',function (req,res) {res.send( 'Hello world! ')})
匹配POST请求，且请求URL为/
app.post('/', function (req,res) {res.send( ' Got a PoST request ')})
3.路由的匹配过程
1. 每当一个请求到达服务器之后，需要先经过路由的匹配，只有匹配成功之后，才会调用对应的处理函数。
2. 在匹配时，会按照路由的顺序进行匹配，如果请求类型和请求的URL同时匹配成功，则 Express 会将这次请求，转交给对应的function 函数进行处理。
3. 路由匹配的注意点:
按照定义的先后顺序进行匹配
请求类型和请求的URL同时匹配成功，才会调用对应的处理函数
4.路由的使用
在Express 中使用路由最简单的方式，就是把路由挂载到app 上，示例代码如下:
const express = require('express')
const app = express()
//挂载路由
app.get('/',(req, res) =>{
res.send("hello word")
})
app.post('/',(req, res) =>{
res.send("post request")
})
app.listen(3000,() => {
console.log('http://localhost:3000');
})
5.模块化路由
为了方便对路由进行模块化的管理，Express 不建议将路由直接挂载到app上，而是推荐将路由抽离为单独的模块。
将路由抽离为单独模块的步骤如下:创建路由模块对应的.js文件
1.创建路由模块对应的.js文件
2.调用express.Router()函数创建路由对象
3.向路由对象上挂载具体的路由
4.使用module.exports向外共享路由对象
//这是路由模块
// 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('post user add')
})
//4.向外导出路由
module.exports = router
5.使用app.use()函数注册路由模块
const express = require('express');
const app = express();
//1.导入路由模块
const routes = require('./05.router');
//2.注册路由模块 app.use这个函数的作用，就是用来注册全局的中间件
app.use(routes)
app.listen(3000,()=>{
console.log('listening on 3000')
});
给路由添加统一的访问前缀
app.use('/api',routes)
6.EXpress中间件
1.什么是中间件
中间件：特指业务流程的中间处理环节
2.express中间件的调度流程
当请求到达Express的服务之后，可以连续调用多个中间件，从而对这次请求进行预处理
3.Express中间件的格式
Express的中间件，本质上就是一个function处理函数，Express中间件的格式如下：
app.get( '/',(req,res,next) => {
next()
})
app.listen(3000);
*注意：中间件函数的形参列表中，必须包含next参数，而路由器处理函数只包含req和res
4.next()形参的作用
next函数是实现多个中间件连续调用的关键，它表示把流转关系转交给下一个中间件或路由
7.Express中间件初体验
1.定义中间件
可以通过如下方式定义，定义一个最简单的中间件
//常量 mw所指向的，就是一个中间件函数
const mw = function(req,res,next){
console.log("这是一个最简单的中间件")
// 注意：在当前中间件的业务处理完毕后，必须调用next()函数
// 表示把流转关系交给下一个中间件或路由
next()
}
2.全局生效的中间件
客户端发起任何请求，到达服务器之后，都会触发的中间件叫做全局生效中间件
通过调用app.use()中间件函数，即可定义一个全局中间件，示例代码如下：
const express = require('express')
const app = express()
const port = 3000
// 定义一个最简单的中间件函数
const mw = function (req, res,next) {
console.log("这是最简单的中间件函数");
//把流转关系，转交给下一个中间件
next()
}
// 将mw注册成为全局的中间件
app.use(mw)
app.get('/', (req, res) =>{
console.log("调用了/这个路由");
res.send('Hello World!')
})
app.get('/user', (req, res) => {
console.log(`调用了${req.url}`);
res.send('my is user')
})
app.listen(port, () => console.log(`Example app listening on port ${port}!`))
3.定义全局中间件的简化形式
app.use((req, res, next) => {
console.log("这是简化的全局中间件");
next();
})
4.中间件的作用
多个中间件之间 共享一份req和res基于这个特性，我们可以在上有的中间件中，统一为req或res对象添加自定义的属性和方法，供下游的中间件或路由使用
5.定义多个全局中间件
可以使用app.use()连续定义多个全局中间件。客户端请求到达服务器之后，会按照中间件的先后顺序，依次进行调用，实例代码：
// 定义第一个全局中间件
app.use((req, res, next) =>{
console.log("调用了第一个全局中间件");
next()
})
//定义第二个全局中间件
app.use((req, res, next) =>{
console.log("调用了第二个全局中间件");
next()
})
//定义一个路由
app.get('/', (req, res, next) =>{
res.send(req.url)
})
6.局部生效的中间件
不使用app.use()定义的中间件，叫做局部生效的中间件 示例代码如下
const mw = (req, res, next) => {
console.log("调用局部生效中间件");
next()
}
app.get('/',mw, (req, res) => {
res.send("/")
})
app.get('/user',(req, res) => {
res.send("/user")
})
7.定义多个局部中间件
可以在路由中通过如下两种等价的方式，使用多个局部中间件
//创建局部生效的中间件
const mw1 = (req, res, next) =>{
console.log('调用了第一个局部生效的中间件');
next()
}
const mw2 = (req, res, next) =>{
console.log("调用了第二个局部生效的中间件");
next()
}
// 以下两种写法均为完全等价，可以使用任意一种
app.get('/', mw1,mw2,(req, res) =>{
res.send('/')
})
app.get('/user',[mw1,mw2],(req, res) =>{
res.send('/user')
})
8.了解中间件的5个注意事项
1.一定要在路由注册之前注册中间件
2.客户端发送过来的请求，可以连续调用多个中间件进行处理
3.执行完中间件的业务代码之后，不要忘记调用next()函数
4.为了防止逻辑混乱，盗用next()函数后不要频再写额外的代码
5.连续调用中间键的时候多个中间件之间，共享req和res对象
8.中间件的分类
1.应用级别的中间件 app
通过app.use()或app.get()或app.post()绑定到app实例上的中间件，叫做应用级别的中间件
2.路由级别的中间件 router
绑定到express.Routerl)实例上的中间件，叫做路由级别的中间件。它的用法和应用级别中间件没有任何区别。只不过，应用级别中间件是绑定到 app实例上，路由级别中间件绑定到router实例上
3.错误级别的中间件
错误级别中间件的作用:专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题。
格式:错误级别中间件的function处理函数中，必须有4个形参，形参顺序从前到后，分别是(err, req, res, next)。
app.get( ' /', function (req,res) { // 路由
//抛出一个自定义的错误
throw new Error( '服务器内部发生了错误!')
res.send( 'Home Page.')
})
app.use( function (err,req,res,next) {
//错误级别的中间件
console.log( '发生了错误:' +err.message)
// 在服务器打印错误消息
res.send( 'Error! ' +err.message) // 2.2向客户端响应错误相关的内容
})
** 错误级别中间件，必须注册再所有路由之后
4.Express内置的中间件
自Express 4.16.0版本开始，Express 内置了3个常用的中间件，极大的提高了Express 项目的开发效率和体验
1.express.static快速托管静态资源的内置中间件，例如:HTML文件、图片、CSS样式等(无兼容性)
2.express.json解析JSON格式的请求体数据（有兼容性，仅在4.16.0+版本中可用)
3.express.urlencoded解析URL-encoded格式的请求体数据（有兼容性，仅在4.16.0+版本中可用)
//配置解析application/json格式数据的内置中间件
app.use(express.json())
//配置解析 application/x-ww-form-urlencoded格式数据的内置中间件
app.use(express.urlencoded( { extended: false }))
app.use(express.json())
app.use(express.urlencoded({extended:false}))
app.post('/book', function (req, res) {
//在客户端可以使用req.body这个属性，来接收客户端发送过来的请求数据
// 默认情况下，如果不配置解析表单的中间件，则req.body 默认等于 undefined
console.log(req.body);
res.send('POST request to the homepage')
})
app.get('/', (req, res) => {
res.send('GET request to the homepage')
})
app.post('/', function (req, res) {
// 在服务器端，可以通过req.body 来获取JSON格式和url-encoded格式的数据
console.log(req.body);
res.send('POST request to the homepage')
})
5.第三方的中间件
非Express 官方内置的，而是由第三方开发出来的中间件，叫做第三方中间件。在项目中，大家可以按需下载并配置第三方中间件，从而提高项目的开发效率。
例如:在[email protected]之前的版本中，经常使用body-parser这个第三方中间件，来解析请求体数据。使用步骤如下:
运行npm install body-parser安装中间件使用require 导入中间件
6.解决跨越问题中间件
cors
cors 是 Express的一个第三方中间件。通过安装和配置cors 中间件，可以很方便地解决跨域问题。
1.运行 npm install cors 安装中间件
2.使用const cors = require('cors') 导入中间件
3.在路由之前调用app.use(cors) 配置中间件
什么是cors
CORS (Cross-Origin Resource Sharing，跨域资源共享）由一系列HTTP响应头组成，这些HTTP响应头决定浏览器是否阻止前端JS代码跨域获取资源。
浏览器的同源安全策略默认会阻止网页“跨域”获取资源。但如果接口服务器配置了CORS相关的HTTP响应头，就可以解除浏览器端的跨域访问限制。
CORS 的注意事项
CORS主要在服务器端进行配置。客户端浏览器无须做任何额外的配置，即可请求开启了CORS的接口。CORS在浏览器中有兼容性。只有支持XMLHttpRequest Level2的浏览器，才能正常访问开启了CORS的服务端接口(例如:IE10+、Chrome4+、FireFox3.5+)。
CORS 响应头部-Access-Control-Allow-Origin
响应头部中可以携带一个 Access-Control-Allow-Origin字段，其语法如下:
Access-Control-Allow-origin: <origin>|*
其中，origin 参数的值指定了允许访问该资源的外域URL。
例如，下面的字段值将只允许来自http://itcast.cn的请求:
res.setHeader ( 'Access-Control-Allow-Origin', 'http:/litcast.cn')
如果指定了Access-Control-Allow-Origin字段的值为通配符*，表示允许来自任何域的请求，示例代码如下:
res.setHeader( 'Access-Control-Allow-Origin', '*')
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 ' )
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 ', '*')
简单请求：
同时满足一下两个大条件的请求，就属于简单请求
1.请求方式GET,POST,HEAD 三者之一
2.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)
预检请求
只要符合以下任何一个条件的请求，都需要进行预检请求:
1.请求方式为GET、POST、HEAD之外的请求Method类型
2.请求头中包含自定义头部字段
3.向服务器发送了application/json格式的数据
在浏览器与服务器正式通信之前，浏览器会先发送OPTION请求进行预检，以获知服务器是否允许该实际请求，所以这-次的OPTION请求称为“预检请求”。服务器成功响应预检请求后，才会发送真正的请求，并且携带真实数据。
简单请求和预检请求的区别
简单请求的特点:客户端与服务器之间只会发生一次请求。
预检请求的特点:客户端与服务器之间会发生两次请求，OPTION预检请求成功之后，才会发起真正的请求。
express+mysql
安装mysql模块
npm install mysql
配置mysql模块
// 1．导入mysql模块
const mysql = require( ' mysql' )
//2．建立与 MySQL数据库的连接
const db = mysql.createPool({
host: '127.0.0.1', //数据库的IP地址
user : 'root',//登录数据库的账号
password: 'admin123',//登录数据库的密码
database: 'my_db_01' //指定要操作哪个数据库
})
测试mysql模块是否正常工作
// 测试mysql 是否正常工作
db.query('SELECT 1', (err, result) => {
if (err) {
return console.log("错误");
}
//只要能打印出{'1':1}的结果，就证明数据库连接成功
console.log(result);
})
查询数据
// 查询list表中的所有数据
const sql = "SELECT * FROM list";
db.query(sql, (err, result) => {
// 查询失败
if (err) { return console.log("查询数据失败"+err.message); }
// 查询失败 得到一个数组
console.log(result);
})
插入数据
// 向user表中插入一条数据
const user = {username:'root',password:'123456'}
const userSql = 'INSERT INTO user (username,password) VALUES (?, ?)'
db.query(userSql,[user.username,user.password],(err, result)=>{
// 插入失败
if (err) { return console.log(err.message); }
// 插入成功
if (result.affectedRows === 1){ console.log("插入成功")}
})
简便的方式：
const user = {username:'root',password:'123456'}
const userSql = 'INSERT INTO user set ?'
db.query(userSql,user,(err, result)=>{
// 插入失败
if (err) { return console.log(err.message); }
// 插入成功
if (result.affectedRows === 1){ console.log("插入成功")}
})
更新数据
// 1.要更新的数据对象
const user = {id:1,username:'lisi',password:'789456'}
const upSql = 'UPDATE user SET username=?,password = ? WHERE id=?'
db.query(upSql,[user.username,user.password,user.id],(err, result)=>{
if (err) { return console.log(err.message); }
if (result.affectedRows === 1){ console.log("更新数据成功")}
})
删除数据：
// 删除user表中的一条数据
const sql = 'DELETE FROM user WHERE id= ?'
db .query(sql,[1], (err, result)=>{
if (err){
return console.log(err.message);
}
if (result.affectedRows === 1){ console.log("删除成功")}
})
标记删除
使用DELETE语句，会把真正的把数据从表中删除掉。为了保险起见，推荐使用标记删除的形式，来模拟删除的动作。
所谓的标记删除，就是在表中设置类似于status这样的状态字段，来标记当前这条数据是否被删除。
当用户执行了删除的动作时，我们并没有执行DELETE语句把数据删除掉，而是执行了UPDATE语句，将这条数据对应的status字段标记为删除即可。
前后端身份认证
web开发模式
目前主流的Web开发模式有两种，分别是:
1基于服务端渲染的传统 Web开发模式
2基于前后端分离的新型Web开发模式
1.服务端渲染的Web开发模式
服务端渲染的概念:服务器发送给客户端的HTML页面，是在服务器通过字符串的拼接，动态生成的。因此，客户端不需要使用Ajax这样的技术额外请求页面的数据.
2.服务端渲染的优缺点
优点:
前端耗时少。因为服务器端负责动态生成HTML内容，浏览器只需要直接渲染页面即可。尤其是移动端，更省电。
有利于SEO。因为服务器端响应的是完整的HTML页面内容，所以爬虫更容易爬取获得信息，更有利于SEO。
缺点:
占用服务器端资源。即服务器端完成HTML页面内容的拼接，如果请求较多，会对服务器造成一定的访问压力。
不利于前后端分离，开发效率低。使用服务器端渲染，则无法进行分工合作，尤其对于前端复杂度高的项目，不利于项目高效开发。
3.前后端分离的 Web开发模式
前后端分离的概念:前后端分离的开发模式，依赖于Ajax技术的广泛应用。简而言之，前后端分离的Web开发模式，就是后端只负责提供API接口，前端使用Ajax调用接口的开发模式。
4.前后端分离的优缺点
优点:
开发体验好。前端专注于UI页面的开发，后端专注于api的开发，且前端有更多的选择性。
用户体验好。Ajax技术的广泛应用，极大的提高了用户的体验，可以轻松实现页面的局部刷新。
减轻了服务器端的渲染压力。因为页面最终是在每个用户的浏览器中生成的。
缺点:
不利于 SEO。因为完整的HTML页面需要在客户端动态拼接完成，所以爬虫对无法爬取页面的有效信息。
(解决方案:利用Vue、React等前端框架的SSR (server side render）技术能够很好的解决SEO问题! )
1.什么是身份认证？
身份认证(Authentication)又称“身份验证”、“鉴权”，是指通过一定的手段，完成对用户身份的确认。
2.为什么需要身份认证
身份认证的目的，是为了确认当前所声称为某种身份的用户，确实是所声称的用户。
3.不同开发模式下的身份认证
对于服务端渲染和前后端分离这两种开发模式来说，分别有着不同的身份认证方案:
1.服务端渲染推荐使用Session 认证机制
2.前后端分离推荐使用JWT认证机制
Session认证机制
1.HTTP协议的无状态性
了解HTTP协议的无状态性是进一步学习Session认证机制的必要前提。
HTTP协议的无状态性，指的是客户端的每次HTTP请求都是独立的，连续多个请求之间没有直接的关系，服务器不会主动保留每次HTTP请求的状态。
2.如何突破HTTP无状态的限制
通过Cookie
3.什么是Cookie
Cookie是存储在用户浏览器中的一段不超过4KB的字符串。它由一个名称(Name)、一个值(Value)和其它几个用于控制Cookie有效期、安全性、使用范围的可选属性组成。
不同域名下的Cookie 各自独立，每当客户端发起请求时，会自动把当前域名下所有未过期的Cookie一同发送到服务器。
Cookie的几大特性：
1.自动发送
2.域名独立
3.过期限制
4.4KB限制
4.Cookie在身份认证中的作用
客户端第一次请求服务器的时候，服务器通过响应头的形式，向客户端发送一个身份认证的Cookie，客户端会自动将Cookie保存在浏览器中。
随后，当客户端浏览器每次请求服务器的时候，浏览器会自动将身份认证相关的Cookie，通过请求头的形式发送给服务器，服务器即可验明客户端的身份。
5.Cookie 不具有安全性
由于Cookie是存储在浏览器中的，而且浏览器也提供了读写Cookie的API，因此Cookie很容易被伪造，不具有安全性。因此不建议服务器将重要的隐私数据，通过Cookie的形式发送给浏览器。
注意:千万不要使用Cookie存储重要且隐私的数据!比如用户的身份信息、密码等。
6.提高身份认证的安全性
为了防止客户伪造会员卡，收银员在拿到客户出示的会员卡之后，可以在收银机上进行刷卡认证。只有收银机确认存在的会员卡，才能被正常使用。
这种“会员卡＋刷卡认证”的设计理念，就是Session认证机制的精髓。
在express中使用session认证
1.安装express-session中间件
npm i express-session
2.配置session中间件
const session = require('express-session')
app.use(
session({
secret: 'xinghuo',
resave: false,
saveUninitialized: true,
})
)
3.向session中存数据
当express-session中间件配置成功后，即可通过 req.session来访问和使用session对象，从而存储用户的关键信息:
app.post('/api/login',(req, res) => {
if (req.body.username != 'admin' || req.body.password != '123456'){
return res.send(
{
statis:1,
msg: '登录失败'
}
)
}
req.session.user = req.body //存储用户信息
req.session.idlogin = true //存储登录信息
})
4.在session中取数据
直接在req.session对象上获取之前存储的数据
app.post('/', function (req, res) {
if(!req.session.islogin){
return res.send({
status:1,
msg: 'fail'
})
}
res.send({
status:0,
msg: 'success',
username : req.session.user.username
})
})
5.清空session
调用req.session.destroy()函数，即可清空服务器保存的session 信息
6.了解 Session 认证的局限性
Session认证机制需要配合Cookie才能实现。由于Cookie 默认不支持跨域访问，所以当涉及到前端跨域请求后端接口的时候，需要做很多额外的配置，才能实现跨域Session认证。
注意:
当前端请求后端接口不存在跨域问题的时候，推荐使用Session身份认证机制。
当前端需要跨域请求后端接口的时候，不推荐使用Session身份认证机制，推荐使用JWT认证机制。
JWT认证机制
1.JWT的组成部分
JWT通常由三部分组成，分别是 Header(头部)、Payload(有效荷载)、Signature(签名)。
三者之间使用英文的“.”分隔，格式如下:
Header.Payload.Signature
2.JWT的三个部分各自代表的含义
JWT的三个组成部分，从前到后分别是 Header、Payload、Signature。
其中:
Payload部分才是真正的用户信息，它是用户信息经过加密之后生成的字符串。
Header和Signature是安全性相关的部分，只是为了保证Token的安全性。
3.JWT的使用方式
客户端收到服务器返回的WT之后，通常会将它储存在localStorage或sessionStorage 中。
此后，客户端每次与服务器通信，都要带上这个WT的字符串，从而进行身份认证。推荐的做法是把JWT放在HTTP请求头的Authorization字段中，格式如下:
Authorization: Bearer <token>
4.expresss中使用JWT
1.安装相关的包
npm install jsonwebtoken express-jwt
jsonwebtoken用于生成JWT字符串
express-jwt用于将JWT字符串解析还原成JSON 对象
2.导入JWT相关的包
使用require()函数，分别导入JWT相关的两个包:
// 安装并导入JWT相关的包 分别是 jsionwebtoken 和 express-jwt
const jwt = require('express-jwt')
const jsont = require('jsonwebtoken')
3.定义secret密钥
为了保证JWT字符串的安全性，防止JWT字符串在网络传输过程中被别人破解，我们需要专门定义一个用于加密和解密的secret密钥:
当生成JWT字符串的时候，需要使用secret密钥对用户的信息进行加密，最终得到加密好的WT字符串当把JWT字符串解析还原成JSON对象的时候，需要使用secret密钥进行解密
4.在登录成功后生成JWT字符串
调用jsonwebtoken包提供sign()方法，将用户的信息加密成JWT字符串，响应给客户端
// 定义一个secret密钥，建议将密钥命名为 secretKey
const secretKey = 'itbnsadklsdbabsdalhnlk ^_^'
//登录接口
app.post('/api/login', function (req, res) {
//将req.body 请求体中的数据，转存为userinfo常量
const userinfo = req.body
// 登录失败
if(userinfo.username != 'admin' || userinfo.password != '123456')
return res.send({
status:400,
message:'登录失败'
})
// 登录成功
// 在登录成功之后调用 jwt.sign()方法生成jwt字符串。并通过token属性发送给客户端
const token = jsont.sign({username: userinfo.username},secretKey,{expiresIn: '30s'})
res.send({
status:200,
message: '登录成功',
token: token
})
res.send('POST request to the homepage')
})
5.将JWT字符串还原为JSON对象
客户端每次东访问那些有权限接口的时候，都需要主动通过请求头中的Authorization字段，将Token字符串发送到服务器进行身份认证。
此时，服务器可以通过express-jwt这个中间件，自动将客户端发送过来的Token解析还原成JSON对象:
// 安装并导入JWT相关的包 分别是 jsionwebtoken 和 express-jwt
const expressjwt = require('express-jwt')
const jsont = require('jsonwebtoken')
// 定义一个secret密钥，建议将密钥命名为 secretKey
const secretKey = 'itbnsadklsdbabsdalhnlk ^_^'
// 初测将JWT字符串解析还原成JSON对象的中间件
app.use(expressjwt({secret: secretKey,algorithms:['HS256']}).unless({path:[/^\/api\//]}))
6.捕获解析JWT失败后产生的错误
当使用express-jwt解析Token字符串时，如果客户端发送过来的Token字符串过期或不合法，会产生一个解析失败的错误，影响项目的正常运行。我们可以通过 Express的错误中间件，捕获这个错误并进行相关的处理，示例代码如下:
app.use((err, req, res,next) => {
if(err.name === 'UnauthorizedError'){
return res.send({
status:401,
msg:'无效的token'
})
}
res.send({
status:500,
message:'未知的错误'
})
})