前端技术(五)—— 使用Node.js编写简单的项目

news2024/11/15 10:58:56

一、 初始化项目

1. 创建项目

⑴ 新建 api_kjzt_server 文件夹作为项目根目录，并初始化包管理配置文件

在这里插入图片描述
在这里插入图片描述
并在项目根目录中运行如下的命令，初始化包管理配置文件：

npm init -y

在这里插入图片描述

⑵ 运行如下的命令，安装特定版本的 express

npm i express@4.17.1

在这里插入图片描述

⑶ 在项目根目录中新建 app.js 作为整个项目的入口文件，并初始化如下的代码：

// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// write your code here...
// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(3007, function () {
    console.log('api server running at http://127.0.0.1:3007')
})

在这里插入图片描述

2. 配置 cors 跨域

⑴ 运行如下的命令，安装 cors 中间件：

npm i cors@2.8.5

在这里插入图片描述

⑵ 在 app.js 中导入并配置 cors 中间件：

// 导入 cors 中间件
const cors = require('cors')
// 将 cors 注册为全局中间件
app.use(cors())

在这里插入图片描述

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

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

//配置解析 application/x-www-form-urlencoded 格式的表单数据的中间件
app.use(express.urlencoded({ extended: false }))

在这里插入图片描述

4. 初始化路由相关的文件夹

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

在这里插入图片描述

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

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

在这里插入图片描述

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

5. 初始化用户路由模块

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

const express = require('express')
// 创建路由对象
const router = express.Router()
// 注册新用户
router.post('/reguser', (req, res) => {
    res.send('reguser OK')
})
// 登录
router.post('/login', (req, res) => {
    res.send('login OK')
})
// 将路由对象共享出去
module.exports = router

在这里插入图片描述

⑵ 在 app.js 中，导入并使用 用户路由模块 ：

// 导入并注册用户路由模块
const userRouter = require('./router/user')
app.use('/api', userRouter)

在这里插入图片描述

⑶ 启动服务测试一下项目的功能

在这里插入图片描述

在这里插入图片描述

请求：http://127.0.0.1:3007/api/reguser 测试注册的功能
在这里插入图片描述
请求http://127.0.0.1:3007/api/login测试登录功能
在这里插入图片描述

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

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

在这里插入图片描述

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

/**
* 在这里定义和用户相关的路由处理函数，供 /router/user.js 模块进行调用
*/
// 注册用户的处理函数
exports.regUser = (req, res) => {
    res.send('reguser OK')
}
// 登录的处理函数
exports.login = (req, res) => {
    res.send('login OK')
}

⑵ 将 /router/user.js 中的代码修改为如下结构：

const express = require('express')
// 创建路由对象
const router = express.Router()
// 导入用户路由处理函数模块
const userHandler = require('../router_handler/user')


// 注册新用户
router.post('/reguser',userHandler.regUser)
// 登录
router.post('/login',userHandler.login)
// 将路由对象共享出去
module.exports = router

在这里插入图片描述

⑶ 启动服务测试一下项目的功能

在这里插入图片描述
请求：http://127.0.0.1:3007/api/reguser 测试注册的功能
在这里插入图片描述
请求http://127.0.0.1:3007/api/login测试登录功能
在这里插入图片描述

二、注册

1. 新建my_db_01数据库 和 ev_users表

在这里插入图片描述
在 my_db_01 数据库中，新建 ev_users 表如下：
在这里插入图片描述

脚本如下

/*
 Navicat Premium Data Transfer

 Source Server         : localhost_3306
 Source Server Type    : MySQL
 Source Server Version : 80026
 Source Host           : localhost:3306
 Source Schema         : my_db_01

 Target Server Type    : MySQL
 Target Server Version : 80026
 File Encoding         : 65001

 Date: 24/08/2024 22:22:04
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for ev_users
-- ----------------------------
DROP TABLE IF EXISTS `ev_users`;
CREATE TABLE `ev_users`  (
  `id` int(0) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `nickname` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `email` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `user_pic` text CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

2. 安装并配置 mysql 模块

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

⑴ 运行如下命令，安装 mysql 模块：

npm i mysql@2.18.1

在这里插入图片描述

⑵ 在项目根目录中新建 /db/index.js 文件，在此自定义模块中创建数据库的连接对象：

// 导入 mysql 模块
const mysql = require('mysql')
// 创建数据库连接对象
const db = mysql.createPool({
    host: '127.0.0.1',
    user: 'root',
    password: '123456',
    database: 'my_db_01',
})
// 向外共享 db 数据库连接对象
module.exports = db

在这里插入图片描述

3. 注册

⑴ 实现步骤

  1. 检测表单数据是否合法
  2. 检测用户名是否被占用
  3. 对密码进行加密处理
  4. 插入新用户

⑵ 检测表单数据是否合法

1) 在router_handle 中的user.js中编写判断用户名和密码是否为空的代码
// 接收表单数据
const userinfo = req.body
// 判断数据是否合法
if (!userinfo.username || !userinfo.password) {
    return res.send({ status: 1, message: '用户名或密码不能为空！' })
}

在这里插入图片描述

2) 启动服务测试一下项目的功能

在这里插入图片描述
请求：http://127.0.0.1:3007/api/reguser 测试注册的功能
在这里插入图片描述
在这里插入图片描述

⑶ 检测用户名是否被占用

1) 导入数据库操作模块：
//导入数据库操作模块：
const db = require('../db/index')
2) 定义 SQL 语句：
//定义 SQL 语句
const sql = `select * from ev_users where username=?`
3) 执行 SQL 语句并根据结果判断用户名是否被占用：
//执行 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) 启动服务测试一下项目的功能

在这里插入图片描述
请求：http://127.0.0.1:3007/api/reguser 测试注册的功能
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

⑷ 对密码进行加密处理

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

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

● 加密之后的密码，无法被逆向破解
● 同一明文密码多次加密，得到的加密结果各不相同，保证了安全性

1) 运行如下命令，安装指定版本的 bcryptjs ：
npm i bcryptjs@2.4.3

在这里插入图片描述

2) 在 /router_handler/user.js 中，导入 bcryptjs ：
//导入bcryptjs模块 
const bcrypt = require('bcryptjs')
3) 在注册用户的处理函数中，确认用户名可用之后，调用 bcrypt.hashSync(明文密码, 随机盐的长度) 方法，对用户的密码进行加密处理：
// 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
userinfo.password = bcrypt.hashSync(userinfo.password, 10)

在这里插入图片描述

完整代码如下：

//导入数据库操作模块：
const db = require('../db/index')
//导入bcryptjs模块 
const bcrypt = require('bcryptjs')
/**
* 在这里定义和用户相关的路由处理函数，供 /router/user.js 模块进行调用
*/
// 注册用户的处理函数
exports.regUser = (req, res) => {
    // 接收表单数据
    const userinfo = req.body
    // 判断数据是否合法
    if (!userinfo.username || !userinfo.password) {
        return res.send({ status: 1, message: '用户名或密码不能为空！' })
    }

    //定义 SQL 语句
    const sql = `select * from ev_users where username=?`
    //执行 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: '用户名被占用，请更换其他用户名！' })
        }
        // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
        console.log('userinfo.password：'+userinfo.password)
        userinfo.password = bcrypt.hashSync(userinfo.password,10)
        console.log('userinfo.password：'+userinfo.password)
        // TODO: 用户名可用，继续后续流程...
    })
}
// 登录的处理函数
exports.login = (req, res) => {
    res.send('login OK')
}
4) 启动服务测试一下项目的功能

*请求：http://127.0.0.1:3007/api/reguser 测试注册的功能
在这里插入图片描述
在这里插入图片描述

⑸ 插入新用户

1) 定义插入用户的 SQL 语句：
const sql = 'insert into ev_users set ?'
2) 调用 db.query() 执行 SQL 语句，插入新用户：
//调用 db.query() 执行 SQL 语句，插入新用户
db.query(sql, { username: userinfo.username, password: userinfo.password }, function (err, results) {
     // 执行 SQL 语句失败
     if (err) return res.send({ status: 1, message: err.message })
     // SQL 语句执行成功，但影响行数不为 1
     if (results.affectedRows !== 1) {
         return res.send({ status: 1, message: '注册用户失败，请稍后再试！' })
     }
     // 注册成功
     res.send({ status: 0, message: '注册成功！' })
 })

在这里插入图片描述
完整代码如下：

//导入数据库操作模块：
const db = require('../db/index')
//导入bcryptjs模块 
const bcrypt = require('bcryptjs')
/**
* 在这里定义和用户相关的路由处理函数，供 /router/user.js 模块进行调用
*/
// 注册用户的处理函数
exports.regUser = (req, res) => {
    // 接收表单数据
    const userinfo = req.body
    // 判断数据是否合法
    if (!userinfo.username || !userinfo.password) {
        return res.send({ status: 1, message: '用户名或密码不能为空！' })
    }

    //定义 SQL 语句
    const sql = `select * from ev_users where username=?`
    //执行 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: '用户名被占用，请更换其他用户名！' })
        }
        // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
        console.log('userinfo.password：' + userinfo.password)
        userinfo.password = bcrypt.hashSync(userinfo.password, 10)
        console.log('userinfo.password：' + userinfo.password)
        //如果用户名没有被占用，则将注册完的用户插入数据库中
        //定义插入用户的SQL
        const sql = 'insert into ev_users set ?'
        //调用 db.query() 执行 SQL 语句，插入新用户
        db.query(sql, { username: userinfo.username, password: userinfo.password }, function (err, results) {
            // 执行 SQL 语句失败
            if (err) return res.send({ status: 1, message: err.message })
            // SQL 语句执行成功，但影响行数不为 1
            if (results.affectedRows !== 1) {
                return res.send({ status: 1, message: '注册用户失败，请稍后再试！' })
            }
            // 注册成功
            res.send({ status: 0, message: '注册成功！' })
        })
    })
}
// 登录的处理函数
exports.login = (req, res) => {
    res.send('login OK')
}
3) 启动服务测试一下项目的功能

请求：http://127.0.0.1:3007/api/reguser 测试注册的功能

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

⑹ 优化 res.send() 代码

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

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

// 响应数据的中间件,一定要在路由封装之前，封装res.cc函数
app.use((req,res,next)=>{
    //status 默认值为1，表示失败的情况, status = 0 为成功
    //err的值，可能是一个错误的对象，也可能是一个错误的描述字符串
    res.cc = function(err,status = 1){
        res.send({
            // 状态
            status,
            // 状态描述，判断 err 是 错误对象 还是 字符串
            message:err instanceof Error ? err.message : err
        })
    }
    next()
})

完整代码如下：

// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// 导入 cors 中间件
const cors = require('cors')
// 将 cors 注册为全局中间件
app.use(cors())
//配置解析 application/x-www-form-urlencoded 格式的表单数据的中间件
app.use(express.urlencoded({ extended: false }))
// 响应数据的中间件,一定要在路由封装之前，封装res.cc函数
app.use((req,res,next)=>{
    //status 默认值为1，表示失败的情况, status = 0 为成功
    //err的值，可能是一个错误的对象，也可能是一个错误的描述字符串
    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 方法，指定端口号并启动web服务器
app.listen(3007, function () {
    console.log('api server running at http://127.0.0.1:3007')
})

将 /router_handler/user.js 中响应的send()方法都用中间件中的res.cc()替换

//导入数据库操作模块：
const db = require('../db/index')
//导入bcryptjs模块 
const bcrypt = require('bcryptjs')
/**
* 在这里定义和用户相关的路由处理函数，供 /router/user.js 模块进行调用
*/
// 注册用户的处理函数
exports.regUser = (req, res) => {
    // 接收表单数据
    const userinfo = req.body
    // 判断数据是否合法
    if (!userinfo.username || !userinfo.password) {
        // return res.send({ status: 1, message: '用户名或密码不能为空！' })
        return res.cc('用户名或密码不能为空！');
    }

    //定义 SQL 语句
    const sql = `select * from ev_users where username=?`
    //执行 SQL 语句并根据结果判断用户名是否被占用
    db.query(sql, [userinfo.username], function (err, results) {
        // 执行 SQL 语句失败
        if (err) {
            //return res.send({ status: 1, message: err.message })
            return res.cc(err);
        }
        // 用户名被占用
        if (results.length > 0) {
            // return res.send({ status: 1, message: '用户名被占用，请更换其他用户名！' })
            return res.cc('用户名被占用，请更换其他用户名！');
        }
        // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
        console.log('userinfo.password：' + userinfo.password)
        userinfo.password = bcrypt.hashSync(userinfo.password, 10)
        console.log('userinfo.password：' + userinfo.password)
        //如果用户名没有被占用，则将注册完的用户插入数据库中
        //定义插入用户的SQL
        const sql = 'insert into ev_users set ?'
        //调用 db.query() 执行 SQL 语句，插入新用户
        db.query(sql, { username: userinfo.username, password: userinfo.password }, function (err, results) {
            // 执行 SQL 语句失败
            // if (err) return res.send({ status: 1, message: err.message })
            if (err) return res.cc(err)
            // SQL 语句执行成功，但影响行数不为 1
            if (results.affectedRows !== 1) {
                // return res.send({ status: 1, message: '注册用户失败，请稍后再试！' })
                return res.cc('注册用户失败，请稍后再试！');
            }
            // 注册成功
            // res.send({ status: 0, message: '注册成功！' })
            res.cc(0, '注册成功！');
        })
    })
}
// 登录的处理函数
exports.login = (req, res) => {
    res.send('login OK')
}

启动服务测试一下项目的功能

请求：http://127.0.0.1:3007/api/reguser 测试注册的功能

在这里插入图片描述
在这里插入图片描述

⑺ 优化表单数据验证

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

在这里插入图片描述

1) 安装 @escook/express-joi 中间件，来实现自动对表单数据进行验证的功能：
npm i @escook/express-joi

在这里插入图片描述

2) 安装 @hapi/joi 包，为表单中携带的每个数据项，定义验证规则：
npm install @hapi/joi@17.1.0

在这里插入图片描述

3) 新建 /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,
    },
}
4) 修改 /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('/reguser', expressJoi(reg_login_schema), userHandler.regUser)
// 登录
router.post('/login',userHandler.login)
// 将路由对象共享出去
module.exports = router

在这里插入图片描述

5) 在app.js的全局错误级别中间件中，捕获验证失败的错误，并把验证失败的结果响应给客户端：
const joi = require('@hapi/joi')
// 错误中间件
app.use(function (err, req, res, next) {
    // 数据验证失败
    if (err instanceof joi.ValidationError) return res.cc(err)
    // 未知错误
    res.cc(err)
})

在这里插入图片描述

6) 启动服务测试一下项目的功能

请求：http://127.0.0.1:3007/api/reguser 测试注册的功能
在这里插入图片描述
点击下载完整代码

三、 登录

1. 实现步骤

  1. 检测表单数据是否合法
  2. 根据用户名查询用户的数据
  3. 判断用户输入的密码是否正确
  4. 生成 JWT 的 Token 字符串

2. 检测登录表单的数据是否合法

将 /router/user.js 中 登录 的路由代码修改如下：

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

在这里插入图片描述

3. 根据用户名查询用户的数据

⑴ 接收表单数据：

const userinfo = req.body

⑵ 定义 SQL 语句：

const sql = `select * from ev_users where username=?`

⑶ 执行 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：判断用户输入的登录密码是否和数据库中的密码一致
})

在这里插入图片描述

⑷ 启动服务测试一下项目的功能

请求：http://127.0.0.1:3007/api/login 测试注册的功能

在这里插入图片描述
在这里插入图片描述

4. 判断用户输入的密码是否正确

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

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

具体的实现代码如下：

// 拿着用户输入的密码,和数据库中存储的密码进行对比
const compareResult = bcrypt.compareSync(userinfo.password, results[0].password)
// 如果对比的结果等于 false, 则证明用户输入的密码错误
if (!compareResult) {
    console.log('登录失败');
    return res.cc( '登录失败!');
}

在这里插入图片描述

5. 生成 JWT 的 Token 字符串

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

⑴ 通过 ES6 的高级语法，快速剔除 密码 和 头像 的值：

// 剔除完毕之后，user 中只保留了用户的 id, username, nickname, email 这四个属性的值
const user = { ...results[0], password: '', user_pic: '' }

在这里插入图片描述

在这里插入图片描述

⑵ 运行如下的命令，安装生成 Token 字符串的包：

npm i jsonwebtoken@8.5.1

在这里插入图片描述

⑶ 在 /router_handler/user.js 模块的头部区域，导入 jsonwebtoken 包：

// 用这个包来生成 Token 字符串
const jwt = require('jsonwebtoken')

⑷ 创建 config.js 文件，并向外共享 加密 和 还原 Token 的 jwtSecretKey 字符串：

//这是全局的配置文件
module.exports = {
    //设置加密和解密的token密钥
    jwtSecretKey: 'kejizhentan No1. ^_^',
}

在这里插入图片描述

⑸ 在 /router_handler/user.js 中将用户信息对象加密成 Token 字符串：

// 导入全局的配置文件
const config = require('../config')
// 生成 Token 字符串
const tokenStr = jwt.sign(user, config.jwtSecretKey, {
     expiresIn: '10h', // token 有效期为 10 个小时
 })

⑹ 在 /router_handler/user.js 中将生成的 Token 字符串响应给客户端：

res.send({
   status: 0,
    message: '登录成功！',
    // 为了方便客户端使用 Token，在服务器端直接拼接上 Bearer 的前缀
    token: 'Bearer ' + tokenStr,
})

⑺ /router_handler/user.js 完整代码

//导入数据库操作模块：
const db = require('../db/index')
//导入bcryptjs模块 
const bcrypt = require('bcryptjs')
// 用这个包来生成 Token 字符串
const jwt = require('jsonwebtoken')
// 导入配置文件
const config = require('../config')
/**
* 在这里定义和用户相关的路由处理函数，供 /router/user.js 模块进行调用
*/
// 注册用户的处理函数
exports.regUser = (req, res) => {
    // 接收表单数据
    const userinfo = req.body
    // 判断数据是否合法
    /**if (!userinfo.username || !userinfo.password) {
        // return res.send({ status: 1, message: '用户名或密码不能为空！' })
        return res.cc('用户名或密码不能为空！');
    }*/

    //定义 SQL 语句
    const sql = `select * from ev_users where username=?`
    //执行 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: '用户名被占用，请更换其他用户名！' })
            return res.cc('用户名被占用，请更换其他用户名！');
        }

        // 对用户的密码,进行 bcrype 加密，返回值是加密之后的密码字符串
        console.log('userinfo.password：' + userinfo.password)
        userinfo.password = bcrypt.hashSync(userinfo.password, 10)
        console.log('userinfo.password：' + userinfo.password)
        //如果用户名没有被占用，则将注册完的用户插入数据库中
        //定义插入用户的SQL
        const sql = 'insert into ev_users set ?'
        //调用 db.query() 执行 SQL 语句，插入新用户
        db.query(sql, { username: userinfo.username, password: userinfo.password }, function (err, results) {
            // 执行 SQL 语句失败
            // if (err) return res.send({ status: 1, message: err.message })
            if (err) return res.cc(err)
            // SQL 语句执行成功，但影响行数不为 1
            if (results.affectedRows !== 1) {
                // return res.send({ status: 1, message: '注册用户失败，请稍后再试！' })
                return res.cc('注册用户失败，请稍后再试！');
            }
            // 注册成功
            // res.send({ status: 0, message: '注册成功！' })
            res.cc(0, '注册成功！');
        })
    })
}
// 登录的处理函数
exports.login = (req, res) => {
    const userinfo = req.body
    const sql = `select * from ev_users where 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('登录失败！')
        // 拿着用户输入的密码,和数据库中存储的密码进行对比
        const compareResult = bcrypt.compareSync(userinfo.password, results[0].password)
        // 如果对比的结果等于 false, 则证明用户输入的密码错误
        if (!compareResult) {
            console.log('登录失败');
            return res.cc('登录失败!');
        }
        // 剔除完毕之后，user 中只保留了用户的 id, username, nickname, email 这四个属性的值
        const user = { ...results[0], password: '', user_pic: '' }
        // 对用户的信息进行加密，生成 Token 字符串
        const tokenStr = jwt.sign(user, config.jwtSecretKey, {
            expiresIn: '10h', // token 有效期为 10 个小时
        })
        res.send({
            status: 0,
            message: '登录成功！',
            // 为了方便客户端使用 Token，在服务器端直接拼接上 Bearer 的前缀
            token: 'Bearer ' + tokenStr,
        })
    })
}

⑻ 启动服务测试一下项目的功能

在这里插入图片描述
在这里插入图片描述

6. 配置解析 Token 的中间件

⑴ 运行如下的命令，安装解析 Token 的中间件：

npm i express-jwt@5.3.3

在这里插入图片描述

⑵ 在 app.js 中注册路由之前，配置解析 Token 的中间件：

//一定要在路由之前配置解析token的中间件
// 导入配置文件
const config = require('./config')
// 解析 token 的中间件
const expressJWT = require('express-jwt')
// 使用 .unless({ path: [/^\/api\//] }) 指定哪些接口不需要进行 Token 的身份认证
app.use(expressJWT({ secret: config.jwtSecretKey }).unless({ path: [/^\/api\//] }))

在这里插入图片描述

⑶ 在 app.js 中的 错误级别中间件 里面，捕获并处理 Token 认证失败后的错误：

// 错误中间件
app.use(function (err, req, res, next) {
    //省略其它代码...
    // 捕获身份认证失败的错误
    if (err.name === 'UnauthorizedError') return res.cc('身份认证失败！')
    // 未知错误...
})

完整代码如下：

// 导入 express
const express = require('express')
// 创建服务器的实例对象
const app = express()
const joi = require('@hapi/joi')

// 导入并配置 cors 中间件
const cors = require('cors')
// 将 cors 注册为全局中间件
app.use(cors())

// 配置解析表单数据的中间件，注意：这个中间件，只能解析 application/x-www-form-urlencoded 格式的表单数据
app.use(express.urlencoded({ extended: false }))

// 一定要在路由之前，封装 res.cc 函数
app.use((req, res, next) => {
  // status 默认值为 1，表示失败的情况
  // err 的值，可能是一个错误对象，也可能是一个错误的描述字符串
  res.cc = function (err, status = 1) {
    res.send({
      status,
      message: err instanceof Error ? err.message : err,
    })
  }
  next()
})

// 一定要在路由之前配置解析 Token 的中间件
const expressJWT = require('express-jwt')
const config = require('./config')

app.use(expressJWT({ secret: config.jwtSecretKey }).unless({ path: [/^\/api/] }))

// 导入并使用用户路由模块
const userRouter = require('./router/user')
app.use('/api', userRouter)

// 定义错误级别的中间件
app.use((err, req, res, next) => {
  // 验证失败导致的错误
  if (err instanceof joi.ValidationError) return res.cc(err)
  // 身份认证失败后的错误
  if (err.name === 'UnauthorizedError') return res.cc('身份认证失败！')
  // 未知的错误
  res.cc(err)
})

// 启动服务器
app.listen(3007, () => {
  console.log('api server running at http://127.0.0.1:3007')
})

⑷ 启动服务测试一下项目的功能

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
点击获取完整代码

四、个人中心

1.获取用户的基本信息

⑴ 实现步骤

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

⑵ 初始化路由模块

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)

在这里插入图片描述

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

1) 创建 /router_handler/userinfo.js 路由处理函数模块，并初始化如下的代码结构：
// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
    res.send('ok')
}

在这里插入图片描述

2) 修改 /router/userinfo.js 中的代码如下：
// 导入 express
const express = require('express')
// 创建路由对象
const router = express.Router()
// 导入用户信息的处理函数模块
const userinfo_handler = require('../router_handler/userinfo')
// 获取用户的基本信息
router.get('/userinfo',userinfo_handler.getUserInfo)
// 向外共享路由对象
module.exports = router

在这里插入图片描述

⑷ 获取用户的基本信息

1) 在 /router_handler/userinfo.js 头部导入数据库操作模块：
// 导入数据库操作模块
const db = require('../db/index')

在这里插入图片描述

2) 定义 SQL 语句：
// 根据用户的 id，查询用户的基本信息
// 注意：为了防止用户的密码泄露，需要排除 password 字段
const sql = `select id, username, nickname, email, user_pic from ev_users where id=?`
3) 调用 db.query() 执行 SQL 语句：
// 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
db.query(sql, req.user.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],
    })
})

在这里插入图片描述

4) 启动服务测试一下项目的功能

在这里插入图片描述
在这里插入图片描述

2. 更新用户的基本信息

⑴ 实现步骤

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

⑵ 定义路由和处理函数

1) 在/router/userinfo.js模块中，新增 更新用户基本信息 的路由：
// 更新用户的基本信息
router.post('/userinfo', userinfo_handler.updateUserInfo)

在这里插入图片描述

2) 在 /router_handler/userinfo.js 模块中，定义并向外共享 更新用户基本信息 的路由处理函数：
// 更新用户基本信息的处理函数
exports.updateUserInfo = (req, res) => {
    res.send('ok')
}

⑶ 验证表单数据

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 模块中，修改 更新用户的基本信息 的路由如下：
// 更新用户的基本信息
router.post('/userinfo', expressJoi(update_userinfo_schema),
    userinfo_handler.updateUserInfo)

在这里插入图片描述

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

1) 定义待执行的 SQL 语句：
const sql = `update ev_users set ? where id=?`
2) 调用 db.query() 执行 SQL 语句并传参：
// 更新用户基本信息的处理函数
exports.updateUserInfo = (req, res) => {
    const sql = `update ev_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)
    })
}

在这里插入图片描述

3) 启动服务测试一下项目的功能

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3. 重置密码

⑴ 实现步骤

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

⑵ 定义路由和处理函数

1) 在/router/userinfo.js模块中，新增 重置密码 的路由：
// 重置密码的路由
router.post('/updatepwd', userinfo_handler.updatePassword)
2) 在 /router_handler/userinfo.js 模块中，定义并向外共享 重置密码 的路由处理函数：
// 重置密码的处理函数
exports.updatePassword = (req, res) => {
    res.send('ok')
}

在这里插入图片描述

⑶ 验证表单数据

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

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)

⑷ 在/router_handler/userinfo.js 模块中 实现重置密码的功能

1) 根据 id 查询用户是否存在：
// 定义根据 id 查询用户数据的 SQL 语句
const querySql = `select * from ev_users where id=?`
// 执行 SQL 语句查询用户是否存在
db.query(querySql, req.user.id, (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err)
    // 检查指定 id 的用户是否存在
    if (results.length !== 1) return res.cc('用户不存在！')
    // 判断提交的旧密码是否正确
    const compareResult = bcrypt.compareSync(req.body.oldPwd, results[0].password)
    if (!compareResult) return res.cc('原密码错误！')
})
2)判断提交的 旧密码 是否正确：
// 在头部区域导入 bcryptjs 后，
// 即可使用 bcrypt.compareSync(提交的密码，数据库中的密码) 方法验证密码是否正确
// compareSync() 函数的返回值为布尔值，true 表示密码正确，false 表示密码错误
const bcrypt = require('bcryptjs')

// 判断提交的旧密码是否正确
const compareResult = bcrypt.compareSync(req.body.oldPwd, results[0].password)
if (!compareResult) return res.cc('原密码错误！')
3)对新密码进行bcrypt加密之后，更新到数据库中：
// 定义更新用户密码的 SQL 语句
const updateSql = `update ev_users set password=? where id=?`
// 对新密码进行 bcrypt 加密处理
const newPwd = bcrypt.hashSync(req.body.newPwd, 10)
// 执行 SQL 语句，根据 id 更新用户的密码
db.query(updateSql, [newPwd, req.user.id], (err, results) => {
    // SQL 语句执行失败
    if (err) return res.cc(err)
    // SQL 语句执行成功，但是影响行数不等于 1
    if (results.affectedRows !== 1) return res.cc('更新密码失败！')
    // 更新密码成功
    res.cc('更新密码成功！', 0)
})

/router_handler/userinfo.js 模块中完整代码如下：

// 导入数据库操作模块
const db = require('../db/index')
// 在头部区域导入 bcryptjs 后，
// 即可使用 bcrypt.compareSync(提交的密码，数据库中的密码) 方法验证密码是否正确
// compareSync() 函数的返回值为布尔值，true 表示密码正确，false 表示密码错误
const bcrypt = require('bcryptjs')
// 获取用户基本信息的处理函数
exports.getUserInfo = (req, res) => {
    // 根据用户的 id，查询用户的基本信息
    // 注意：为了防止用户的密码泄露，需要排除 password 字段
    const sql = `select id, username, nickname, email, user_pic from ev_users where id=?`
    // 注意：req 对象上的 user 属性，是 Token 解析成功，express-jwt 中间件帮我们挂载上去的
    db.query(sql, req.user.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],
        })
    })
}

// 更新用户基本信息的处理函数
exports.updateUserInfo = (req, res) => {
    const sql = `update ev_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 查询用户的信息
    const sql = `select * from ev_users where id=?`
    // 执行根据 id 查询用户的信息的 SQL 语句
    db.query(sql, req.user.id, (err, results) => {
      // 执行 SQL 语句失败
      if (err) return res.cc(err)
      // 判断结果是否存在
      if (results.length !== 1) return res.cc('用户不存在！')
  
      // 判断密码是否正确
      const compareResult = bcrypt.compareSync(req.body.oldPwd, results[0].password)
      if (!compareResult) return res.cc('旧密码错误！')
  
      // 定义更新密码的 SQL 语句
      const sql = `update ev_users set password=? where id=?`
      // 对新密码进行加密处理
      const newPwd = bcrypt.hashSync(req.body.newPwd, 10)
      // 调用 db.query() 执行 SQL 语句
      db.query(sql, [newPwd, req.user.id], (err, results) => {
        // 执行 SQL 语句失败
        if (err) return res.cc(err)
        // 判断影响的行数
        if (results.affectedRows !== 1) return res.cc('更新密码失败！')
        // 成功
        res.cc('更新密码成功', 0)
      })
    })
  }
4) 启动服务测试一下项目的功能

在这里插入图片描述
在这里插入图片描述

4. 更新用户头像

⑴ 实现步骤

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

⑵ 定义路由和处理函数

1) 在/router/userinfo.js 模块中，新增 更新用户头像 的路由：
// 更新用户头像的路由
router.post('/update/avatar', userinfo_handler.updateAvatar)
2)在 /router_handler/userinfo.js 模块中，定义并向外共享 更新用户头像 的路由处理函数：
// 更新用户头像的处理函数
exports.updateAvatar = (req, res) => {
    res.send('ok')
}

⑶ 验证表单数据

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)

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

1) 定义更新用户头像的 SQL 语句：
const sql = 'update ev_users set user_pic=? where id=?'
2) 调用 db.query() 执行 SQL 语句，更新对应用户的头像：
// 更新用户头像的处理函数
exports.updateAvatar = (req, res) => {
  // 1. 定义更新头像的 SQL 语句
  const sql = `update ev_users set user_pic=? where id=?`
  // 2. 调用 db.query() 执行 SQL 语句
  db.query(sql, [req.body.avatar, req.user.id], (err, results) => {
    // 执行 SQL 语句失败
    if (err) return res.cc(err)
    // 影响的行数是否等于 1
    if (results.affectedRows !== 1) return res.cc('更换头像失败！')
    // 成功
    res.cc('更换头像成功！', 0)
  })
}
3) 启动服务测试一下项目的功能

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2074127.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

企业级WEB应用服务器TOMCAT详解

企业级WEB应用服务器TOMCAT详解

一、什么是TOMCAT 1.1来源 Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成。由于有了Sun 的参与和支持，最新的Servlet 和JSP 规范总是能…
阅读更多...
A Neural Probabilistic Language Model

A Neural Probabilistic Language Model

摘要 统计语言建模的一个目标是学习单词序列的联合概率函数。由于维度的诅咒，这在本质上是困难的:我们建议用它自己的武器来对抗它。在提出的方法中，人们同时学习(1)每个单词的分布式表示（词向量）(即单词之间的相似性)以及(2)表示…
阅读更多...
TypeScript 类型注解（二）

TypeScript 类型注解（二）

一、TypeScript类型约束--对象 对象其实和数组类似，不是限制对象本身的类型，而是对对象属性类型进行限制 结构简化： 对对象做类型限制的好处： 大家都学习过一段时间编程了，会发现咱们经常操作的类型就是对象&#xf…
阅读更多...
使用miniconda构建数据科学环境

使用miniconda构建数据科学环境

背景 数据科学中，不同时期项目代码往往是由不同的版本的python和第三方数据科学包构建，这些不同版本往往会存在兼容性问题，要运行这些代码，需要管理不同的版本的安装包。Conda是一个开源的包管理和环境管理系统，环境管…
阅读更多...
Linux | 编译和使用自定义动静态库的全面解析

Linux | 编译和使用自定义动静态库的全面解析

新竹高于旧竹枝，全凭老干为扶持。 - 《新竹》(郑燮) 2024.8.25 目录 1、静态库和动态库简介 静态库（.a）： 动态库（.so）： 动态库和静态库的比较： 2、静态库的生成和使用&#xff…
阅读更多...
GCB | 首次揭示！气候变化对常绿和落叶植物物候差异化影响的机制

GCB | 首次揭示！气候变化对常绿和落叶植物物候差异化影响的机制

气候变化引起的植物物候改变已对全球范围内生物多样性和生态系统产生重大影响（Nature高引文章 | 北京大学朴世龙院士等：全球变暖对植被物候的影响及其机制；Nature Ecology & Evolution | 南京大学张永光教授团队揭示延长的植被物候期受CO…
阅读更多...
set容器的所有操作

set容器的所有操作

1.基本概念 2.构造和赋值 3.大小和交换 4.插入和删除 5.查找和统计 6.set和multiset的区别 7.pair对组创建 用p.first和p.second调用前后两个属性。 8.仿函数实现降序排列 自定义数据类型也一样用仿函数：
阅读更多...
【领域驱动设计 打通DDD最小闭环】领域建模

【领域驱动设计 打通DDD最小闭环】领域建模

本篇BLOG为DDD流程的第二步，在模型的建立阶段，领域专家与技术人员通过领域建模来完成更为细致的模型建立讨论 领域建模的目的 领域建模主要有两个目的： 将知识可视化，准确、深刻地反映领域知识，并且在业务和技术人…
阅读更多...
Python优化算法14——海鸥优化算法(SOA)

Python优化算法14——海鸥优化算法(SOA)

科研里面优化算法都用的多，尤其是各种动物园里面的智能仿生优化算法，但是目前都是MATLAB的代码多，python几乎没有什么包，这次把优化算法系列的代码都从底层手写开始。 需要看以前的优化算法文章可以参考：Python优化算…
阅读更多...
【图文并茂】ant design pro 如何给后端发送 json web token - 请求拦截器的使用

【图文并茂】ant design pro 如何给后端发送 json web token - 请求拦截器的使用

上一节有讲过 【图文并茂】ant design pro 如何对接后端个人信息接口 还差一个东西，去获取个人信息的时候，是要发送 token 的，不然会报 403. 就是说在你登录之后才去获得个人信息。这样后端才能知道是谁的信息。 token 就代码了某个人。 …
阅读更多...
工作实战-项目压测记录

工作实战-项目压测记录

1-1-1每分钟的单量 1-1-2第二版测试 2022年5月16日 17:43:11 成功 失败 其它(nginx) 真实入库单量 总单量 52 1 447 500 2022年5月16日 19:42:18 成功 失败 其它(nginx) 真实入库单量 总单量 311 689 306 1000 2-0-1. 20线程-2000单执行结果 2-1-0. 40线…
阅读更多...
金融科技 API 接口：提升金融服务效率的关键

金融科技 API 接口：提升金融服务效率的关键

金融科技是应用技术手段和创新理念来提升金融服务效率的重要途径。而其中的API接口则是实现金融科技的关键。API接口的简单定义是提供计算机程序之间通信的规范和工具，提供一种方法和数据的交互形式，以便开发人员能够利用现有的软件来创建新的应用和服务…
阅读更多...
前端网格布局display: grid；

前端网格布局display: grid；

display: grid; 块级网格 （常用） display: inline-grid; 行内块级网格 （一般不用） HTML 元素将 display 属性设置为 grid 或 inline-grid 后，它就变成了一个网格容器，这个元素的所有直系子元素将…
阅读更多...
Mobile-Agent项目部署与学习总结（DataWhale AI夏令营）

Mobile-Agent项目部署与学习总结（DataWhale AI夏令营）

前言 你好，我是GISer Liu，一名热爱AI技术的GIS开发者，本文是DataWhale 2024 AI夏令营的最后一期——Mobile-Agent赛道，这是作者的学习文档，这里总结一下，和作者一起学习这个多模态大模型新项目吧&#x1f6…
阅读更多...
开放式耳机对耳朵的伤害会减小吗？亲测好用的四款蓝牙耳机

开放式耳机对耳朵的伤害会减小吗？亲测好用的四款蓝牙耳机

开放式耳机对耳朵的伤害相对较小。 首先，开放式耳机不入耳，不会直接堵塞耳道，减少了对耳道的挤压和摩擦，降低了因长期佩戴入耳式耳机可能导致的耳道发炎、疼痛等问题。 其次，由于耳朵没有被完全封闭，耳部能…
阅读更多...
【C/C++】结构体指针赋值的方法

【C/C++】结构体指针赋值的方法

在C语言中，结构体指针赋值有两种方法： 1.使用"->"操作符：通过结构体指针访问结构体成员并赋值。例如： struct Student {int id;char name[20]; };int main() {struct Student s1;struct Student *ptr_s1 &s1;…
阅读更多...
设计模式学习[4]---依赖倒置原则+里氏代换原则

设计模式学习[4]---依赖倒置原则+里氏代换原则

文章目录 前言1. 依赖倒置原则1.1 原理阐述1.2 举例 2.里氏代换原则2.1 原理阐述2.2 举例说明 总结 前言 在给发新功能模块之前，都先要画UML类图进行需求分析。对每一个类的作用，类与类之间的关系做一个详细的阐述。确定好基本的框架之后，才…
阅读更多...
Lumos学习王佩丰Excel第十四讲：日期函数

Lumos学习王佩丰Excel第十四讲：日期函数

一、认识时间和日期 1、回顾日期格式 日期可以由数字表示。 2、时间格式 时间由小数表示。 3、基本的时间与日期运算 二、日期函数 1、Year、Month、Day函数 2、Date函数 DATE(year,month,day）：year为必需参数，可以包含1到4个数字。Day函…
阅读更多...
LeetCode 热题 100 回顾

LeetCode 热题 100 回顾

目录 一、哈希部分 1.两数之和 （简单） 2.字母异位词分组 （中等） 3.最长连续序列 （中等） 二、双指针部分 4.移动零 （简单） 5.盛最多水的容器 （中等） 6…
阅读更多...
文心一言 VS 讯飞星火 VS chatgpt （332）-- 算法导论23.1 1题

文心一言 VS 讯飞星火 VS chatgpt （332）-- 算法导论23.1 1题

一、设(u,v)是连通图G中的一条权重最小的边，证明：边(u,v)为图G的某棵最小生成树中的一条边。如果要写代码，请用go语言。 文心一言： 为了证明边(u,v)是图G的某棵最小生成树中的一条边，我们可以使用反证法结合最小生成…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023