首页 > 编程语言 >2024-03-11-Nodejs(4-大事件项目)

2024-03-11-Nodejs(4-大事件项目)

时间：2024-03-14 10:44:44浏览次数：33  
标签：11 03 const err Nodejs res require req router

4.大事件项目

4.1 项目初始化

项目整体架构图

大事件项目
	|--- 	db
	|	  	|--- index.js
	|--- router
	|		|--- user.js
	|--- router_handler
	|		|--- user.js
	|--- schema
	|		|--- user.js
	|--- app.js
	|--- config.js

4.1.1 创建项目

  1. 新建 api_server 文件夹作为项目根目录，并在项目根目录中运行如下的命令，初始化包管理配置文件：
npm init -y
  1. 运行如下的命令，安装特定版本的 express：
npm i [email protected]
  1. 在项目根目录中新建 app.js 作为整个项目的入口文件，并初始化如下的代码：

app.js

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

// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(3007, function () {
  console.log('api server running at http://127.0.0.1:3007')
})

4.1.2 配置 cors 跨域

  1. 运行如下的命令，安装 cors 中间件：
npm i [email protected]
  1. 在 app.js 中导入并配置 cors 中间件：

app.js

const express = require("express");
const app = express();
const cors = require("cors");

app.use(cors());

app.listen(3000, () => {
  console.log("server is running on port 3000");
});

4.1.3 配置解析表单数据的中间件

  1. 通过如下的代码，配置解析 application/x-www-form-urlencoded 格式的表单数据的中间件：

app.js

const express = require("express");
const app = express();
const cors = require("cors");

app.use(cors());

// 接收x-www-form-urlencoded格式的数据
app.use(express.urlencoded({ extended: false }));

app.listen(3000, () => {
  console.log("server is running on port 3000");
});

4.1.4 初始化路由相关的文件夹

  1. 在项目根目录中，新建 router 文件夹，用来存放所有的路由模块

    路由模块中，只存放客户端的请求与处理函数之间的映射关系

  2. 在项目根目录中，新建 router_handler 文件夹，用来存放所有的 路由处理函数模块

    路由处理函数模块中，专门负责存放每个路由对应的处理函数

4.1.5 初始化用户路由模块

  1. 在 router 文件夹中，新建 user.js 文件，作为用户的路由模块，并初始化代码：

router.js/user.js

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

// 注册新用户
router.post('/register', (req, res) => {
    res.send('reguser OK')
})

// 登录
router.post('/login', (req, res) => {
    res.send('login OK')
})

module.exports = router

4.1.6 抽离用户路由模块中的处理函数

目的：为了保证 路由模块 的纯粹性，所有的 路由处理函数，必须抽离到对应的 路由处理函数模块 中

  1. 在 /router_handler/user.js 中，使用 exports 对象，分别向外共享如下两个 路由处理函数 ：

/router_handler/user.js

/**
 * 在这里定义和用户相关的路由处理函数，供 /router/user.js 模块进行调用
 */

// 注册用户的处理函数
exports.regUser = (req, res) => {
  res.send('reguser OK')
}

// 登录的处理函数
exports.login = (req, res) => {
  res.send('login OK')
}

4.2. 登录注册

4.2.0 初始化数据库

  1. 在 test 数据库中，新建 ev_users 表如下：

image-20240312150031267

  1. 安装并配置 mysql 模块

在 API 接口项目中，需要安装并配置 mysql 这个第三方模块，来连接和操作 MySQL 数据库

  1. 运行如下命令，安装 mysql 模块：
npm i mysql
  1. 在项目根目录中新建 /db/index.js 文件，在此自定义模块中创建数据库的连接对象：

db/index.js

const mysql = require("mysql");
const db = mysql.createConnection({
  host: "192.168.1.84",
  user: "zheng",
  password: "123",
  database: "test",
});

module.exports = db;

4.2.1 注册

4.2.1.0 实现步骤
  1. 检测表单数据是否合法
  2. 检测用户名是否被占用
  3. 对密码进行加密处理
  4. 插入新用户
4.2.1.1 表单数据验证

表单验证的原则：前端验证为辅，后端验证为主，后端永远不要相信前端提交过来的任何内容

  1. 判断用户名和密码是否为空
// 接收表单数据
const userinfo = req.body
// 判断数据是否合法
if (!userinfo.username || !userinfo.password) {
  return res.send({ status: 1, message: '用户名或密码不能为空！' })
}
  1. 导入数据库操作模块：
const db = require('../db/index')
  1. 定义 SQL 语句：
const sql = `select * from ev_users where username=?`
  1. 执行 SQL 语句并根据结果判断用户名是否被占用：
db.query(sql, [userinfo.username], function (err, results) {
  // 执行 SQL 语句失败
  if (err) {
    return res.send({ status: 1, message: err.message })
  }
  // 用户名被占用
  if (results.length > 0) {
    return res.send({ status: 1, message: '用户名被占用，请更换其他用户名！' })
  }
  // TODO: 用户名可用，继续后续流程...
})
4.2.1.2 优化表单验证

在实际开发中，前后端都需要对表单的数据进行合法性的验证，而且，后端做为数据合法性验证的最后一个关口，在拦截非法数据方面，起到了至关重要的作用。

单纯的使用 if...else... 的形式对数据合法性进行验证，效率低下、出错率高、维护性差。因此，推荐使用第三方数据验证模块，来降低出错率、提高验证的效率与可维护性，让后端程序员把更多的精力放在核心业务逻辑的处理上。

  1. 安装 joi 包，为表单中携带的每个数据项，定义验证规则：
npm install joi
  1. 安装 @escook/express-joi 中间件，来实现自动对表单数据进行验证的功能：
npm i @escook/express-joi
  1. 新建 /schema/user.js 用户信息验证规则模块，并初始化代码如下：

schema/user.js

const joi = require('joi')

/**
 * string() 值必须是字符串
 * alphanum() 值只能是包含 a-zA-Z0-9 的字符串
 * min(length) 最小长度
 * max(length) 最大长度
 * required() 值是必填项，不能为 undefined
 * pattern(正则表达式) 值必须符合正则表达式的规则
 */

// 用户名的验证规则
const username = joi.string().alphanum().min(1).max(10).required()
// 密码的验证规则
const password = joi
  .string()
  .pattern(/^[\S]{6,12}$/)
  .required()

// 注册和登录表单的验证规则对象
exports.reg_login_schema = {
  // 表示需要对 req.body 中的数据进行验证
  body: {
    username,
    password,
  },
}
  1. 修改 /router/user.js 中的代码如下：

router/user.js

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

// 导入用户路由处理函数模块
const userHandler = require('../router_handler/user')

// 1. 导入验证表单数据的中间件
const expressJoi = require('@escook/express-joi')
// 2. 导入需要的验证规则对象
const { reg_login_schema } = require('../schema/user')

// 注册新用户
// 3. 在注册新用户的路由中，声明局部中间件，对当前请求中携带的数据进行验证
// 3.1 数据验证通过后，会把这次请求流转给后面的路由处理函数
// 3.2 数据验证失败后，终止后续代码的执行，并抛出一个全局的 Error 错误，进入全局错误级别中间件中进行处理
router.post('/register', expressJoi(reg_login_schema),userHandler.regUser);

router.post('/login', expressJoi(reg_login_schema), userHandler.login);

module.exports = router

在 app.js 的全局错误级别中间件中，捕获验证失败的错误，并把验证失败的结果响应给客户端：

app.js

// 这个地方试了很久，还是没办法捕捉到joi的错误
4.2.1.3 后台数据验证与写入

当前端数据通过验证，满足前端设置的条件和后端的数据校验后，还需要验证该数据是否可用：

  1. 如果数据库中有同名数据，数据将不可用来注册，返回错误
  2. 其他验证等

router_handler/user.js

const db = require("../db");

exports.regUser = (req, res) => {
  // 做验证，验证注册的用户名和密码
  const userinfo = req.body;
  console.log(userinfo);
  // 验证用户是否存在
  const sql = `select * from EN_USERS where username = '${userinfo.username}'`;
  db.query(sql, (err, data) => {
    if (err) {
      console.log(err);
    } else {
      if (data.length > 0) {
        res.send("用户已存在");
      } else {
        // 用户不存在，可以注册
        const sql = `insert into EN_USERS set ?`;
        db.query(sql, userinfo, (err, data) => {
          if (err) {
            console.log(err);
          } else {
            console.log(data);
          }
        });
      }
    }
  });
};

exports.login = (req, res) => {
  const userinfo = req;
  console.log(userinfo);
  res.send("login ok");
};

这样插入的数据就可以在数据库中看到

image-20240313105228580

4.2.1.4 res.send()优化

在处理函数中，需要多次调用 res.send() 向客户端响应 处理失败 的结果，为了简化代码，可以手动封装一个 res.cc() 函数

  1. 在 app.js 中，所有路由之前，声明一个全局中间件，为 res 对象挂载一个 res.cc() 函数 ：

app.js

const express = require("express");
const app = express();
const cors = require("cors");

app.use(cors());

// 接收x-www-form-urlencoded格式的数据
app.use(express.urlencoded({ extended: false }));

// 响应数据的中间件,绑定到全局res上
app.use(function (req, res, next) {
  // status = 0 为成功； status = 1 为失败； 默认将 status 的值设置为 1，方便处理失败的情况
  res.cc = function (err, status = 1) {
    res.send({
      // 状态
      status,
      // 状态描述，判断 err 是 错误对象 还是 字符串
      message: err instanceof Error ? err.message : err,
    });
  };
  next();
});

const userRouter = require("./router/user");
app.use("/api", userRouter);

app.listen(3000, () => {
  console.log("server is running on port 3000");
});

如果出错，就会返回错误的信息到前端，比如

image-20240313111059347

4.2.1.5 对密码进行加密处理

为了保证密码的安全性，不建议在数据库以 明文 的形式保存用户密码，推荐对密码进行 加密存储

在当前项目中，使用 bcryptjs 对用户密码进行加密，优点：

  • 加密之后的密码，无法被逆向破解
  • 同一明文密码多次加密，得到的加密结果各不相同，保证了安全性
  1. 运行如下命令，安装指定版本的 bcryptjs ：
npm i [email protected]
  1. 在 /router_handler/user.js 中，导入 bcryptjs ：
const bcrypt = require('bcryptjs')
  1. 在注册用户的处理函数中，确认用户名可用之后，调用 bcrypt.hashSync(明文密码, 随机盐的长度) 方法，对用户的密码进行加密处理：
// 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
userinfo.password = bcrypt.hashSync(userinfo.password, 10)

修改router_handler/user.js的内容如下：

router_handler/user.js

const db = require("../db");
const bcrypt = require("bcryptjs")

exports.regUser = (req, res) => {
  // 做验证，验证注册的用户名和密码
  const userinfo = req.body;
  console.log(userinfo);
  // 验证用户是否存在
  const sql = `select * from EN_USERS where username = '${userinfo.username}'`;
  db.query(sql, (err, data) => {
    if (err) return res.cc(err);
    if (data.length > 0) {
      res.send("用户已存在！");
    } else {
      // 用户不存在，可以注册
      const sql = `insert into EN_USERS set ?`;
      // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
      userinfo.password = bcrypt.hashSync(userinfo.password, 10);
      db.query(sql, userinfo, (err, data) => {
        if (err) return res.cc(err);
        res.send("注册成功！");
      });
    }
  });
};

exports.login = (req, res) => {
  const userinfo = req;
  console.log(userinfo);
  res.send("login ok");
};

执行插入操作，查看数据库

image-20240313111747411

4.2.2 登录

4.2.2.0 实现步骤
  1. 检测表单数据是否合法
  2. 根据用户名查询用户的数据
  3. 判断用户输入的密码是否正确
  4. 生成 JWT 的 Token 字符串
4.2.2.1 检测登录表单的数据是否
  1. 将 /router/user.js 中 登录 的路由代码修改如下：
const express = require('express');
const router = express.Router();

// 导入模块,用于验证用户名和密码
const expressJoi = require('@escook/express-joi')
const { reg_login_schema } = require('../schema/user');

// 导入路由处理模块
const userHandler = require('../router_handler/user');

router.post('/register', expressJoi(reg_login_schema),userHandler.regUser);

// 登录的路由
router.post('/login', expressJoi(reg_login_schema), userHandler.login);

module.exports = router;
4.2.6.2 根据用户名查询用户的数据
  1. 接收表单数据：
const userinfo = req.body
  1. 定义 SQL 语句：
const sql = `select * from ev_users where username=?`
  1. 执行 SQL 语句，查询用户的数据：
db.query(sql, userinfo.username, function (err, results) {
  // 执行 SQL 语句失败
  if (err) return res.cc(err)
  // 执行 SQL 语句成功，但是查询到数据条数不等于 1
  if (results.length !== 1) return res.cc('登录失败！')
  // TODO：判断用户输入的登录密码是否和数据库中的密码一致
})

router_handler/user.js

const db = require("../db");
const bcrypt = require("bcryptjs");

exports.regUser = (req, res) => {
  // 做验证，验证注册的用户名和密码
  const userinfo = req.body;
  console.log(userinfo);
  // 验证用户是否存在
  const sql = `select * from EN_USERS where username = '${userinfo.username}'`;
  db.query(sql, (err, data) => {
    if (err) return res.cc(err);
    if (data.length > 0) {
      res.send("用户已存在！");
    } else {
      // 用户不存在，可以注册
      const sql = `insert into EN_USERS set ?`;
      // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
      userinfo.password = bcrypt.hashSync(userinfo.password, 10);
      db.query(sql, userinfo, (err, data) => {
        if (err) return res.cc(err);
        res.send("注册成功！");
      });
    }
  });
};

exports.login = (req, res) => {
  const userinfo = req.body;
  console.log(userinfo);
  const sql = `select * from EN_USERS where username = '${userinfo.username}'`;

  db.query(sql, userinfo.username, function (err, results) {
    // 执行 SQL 语句失败
    if (err) return res.cc(err);
    // 执行 SQL 语句成功，但是查询到数据条数不等于 1
    if (results.length !== 1) return res.cc("登录失败！");
    // TODO：判断用户输入的登录密码是否和数据库中的密码一致
  });
};
4.2.6.3 判断用户输入的密码是否正确

核心实现思路：调用 bcrypt.compareSync(用户提交的密码, 数据库中的密码) 方法比较密码是否一致

返回值是布尔值（true 一致、false 不一致）

具体的实现代码如下：

router_handler/user.js

const db = require("../db");
const bcrypt = require("bcryptjs");

exports.regUser = (req, res) => {
  // 做验证，验证注册的用户名和密码
  const userinfo = req.body;
  console.log(userinfo);
  // 验证用户是否存在
  const sql = `select * from EN_USERS where username = '${userinfo.username}'`;
  db.query(sql, (err, data) => {
    if (err) return res.cc(err);
    if (data.length > 0) {
      res.send("用户已存在！");
    } else {
      // 用户不存在，可以注册
      const sql = `insert into EN_USERS set ?`;
      // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
      userinfo.password = bcrypt.hashSync(userinfo.password, 10);
      db.query(sql, userinfo, (err, data) => {
        if (err) return res.cc(err);
        res.send("注册成功！");
      });
    }
  });
};

exports.login = (req, res) => {
  const userinfo = req.body;
  console.log(userinfo);
  const sql = `select * from EN_USERS where username = '${userinfo.username}'`;

  db.query(sql, userinfo.username, function (err, results) {
    // 执行 SQL 语句失败
    if (err) return res.cc(err);
    // 执行 SQL 语句成功，但是查询到数据条数不等于 1
    if (results.length !== 1) return res.cc("登录失败！");
    // 判断用户输入的登录密码是否和数据库中的密码一致
    if (bcrypt.compareSync(userinfo.password, results[0].password)) {
      // 登录成功
      res.send("登录成功！");
      // todo 生成 token
      
    } else {
      // 登录失败
      return res.cc("登录失败！");
    }
  });
};
4.2.6.4 生成 JWT 的 Token 字符串

核心注意点：在生成 Token 字符串的时候，一定要剔除 密码 和 头像 的值

  1. 通过 ES6 的高级语法，快速剔除 密码 和 头像 的值：
// 剔除完毕之后，user 中只保留了用户的 id, username, nickname, email 这四个属性的值
const user = { ...results[0], password: '', user_pic: '' }
  1. 运行如下的命令，安装生成 Token 字符串的包：
npm i [email protected]
  1. 在 /router_handler/user.js 模块的头部区域，导入 jsonwebtoken 包：
// 用这个包来生成 Token 字符串
const jwt = require('jsonwebtoken')
  1. 创建 config.js 文件，并向外共享 加密 和 还原 Token 的 jwtSecretKey 字符串：
module.exports = {
  jwtSecretKey: 'zheng',
}
  1. 将用户信息对象加密成 Token 字符串：
// 导入配置文件
const config = require('../config')

// 生成 Token 字符串
const tokenStr = jwt.sign(user, config.jwtSecretKey, {
  expiresIn: '10h', // token 有效期为 10 个小时
})
  1. 将生成的 Token 字符串响应给客户端：
res.send({
  status: 0,
  message: '登录成功！',
  // 为了方便客户端使用 Token，在服务器端直接拼接上 Bearer 的前缀
  token: 'zheng ' + tokenStr,
})

router_handler/user.js

const db = require("../db");
const bcrypt = require("bcryptjs");
const jwt = require("jsonwebtoken");
const config = require("../config");

exports.regUser = (req, res) => {
  // 做验证，验证注册的用户名和密码
  const userinfo = req.body;
  console.log(userinfo);
  // 验证用户是否存在
  const sql = `select * from EN_USERS where username = '${userinfo.username}'`;
  db.query(sql, (err, data) => {
    if (err) return res.cc(err);
    if (data.length > 0) {
      res.send("用户已存在！");
    } else {
      // 用户不存在，可以注册
      const sql = `insert into EN_USERS set ?`;
      // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
      userinfo.password = bcrypt.hashSync(userinfo.password, 10);
      db.query(sql, userinfo, (err, data) => {
        if (err) return res.cc(err);
        res.send("注册成功！");
      });
    }
  });
};

exports.login = (req, res) => {
  const userinfo = req.body;

  const sql = `select * from EN_USERS where username = '${userinfo.username}'`;

  db.query(sql, userinfo.username, function (err, results) {
    // 执行 SQL 语句失败
    if (err) return res.cc(err);
    // 执行 SQL 语句成功，但是查询到数据条数不等于 1
    if (results.length !== 1) return res.cc("登录失败！");
    // 判断用户输入的登录密码是否和数据库中的密码一致
    if (bcrypt.compareSync(userinfo.password, results[0].password)) {
      //  生成 token
      const tokenStr = jwt.sign(
        { user: userinfo.username },
        config.jwtSecretKey,
        {
          expiresIn: "10h", // token 有效期为 10 个小时
        }
      );
      res.send({
        status: 0,
        message: "登录成功！",
        // 为了方便客户端使用 Token，在服务器端直接拼接上 Bearer 的前缀
        token: "zheng " + tokenStr,
      });
    } else {
      // 登录失败
      return res.cc("登录失败！");
    }
  });
};

返回到前端结果

image-20240313143940737

4.2.6.5 配置解析 Token 的中间件
  1. 运行如下的命令，安装解析 Token 的中间件：
npm i [email protected]
  1. 在 app.js 中注册路由之前，配置解析 Token 的中间件：
// 导入配置文件
const config = require('./config')

// 解析 token 的中间件
const  { expressjwt: expressJWT} = require("express-jwt");

// 使用 .unless({ path: [/^\/api\//] }) 指定哪些接口不需要进行 Token 的身份认证
app.use(
    expressJWT({ secret: config.jwtSecretKey, algorithms: ["HS256"] }).unless({ path: [/^\/api\//] })
);
  1. 在 app.js 中的 错误级别中间件 里面，捕获并处理 Token 认证失败后的错误：
// 错误中间件
app.use(function (err, req, res, next) {
  // 省略其它代码...

  // 捕获身份认证失败的错误
  if (err.name === 'UnauthorizedError') return res.cc('身份认证失败！')

  // 未知错误...
})

app.js

const express = require("express");
const app = express();
const cors = require("cors");
const joi = require("joi");

app.use(cors());

// 接收x-www-form-urlencoded格式的数据
app.use(express.urlencoded({ extended: false }));

// 响应数据的中间件,绑定到全局res上
app.use(function (req, res, next) {
  // status = 0 为成功； status = 1 为失败； 默认将 status 的值设置为 1，方便处理失败的情况
  res.cc = function (err, status = 1) {
    res.send({
      // 状态
      status,
      // 状态描述，判断 err 是 错误对象 还是 字符串
      message: err instanceof Error ? err.message : err,
    });
  };
  next();
});

// 导入配置文件
const config = require("./config");

// 解析 token 的中间件
const { expressjwt: expressJWT } = require("express-jwt");

// 使用 .unless({ path: [/^\/api\//] }) 指定哪些接口不需要进行 Token 的身份认证
app.use(
  expressJWT({ secret: config.jwtSecretKey, algorithms: ["HS256"] }).unless({
    path: [/^\/api\//],
  })
);

// 错误中间件
app.use(function (err, req, res, next) {
  // 省略其它代码...

  // 捕获身份认证失败的错误
  if (err.name === "UnauthorizedError") return res.cc("身份认证失败！");

  // 未知错误...
});

const userRouter = require("./router/user");
app.use("/api", userRouter);

app.listen(3000, () => {
  console.log("server is running on port 3000");
});

在apifox中编辑auth属性，其中token是前面登录后返回的token

image-20240313145057379

出现下面的结果，证明可以登录

image-20240313145133884

如果token不对，则会出现身份认证失败的返回值

image-20240313145220060

4.3 个人中心

根据文档，编写个人中心的接口，项目架构

大事件项目
	|--- 	db
	|	  	|--- index.js
	|--- router
	|		|--- user.js
	|		|--- userinfo.js  // 新增userinfo的路由模块
	|--- router_handler
	|		|--- user.js
	|		|--- userinfo.js  // 新增路由处理模块
	|--- schema
	|		|--- user.js
	|--- app.js
	|--- config.js

4.3.0 初始化路由模块

router/userinfo.js

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

// 获取用户的基本信息
router.get('/userinfo', (req, res) => {
    res.send('ok')
  })
  
  // 向外共享路由对象
  module.exports = router

app.js

const express = require("express");
const app = express();
const cors = require("cors");
const joi = require("joi");

app.use(cors());

// 接收x-www-form-urlencoded格式的数据
app.use(express.urlencoded({ extended: false }));

// 响应数据的中间件,绑定到全局res上
app.use(function (req, res, next) {
  // status = 0 为成功； status = 1 为失败； 默认将 status 的值设置为 1，方便处理失败的情况
  res.cc = function (err, status = 1) {
    res.send({
      // 状态
      status,
      // 状态描述，判断 err 是 错误对象 还是 字符串
      message: err instanceof Error ? err.message : err,
    });
  };
  next();
});

// 导入配置文件
const config = require("./config");

// 解析 token 的中间件
const { expressjwt: expressJWT } = require("express-jwt");

// 使用 .unless({ path: [/^\/api\//] }) 指定哪些接口不需要进行 Token 的身份认证
app.use(
  expressJWT({ secret: config.jwtSecretKey, algorithms: ["HS256"] }).unless({
    path: [/^\/api\//],
  })
);

// 错误中间件
app.use(function (err, req, res, next) {
  // 省略其它代码...

  // 捕获身份认证失败的错误
  if (err.name === "UnauthorizedError") return res.cc("身份认证失败！");

  // 未知错误...
});

const userRouter = require("./router/user");
app.use("/api", userRouter);

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

app.listen(3000, () => {
  console.log("server is running on port 3000");
});

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

router_handler/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

4.3.2 获取用户基本信息

router_handler/userinfo.js

const db = require("../db");

// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
  // 根据用户的 id，查询用户的基本信息
  // 注意：为了防止用户的密码泄露，需要排除 password 字段
  const sql = `select id, username, nickname, email, user_pic from EN_USERS where id=?`;

  // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
  console.log(req.query.userid);
  db.query(sql, req.query.userid, (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],
    });
  });
};

在apifox中设置请求头中的token，在query参数中设置userid

image-20240313151820225

执行请求，返回如下结果

image-20240313151842650

4.3.3 更新用户基本信息

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

router/userinfo.js

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

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

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

module.exports = router

router_handler/userinfo.js

const db = require("../db");

// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
  // 根据用户的 id，查询用户的基本信息
  // 注意：为了防止用户的密码泄露，需要排除 password 字段
  const sql = `select id, username, nickname, email, user_pic from EN_USERS where id=?`;

  // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
  console.log(req.query.userid);
  db.query(sql, req.query.userid, (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],
    });
  });
};


exports.updateUserInfo=(req,res)=>{
    res.send('ok')
}
4.3.3.2 验证表单数据

schema/user.js

const joi = require("joi");

/**
 * string() 值必须是字符串
 * alphanum() 值只能是包含 a-zA-Z0-9 的字符串
 * min(length) 最小长度
 * max(length) 最大长度
 * required() 值是必填项，不能为 undefined
 * pattern(正则表达式) 值必须符合正则表达式的规则
 */

// 用户名的验证规则
const username = joi.string().alphanum().min(1).max(10).required();
// 密码的验证规则
const password = joi
  .string()
  .pattern(/^[\S]{6,12}$/)
  .required();

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

// 注册和登录表单的验证规则对象
exports.reg_login_schema = {
  // 表示需要对 req.body 中的数据进行验证
  body: {
    username,
    password,
  },
};

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

router/userinfo.js

const express = require('express')
const router = express.Router()
// 导入用户信息验证
const expressJoi = require('@escook/express-joi')
const { update_userinfo_schema } = require('../schema/user');
// 导入用户信息的处理函数模块
const userinfo_handler = require('../router_handler/userinfo')

// 获取用户的基本信息
router.get('/userinfo', userinfo_handler.getUserInfo)
// 更新用户基本信息
router.post('/userinfo',expressJoi(update_userinfo_schema) , userinfo_handler.updateUserInfo)

module.exports = router
4.3.3.3 实现更新用户基本信息的功能

router_handler/userinfo.js

const db = require("../db");

// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
  // 根据用户的 id，查询用户的基本信息
  // 注意：为了防止用户的密码泄露，需要排除 password 字段
  const sql = `select id, username, nickname, email, user_pic from EN_USERS where id=?`;

  // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
  console.log(req.query.userid);
  db.query(sql, req.query.userid, (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],
    });
  });
};

exports.updateUserInfo = (req, res) => {
  // 实现更新用户基本信息的功能
  const sql = `update EN_USERS set ? where id=?`;
  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);
  });
};

image-20240313153522561

运行返回结果

image-20240313153543341

查看数据库，可以发现数据已经被修改

image-20240313153627595

4.3.4 重置密码

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

router/userinfo.js

const express = require('express')
const router = express.Router()
const expressJoi = require('@escook/express-joi')
const { update_userinfo_schema } = require('../schema/user');
// 导入用户信息的处理函数模块
const userinfo_handler = require('../router_handler/userinfo')

// 获取用户的基本信息
router.get('/userinfo', userinfo_handler.getUserInfo)
// 更新用户基本信息
router.post('/userinfo',expressJoi(update_userinfo_schema) , userinfo_handler.updateUserInfo)

// 更改用户密码
router.post('/updatepwd', userinfo_handler.updatePassword)


module.exports = router

router_handler/userinfo.js

const db = require("../db");

// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
  // 根据用户的 id，查询用户的基本信息
  // 注意：为了防止用户的密码泄露，需要排除 password 字段
  const sql = `select id, username, nickname, email, user_pic from EN_USERS where id=?`;

  // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
  console.log(req.query.userid);
  db.query(sql, req.query.userid, (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],
    });
  });
};

exports.updateUserInfo = (req, res) => {
  // 实现更新用户基本信息的功能
  const sql = `update EN_USERS set ? where id=?`;
  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);
  });
};

// 重置密码的处理函数
exports.updatePassword = (req, res) => {
  res.send("ok");
};
4.3.4.2 验证表单数据

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

需要在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),
  },
}

router_handler/userinfo.js

const db = require("../db");
const bcrypt = require("bcryptjs");

// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
  // 根据用户的 id，查询用户的基本信息
  // 注意：为了防止用户的密码泄露，需要排除 password 字段
  const sql = `select id, username, nickname, email, user_pic from EN_USERS where id=?`;

  // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的

  db.query(sql, req.query.userid, (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],
    });
  });
};

exports.updateUserInfo = (req, res) => {
  // 实现更新用户基本信息的功能
  const sql = `update EN_USERS set ? where id=?`;
  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);
  });
};

// 重置密码的处理函数
exports.updatePassword = (req, res) => {
  // 定义根据 id 查询用户数据的 SQL 语句
  const sql = `select * from EN_USERS where id=?`;
    console.log(req.query.id)
  // 执行 SQL 语句查询用户是否存在
  db.query(sql, req.query.id, (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err);

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

    // 判断提交的旧密码是否正确
    // 在头部区域导入 bcryptjs 后，
    // 即可使用 bcrypt.compareSync(提交的密码，数据库中的密码) 方法验证密码是否正确
    // compareSync() 函数的返回值为布尔值，true 表示密码正确，false 表示密码错误
    // 判断提交的旧密码是否正确
    const compareResult = bcrypt.compareSync(
      req.body.oldPwd,
      results[0].password
    );
    if (!compareResult) return res.cc("原密码错误！");

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

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

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

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

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

router/userinfo.js

const express = require('express')
const router = express.Router()
const expressJoi = require('@escook/express-joi')
const { update_userinfo_schema,update_password_schema } = require('../schema/user');
// 导入用户信息的处理函数模块
const userinfo_handler = require('../router_handler/userinfo')

// 获取用户的基本信息
router.get('/userinfo', userinfo_handler.getUserInfo)
// 更新用户基本信息
router.post('/userinfo',expressJoi(update_userinfo_schema) , userinfo_handler.updateUserInfo)

// 更改用户密码
router.post('/updatepwd',expressJoi(update_password_schema) , userinfo_handler.updatePassword)

module.exports = router

在params中定义请求的id，在body中定义新密码和旧密码

image-20240313160241041

执行显示

image-20240313160342108

4.3.5 更新用户头像

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

router/userinfo.js

const express = require('express')
const router = express.Router()
const expressJoi = require('@escook/express-joi')
const { update_userinfo_schema,update_password_schema } = require('../schema/user');
// 导入用户信息的处理函数模块
const userinfo_handler = require('../router_handler/userinfo')

// 获取用户的基本信息
router.get('/userinfo', userinfo_handler.getUserInfo)
// 更新用户基本信息
router.post('/userinfo',expressJoi(update_userinfo_schema) , userinfo_handler.updateUserInfo)

// 更改用户密码
router.post('/updatepwd',expressJoi(update_password_schema) , userinfo_handler.updatePassword)

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

module.exports = router

router_handler.js

const db = require("../db");
const bcrypt = require("bcryptjs");

// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
  // 根据用户的 id，查询用户的基本信息
  // 注意：为了防止用户的密码泄露，需要排除 password 字段
  const sql = `select id, username, nickname, email, user_pic from EN_USERS where id=?`;

  // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的

  db.query(sql, req.query.userid, (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],
    });
  });
};

exports.updateUserInfo = (req, res) => {
  // 实现更新用户基本信息的功能
  const sql = `update EN_USERS set ? where id=?`;
  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);
  });
};

// 重置密码的处理函数
exports.updatePassword = (req, res) => {
  // 定义根据 id 查询用户数据的 SQL 语句
  const sql = `select * from EN_USERS where id=?`;
  console.log(req.query.id);
  // 执行 SQL 语句查询用户是否存在
  db.query(sql, req.query.id, (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err);

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

    // 判断提交的旧密码是否正确
    // 在头部区域导入 bcryptjs 后，
    // 即可使用 bcrypt.compareSync(提交的密码，数据库中的密码) 方法验证密码是否正确
    // compareSync() 函数的返回值为布尔值，true 表示密码正确，false 表示密码错误
    // 判断提交的旧密码是否正确
    const compareResult = bcrypt.compareSync(
      req.body.oldPwd,
      results[0].password
    );
    if (!compareResult) return res.cc("原密码错误！");

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

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

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

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

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

// 更新用户头像的处理函数
exports.updateAvatar = (req, res) => {
  const sql = "update EN_USERS set user_pic=? where id=?";
  db.query(sql, [req.body.avatar, req.query.id], (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err);

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

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

schema/user.js

const joi = require("joi");

/**
 * string() 值必须是字符串
 * alphanum() 值只能是包含 a-zA-Z0-9 的字符串
 * min(length) 最小长度
 * max(length) 最大长度
 * required() 值是必填项，不能为 undefined
 * pattern(正则表达式) 值必须符合正则表达式的规则
 */

// 用户名的验证规则
const username = joi.string().alphanum().min(1).max(10).required();
// 密码的验证规则
const password = joi
  .string()
  .pattern(/^[\S]{6,12}$/)
  .required();

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

// 定义头像的验证规则，base64 的格式
// dataUri() 指的是如下格式的字符串数据：
// data:image/png;base64,VE9PTUFOWVNFQ1JFVFM=
const avatar = joi.string().dataUri().required()

// 注册和登录表单的验证规则对象
exports.reg_login_schema = {
  // 表示需要对 req.body 中的数据进行验证
  body: {
    username,
    password,
  },
};

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

// 验证规则对象 - 重置密码
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),
  },
}

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

image-20240313163106896

image-20240313163121736

4.4 文章管理分类

4.4.0 创建ARTICLE_CATE表

image-20240313174148360

大事件项目
	|--- 	db
	|	  	|--- index.js
	|--- router
	|		|--- user.js
	|		|--- userinfo.js 
	|		|--- article.js  // 新增article的路由模块
	|--- router_handler
	|		|--- user.js
	|		|--- userinfo.js  
	|		|--- article.js  // 新增路由处理模块
	|--- schema
	|		|--- user.js
	|		|--- article.js  // 新增article验证处理模块
	|--- app.js
	|--- config.js

4.4.1 获取文章分类列表

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

router/article.js

// 导入 express
const express = require('express')
// 创建路由对象
const router = express.Router()
const article_handler = require('../router_handler/article')
// 获取文章分类的列表数据
router.get('/cates', article_handler.getArticleCates)

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

router_handler/article.js

const db = require("../db/index");
exports.getArticleCates = (req, res) => {
  // 根据分类的状态，获取所有未被删除的分类列表数据
  // is_delete 为 0 表示没有被 标记为删除 的数据
  const sql = "select * from ARTICLE where is_deleted=0 order by id asc";
  db.query(sql, (err, results) => {
    // 1. 执行 SQL 语句失败
    if (err) return res.cc(err);

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

app.js

const express = require("express");
const app = express();
const cors = require("cors");
const joi = require("joi");

app.use(cors());

// 接收x-www-form-urlencoded格式的数据
app.use(express.urlencoded({ extended: false }));

// 响应数据的中间件,绑定到全局res上
app.use(function (req, res, next) {
  // status = 0 为成功； status = 1 为失败； 默认将 status 的值设置为 1，方便处理失败的情况
  res.cc = function (err, status = 1) {
    res.send({
      // 状态
      status,
      // 状态描述，判断 err 是 错误对象 还是 字符串
      message: err instanceof Error ? err.message : err,
    });
  };
  next();
});

// 导入配置文件
const config = require("./config");

// 解析 token 的中间件
const { expressjwt: expressJWT } = require("express-jwt");

// 使用 .unless({ path: [/^\/api\//] }) 指定哪些接口不需要进行 Token 的身份认证
app.use(
  expressJWT({ secret: config.jwtSecretKey, algorithms: ["HS256"] }).unless({
    path: [/^\/api\//],
  })
);

// 错误中间件
app.use(function (err, req, res, next) {
  // 省略其它代码...

  // 捕获身份认证失败的错误
  if (err.name === "UnauthorizedError") return res.cc("身份认证失败！");

  // 未知错误...
});

const userRouter = require("./router/user");
app.use("/api", userRouter);

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

app.listen(3000, () => {
  console.log("server is running on port 3000");
});

image-20240313164858357

4.4.2 新增文章分类

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

router/article.js

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

const article_handler = require('../router_handler/article')
// 导入文章分类的验证模块
const expressJoi = require('@escook/express-joi')
const { add_cate_schema } = require('../schema/article')

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

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

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

router_handler/article.js

const db = require("../db/index");

exports.getArticleCates = (req, res) => {
  // 根据分类的状态，获取所有未被删除的分类列表数据
  // is_delete 为 0 表示没有被 标记为删除 的数据
  const sql = "select * from ARTICLE_CATE where is_delete=0 order by id asc";
  db.query(sql, (err, results) => {
    // 1. 执行 SQL 语句失败
    if (err) return res.cc(err);

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

// 新增文章分类的处理函数
exports.addArticleCates = (req, res) => {
  // 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
  const sql = `select * from ARTICLE_CATE where name=? or alias=?`;
  // 执行查重操作
  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)
      return res.cc("分类名称被占用，请更换后重试！");
    if (results.length === 1 && results[0].alias === req.body.alias)
      return res.cc("分类别名被占用，请更换后重试！");
  });

  const add_sql = `insert into ARTICLE_CATE set ?`;
  db.query(add_sql, req.body, (err, results) => {
    // SQL 语句执行失败
    if (err) return res.cc(err);

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

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

schema/article.js

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

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

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

image-20240313171356988

4.4.3 根据 Id 删除文章分类

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

router/article.js

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

const article_handler = require("../router_handler/article");
// 导入文章分类的验证模块
const expressJoi = require("@escook/express-joi");
const { add_cate_schema, delete_cate_schema } = require("../schema/article");

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

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

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

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

router_handler/article.js

const db = require("../db/index");

exports.getArticleCates = (req, res) => {
  // 根据分类的状态，获取所有未被删除的分类列表数据
  // is_delete 为 0 表示没有被 标记为删除 的数据
  const sql = "select * from ARTICLE_CATE where is_delete=0 order by id asc";
  db.query(sql, (err, results) => {
    // 1. 执行 SQL 语句失败
    if (err) return res.cc(err);

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

// 新增文章分类的处理函数
exports.addArticleCates = (req, res) => {
  // 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
  const sql = `select * from ARTICLE_CATE where name=? or alias=?`;
  // 执行查重操作
  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)
      return res.cc("分类名称被占用，请更换后重试！");
    if (results.length === 1 && results[0].alias === req.body.alias)
      return res.cc("分类别名被占用，请更换后重试！");
  });

  const add_sql = `insert into ARTICLE_CATE set ?`;
  db.query(add_sql, req.body, (err, results) => {
    // SQL 语句执行失败
    if (err) return res.cc(err);

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

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

// 删除文章分类的处理函数
exports.deleteCateById = (req, res) => {
  const sql = `update ARTICLE_CATE set is_delete=1 where id=?`;
  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);
  });
};

schema/article.js

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

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

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

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

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

image-20240313172423015

image-20240313172820552

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

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

router/article.js

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

const article_handler = require("../router_handler/article");
// 导入文章分类的验证模块
const expressJoi = require("@escook/express-joi");
const { add_cate_schema, delete_cate_schema,get_cate_schema } = require("../schema/article");

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

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

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

// 获取文章分类数据
router.get('/cates/:id',expressJoi(get_cate_schema), article_handler.getArticleById)

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

router_handler/article.js

const db = require("../db/index");

exports.getArticleCates = (req, res) => {
  // 根据分类的状态，获取所有未被删除的分类列表数据
  // is_delete 为 0 表示没有被 标记为删除 的数据
  const sql = "select * from ARTICLE_CATE where is_delete=0 order by id asc";
  db.query(sql, (err, results) => {
    // 1. 执行 SQL 语句失败
    if (err) return res.cc(err);

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

// 新增文章分类的处理函数
exports.addArticleCates = (req, res) => {
  // 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
  const sql = `select * from ARTICLE_CATE where name=? or alias=?`;
  // 执行查重操作
  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)
      return res.cc("分类名称被占用，请更换后重试！");
    if (results.length === 1 && results[0].alias === req.body.alias)
      return res.cc("分类别名被占用，请更换后重试！");
  });

  const add_sql = `insert into ARTICLE_CATE set ?`;
  db.query(add_sql, req.body, (err, results) => {
    // SQL 语句执行失败
    if (err) return res.cc(err);

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

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

// 删除文章分类的处理函数
exports.deleteCateById = (req, res) => {
  const sql = `update ARTICLE_CATE set is_delete=1 where id=?`;
  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);
  });
};

// 根据 Id 获取文章分类的处理函数
exports.getArticleById = (req, res) => {
  const sql = `select * from ARTICLE_CATE where id=?`;
  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],
    });
  });
};

schema/article.js

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

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

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

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

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


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

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

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

router/article.js

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

const article_handler = require("../router_handler/article");
// 导入文章分类的验证模块
const expressJoi = require("@escook/express-joi");
const { add_cate_schema, delete_cate_schema,get_cate_schema,update_cate_schema } = require("../schema/article");

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

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

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

// 获取文章分类数据
router.get('/cates/:id',expressJoi(get_cate_schema), article_handler.getArticleById)

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

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

router_handler/article.js

const db = require("../db/index");

exports.getArticleCates = (req, res) => {
  // 根据分类的状态，获取所有未被删除的分类列表数据
  // is_delete 为 0 表示没有被 标记为删除 的数据
  const sql = "select * from ARTICLE_CATE where is_delete=0 order by id asc";
  db.query(sql, (err, results) => {
    // 1. 执行 SQL 语句失败
    if (err) return res.cc(err);

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

// 新增文章分类的处理函数
exports.addArticleCates = (req, res) => {
  // 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
  const sql = `select * from ARTICLE_CATE where name=? or alias=?`;
  // 执行查重操作
  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)
      return res.cc("分类名称被占用，请更换后重试！");
    if (results.length === 1 && results[0].alias === req.body.alias)
      return res.cc("分类别名被占用，请更换后重试！");
  });

  const add_sql = `insert into ARTICLE_CATE set ?`;
  db.query(add_sql, req.body, (err, results) => {
    // SQL 语句执行失败
    if (err) return res.cc(err);

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

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

// 删除文章分类的处理函数
exports.deleteCateById = (req, res) => {
  const sql = `update ARTICLE_CATE set is_delete=1 where id=?`;
  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);
  });
};

// 根据 Id 获取文章分类的处理函数
exports.getArticleById = (req, res) => {
  const sql = `select * from ARTICLE_CATE where id=?`;
  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],
    });
  });
};

// 更新文章分类的处理函数
exports.updateCateById = (req, res) => {
  // 定义查询 分类名称 与 分类别名 是否被占用的 SQL 语句
  const sql = `select * from ARTICLE_CATE where Id<>? and (name=? or alias=?)`;
  // 执行查重操作
  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)
        return res.cc("分类名称被占用，请更换后重试！");
      if (results.length === 1 && results[0].alias === req.body.alias)
        return res.cc("分类别名被占用，请更换后重试！");

      // 更新文章分类
      const sql = `update ARTICLE_CATE set ? where id=?`;
      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);
      });
    }
  );
};

schema/article.js

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

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

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

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

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


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

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

image-20240313174046841

image-20240313174059006

4.5. 文章管理

4.5.0 新建 ARTICLE表

image-20240313163710733

大事件项目
	|--- 	db
	|	  	|--- index.js
	|--- router
	|		|--- user.js
	|		|--- userinfo.js 
	|		|--- article.js 
	|		|--- pubarticle.js  // 新增pubarticle的路由模块
	|--- router_handler
	|		|--- user.js
	|		|--- userinfo.js  
	|		|--- article.js  
	|		|--- pubarticle.js  // 新增pubarticle路由处理模块
	|--- schema
	|		|--- user.js
	|		|--- article.js  // 新增article验证处理模块
	|--- app.js
	|--- config.js

4.5.1发布新文章

4.5.1.0 实现步骤
  1. 初始化路由模块
  2. 初始化路由处理函数模块
  3. 使用 multer 解析表单数据
  4. 验证表单数据
  5. 实现发布文章的功能
4.5.1.1 使用multer工具解析表单

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

当前项目，推荐使用 multer 来解析 multipart/form-data 格式的表单数据。https://www.npmjs.com/package/multer

  1. 运行如下的终端命令，在项目中安装 multer：
npm i [email protected]
  1. 在 /router_handler/pubarticle.js 模块中导入并配置 multer：
// 导入解析 formdata 格式表单数据的包
const multer = require('multer')
// 导入处理路径的核心模块
const path = require('path')

// 创建 multer 的实例对象，通过 dest 属性指定文件的存放路径
const upload = multer({ dest: path.join(__dirname, '../uplos') })
  1. 修改 发布新文章 的路由如下：
// 发布新文章的路由
// upload.single() 是一个局部生效的中间件，用来解析 FormData 格式的表单数据
// 将文件类型的数据，解析并挂载到 req.file 属性中
// 将文本类型的数据，解析并挂载到 req.body 属性中
// cover_img 这个字段在请求的body中是file格式，且需要配置需要上传的文件
router.post('/add', upload.single('cover_img'), article_handler.addArticle)
  1. 在 /router_handler/pubarticle.js 模块中的 addArticle 处理函数中，将 multer 解析出来的数据进行打印：
// 发布新文章的处理函数
exports.addArticle = (req, res) => {
  console.log(req.body) // 文本类型的数据
  console.log('--------分割线----------')
  console.log(req.file) // 文件类型的数据

  res.send('ok')
}
4.5.1.2 发布新文章

image-20240314093350992

需要对前段的内容进行校验和上传

schema/pubarticle.js

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

// 定义 标题、分类Id、内容、发布状态 的验证规则
const title = joi.string().required();
const cate_id = joi.number().integer().min(1).required();
const content = joi.string().required().allow("");
const state = joi.string().valid("已发布", "草稿").required();

// 验证规则对象 - 发布文章
exports.add_article_schema = {
  body: {
    title,
    cate_id,
    content,
    state,
  },
};

router/pubarticle.js

const express = require('express')
const router = express.Router()
// 导入处理路径的 path 核心模块
const path = require("path");
// 导入解析 formdata 格式表单数据的包
const multer = require("multer");

// 导入验证数据的中间件
const expressJoi = require('@escook/express-joi')
// 导入文章的验证模块
const { add_article_schema } = require('../schema/article')
// 导入文章的路由处理函数模块
const article_handler = require('../router_handler/pubarticle')

// 创建 multer 的实例对象，通过 dest 属性指定文件的存放路径
const upload = multer({ dest: path.join(__dirname, "../uploads") });
// 发布新文章
// 发布新文章的路由
// upload.single() 是一个局部生效的中间件，用来解析 FormData 格式的表单数据
// 将文件类型的数据，解析并挂载到 req.file 属性中
// 将文本类型的数据，解析并挂载到 req.body 属性中
router.post('/add', upload.single('cover_img'),expressJoi(add_article_schema),article_handler.addArticle)


module.exports = router

router_handler/pubarticle.js

// 导入处理路径的 path 核心模块
const path = require("path");
const jwt = require("jsonwebtoken");
const secret = require("../config");

// 发布新文章的处理函数
exports.addArticle = (req, res) => {
  if (!req.file || req.file.fieldname !== "cover_img")
    return res.cc("文章封面是必选参数！");

  //  根据token查找用户的id
  const authorization = req.headers.authorization;
  const token = authorization.split(" ")[1];

  jwt.verify(token, secret.jwtSecretKey, (err, decoded) => {
    if (err) return res.cc("token 验证失败！");

    // token 验证成功,查找出用户名
    // 根据用户名，查找用户id
    user = decoded.user;
    const db = require("../db");
    const id_sql = `select id from EN_USERS where username = ?`;
    db.query(id_sql, user, (err, results) => {
      if (err) return res.cc(err);

      if (results.length !== 1) return res.cc("用户不存在！");

      // 用户存在，继续执行
      const articleInfo = {
        // 标题、内容、状态、所属的分类Id
        ...req.body,
        // 文章封面在服务器端的存放路径
        cover_img: path.join("/uploads", req.file.filename),
        // 文章发布时间
        pub_date: new Date(),
        // 文章作者的Id
        //
        author_id: results[0].id,
      };

      const sql = `insert into ARTICLE set ?`;
      // 执行 SQL 语句
      db.query(sql, articleInfo, (err, results) => {
        // 执行 SQL 语句失败
        if (err) return res.cc(err);

        // 执行 SQL 语句成功，但是影响行数不等于 1
        if (results.affectedRows !== 1) return res.cc("发布文章失败！");

        // 发布文章成功
        res.cc("发布文章成功", 0);
      });
    });
  });
};

最后将存储位置加入到app的静态库

app.js

const express = require("express");
const app = express();
const cors = require("cors");
const joi = require("joi");

app.use(cors());

// 接收x-www-form-urlencoded格式的数据
app.use(express.urlencoded({ extended: false }));

// 响应数据的中间件,绑定到全局res上
app.use(function (req, res, next) {
  // status = 0 为成功； status = 1 为失败； 默认将 status 的值设置为 1，方便处理失败的情况
  res.cc = function (err, status = 1) {
    res.send({
      // 状态
      status,
      // 状态描述，判断 err 是 错误对象 还是 字符串
      message: err instanceof Error ? err.message : err,
    });
  };
  next();
});

// 导入配置文件
const config = require("./config");

// 解析 token 的中间件
const { expressjwt: expressJWT } = require("express-jwt");

// 使用 .unless({ path: [/^\/api\//] }) 指定哪些接口不需要进行 Token 的身份认证
app.use(
  expressJWT({ secret: config.jwtSecretKey, algorithms: ["HS256"] }).unless({
    path: [/^\/api\//],
  })
);

// 错误中间件
app.use(function (err, req, res, next) {
  // 省略其它代码...

  // 捕获身份认证失败的错误
  if (err.name === "UnauthorizedError") return res.cc("身份认证失败！");

  // 未知错误...
});

const userRouter = require("./router/user");
app.use("/api", userRouter);

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

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

// 托管静态资源文件
app.use('/uploads', express.static('./uploads'))

app.listen(3000, () => {
  console.log("server is running on port 3000");
});

image-20240314102404767

标签：11,03,const,err,Nodejs,res,require,req,router
From： https://www.cnblogs.com/hasaki-yasuo/p/18072310

相关文章

  • AcWing 503. 借教室（每日一题）
    原题链接：503.借教室-AcWing题库在大学期间，经常需要租借教室。大到院系举办活动，小到学习小组自习讨论，都需要向学校申请借教室。教室的大小功能不同，借教室人的身份不同，借教室的手续也不一样。 面对海量租借教室的信息，我们自然希望编程解决这个问题。我们需要处理接下来......
  • 【BFS二叉树】113路径总和II
    113路径总和II给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。思路：题目最终输出的是路径，因此用BFS遍历的时候，需要记录走到每个节点的路径；又因为路径和是要等于某个目标值的，因此也需要记录目标和。⇒......
  • [GPT] nodejs 什么情况下可以使用 import 来引入 export 的模块
    在Node.js中，原生并不支持ES6的import语句来引入模块。不过从Node.jsv12开始，通过实验性功能（--experimental-modules）可以使用.mjs扩展名的文件来启用对ES6模块的支持，并使用import语句。新版本Nodejs已移除了--experimental-modules但是，在生产环境中，为了确保兼......
  • 实验1朱笑雨202383310038
    #include<stdio.h>#include<stdlib.h>intmain(){printf("0\n");printf("<H>\n");printf("II\n");system("pause");return0;}#include<stdio.h>#include<stdl......
  • P1138 第 k 小整数
    首先第一想到的是排序，想着刚好练练各种排序，然后看到每个数只计算一次，还全是正整数，于是直接读的时候记录读到啥数字，专门拿一个数组（代码中的b）记录，最后要第k个，直接数就可以，不成立的情况中间筛选了。#include<stdio.h>intmain(){intnum,k,a[10001]={0},b[10001]={0},tmp,......
  • [20240312]sqlplus define数据类型问题.txt
    [20240312]sqlplusdefine数据类型问题.txt--//编写sql脚本遇到的问题，通过例子说明。1.环境：SCOTT@book>@ver1111PORT_STRING                   VERSION       BANNER------------------------------------------------------------------------......
  • 111. 二叉树的最小深度c
    /***Definitionforabinarytreenode.*structTreeNode{*intval;*structTreeNode*left;*structTreeNode*right;*};*/intmin(inti,intj){if(i>j)returnj;returni;}intminDepth(structTreeNode*root){......
  • [20240313]toad gather_plan_statistics执行计划相关问题.txt
    [20240313]toadgather_plan_statistics执行计划相关问题.txt--//自己现在已经很少使用toad,使用也是作为辅助功能,毕竟图形界面能更快的操作显示信息.--//昨天遇到一个问题,自己当时没有反映过来,浪费点时间,做一个记录避免以后再次犯浑.--//我一般在toad的sql编辑界面下尽可能看......
  • 2024.03.13 题解
    CF566A.MatchingNames注意到要求公共前缀，所以先对所有字符串建出Trie树，则公共前缀长度等价于Trie树上两节点最近公共祖先的深度。设\(dfn_u\)表示u点的dfs序，\(dep_u\)表示u的深度，\(lca_{u,v}\)表示\(u\)和\(v\)的最近公共祖先。则对于\(dfn_a<dfn_b<d......
  • 20240313打卡
    第三周第一天第二天第三天第四天第五天第六天第七天所花时间3h5h0h代码量（行）2742560博客量（篇）111知识点了解完成AndroidStudio中原生数据库SQlite简单的CRUD本地数据库连接到远程数据库海底谭练习......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99