1. 简介

基于 Node.js 平台，快速、开放、极简的 Web 开发框架 Express官网网站

简单讲，Express 的作用和 Node.js 内置的 http 模块类似，是专门用来创建 Web 服务器的，Express 是基于内置的 http 模块进一步封装出来的，能够极大的提高开发效率

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

1.1 作用

对于前端来说，最常见的两种服务器，分别是Web网站服务器和API接口服务器

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

2、 API 接口服务器：专门对外提供 API 接口的服务器

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

2. 项目创建和安装依赖

# 1.  初始化项目
npm init -y

# 2.  安装 Express 并将其保存到依赖列表中
npm install express --save

# 3. 直接使用
     参考案例：我的第一个hello world

3. 案例解析

// 1. 引入express
var express = require('express')

// 2. 创建服务器应用程序，也就是原来的 http.createServer
var app = express()

// 3. 请求和响应 
//    当服务器收到 get 请求 / 的时候，执行回调处理函数
app.get('/', function(req, res) {
    // 在 Express 中可以直接 req.query 来获取查询字符串参数
    console.log(req.query)
    
    //  通过 res.send() 方法，可以把处理好的内容，发送给客户端
    res.send('Hello World!')
})


// 登陆页面
app.get('/login', function(req, res) {
    res.send('Login page')
})

// 4. 统一处理网站静态资源，你就可以直接通过 /public/xx 的方式访问 public 目录中的所有资源了
//    当以 /public/ 开头的时候，去 ./public/ 目录中找找对应的资源
app.use('/public/', express.static('./public/')) // 推荐使用这种方式

// 当省略第一个参数的时候，则可以直接访问./public里面的资源， 省略 /public 的来访问
// 比如之前访问 locallhost:/public/login.html ，现在就可以这样访问：locallhost:/login.html
// 这种方式的好处就是可以省略 /public/
app.use(express.static('./public/'))


// 5. 监听并设置端口号 
app.listen(3000, function() {
    console.log(`Example app listening at http://localhost:3000`)
})

注意：Express 对于没有设定的请求路径，默认会返回 Cat not get xxx，如果你想要定制自己的404页面，只需要在自己的路由之后增加如下设置即可

app.use(function (req, res) {
  // 所有未处理的请求路径都会跑到这里
  // 404 页面
})

3.1 路由

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

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

app.Method(path,handler)

get请求

// 当以get方法请求  /  的时候，执行对应的处理函数
app.get('/',function(req,res){
    res.send('hello world');
})

post请求

//  当以post方法请求  /  的时候，执行对应的处理函数
app.post('/',function(req,res){
    res.send('hello world');
})

3.1.1 路由的匹配过程

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

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

3.1.2 模块化路由处理 `express.Router()`

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

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

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

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

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

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

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

创建一个路由模块 router.js

var express = require('express')

// 1. 创建一个路由容器对象，Express 提供的，专门用来包装路由的
var router = express.Router()

// 2. 把路由都挂载到 router 路由容器中
router.get('/', function (req, res, next) {
  res.send('加载成功')
})

// 3.  导出路由
module.exports = router

注册路由

var express = require('express')

// 引入路由模块
var router = require('./routers')

// 0.  创建web服务器
var app = express()

// 将路由挂载到app中
app.use(router)

app.listen(3000, function () {
	console.log('Server is runing at http://localhost:3000/')
})

注册一个二级路由

为路由模块添加前缀

// 设置二级路由--用户个人信息配置模块 里面的页面访问路径是 /user/XXX
var profile = require('./profile');
// 注册路由模块，并添加访问理由前缀
router.use('/user', profile)

3.2 统一处理静态资源

app.use 不仅仅是用来处理静态资源的，还可以做很多工作(body-parser的配置)

访问目录 public下面的index.html 资源

// 方式一：  http://localhost:3000/public/index.html
app.use('/public',express.static('public'));
// 推荐使用
app.use('/public',express.static(path.join(__dirname+'public')));  

// 方式二：  http://localhost:3000/index.html 可以不写 public
app.use(express.static('public'));

// 方式三：  http://localhost:3000/static/index.html
app.use('/static',express.static('public'));

3.3 express结合 express-art-template案例

var path = require('path')
var express = require('express')

// 1.  创建web服务器
var app = express()

// 2.  指定.html使用的解析引擎(官方给出的是art)
app.engine('html', require('express-art-template'))

// 3.  express-art-template 默认的渲染的目录是 views 下面的，如果需要修,则设置如下：
app.set('views', path.join(__dirname, 'www')); // www 目录是放置模板html的位置

// 请求与响应
app.get('/', function (req, res) {
    // 使用模板传值
    res.render('index.html', {
        name: '李思雨',
        age: 18,
        province: '北京市',
        hobbies: [
            '写代码',
            '唱歌',
            '打游戏'
        ],
        title: '个人信息'
    });
});

app.listen(3000, function () {
    console.log('server is running ......')
})

修好默认的模板路径 views

// 3.  express-art-template 默认的渲染的目录是 views 下面的，如果需要修,则设置如下：
app.set('views', path.join(__dirname, 'www')); // www 目录是放置模板html的位置

3.4 获取 `url` 中携带的参数

3.4.1 获取 get 请求传递的参数

获取 URL 中携带的查询参数

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

客户端使用 ?name=zs&age=19这种查询字符串的形式

app.get('/user', (req, res) => {
  // 返回： { name: 'zs', age: '19' }
  console.log(req.query);

  res.send('获取 http://localhost:3000/user?name=zs&age=19 请求的参数')
})

获取 URL 中的动态参数

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

app.get('/user/:ids/:name', (req, res) => {
  // 返回： { ids: '90', name: 'Tom' }
  console.log(req.params);

  res.send('获取 http://localhost:3000/user/90/Tom 请求的参数')
})

3.4.2 获取 post 请求传递的参数

使用 body-parser 中间件，req.body方式获取

// 0.  引入 body-parser 
const bodyParser = require('body-parser')

// 1.  创建web服务器
var app = express()

// 2.  配置模板引擎和 body-parser 一定要在 app.use(router) 挂载路由之前
app.use(bodyParser.urlencoded({
	extended: false
}))
app.use(bodyParser.json())

4. Express之中间件

4.1 概述

中间件的本质就是一个请求处理方法，我们把用户从请求到响应的整个过程分发到多个中间件去处理，这样做的目的就是提高代码的灵活性，动态可扩展

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

中间件请求处理顺序：

当请求进来，会从第一个中间件开始进行匹配
如果匹配，则进来
如果请求进入中间件之后，没有调用 next 则代码会停在当前中间件
如果调用了 next 则继续向后找到第一个匹配的中间件
如果不匹配，则继续判断匹配下一个中间件

4.1.1 next 方法

中间件的主要功能就是用来处理请求的，其本质还是函数，而且必须包含 next 方法

next方法：当一个请求进入一个中间件之后，如果不调用 next 则会停留在当前中间件，所以 next 是一个方法，用来调用下一个中间件的

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

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

var express = require('express')
var app = express()

app.use(function(req, res, next) {
	console.log('1')
	next() // 如果此处没有next()，则不会继续往下执行，会继续停留在当前中间件
})

app.use(function(req, res, next) {
	console.log('2')
	next()
})

app.listen(3000, function() {
	console.log('app is running at port 3000.')
})

4.1.2 作用

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

4.1.3 注意事项

1、一定要在路由之前注册中间件

2、客户端发送过来的请求，可以连续调用多个中间件进行处理

3、执行完中间件的业务代码之后，不要忘记调用 next() 函数

4、为了防止代码逻辑混乱，调用 next() 函数后不要再写额外的代码

5、连续调用多个中间件时，多个中间件之间，共享 req 和 res 对象

4.2 中间件的分类

4.2.1 应用级别中间件

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

// 全局中间件
app.use(function(req, res, next) {
	console.log('a')
	next()
})

// 局部中间件
const mw1 = (req, res, next) => {
  console.log('调用了局部生效的中间件')
  next()
}
app.get('/', mw1, (req, res) => {
  res.send('Home page.')
})

4.2.2 路由级别中间件

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

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

// 1.  导入 express 模块
const express = require('express')

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


// 3. 创建路由
router.get('/', (req, res) => {
  res.send('Home page GET request')
})

router.post('/', (req, res) => {
  res.send('Home page POST request')
})

module.exports = router

4.2.3 错误级别中间件

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

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

app.get('/a', function(req, res, next) {
	fs.readFile('.a/bc', funtion() {
		if (err) {
        	// 当调用next()传参后，如果传递了参数，则直接往后知道带有4个参数的的 处理错误的中间件
        	// 当发生全局错误的时候，我们可以调用next传递错误对象
        	// 然后被全局错误处理中间件匹配到并进行处理
			return next(err);
		}
	})
});

// 全局错误处理中间件：注意：参数一定是4个
app.use(function(err,req,res,next){
    res.status(500).json({
        err_code:500,
        message:err.message
    });
});

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

4.2.4 express内置中间件

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

① express.static 快速托管静态资源的内置中间件，例如： HTML 文件、图片、CSS 样式等（无兼容性）

var express = require('express')

// 0.  创建web服务器
var app = express()

// 1.  开放网站统一静态资源：使用 express.static 内置的中间件
app.use('/public/', express.static(path.join(__dirname, './public')))


app.listen(3000, function () {
	console.log('Server is runing at http://localhost:3000/')
})

② express.json 解析 JSON 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用） app.use(express.json())

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

// 注意：除了错误级别的中间件，其他的中间件，必须在路由之前进行配置
// 通过 express.json() 这个中间件，解析表单中的 JSON 格式的数据
app.use(express.json())

app.post('/user', (req, res) => {
  // 在服务器，可以使用 req.body 这个属性，来接收客户端发送过来的请求体数据
  // 默认情况下，如果不配置解析表单数据的中间件，则 req.body 默认等于 undefined
  console.log(req.body)
  res.send('ok')
})

// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(3000, function () {
	console.log('Server is runing at http://localhost:3000/')
})

③ express.urlencoded 解析 URL-encoded 格式的请求体数据（有兼容性，仅在 4.16.0+ 版本中可用）

app.use(express.urlencoded({ extended: false }))

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

// 通过 express.urlencoded() 这个中间件，来解析 表单中的 url-encoded 格式的数据
app.use(express.urlencoded({ extended: false }))

app.post('/book', (req, res) => {
  // 在服务器端，可以通过 req,body 来获取 JSON 格式的表单数据和 url-encoded 格式的数据
  console.log(req.body)
  res.send('ok')
})

// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(3000, function () {
	console.log('Server is runing at http://localhost:3000/')
})

4.2.5 404页面处理中间件

// 404 处理 所要未处理的请求路径都会在这里处理
app.use(function (req, res) {
	res.render("404.html")
})

4.2.6 第三方中间件

1 `body-parser` 解析post请求体参数

在 4.16.0+ 以前的版本中，一把是使用 body-parser 这个第三方的中间来解析处理post请求体中的参数的

处理post请求参数的中间件

var express = require('express')
// 引入第三方中间件，处理 post 请求体中的参数
var bodyParser = require('body-parser')

// 引入路由模块
var router = require('./routers')

// 0.  创建web服务器
var app = express()

// 2.  配置模板引擎和 body-parser 
app.use(bodyParser.urlencoded({
	extended: false
}))
app.use(bodyParser.json())


app.listen(3000, function () {
	console.log('Server is runing at http://localhost:3000/')
})

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

2 cors 跨域请求

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

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

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

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

下载安装依赖

npm i cors

配置

// 0.  引入
const cors = require('cors')

// 1.  配置：在路由之前调用
app.use(cors())

multer 处理 `multipart/form-data` 表单数据

使用 multer 来解析 multipart/form-data 格式的表单数据

使用 express.urlencoded() 中间件无法解析 multipart/form-data 格式的请求体数据

下载安装依赖

npm i multer

在路由模块中配置

// 导入解析 formdata 格式表单数据的包
const multer = require('multer')

// 导入处理路径的核心模块
const path = require('path')

// 创建 multer 的实例对象，通过 dest 属性指定 上传的文件的存放路径
const upload = multer({ dest: path.join(__dirname, '../uploads') })

// 发布新文章的路由
// 将文件类型的数据，解析并挂载到 req.file 属性中
// 将文本类型的数据，解析并挂载到 req.body 属性中
router.post('/add', upload.single('cover_img'), articleHandler.addArticle)

upload.single() 是一个局部生效的中间件，用来解析 FormData 格式的表单数据

将文件类型的数据，解析并挂载到 req.file 属性中
将文本类型的数据，解析并挂载到 req.body 属性中

5 跨域

5.1 概述

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

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

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

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

5.2 CORS 响应头部

5.2.1 `Access-Control-Allow-Origin`

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

// 只允许来自 http://itcast.cn 的请求：
res.setHeader('Access-Control-Allow-Origin', 'http://itcast.cn')

// 表示允许来自任何域的请求
res.setHeader('Access-Control-Allow-Origin', '*')

5.2.2 `Access-Control-Allow-Headers`

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

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

// 允许客户端 额外向服务器 发送 Content-type 请求头 和 X-Custom-Header 请求头
res.setHeader('Access-Control-Allow-Headers', 'Content-type,X-Custom-Header')

5.2.3 `Access-Control-Allow-Methods`

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

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

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

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

5.3 CORS请求分类

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

5.3.1 简单请求

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

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

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

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

5.3.2 预检请求

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

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

2、请求头中包含自定义头部字段

3、向服务器发送了 application/json 格式的数据

预检请求的过程：

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

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

6 数据库 `MySQL`

6.1 概述

数据库（database）是用来组织、存储和管理数据的仓库。

用户可以对数据库中的数据进行新增、查询、更新、删除等操作

6.2 常见数据库及其分类

市面上的数据库有很多种，最常见的数据库有如下几个：

MySQL 数据库（目前使用最广泛、流行度最高的开源免费数据库；Community + Enterprise）
Oracle 数据库（收费）
SQL Server 数据库（收费）
Mongodb 数据库（Community + Enterprise）

其中，MySQL、Oracle、SQL Server 属于传统型数据库（又叫做：关系型数据库或 SQL 数据库），这三者的设计理念相同，用法比较类似。

而 Mongodb 属于新型数据库（又叫做：非关系型数据库或 NoSQL 数据库），它在一定程度上弥补了传统型数据库的缺陷

6.3 SQL基本操作

SQL（英文全称：Structured Query Language）是结构化查询语言，专门用来访问和处理数据库的编程语言。能够让我们以编程的形式，操作数据库里面的数据

6.3.1 查询 `select`

SELECT 语句用于从表中查询数据。执行的结果被存储在一个结果表中（称为结果集）。

-- 通过 * 把 users 表中所有的数据查询出来
select * from users

-- 从 users 表中把 username 和 password 对应的列数据查询出来
select username, password from users

6.3.2 插入 `insert into`

INSERT INTO 语句用于向数据表中插入新的数据行

INSERT INTO 表名 (列名1,列名2,列名3...) values (值1,值2,值3...)

-- 向 users 表中，插入一条 username 为 admin，password 为 123456 的用户数据
insert into users (username,password) values ('admin','123456')

6.3.3 更新 `update`

update 语句用于修改表中的数据

UPDATE 表名 set 列名称=新值 where 列名称=某值

-- 把 users 表中 id 为 7 的用户密码，更新为 888888
update users set password='888888' where id=7

-- 把 users 表中 id 为 2 的用户密码和用户状态，分别更新为 admin123 和 1
-- 更改多列数据，使用 , 隔开
update users set password='admin123', status=1 where id=2

6.3.4 删除 `delete`

DELETE 语句用于删除表中的行

DELETE FROM 表名 WHERE 列名称=值

-- 删除 users 表中， id 为 4 的用户
delete from users where id=4

6.3.5 子句 `where`

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

select 列名 from 表名 where 列 运算符 值
update 表名 set 列=新值 where 列 运算符 值
delete from 表名 where 列 运算符 值

运算符常用如下：

操作符	说明
=	等于
<> 或者 !=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于
between	在某个搜索范围内查找
like	搜索某种模式

-- 查询 status 为 1 的所有用户
select * from users where status=1

-- 查询 id 大于 2 的所有用户
select * from users where id>=2

-- 查询 username 不等于 ls 的所有用户
select * from users where username<>'ls'
select * from users where username!='ls'

6.3.6 `ADN` 和 `OR`

AND 和 OR 可在 WHERE 子语句中把两个或多个条件结合起来

AND 表示必须同时满足多个条件，相当于 JavaScript 中的 && 运算符

OR 表示只要满足任意一个条件即可，相当于 JavaScript 中的 || 运算符

-- 查询 所有状态为0且id小于3的用户
select * from users where status=0 and id<3

-- 查询 所有状态为1 或 username 为 zs 的用户
select * from users where status=1 or username='zs'

6.3.7 `order by` 排序

ORDER BY 语句用于根据指定的列对结果集进行排序。

ORDER BY 语句默认按照升序（ASC）对记录进行排序

如果您希望按照降序对记录进行排序，可以使用 DESC 关键字

-- desc 表示降序排序   asc 表示升序排序（默认情况下，就是升序排序的）

-- 1.  对users表中的数据，按照 status 字段进行升序排序
select * from users order by status

-- 2.  按照 id 对结果进行降序的排序  
select * from users order by id desc

-- 3.  对 users 表中的数据，先按照 status 进行降序排序，再按照 username 字母的顺序，进行升序的排序
select * from users order by status desc, username asc

6.3.8 `COUNT(*)` 函数

COUNT(*) 函数用于返回查询结果的总数据条数

-- 使用 count(*) 来统计 users 表中，状态为 0 用户的总数量
select count(*) from users where status=0

6.3.9 AS 设置别名

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

-- 使用 AS 关键字给列起别名
select count(*) as total from users where status=0
select username as uname, password as upwd from users

7 Node操作MySQL数据库

npm文档

7.1 安装项目依赖

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

npm i mysql

7.2 配置 mysql 连接

// 0. 引入项目依赖 mysql
var mysql = require('mysql');

// 1. 创建数据库连接
var connection = mysql.createConnection({
	host: 'localhost',  // localhost==本机
	port: '3356',            // 端口号
	user: 'root',             // 用户名
	password: 'root',        // 密码
	database: 'dbname'         // 数据库名
});

// 2. 连接数据库
connection.connect();

// 3. sql查询

// 4. 关闭连接
connection.end();


// 或者采用下面的方式 创建连接也可以
// 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', // 指定要操作哪个数据库
})

7.3 使用

7.3.1 查询

查询 users 表中所有的数据

const sqlStr = 'select * from users'
db.query(sqlStr, (err, results) => {
  // 查询数据失败
  if (err) return console.log(err.message)
    
  // 查询数据成功
  // 注意：如果执行的是 select 查询语句，则执行的结果是数组
  console.log(results)
})

7.3.2 插入/新增

向 users 表中，新增一条数据，其中 username 的值为 Spider-Man，password 的值为 pcc123

// 1.  定义一个待插入的数据对象
const user = { username: 'Spider-Man', password: 'pcc123' }

// 2.  定义待执行的 SQL 语句：? 表示占位符
const sqlStr = 'insert into users (username, password) values (?, ?)'

// 3.  执行 SQL 语句：使用数组的形式，依次为 上面的占位符指定具体的值
db.query(sqlStr, [user.username, user.password], (err, results) => {
  // 执行 SQL 语句失败了
  if (err) return console.log(err.message)

  // 注意：如果执行的是 insert into 插入语句，则 results 是一个对象
  // 可以通过 affectedRows 属性，来判断是否插入数据成功
  if (results.affectedRows === 1) {
    console.log('插入数据成功!')
  }
})

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

// 1.  定义一个待插入的数据对象
 const user = { username: 'Spider-Man2', password: 'pcc4321' }
 
// 2. 定义待执行的 SQL 语句
const sqlStr = 'insert into users set ?'

// 3. 执行 SQL 语句：直接将数据对象作为占位符的值
db.query(sqlStr, user, (err, results) => {
  if (err) return console.log(err.message)
  if (results.affectedRows === 1) {
    console.log('插入数据成功')
  }
})

7.3.3 更新

将 id 为6的用户的用户名和密码更新为 aaa 000

// 1. 要更新的对象
const user = { id: 6, username: 'aaa', password: '000' }

// 2.  定义 SQL 语句，设置占位符
const sqlStr = 'update users set username=?, password=? where id=?'

// 3.  执行 SQL 语句：依次为占位符赋值
db.query(sqlStr, [user.username, user.password, user.id], (err, results) => {
  if (err) return console.log(err.message)
    
  // 注意：执行了 update 语句之后，执行的结果，也是一个对象，可以通过 affectedRows 判断是否更新成功
  if (results.affectedRows === 1) {
    console.log('更新成功')
  }
})

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

// 1. 要更新的对象
const user = { id: 6, username: 'aaa', password: '000' }

// 2.  定义 SQL 语句，设置占位符
const sqlStr = 'update users set ? where id=?'

// 3.  执行 SQL 语句：依次为占位符赋值
db.query(sqlStr, [user, user.id], (err, results) => {
  if (err) return console.log(err.message)
    
  // 注意：执行了 update 语句之后，执行的结果，也是一个对象，可以通过 affectedRows 判断是否更新成功
  if (results.affectedRows === 1) {
    console.log('更新成功')
  }
})

7.3.4 删除

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

删除 id 为 5 的用户

// 1. 要执行的sql语句
const sqlStr = 'delete from users where id=?'

// 2. 执行 SQL 语句：依次为占位符赋值
db.query(sqlStr, 5, (err, results) => {
  if (err) return console.log(err.message)
    
  // 注意：执行 delete 语句之后，结果也是一个对象，也会包含 affectedRows 属性
  if (results.affectedRows === 1) {
    console.log('删除数据成功')
  }
})

如果sql语句中有多个占位符，必须使用数组为每个占位符指定特定的值

如果sql语句中有1个占位符，则可以省略数组