node.js

01_Node.js入门

什么是 Node.js

1. Node.js 是一个独立的 JavaScript 运行环境，能独立执行 JS 代码，因为这个特点，它可以用来编写服务器后端的应用程序
2. Node.js 作用除了编写后端应用程序，也可以对前端代码进行压缩，转译，整合等等，提高前端开发和运行效率
3. Node.js 基于Chrome V8 引擎封装，独立执行 JS 代码，但是语法和浏览器环境的 V8 有所不同，没有 document 和 window 但是都支持 ECMAScript 标准的代码语法
4. Node.js 执行目标 JS 文件，需要使用 node xxx.js 命令来执行
   注：tab键 补全路径 esc键 快速删除已输入命令 cls命令 清空终端

fs模块-读写文件

1. 模块：类似插件，封装了方法和属性供我们使用
2. fs 模块：封装了与本机文件系统进行交互的，方法和属性
3. 语法：

• 加载 fs 模块，得到 fs 对象

1const fs = require('fs')
2

• 写入文件内容语法：

1fs.writeFile('文件路径', '写入内容', err => {
2  // 写入后的回调函数
3})
4

• 读取文件内容的语法：

1fs.readFile('文件路径', (err, data) => {
2  // 读取后的回调函数
3  // data 是文件内容的 Buffer 数据流
4  // data 是 buffer 16 进制数据流对象 .toString() 转换成字符串
5})
6

path模块-路径处理

建议：在Node.js代码中，使用绝对路径
补充：__dirname （动态获取当前文件所在文件夹的绝对路径）
注意：path.join()会使用特定于平台的分隔符，作为定界符，将所有给定的路径片段连接在一起

案例-压缩前端html

1. 读取源 html 文件内容
2. 正则替换字符串
3. 写入到新的 html 文件中，并运行查看是否能正常打开网页

1const fs = require('fs')
2const path = require('path')
3// 1.1 读取 public/index.html 内容
4fs.readFile(path.join(__dirname, 'public', 'index.html'), (err, data) => {
5  const htmlStr = data.toString()
6  // 1.2 使用正则替换内容字符串里的，回车符\r 换行符\n
7  const resultStr = htmlStr.replace(/[\r\n]/g, '')
8  // 1.3 确认后，写入到 dist/index.html 内
9  fs.writeFile(path.join(__dirname, 'dist', 'index.html'), resultStr, err => {
10    if (err) console.log(err)
11    else console.log('压缩成功')
12  })
13})
14

URL中的端口号

1. URL 是统一资源定位符，简称网址，用于访问网络上的资源
2. 端口号的作用：标记服务器里对应的服务程序，值为（0-65535 之间的任意整数）
3. 注意：http 协议，默认访问的是 80 端口
4. Web服务：一个程序，用于提供网上信息浏览功能
5. 注意：0-1023 和一些特定的端口号被占用，我们自己编写服务程序请避开使用

http模块-创建Web服务

1. 引入 http 模块，创建 Web 服务对象
2. 监听 request 请求事件，设置响应头和响应体
3. 启动 Web 服务监听对应端口号
4. 浏览器请求 http://localhost:3000 测试
   注意：本机的域名叫做 localhost

Node.js模块化

模块化简介

1. 在 Node.js 中每个文件都被当做是一个独立的模块，模块内定义的变量和函数都是独立作用域的
2. 项目是由多个模块组成的，每个模块之间都是独立的
3. 模块内的属性和函数都是私有的，如果对外使用，需要使用标准语法导出和导入才可以，而这个标准叫 CommonJS 标准
4. 导出语法：

1module.exports = {
2  对外属性名: 模块内私有变量
3}
4

1. 导入语法：

1const 变量名 = require('模块名或路径')
2// Node.js 环境内置模块直接写模块名（例如：fs，path，http）
3// 自定义模块：写模块文件路径（例如：./utils.js)
4

变量名的值接收的就是目标模块导出的对象

ECMAScript标准-默认导出和导入

1. 导出语法：

1export default {
2  对外属性名: 模块内私有变量
3}
4

1. 导入语法：

1import 变量名 from '模块名或路径'
2

变量名的值接收的就是目标模块导出的对象

1. 注意：Node.js 默认只支持 CommonJS 标准语法，如果想要在当前项目环境下使用 ECMAScript 标准语法，请新建 package.json 文件设置 type: ‘module’ 来进行设置

1{ “type”: "module" }
2

ECMAScript标准-命名导出和导入

1. 命名导出语法：

1export 修饰定义语句
2

1. 命名导入语法：

1import { 同名变量 } from '模块名或路径'
2

注意：同名变量指的是模块内导出的变量名

1. 与默认导出如何选择：

• 按需加载，使用命名导出和导入
• 全部加载，使用默认导出和导入

包的概念

1. 包：将模块，代码，其他资料整合成一个文件夹，这个文件夹就叫包
2. 包分类：

• 项目包：主要用于编写项目和业务逻辑
• 软件包：封装工具和方法进行使用

1. 包要求：根目录中，必须有 package.json 文件（记录包的清单信息）
2. 包使用：在引入一个包文件夹到代码中，默认引入的是包文件节下的 index.js 模块文件里导出的对象，如果没有 index.js 文件，则会引入 package.json 里 main 属性指定的文件模块导出的对象

npm软件包管理器

npm 使用步骤：

1. 初始化清单文件： npm init -y （得到 package.json 文件，有则跳过此命令）

注意 -y 就是所有选项用默认值，所在文件夹不要有中文/特殊符号，建议英文和数字组成，因为 npm 议用英文和数字或者下划线中划线

2. 下载软件包：npm i 软件包名称
3. 使用软件包

npm安装所有依赖

拿到了一个别人编写的项目，但是没有 node_modules，如何得到需要的所有依赖软件包？直接在项目目录下，运行终端命令：npm i 即可安装 package.json 里记录的所有包和对应版本到本项目中的 node_modules

npm全局软件包-nodemon

1. 软件包区别：

• 本地软件包：当前项目内使用，封装属性和方法，存在于 node_modules
• 全局软件包：本机所有项目使用，封装命令和工具，存在于系统设置的位置

1. nodemon 作用：替代 node 命令，检测代码更改，自动重启程序
2. 使用：
3. 安装：npm i nodemon -g （-g 代表安装到全局环境中）
4. 运行：nodemon 待执行的目标 js 文件

Node.js概念和常用命令总结

1. 执行js文件 node xxx
2. 初始化 package.json npm init -y
3. 下载本地软件包 npm i 软件包名
4. 下载全局软件包 npm i 软件包名 -g
5. 删除软件包 npm uni 软件包名

Express

初识Express

用来创造web服务器的
本质：npm的第三方包，提供了快速创造服务器的方法
可以快速创建web服务器和api接口服务器

基本使用

安装：npm i express@4.17.1
创建基本的web服务器

1// 1. 导入 express
2const express = require('express')
3// 2. 创建 web 服务器
4const app = express()
5
6// 4. 监听客户端的 GET 和 POST 请求，并向客户端响应具体的内容 req是请求对象 res是响应对象
7app.get('/user', (req, res) => {
8  // 调用 express 提供的 res.send() 方法（把处理好的内容发送给客户端），向客户端响应一个 JSON 对象
9  res.send({ name: 'zs', age: 20, gender: '男' })
10})
11app.post('/user', (req, res) => {
12  // 调用 express 提供的 res.send() 方法，向客户端响应一个 文本字符串
13  res.send('请求成功')
14})
15app.get('/', (req, res) => {
16  // 通过 req.query 可以获取到客户端发送过来的 查询参数
17  // 注意：默认情况下，req.query 是一个空对象
18  console.log(req.query)
19  res.send(req.query)
20})
21// 注意：这里的 :id 是一个动态的参数
22app.get('/user/:ids/:username', (req, res) => {
23  // req.params 是动态匹配到的 URL 参数，默认也是一个空对象
24  console.log(req.params)
25  res.send(req.params)
26})
27
28// 3. 启动 web 服务器
29app.listen(80, () => {
30  console.log('express server running at http://127.0.0.1')
31})
32
33

托管静态资源

1const express = require('express')
2const app = express()
3
4// 在这里，调用 express.static() 方法，快速的对外提供静态资源
5app.use('/files', express.static('./files'))
6app.use(express.static('./clock'))
7
8app.listen(80, () => {
9  console.log('express server running at http://127.0.0.1')
10})
11
12

Express路由

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

1app.METHOD(PATH,HANDLER)
2

路由的匹配过程

路由匹配的注意点：

• 按照定义的先后顺序进行匹配
• 请求类型和请求的URL同时匹配成功,才会调用对应的处理函数

路由的使用

1. 最简单的路由

1const express = require('express')
2const app = express()
3
4// 挂载路由
5app.get('/', (req, res) => {
6  res.send('hello world.')
7})
8app.post('/', (req, res) => {
9  res.send('Post Request.')
10})
11
12app.listen(80, () => {
13  console.log('http://127.0.0.1')
14})
15
16

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

• 创建路由模块对应的.js 文件
• 调用express.Router() 函数创建路由对象
• 向路由对象上挂载具体的路由
• 使用module.exports 向外共享路由对象
• 使用app.use() 函数注册路由模块

1. 注册路由模块

1// 1. 导入路由模块
2const router = require('./03.router')
3// 2. 注册路由模块
4app.use('/api', router)
5
6// 注意： app.use() 函数的作用，就是来注册全局中间件
7

1. 为路由模块添加前缀
   直接在第一个参数加前缀

Express中间件

中间件的概念

当一个请求到达Express 的服务器之后，可以连续调用多个中间件，从而对这次请求进行预处理
Express 的中间件，本质上就是一个function 处理函数
注：中间件函数的形参列表中，必须包含next 参数。而路由处理函数中只包含req 和res

1app.use((req, res, next) => {
2  next()
3})
4

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

Express 中间件的初体验

1. 定义中间件函数

1const express = require('express')
2const app = express()
3
4// 定义一个最简单的中间件函数
5const mw = function (req, res, next) {
6  console.log('这是最简单的中间件函数')
7  // 把流转关系，转交给下一个中间件或路由
8  next()
9}
10
11app.listen(80, () => {
12  console.log('http://127.0.0.1')
13})
14
15

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

1const express = require('express')
2const app = express()
3
4// // 定义一个最简单的中间件函数
5// const mw = function (req, res, next) {
6//   console.log('这是最简单的中间件函数')
7//   // 把流转关系，转交给下一个中间件或路由
8//   next()
9// }
10
11// // 将 mw 注册为全局生效的中间件
12// app.use(mw)
13
14// 这是定义全局中间件的简化形式
15app.use((req, res, next) => {
16  console.log('这是最简单的中间件函数')
17  next()
18})
19
20app.get('/', (req, res) => {
21  console.log('调用了 / 这个路由')
22  res.send('Home page.')
23})
24app.get('/user', (req, res) => {
25  console.log('调用了 /user 这个路由')
26  res.send('User page.')
27})
28
29app.listen(80, () => {
30  console.log('http://127.0.0.1')
31})
32
33

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

1const express = require('express')
2const app = express()
3
4// 这是定义全局中间件的简化形式
5app.use((req, res, next) => {
6  // 获取到请求到达服务器的时间
7  const time = Date.now()
8  // 为 req 对象，挂载自定义属性，从而把时间共享给后面的所有路由
9  req.startTime = time
10  next()
11})
12
13app.get('/', (req, res) => {
14  res.send('Home page.' + req.startTime)
15})
16app.get('/user', (req, res) => {
17  res.send('User page.' + req.startTime)
18})
19
20app.listen(80, () => {
21  console.log('http://127.0.0.1')
22})
23
24

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

1const express = require('express')
2const app = express()
3
4// 定义第一个全局中间件
5app.use((req, res, next) => {
6  console.log('调用了第1个全局中间件')
7  next()
8})
9// 定义第二个全局中间件
10app.use((req, res, next) => {
11  console.log('调用了第2个全局中间件')
12  next()
13})
14
15// 定义一个路由
16app.get('/user', (req, res) => {
17  res.send('User page.')
18})
19
20app.listen(80, () => {
21  console.log('http://127.0.0.1')
22})
23
24

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

1// 导入 express 模块
2const express = require('express')
3// 创建 express 的服务器实例
4const app = express()
5
6// 1. 定义中间件函数
7const mw1 = (req, res, next) => {
8  console.log('调用了局部生效的中间件')
9  next()
10}
11
12// 2. 创建路由
13app.get('/', mw1, (req, res) => {
14  res.send('Home page.')
15})
16app.get('/user', (req, res) => {
17  res.send('User page.')
18})
19
20// 调用 app.listen 方法，指定端口号并启动web服务器
21app.listen(80, function () {
22  console.log('Express server running at http://127.0.0.1')
23})
24
25

1. 定义多个局部中间件

1// 导入 express 模块
2const express = require('express')
3// 创建 express 的服务器实例
4const app = express()
5
6// 1. 定义中间件函数
7const mw1 = (req, res, next) => {
8  console.log('调用了第一个局部生效的中间件')
9  next()
10}
11
12const mw2 = (req, res, next) => {
13  console.log('调用了第二个局部生效的中间件')
14  next()
15}
16
17// 2. 创建路由
18app.get('/', [mw1, mw2], (req, res) => {
19  res.send('Home page.')
20})
21app.get('/user', (req, res) => {
22  res.send('User page.')
23})
24
25// 调用 app.listen 方法，指定端口号并启动web服务器
26app.listen(80, function () {
27  console.log('Express server running at http://127.0.0.1')
28})
29
30

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

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

中间件的分类

• 应用级别的中间件
• 路由级别的中间件
• 错误级别的中间件
• Express 内置的中间件
• 第三方的中间件

1. 应用级别的中间件
   通过app.use() 或 app.get() 或 app.post() ，绑定到 app 实例上的中间件，叫做应用级别的中间件
2. 路由级别的中间件
   绑定到express.Router() 实例上的中间件，叫做路由级别的中间件。它的用法和应用级别中间件没有任何区别。只不
   过，应用级别中间件是绑定到app 实例上，路由级别中间件绑定到router 实例上
3. 错误级别的中间件
   错误级别中间件的作用：专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题。
   格式：错误级别中间件的function 处理函数中，必须有4 个形参，形参顺序从前到后，分别是(err, req, res, next)
   注意：错误级别的中间件，必须注册在所有路由之后！
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+ 版本中可用）
  内置中间件的使用

1// 导入 express 模块
2const express = require('express')
3// 创建 express 的服务器实例
4const app = express()
5
6// 注意：除了错误级别的中间件，其他的中间件，必须在路由之前进行配置
7// 通过 express.json() 这个中间件，解析表单中的 JSON 格式的数据
8app.use(express.json())
9// 通过 express.urlencoded() 这个中间件，来解析 表单中的 url-encoded 格式的数据
10app.use(express.urlencoded({ extended: false }))
11
12app.post('/user', (req, res) => {
13  // 在服务器，可以使用 req.body 这个属性，来接收客户端发送过来的请求体数据
14  // 默认情况下，如果不配置解析表单数据的中间件，则 req.body 默认等于 undefined
15  console.log(req.body)
16  res.send('ok')
17})
18
19app.post('/book', (req, res) => {
20  // 在服务器端，可以通过 req,body 来获取 JSON 格式的表单数据和 url-encoded 格式的数据
21  console.log(req.body)
22  res.send('ok')
23})
24
25// 调用 app.listen 方法，指定端口号并启动web服务器
26app.listen(80, function () {
27  console.log('Express server running at http://127.0.0.1')
28})
29
30

1. 第三方的中间件
   非Express 官方内置的，而是由第三方开发出来的中间件，叫做第三方中间件。在项目中，大家可以按需下载并配置
   第三方中间件，从而提高项目的开发效率。
   例如：在express@4.16.0 之前的版本中，经常使用body-parser 这个第三方中间件，来解析请求体数据。使用步
   骤如下：

• 运行npm install body-parser安装中间件
• 使用require导入中间件
• 调用app.use() 注册并使用中间件
  注意：Express 内置的 express.urlencoded 中间件，就是基于body-parser 这个第三方中间件进一步封装出来的
  演示body-parser中间件的使用

1// 导入 express 模块
2const express = require('express')
3// 创建 express 的服务器实例
4const app = express()
5
6// 1. 导入解析表单数据的中间件 body-parser
7const parser = require('body-parser')
8// 2. 使用 app.use() 注册中间件
9app.use(parser.urlencoded({ extended: false }))
10// app.use(express.urlencoded({ extended: false }))
11
12app.post('/user', (req, res) => {
13  // 如果没有配置任何解析表单数据的中间件，则 req.body 默认等于 undefined
14  console.log(req.body)
15  res.send('ok')
16})
17
18// 调用 app.listen 方法，指定端口号并启动web服务器
19app.listen(80, function () {
20  console.log('Express server running at http://127.0.0.1')
21})
22
23

自定义中间件

1. 需求描述与实现步骤
   自己手动模拟一个类似于express.urlencoded这样的中间件，来解析POST 提交到服务器的表单数据。
   实现步骤：

• 定义中间件
• 监听req 的data 事件
• 监听req 的end 事件
• 使用querystring模块解析请求体数据
• 将解析出来的数据对象挂载为req.body
• 将自定义中间件封装为模块

1. 定义中间件
2. 监听 req 的 data 事件
   在中间件中，需要监听req 对象的data 事件，来获取客户端发送到服务器的数据。
   如果数据量比较大，无法一次性发送完毕，则客户端会把数据切割后，分批发送到服务器。所以data 事件可能会触
   发多次，每一次触发data 事件时，获取到数据只是完整数据的一部分，需要手动对接收到的数据进行拼接
3. 监听 req 的 end 事件
   当请求体数据接收完毕之后，会自动触发req 的end 事件。
   因此，我们可以在req 的end 事件中，拿到并处理完整的请求体数据。
4. 使用 querystring 模块解析请求体数据
   Node.js 内置了一个querystring 模块，专门用来处理查询字符串。通过这个模块提供的parse() 函数，可以轻松把
   查询字符串，解析成对象的格式。
5. 将解析出来的数据对象挂载为req.body
   上游的中间件和下游的中间件及路由之间，共享同一份req 和res。因此，我们可以将解析出来的数据，挂载为req
   的自定义属性，命名为req.body，供下游使用。
6. 将自定义中间件封装为模块
   为了优化代码的结构，我们可以把自定义的中间件函数，封装为独立的模块

1// 导入 express 模块
2const express = require('express')
3// 创建 express 的服务器实例
4const app = express()
5// 导入 Node.js 内置的 querystring 模块
6const qs = require('querystring')
7
8// 这是解析表单数据的中间件
9app.use((req, res, next) => {
10  // 定义中间件具体的业务逻辑
11  // 1. 定义一个 str 字符串，专门用来存储客户端发送过来的请求体数据
12  let str = ''
13  // 2. 监听 req 的 data 事件
14  req.on('data', (chunk) => {
15    str += chunk
16  })
17  // 3. 监听 req 的 end 事件
18  req.on('end', () => {
19    // 在 str 中存放的是完整的请求体数据
20    // console.log(str)
21    // TODO: 把字符串格式的请求体数据，解析成对象格式
22    const body = qs.parse(str)
23    req.body = body
24    next()
25  })
26})
27
28app.post('/user', (req, res) => {
29  res.send(req.body)
30})
31
32// 调用 app.listen 方法，指定端口号并启动web服务器
33app.listen(80, function () {
34  console.log('Express server running at http://127.0.0.1')
35})
36
37

使用Express写接口

• 创建基本的服务器
• 创建API 路由模块
• 编写GET 接口
• 编写POST 接口
  注意：如果要获取URL-encoded 格式的请求体数据，必须配置中间件app.use(express.urlencoded({ extended: false }))

1// 导入 express
2const express = require('express')
3// 创建服务器实例
4const app = express()
5
6// 配置解析表单数据的中间件
7app.use(express.urlencoded({ extended: false }))
8
9// 必须在配置 cors 中间件之前，配置 JSONP 的接口
10app.get('/api/jsonp', (req, res) => {
11  // TODO: 定义 JSONP 接口具体的实现过程
12  // 1. 得到函数的名称
13  const funcName = req.query.callback
14  // 2. 定义要发送到客户端的数据对象
15  const data = { name: 'zs', age: 22 }
16  // 3. 拼接出一个函数的调用
17  const scriptStr = [`${funcName}(${JSON.stringify(data)})`](https://xplanc.org/primers/document/zh/03.HTML/EX.HTML%20%E5%85%83%E7%B4%A0/EX.data.md)
18  // 4. 把拼接的字符串，响应给客户端
19  res.send(scriptStr)
20})
21
22// 一定要在路由之前，配置 cors 这个中间件，从而解决接口跨域的问题
23const cors = require('cors')
24app.use(cors())
25
26// 导入路由模块
27const router = require('./16.apiRouter')
28// 把路由模块，注册到 app 上
29app.use('/api', router)
30
31// 启动服务器
32app.listen(80, () => {
33  console.log('express server running at http://127.0.0.1')
34})
35
36

16.apiRouter

1const express = require('express')
2const router = express.Router()
3
4// 在这里挂载对应的路由
5router.get('/get', (req, res) => {
6  // 通过 req.query 获取客户端通过查询字符串，发送到服务器的数据
7  const query = req.query
8  // 调用 res.send() 方法，向客户端响应处理的结果
9  res.send({
10    status: 0, // 0 表示处理成功，1 表示处理失败
11    msg: 'GET 请求成功！', // 状态的描述
12    data: query, // 需要响应给客户端的数据
13  })
14})
15
16// 定义 POST 接口
17router.post('/post', (req, res) => {
18  // 通过 req.body 获取请求体中包含的 url-encoded 格式的数据
19  const body = req.body
20  // 调用 res.send() 方法，向客户端响应结果
21  res.send({
22    status: 0,
23    msg: 'POST 请求成功！',
24    data: body,
25  })
26})
27
28// 定义 DELETE 接口
29router.delete('/delete', (req, res) => {
30  res.send({
31    status: 0,
32    msg: 'DELETE请求成功',
33  })
34})
35
36module.exports = router
37
38

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

• CORS（主流的解决方案，推荐使用）
• JSONP（有缺陷的解决方案：只支持GET 请求）
  CORS （Cross-Origin Resource Sharing，跨域资源共享）由一系列HTTP 响应头组成，这些HTTP 响应头决定
  浏览器是否阻止前端JS 代码跨域获取资源。
  浏览器的同源安全策略默认会阻止网页“跨域”获取资源。但如果接口服务器配置了CORS 相关的HTTP 响应头，
  就可以解除浏览器端的跨域访问限制
  CORS 的注意事项
• CORS 主要在服务器端进行配置。客户端浏览器无须做任何额外的配置，即可请求开启了CORS 的接口。
• CORS 在浏览器中有兼容性。只有支持XMLHttpRequest Level2 的浏览器，才能正常访问开启了CORS的服
  务端接口（例如：IE10+、Chrome4+、FireFox3.5+）

1. JSONP 接口
2. 特点：

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

1. 创建 JSONP 接口的注意事项
   如果项目中已经配置了CORS跨域资源共享，为了防止冲突，必须在配置CORS 中间件之前声明JSONP的接口。否则
   JSONP 接口会被处理成开启了CORS 的接口。
2. 实现 JSONP 接口的步骤
   -获取客户端发送过来的回调函数的名字
   -得到要通过JSONP 形式发送给客户端的数据
   -根据前两步得到的数据，拼接出一个函数调用的字符串
   -把上一步拼接得到的字符串，响应给客户端的

数据库与身份认证

数据库基础概念

1. 数据库：组织、存储、管理数据的仓库，可对数据做增删改查。
2. 数据库分类
   • 关系型 (SQL)：MySQL、Oracle、SQL Server；数据以表结构存储。
   • 非关系型 (NoSQL)：Mongodb。
3. 关系型数据库结构（类比 Excel）
   表格
   | MySQL | Excel |
   | — | — |
   | database 数据库 | 工作簿 |
   | table 数据表 | 工作表 |
   | row 数据行 | 一行数据 |
   | field 字段 | 列 |

开发规范：一个项目对应一个独立数据库；不同业务存不同数据表。

MySQL 安装

需要安装两个软件：

1. MySQL Server：提供数据存储服务
2. MySQL Workbench：可视化管理工具

SQL 基础语法（重点 CRUD）

SQL 大小写不敏感；字符串值必须加引号；UPDATE / DELETE 务必写 WHERE 条件，否则会操作全表！

1. SELECT 查询

1-- 查询全部列
2SELECT * FROM users;
3-- 查询指定列
4SELECT username,password FROM users;
5

1. INSERT INTO 插入

1INSERT INTO users(username,password) VALUES('tom','123456');
2

1. UPDATE 更新

1UPDATE users SET password='888888' WHERE id=7;
2-- 更新多列
3UPDATE users SET password='admin123',status=1 WHERE id=2;
4

1. DELETE 删除

1DELETE FROM users WHERE id=4;
2

1. WHERE 条件：用于SELECT/UPDATE/DELETE做条件过滤

• AND同时满足；OR满足任意一个

1SELECT * FROM users WHERE status=0 AND id<3;
2SELECT * FROM users WHERE status=1 OR username='zs';
3

1. ORDER BY 排序

• ASC升序（默认），DESC降序

1SELECT * FROM users ORDER BY id DESC;
2

1. COUNT (*) 统计行数，AS设置别名

1SELECT COUNT(*) AS total FROM users WHERE status=0;
2

Node.js 中操作 MySQL

1. 安装模块：npm install mysql
2. 基础配置连接池

1const mysql = require('mysql')
2const db = mysql.createPool({
3  host:'127.0.0.1',
4  user:'root',
5  password:'xxx',
6  database:'my_db_01'
7})
8

1. 核心：使用**? 占位符**防止 SQL 注入

1// 查询
2db.query('SELECT * FROM users', (err, res)=>{})
3// 插入
4const sql = 'INSERT INTO users SET ?'
5db.query(sql, {username:'xxx',password:'123'}, callback)
6// 更新
7db.query('UPDATE users SET ? WHERE id=?',[userObj,7], callback)
8// 删除
9db.query('DELETE FROM users WHERE id=?',7, callback)
10