【nodejs】大事件后台管理项目（二）——个人与文章管理

3. 个人中心

3.1 获取用户的基本信息

3.1.0 实现步骤

1. 初始化 路由 模块
2. 初始化 路由处理函数 模块
3. 获取用户的基本信息

3.1.1 初始化路由模块

1. 创建 /router/userinfo.js 路由模块，并初始化如下的代码结构：

// 导入 express
const express = require('express')
// 创建路由对象
const router = express.Router()

// 获取用户的基本信息
router.get('/userinfo', (req, res) => {
  res.send('ok')
})

// 向外共享路由对象
module.exports = router

2. 在 app.js 中导入并使用个人中心的路由模块：

// 导入并使用用户信息路由模块
const userinfoRouter = require('./router/userinfo')
// 注意：以 /my 开头的接口，都是有权限的接口，需要进行 Token 身份认证
app.use('/my', userinfoRouter)

测试

现在换到存在的接口，可以发现确实没有获得授权

然后选择获取token再尝试认证，可以看到成功了

当然在header中添加也可以的，不过注意token要加上Bearer字符串

3.1.2 初始化路由处理函数模块

创建 /router_handler/userinfo.js 路由处理函数模块，并完成对/router/userinfo.js映射路由模块的处理：

// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
  res.send('ok')
}

修改 /router/userinfo.js ：

const express = require('express')
const router = express.Router()

// 导入用户信息的处理函数模块
const userinfo_handler = require('../router_handler/userinfo')

// 获取用户的基本信息
router.get('/userinfo', userinfo_handler.getUserInfo)

module.exports = router

3.1.3 获取用户的基本信息

1. 在 /router_handler/userinfo.js 头部导入数据库操作模块：

// 导入数据库操作模块
const db = require('../db/index')

2. 在获取用户基本信息的处理函数中 定义 SQL 语句，另外要记得把res.send('ok')注释掉：

// 根据用户的 id，查询用户的基本信息
// 注意：为了防止用户的密码泄露，需要排除 password 字段
const sql = `select id, username, nickname, email, user_pic from ev_user where id=?`

3. 调用 db.query() 执行 SQL 语句，获取user信息会被挂载到req，但是新版本要用req.auth获取到id：

// 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
db.query(sql, req.auth.id, (err, results) => {
  // 1. 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 2. 执行 SQL 语句成功，但是查询到的数据条数不等于 1
  if (results.length !== 1) return res.cc('获取用户信息失败！')

  // 3. 将用户信息响应给客户端
  res.send({
    status: 0,
    message: '获取用户基本信息成功！',
    data: results[0],
  })
})

测试

获取到用户的信息

3.2 更新用户的基本信息

3.2.0 实现步骤

1. 定义路由和处理函数
2. 验证表单数据
3. 实现更新用户基本信息的功能

3.2.1 定义路由和处理函数

1. 在 /router/userinfo.js 模块中，新增 更新用户基本信息 的路由：

// 更新用户的基本信息
router.post('/userinfo', userinfo_handler.updateUserInfo)

2. 在 /router_handler/userinfo.js 模块中，定义并向外共享 更新用户基本信息 的路由处理函数：

// 更新用户基本信息的处理函数
exports.updateUserInfo = (req, res) => {
  res.send('ok')
}

3.2.2 验证表单数据

1. 在 /schema/user.js 验证规则模块中，定义 id，nickname，email 的验证规则如下：

// 定义 id, nickname, emial 的验证规则
const id = joi.number().integer().min(1).required()
const nickname = joi.string().required()
const email = joi.string().email().required()

2. 并使用 exports 向外共享如下的 验证规则对象：

// 验证规则对象 - 更新用户基本信息
exports.update_userinfo_schema = {
  body: {
    id,
    nickname,
    email,
  },
}

3. 在 /router/userinfo.js 模块中，导入验证数据合法性的中间件：

// 导入验证数据合法性的中间件
const expressJoi = require('@escook/express-joi')

4. 在 /router/userinfo.js 模块中，导入需要的验证规则对象：

// 导入需要的验证规则对象
const { update_userinfo_schema } = require('../schema/user')

5. 在 /router/userinfo.js 模块中，修改 更新用户的基本信息 的路由如下：

// // 更新用户的基本信息,这样服务端的信息就到expressJoi进行验证，只有验证成功后才能调用updateUserInfo处理函数
router.post('/userinfo', expressJoi(update_userinfo_schema), userinfo_handler.updateUserInfo)

3.2.3 实现更新用户基本信息的功能

1. 定义待执行的 SQL 语句：

const sql = `update ev_user set ? where id=?`

2. 调用 db.query() 执行 SQL 语句并传参，另外还是要注释掉res.send('ok')：

db.query(sql, [req.body, req.body.id], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 执行 SQL 语句成功，但影响行数不为 1
  if (results.affectedRows !== 1) return res.cc('修改用户基本信息失败！')

  // 修改用户信息成功
  return res.cc('修改用户基本信息成功！', 0)
})

测试

不知道出了什么bug，我命名传入的id都不是int类型，还可以修改成功过,不知道是不是测试工具有问题，表单验证应该是没问题的

后面我觉得有可能它的类型并不是严格定义的，而是类似js的==一样，可以进行值的判断与类型转换。

另外我竟然可以在获得用户id为2的token修改用户id为1的数据，这确实有问题。
解决方案：

1. 可以在数据库增加多一个用户权限的中间表或者直接字段，限定用户的权限。
2. 或者可以增加一个判断条件，限定在执行sql语句之前，先判断请求body中的id与auth中的id即当前token得到的id是一致的

// 更新用户基本信息的处理函数
exports.updateUserInfo = (req, res) => {
	const sql = `update ev_user set ? where id=?`

	//判断用户id，限定修改权限
	if (req.auth.id !== req.body.id) return res.cc('用户id不一致')

	db.query(sql, [req.body, req.body.id], (err, results) => {
		// console.log(req)
		// 执行 SQL 语句失败
		if (err) return res.cc(err)

		// 执行 SQL 语句成功，但影响行数不为 1
		if (results.affectedRows !== 1) return res.cc('修改用户基本信息失败！')

		// 修改用户信息成功
		return res.cc('修改用户基本信息成功！', 0)
	})
	// res.send('ok')
}

用户不一致测试

3.3 重置密码

以下的实现步骤还是挺简陋的，没有邮箱或手机第三方的本人信息验证，也没有人机交互判断。

3.3.0 实现步骤

1. 定义路由和处理函数
2. 验证表单数据
3. 实现重置密码的功能

3.3.1 定义路由和处理函数

1. 在 /router/userinfo.js 模块中，新增 重置密码 的路由：

// 重置密码的路由
router.post('/updatepwd', userinfo_handler.updatePassword)

2. 在 /router_handler/userinfo.js 模块中，定义并向外共享 重置密码 的路由处理函数：

// 重置密码的处理函数
exports.updatePassword = (req, res) => {
  res.send('ok')
}

3.3.2 验证表单数据

核心验证思路：旧密码与新密码，必须符合密码的验证规则，并且新密码不能与旧密码一致！

1. 在 /schema/user.js 模块中，使用 exports 向外共享如下的 验证规则对象：

// 验证规则对象 - 重置密码
exports.update_password_schema = {
  body: {
    // 使用 password 这个规则，验证 req.body.oldPwd 的值
    oldPwd: password,
    // 使用 joi.not(joi.ref('oldPwd')).concat(password) 规则，验证 req.body.newPwd 的值
    // 解读：
    // 1. joi.ref('oldPwd') 表示 newPwd 的值必须和 oldPwd 的值保持一致
    // 2. joi.not(joi.ref('oldPwd')) 表示 newPwd 的值不能等于 oldPwd 的值
    // 3. .concat() 用于合并 joi.not(joi.ref('oldPwd')) 和 password 这两条验证规则
    newPwd: joi.not(joi.ref('oldPwd')).concat(password),
  },
}

2. 在 /router/userinfo.js 模块中，导入需要的验证规则对象：

// 导入需要的验证规则对象
const { update_userinfo_schema, update_password_schema } = require('../schema/user')

3. 并在 重置密码的路由 中，使用 update_password_schema 规则验证表单的数据，再调用函数：

router.post('/updatepwd', expressJoi(update_password_schema), userinfo_handler.updatePassword)

3.3.3 实现重置密码的功能

以下代码在/router_handler/userinfo.js的重置密码的处理函数修改

1. 根据 id 查询用户是否存在：

// 定义根据 id 查询用户数据的 SQL 语句
const sql = `select * from ev_user where id=?`

// 执行 SQL 语句查询用户是否存在
db.query(sql, req.auth.id, (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 检查指定 id 的用户是否存在
  if (results.length !== 1) return res.cc('用户不存在！')

  // TODO：判断提交的旧密码是否正确
})

2. 判断提交的 旧密码 是否正确：

// 在头部区域导入 bcryptjs 后，
// 即可使用 bcrypt.compareSync(提交的密码，数据库中的密码) 方法验证密码是否正确
// compareSync() 函数的返回值为布尔值，true 表示密码正确，false 表示密码错误
const bcrypt = require('bcryptjs')

// 就可以在运行sql函数的方法中，定义判断提交的旧密码是否正确
const compareResult = bcrypt.compareSync(req.body.oldPwd, results[0].password)
if (!compareResult) return res.cc('原密码错误！')

测试

由于query实现函数可以通过token获得到对应用户的id到sql参数中，所以很多时候不需要传入id的值。

现在测试旧密码跟用户的原来密码不一致的情况，发现成功了。

如果旧密码对应原密码，同时保证旧密码与新密码不一致，则是不断加载

3. 对新密码进行 bcrypt 加密之后，更新到数据库中：

// 定义更新用户密码的 SQL 语句
const sql = `update ev_user set password=? where id=?`

// 对新密码进行 bcrypt 加密处理
const newPwd = bcrypt.hashSync(req.body.newPwd, 10)

// 执行 SQL 语句，根据 id 更新用户的密码
db.query(sql, [newPwd, req.auth.id], (err, results) => {
  // SQL 语句执行失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('更新密码失败！')

  // 更新密码成功
  res.cc('更新密码成功！', 0)
})

测试

另外也可以看到数据库的密码仍旧保持密文形式

3.4 更新用户头像

3.4.0 实现步骤

1. 定义路由和处理函数
2. 验证表单数据
3. 实现更新用户头像的功能

3.4.1 定义路由和处理函数

1. 在 /router/userinfo.js 模块中，新增 更新用户头像 的路由：

// 更新用户头像的路由
router.post('/update/avatar', userinfo_handler.updateAvatar)

2. 在 /router_handler/userinfo.js 模块中，定义并向外共享 更新用户头像 的路由处理函数：

// 更新用户头像的处理函数
exports.updateAvatar = (req, res) => {
  res.send('ok')
}

3.4.2 验证表单数据

1. 在 /schema/user.js 验证规则模块中，定义 avatar 的验证规则如下：

// dataUri() 指的是如下格式的字符串数据：
// data:image/png;base64,VE9PTUFOWVNFQ1JFVFM=
const avatar = joi.string().dataUri().required()

2. 并使用 exports 向外共享如下的 验证规则对象：

// 验证规则对象 - 更新头像
exports.update_avatar_schema = {
  body: {
    avatar,
  },
}

3. 在 /router/userinfo.js 模块中，导入需要的验证规则对象：

const { update_avatar_schema } = require('../schema/user')

4. 在 /router/userinfo.js 模块中，修改 更新用户头像 的路由如下：

router.post('/update/avatar', expressJoi(update_avatar_schema), userinfo_handler.updateAvatar)

3.4.3 实现更新用户头像的功能

到handler/userinfo.js修改

1. 定义更新用户头像的 SQL 语句：

const sql = 'update ev_user set user_pic=? where id=?'

2. 调用 db.query() 执行 SQL 语句，更新对应用户的头像：

db.query(sql, [req.body.avatar, req.auth.id], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 执行 SQL 语句成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('更新头像失败！')

  // 更新用户头像成功
  return res.cc('更新头像成功！', 0)
})

测试

如果不符合dataUri()，会报如下的错误：

4. 文章分类管理

4.1 新建 ev_article_cate 表

4.1.1 创建表结构

CREATE TABLE `my_db_01`.`ev_article_cate`  (
  `id` int(0) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL COMMENT '文章名',
  `alias` varchar(255) NOT NULL COMMENT '别名',
  `is_delete` tinyint(1) NOT NULL DEFAULT 0 COMMENT '0表示数据没有删除，1相反',
  PRIMARY KEY (`id`),
  INDEX(`id`, `name`, `alias`)
) COMMENT = '文章分类表';

4.1.2 新增两条初始数据

4.2 获取文章分类列表

4.2.0 实现步骤

1. 初始化路由模块
2. 初始化路由处理函数模块
3. 获取文章分类列表数据

4.2.1 初始化路由模块

1. 创建 /router/artcate.js 路由模块，并初始化如下的代码结构：

// 导入 express
const express = require('express')
// 创建路由对象
const router = express.Router()

// 获取文章分类的列表数据
router.get('/cates', (req, res) => {
  res.send('ok')
})

// 向外共享路由对象
module.exports = router

2. 在 app.js 中导入并使用文章分类的路由模块：

// 导入并使用文章分类路由模块
const artCateRouter = require('./router/artcate')
// 为文章分类的路由挂载统一的访问前缀 /my/article
app.use('/my/article', artCateRouter)

4.2.2 初始化路由处理函数模块

1. 创建 /router_handler/artcate.js 路由处理函数模块，并初始化如下的代码结构：

// 获取文章分类列表数据的处理函数
exports.getArticleCates = (req, res) => {
  res.send('ok')
}

2. 修改 /router/artcate.js 中的代码如下：

const express = require('express')
const router = express.Router()

// 导入文章分类的路由处理函数模块
const artcate_handler = require('../router_handler/artcate')

// 获取文章分类的列表数据
router.get('/cates', artcate_handler.getArticleCates)

module.exports = router

4.2.3 获取文章分类列表数据

1. 在 /router_handler/artcate.js 头部导入数据库操作模块：

// 导入数据库操作模块
const db = require('../db/index')

2. 在获取文章分类列表数据的处理函数中：定义 SQL 语句：

// 根据分类的状态，获取所有未被删除的分类列表数据
// is_delete 为 0 表示没有被 标记为删除 的数据
const sql = 'select * from ev_article_cate where is_delete=0 order by id asc'

3. 调用 db.query() 执行 SQL 语句：

db.query(sql, (err, results) => {
  // 1. 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 2. 执行 SQL 语句成功
  res.send({
    status: 0,
    message: '获取文章分类列表成功！',
    data: results,
  })
})

测试

4.3 新增文章分类

4.3.0 实现步骤

1. 定义路由和处理函数
2. 验证表单数据
3. 查询 分类名称 与 分类别名 是否被占用
4. 实现新增文章分类的功能

4.3.1 定义路由和处理函数

1. 在 /router/artcate.js 模块中，添加 新增文章分类 的路由：

// 新增文章分类的路由
router.post('/addcates', artcate_handler.addArticleCates)

2. 在 /router_handler/artcate.js 模块中，定义并向外共享 新增文章分类 的路由处理函数：

// 新增文章分类的处理函数
exports.addArticleCates = (req, res) => {
  res.send('ok')
}

4.3.2 验证表单数据

1. 创建 /schema/artcate.js 文章分类数据验证模块，并定义如下的验证规则：

// 导入定义验证规则的模块
const joi = require('joi')

// 定义 分类名称 和 分类别名 的校验规则
const name = joi.string().required()
const alias = joi.string().alphanum().required()

// 校验规则对象 - 添加分类
exports.add_cate_schema = {
  body: {
    name,
    alias,
  },
}

2. 在 /router/artcate.js 模块中，使用 add_cate_schema 对数据进行验证：

// 导入验证数据的中间件
const expressJoi = require('@escook/express-joi')
// 导入文章分类的验证模块
const { add_cate_schema } = require('../schema/artcate')

// 新增文章分类的路由
router.post('/addcates', expressJoi(add_cate_schema), artcate_handler.addArticleCates)

4.3.3 查询分类名称与别名是否被占用

在router_handler/artcate.js中的新增文章分类的处理函数新增如下内容：

• 先检查文章的分类标签是否有被占用
• 再新增文章的分类标准名与别名

1. 定义查重的 SQL 语句：

// 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
const sql = `select * from ev_article_cate where name=? or alias=?`

2. 调用 db.query() 执行查重的操作：

// 执行查重操作
db.query(sql, [req.body.name, req.body.alias], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 判断 分类名称 和 分类别名 是否被占用
		//if (results.length === 2)
		//	return res.cc('分类名称与别名被占用，请更换后重试！')
		if (
			results.length === 1 &&
			results[0].name === req.body.name &&
			results[0].alias === req.body.alias
		)
			return res.cc('分类名称与别名被占用，请更换后重试！')
		if (results.length === 1 && results[0].name === req.body.name)
			// 分别判断 分类名称 和 分类别名 是否被占用
			return res.cc('分类名称被占用，请更换后重试！')
		if (results.length === 1 && results[0].alias === req.body.alias)
			return res.cc('分类别名被占用，请更换后重试！')

  // TODO：新增文章分类
})

4.3.4 实现新增文章分类的功能

1. 定义新增文章分类的 SQL 语句：

const sql = `insert into ev_article_cate set ?`

2. 调用 db.query() 执行新增文章分类的 SQL 语句：

db.query(sql, req.body, (err, results) => {
  // SQL 语句执行失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('新增文章分类失败！')

  // 新增文章分类成功
  res.cc('新增文章分类成功！', 0)
})

测试

新增成功的情况

4.4 根据 Id 删除文章分类

4.4.0 实现步骤

1. 定义路由和处理函数
2. 验证表单数据
3. 实现删除文章分类的功能

4.4.1 定义路由和处理函数

1. 在 /router/artcate.js 模块中，添加 删除文章分类 的路由：

// 删除文章分类的路由
router.get('/deletecate/:id', artcate_handler.deleteCateById)

2. 在 /router_handler/artcate.js 模块中，定义并向外共享 删除文章分类 的路由处理函数：

// 删除文章分类的处理函数
exports.deleteCateById = (req, res) => {
  res.send('ok')
}

4.4.2 验证表单数据

1. 在 /schema/artcate.js 验证规则模块中，定义 id 的验证规则如下：

// 定义 分类Id 的校验规则
const id = joi.number().integer().min(1).required()

2. 并使用 exports 向外共享如下的 验证规则对象：

// 校验规则对象 - 删除分类
exports.delete_cate_schema = {
  params: {
    id,
  },
}

3. 在 /router/artcate.js 模块中，导入需要的验证规则对象，并在路由中使用，因此要进行修改：

// 导入删除分类的验证规则对象
const { delete_cate_schema } = require('../schema/artcate')

// 删除文章分类的路由
router.get('/deletecate/:id', expressJoi(delete_cate_schema), artcate_handler.deleteCateById)

4.4.3 实现删除文章分类的功能

在/router_handler/artcate.js中的删除文章分类的处理函数新增如下

1. 定义删除文章分类的 SQL 语句：

const sql = `update ev_article_cate set is_delete=1 where id=?`

2. 调用 db.query() 执行删除文章分类的 SQL 语句：

db.query(sql, req.params.id, (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('删除文章分类失败！')

  // 删除文章分类成功
  res.cc('删除文章分类成功！', 0)
})

测试

通过设置变量进行伪删除，减少性能消耗的同时，也起到安全的作用

现在查找文章

4.5 根据 Id 获取文章分类数据

4.5.0 实现步骤

1. 定义路由和处理函数
2. 验证表单数据
3. 实现获取文章分类的功能

4.5.1 定义路由和处理函数

1. 在 /router/artcate.js 模块中，添加 根据 Id 获取文章分类 的路由：

//根据 Id 获取文章分类的路由
router.get('/cates/:id', artcate_handler.getArticleById)

2. 在 /router_handler/artcate.js 模块中，定义并向外共享 根据 Id 获取文章分类 的路由处理函数：

// 根据 Id 获取文章分类的处理函数
exports.getArticleById = (req, res) => {
  res.send('ok')
}

4.5.2 验证表单数据

1. 在 /schema/artcate.js 验证规则模块中，使用 exports 向外共享如下的 验证规则对象：

// 校验规则对象 - 根据 Id 获取分类
exports.get_cate_schema = {
  params: {
    id,
  },
}

2. 在 /router/artcate.js 模块中，导入需要的验证规则对象，并在路由中使用：

// 导入根据 Id 获取分类的验证规则对象
const { get_cate_schema } = require('../schema/artcate')

// 根据 Id 获取文章分类的路由
router.get('/cates/:id', expressJoi(get_cate_schema), artcate_handler.getArticleById)

4.5.3 实现获取文章分类的功能

/router_handler/artcate.js的根据 Id 获取文章分类的处理函数添加如下内容

1. 定义根据 Id 获取文章分类的 SQL 语句：

const sql = `select * from ev_article_cate where id=?`

2. 调用 db.query() 执行 SQL 语句：

db.query(sql, req.params.id, (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是没有查询到任何数据
  if (results.length !== 1) return res.cc('获取文章分类数据失败！')

  // 把数据响应给客户端
  res.send({
    status: 0,
    message: '获取文章分类数据成功！',
    data: results[0],
  })
})

测试

因为sql没有限制is_delete为1不显示，所以伪删除的数据也可以看到

4.6 根据 Id 更新文章分类数据

4.6.0 实现步骤

1. 定义路由和处理函数
2. 验证表单数据
3. 查询 分类名称 与 分类别名 是否被占用
4. 实现更新文章分类的功能

4.6.1 定义路由和处理函数

1. 在 /router/artcate.js 模块中，添加 更新文章分类 的路由：

// 更新文章分类的路由
router.post('/updatecate', artcate_handler.updateCateById)

2. 在 /router_handler/artcate.js 模块中，定义并向外共享 更新文章分类 的路由处理函数：

// 更新文章分类的处理函数
exports.updateCateById = (req, res) => {
  res.send('ok')
}

4.6.2 验证表单数据

1. 在 /schema/artcate.js 验证规则模块中，使用 exports 向外共享如下的 验证规则对象：

// 校验规则对象 - 更新分类
exports.update_cate_schema = {
  body: {
    Id: id,
    name,
    alias,
  },
}

2. 在 /router/artcate.js 模块中，导入需要的验证规则对象，并在路由中使用：

// 导入更新文章分类的验证规则对象
const { update_cate_schema } = require('../schema/artcate')

// 更新文章分类的路由
router.post('/updatecate', expressJoi(update_cate_schema), artcate_handler.updateCateById)

4.6.3 查询分类名称与别名是否被占用

在 /router_handler/artcate.js的更新文章分类的处理函数添加如下内容。

1. 定义查重的 SQL 语句：

// 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
const sql = `select * from ev_article_cate where Id<>? and (name=? or alias=?)`

2. 调用 db.query() 执行查重的操作：

// 执行查重操作
db.query(sql, [req.body.Id, req.body.name, req.body.alias], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // 判断 分类名称 和 分类别名 是否被占用
  if (results.length === 2) return res.cc('分类名称与别名被占用，请更换后重试！')
  if (results.length === 1 && results[0].name === req.body.name && results[0].alias === req.body.alias)return res.cc('分类名称与别名被占用，请更换后重试！')
  if (results.length === 1 && results[0].name === req.body.name) return res.cc('分类名称被占用，请更换后重试！')
  if (results.length === 1 && results[0].alias === req.body.alias) return res.cc('分类别名被占用，请更换后重试！')

  // TODO：更新文章分类
})

4.6.4 实现更新文章分类的功能

1. 定义更新文章分类的 SQL 语句：

const sql = `update ev_article_cate set ? where Id=?`

2. 调用 db.query() 执行 SQL 语句：

db.query(sql, [req.body, req.body.Id], (err, results) => {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)

  // SQL 语句执行成功，但是影响行数不等于 1
  if (results.affectedRows !== 1) return res.cc('更新文章分类失败！')

  // 更新文章分类成功
  res.cc('更新文章分类成功！', 0)
})

测试

要注意填入的规则对象大小写对应我们POST要填的字符名称

标签：分类,管理,res,nodejs,id,后台,router,处理函数,路由
来源： https://www.cnblogs.com/PaturNax/p/16536827.html