• Express笔记

     1. 简介

    1.1 概念

    Express是一个简介灵活的node.js web应用框架，提供了一系列强大特性 帮助创建各种web应用，和丰富的工具。使用Express可以快速搭建一个完整功能的网站

    1.2 本质

    对之前的内置模块http进行了封装，使用更方便

    1.3 核心

    可以设置中间件来响应HTTP请求

    定义了路由表用于执行不同的HTTP请求动作

    1.4* 核心概念

    路由：根据不同url路径，调用后台不同的处理函数

    中间件：从请求开始到响应结束这个业务流程中的所有处理环节

    2. 安装使用

    2.1 express安装

    新建英文目录（目录名不以express开头）

    进入目录 初始化（地址栏输入打开cmd：npm init -y）

    在此处安装express（npm i express）

    2.2 使用

    新建js文件，编写代码

    执行代码： node .\demo.js

    1. //1. 导入express包
    2. const express = require("express");
    3. const path = require("path");
    4. //2. 实例化对象
    5. const app = express()
    6. //3. 处理请求
    7. app.get("/", function(req,res) {
    8.     //end原生。发字符串，send什么都能发
    9.     //res.sendFile(path.join(__dirname, "../file/news.html"))
    10.   	res.send("
      Hello
      "      );
    11. })
    12. app.get("*", function(req,res) {
    13.     res.send("其它路径！")
    14. })
    15. //4. 设置端口
    16. app.listen(3000, () => {console.log("访问地址：http://localhost:3000");})

    2.3 express集成nodemon

    1. 修改package.json的script脚本

            "dev": "nodemon src/index.js"

    2. 使用 npm run dev 执行代码

    2.4 区别（对比http创建web服务）

    不需要处理乱码问题

    不需要判断请求方式

    2.5 res.send()与res.end()

    end：原生http模块方法 express也支持。只能传字符串，不能处理乱码问题

    send：express中封装的方法。可以传任何类型，可以处理乱码问题

    3. Express路由

    3.1 概念

    根据不同url路径，调用后台不同的处理函数

    3.2 语法

    app.请求方式(访问路径, 处理函数)

            请求方式：get，post，put，delete

            访问路径：也可以正则（ * 通配符）

            处理函数：匿名函数，匹配未列举的路径

    3.3 注意事项

    匹配顺序：从上到下 ↓

    请求方式和访问路径同时匹配成功，express会将请求转移到对应的处理函数处理

    4. 跨域请求问题

    从一个请求跳到另外一个请求，协议/域名/端口 只要有一个不同，即为跨域请求

    解决： res.setHeader('Access-Control-Allow-Origin','*') //允许跨域请求

    5. Express增删改查

    5.1 查询 app.get()

    查询所有 http://localhost:3000/users            后台: /users 直接返回数组

    查询一个 http://localhost:3000/users?id=1   后台: /users 通过req.query获取参数

    查询一个 http://localhost:3000/users/1         后台 /users/:id 通过req.params获取参数

    5.2 新增 app.post()

    前台

    http://localhost:3000/users application/json {"name":"赵六","age":26}

    后台

            获取请求体数据

            设置新增用户的id

            把新增的用户添加到数组

    5.3 修改 app.put()

    前台

    http://localhost:3000/users/1 application/json {"name":"赵六","age":26}

    后台

            获取要修改元素的id

            获取请求体数据

            查找id相同的元素进行修改

    5.4 删除 app.delete()

    前台

    http://localhost:3000/users/1

    后台

            获取要修改元素的id

            查找id相同的元素进行删除

    🟢 代码

    1. //1. 引入模块
    2. const express = require("express");
    3. //2. 创建server服务
    4. const app = express();
    5.  
    6. const db = [
    7.     {id:1, name:"张三", age:23},
    8.     {id:2, name:"李四", age:24},
    9. ]
    10. //3. 处理请求
    11. //查全部
    12. app.get("/users", function(req, res) {
    13.     //解决跨域请求
    14.     res.setHeader("Access-Control-Allow-Origin", "*")
    15.     res.send(db);
    16. })
    17. //查一个query
    18. app.get("/users", function(req, res) {
    19.     //解决跨域请求
    20.     res.setHeader("Access-Control-Allow-Origin", "*")
    21.     //获取id
    22.     db.forEach(item => {
    23.         if (item.id == req.query.id){
    24.             res.send(item);
    25.         }
    26.     });
    27. })
    28. //查一个params
    29. app.get("/users/:id", function(req, res) {
    30.     //解决跨域请求
    31.     res.setHeader("Access-Control-Allow-Origin", "*")
    32.     //获取id
    33.     db.forEach(item => {
    34.         if(item.id == req.params.id){
    35.             res.send(item);
    36.         }
    37.     })
    38. })
    39.  
    40. //增
    41. app.post("/users", function(req, res) {
    42.     //解决跨域请求
    43.     res.setHeader("Access-Control-Allow-Origin", "*")
    44.     let postData = "";
    45.     req.on("data", data => postData += data)
    46.     req.on("end", () => {
    47.         let item = JSON.parse(postData);
    48.         item.id = db.length + 1;
    49.         db.push(item);
    50.         res.send(db)
    51.     })
    52. })
    53. //删
    54. app.delete("/users/:id", function(req,res) {
    55.     //解决跨域请求
    56.     res.setHeader("Access-Control-Allow-Origin", "*")
    57.     db.forEach((item, index) => {
    58.         if (item.id == req.params.id) {
    59.             db.splice(index, 1)
    60.         }
    61.     })
    62.     res.send(db)
    63. })
    64. //改
    65. app.put("/users/:id", function(req, res) {
    66.     //解决跨域请求
    67.     res.setHeader("Access-Control-Allow-Origin", "*")
    68.     let getData = "";
    69.     req.on("data", data => getData += data)
    70.     req.on("end", () => {
    71.         db.forEach(item => {
    72.             let user = JSON.parse(getData); //?？
    73.             if (item.id == req.params.id) {
    74.                 item.name = user.name;
    75.                 item.age = user.age;
    76.             }
    77.         })
    78.         res.send(db)
    79.     })
    80. })
    81. //4. 设置端口
    82. app.listen(3000, () => { console.log(" http://localhost:3000"); })

    6. 中间件

    6.1 抽取及中间件简化

    中间件函数

    概念（middieWare）

            指业务流程的中间处理环节，本质是一个function处理函数

    调用流程

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

    分类

            按作用范围

                    局部生效中间件

                    全局生效中间件

            按级别分

                    express内置中间件

                    第三方 如：处理跨域请求

                            应用级中间件

                            路由级中间件

    注意

            中间件函数形参列表中必须含next参数，与路由处理函数不同（路由只包含req、res）

            next作用：实现多个中间件连续调用，把流转关系移交到下一个中间件 或 处理函数。（接力棒）

    6.2 中间件的范围划分

    局部生效中间件

    概念：只在某些访问路径中使用

    举例：getPostData中间件，只在新增与修改 的路由中生效，处理请求时要将中间件函数名写在参数中

    1. // 定义中间件函数m1
    2. const m1 = function(req,res,next){
    3.   console.log('这是中间件m1');
    4.   next()  // 以next结尾
    5. }
    6. app.get("/index", m1, m2, function(req, res) {}) //连用中间件

    注意

            要在路由前注册中间件

            客户端发来的请求，可以连续调用多个中间件处理

            执行完中间件业务代码后，务必调用next()！

            防止代码逻辑混乱，以next()结尾

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

    全局生效中间件

            概念：客户端发起的任何请求，到达服务器都会触发的中间件

            使用：使用app.use(中间件函数) 来定义全局中间件

    6.3 🟡中间件的级别划分

    内置中间件

    概念：由express官方提供，常见3个

    分类：

            express.json 解析json格式的请求体数据

            express.urlencoded 解析url-encode格式的请求体数据

            express.static 快速托管静态资源，可以帮助加载html文件、css样式、图片

    使用：

            app.use(express.json())

            app.use(express.urlencoded())

            app.use(express.static(path.join(__dirname,"../../file/")))

            引入内置中间件：注册托管静态资源的中间件 将在file文件夹下的静态进行托管

            效果： http://localhost:3000/new.html 可以直接加载

            index.html不必输入文件名 http://localhost:3000

    第三方中间件

            概念：第三方个人/团队开发，使用前需下载

            分类：cors() 处理跨域请求

    使用

            下载：npm i cors

            导包：const cors = require("cors")

            引入：app.use(cors())

    原理：每个响应中添加响应头

    应用级中间件

            概念：通过app.use() app.get() app.post()绑定到app实例上的

            注意：应用及中间件，可以全局可以局部，但都要绑定到app实例上

    路由级中间件

            概念：绑定到路由对象（express.router()创建的）中间件

            注意：路由级中间件用处不是很多，了解

    6.4 🟢模块化路由

    产生的原因

            1. 路由很多时，若全都卸载app入口文件，文件太大不好维护

            2. 项目中有不同类型的请求路径（用户相关，商品相关），都放在一个文件中不好维护

            3. 为了便于对路由进行模块化管理，express不建议将路由直接挂在在app上（建议将路由抽成单独模块）

    使用步骤

            1. 创建路由模块对应的js文件，放在routes文件夹下

            2. 调用express.router()创建路由器对象

            3. 向路由对象挂载具体路由

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

            5. 在入口文件中使用app.use() 注册路由模块

    代码

            调用 http://localhost:3000/goods/list

    1. //导入express包
    2. const express = require("express");
    3.  
    4. //实例化express对象
    5. const app = express()
    6.  
    7. //导入路由模块
    8. const goodsRouter = require("../routes/goods");
    9. const usersRouter = require("../routes/users");
    10.  
    11. //注册各个路由模块
    12. app.use("/goods", goodsRouter)
    13. app.use("/users", usersRouter)
    14.  
    15. //设置监听端口
    16. app.listen(3000, () => {
    17.     console.log("运行在： http://localhost:3000");
    18. })
    19. //导入express包
    20. const express = require("express");
    21.  
    22. //使用express创建路由对象
    23. const router = express.Router()
    24.  
    25. //向router挂在具体路由
    26. router.get("/list", function(req, res) {
    27.     res.send("商品列表页")
    28. })
    29. router.get("/add", function(req, res) {
    30.     res.send("商品添加页")
    31. })
    32.  
    33. //导出路由对象（对外共享
    34. module.exports = router

    7. 数据库操作

    7.1 node连接数据库

    报错解决：

    alter user 'root'@'localhost' identified with mysql_native_password by '1234';

    Error: ER_NOT_SUPPORTED_AUTH_MODE: Client does not support authentication protocol requested by serv_畱䶒的博客-CSDN博客

    7.2 增删改查（数组实现，优化）

    1. //使用内置中间件处理请求体
    2. app.use(express.json());
    3. app.use(express.urlencoded());
    4. //使用第三方中间件处理跨域问题 --需下载安装
    5. app.use(cors());

    7.3 增删改查（数据库实现）

    思路

            1. 导包、创建连接、连接，三个步骤拷贝进去

            2. 在路由里 编写sql语句，执行并返回数据

    7.4 增删改查（提取数据库操作）

    目的：将数据库操作的代码单独放到一个文件中，便于后期代码维护

    做法

            1. 将数据库导包、创建连接、连接 代码剪切进一个js文件中

            2. 提供查询所有getAll 查询单个getById 增删改exec方法，方法里用promise封装

            3. 导出这三个方法

            4. 在后台代码中导入js文件，解构这三个方法并使用

    模块导出简写：

    1. //导出对象
    2. module.exports = {
    3.     getAll: getAll,
    4.     getById: getById,
    5.     exec: exec,
    6. };
    7. //属性名和属性值相同，可简写为一个
    8. module.exports = {
    9.     getAll,
    10.     getById,
    11.     exec,
    12. };
    13. //引入：const {getAll, exec}= require("./引入.js")

    8. ES7 语法糖（async_await）

    8.1 async 异步

    作用：将同步函数变成异步函数（返回promise对象），就可以使用then() 调用

    使用：

    1. //定义
    2. async function m1() {
    3.     return 222;
    4. }
    5. //调用
    6. const p = m1()
    7. p.then((data) => {
    8.     console.log(data); //222
    9. });

    8.2 await 等待

    作用：await可以等待后面的 promise对象执行后，拿到返回的结果

    注意：

            1. await不能单独使用，必须跟async连用，存在于异步函数中

            2. await后面必须跟一个promise对象，如果不是promise对象，自动转成promise对象

            3. await表达式，返回的是promise执行后的结果

    使用：

    1. //在外面套一个异步函数壳，或将外层函数添加async关键字改为异步
    2. async function fn() {
    3.     async function m1() {
    4.         return 222;
    5.     }
    6.     //await 等待m1返回的promise对象执行完后，拿到返回的值
    7.     const res = await m1(); 
    8.     console.log(res);
    9. }
    10. fn();

    8.3 增删改查await改写

    1. app.get("/users", async function(req, res) {
    2.     let sql = 'select * from student';
    3.     const data = await exec(sql);//执行SQL语句
    4.     res.send(data);//发给浏览器
    5. })

    9. 错误处理机制

    1. throw "错误信息"
    2. try{ 
    3.      //可能会出问题的代码
    4. } catch (err) { 
    5.      //出问题的处理方案
    6. }

    10. 🟢用户管理系统搭建

    10.1 思路

    1. 需求分析（系统框架、具体业务分析）

    2. 技术方案

            数据库设计

            设计接口

                    前台：发送请求的url，需要的参数

                    后台：返回数据的格式

    3. 技术实现（编写代码）

            先写后端（express脚手架快速生成）再写前端

    10.2 用户管理系统搭建

    1. 全局安装脚手架（项目生成器） npm i express-generator -g

    2. 创建项目文件夹，执行命令生成后端目录  express --no-view backEnd

            在目录下创建一个`backEnd`的目录, 作为后端项目的目录

            `--no-view`: 创建一个数据服务, 不提供页面服务

    3. 在后端目录安装相关依赖（cd backEnd，npm i）

            进入backEnd目录, 执行命令, 根据`package.json`中的依赖项, 安装项目所有的依赖

    4. 启动项目

            1）npm i nodemon -D

                    将nodemon作为开发时的依赖安装（会在package.json中, 生成devDependencies）

            2）修改启动脚本： package.json>"scripts">"start": "nodemon ./bin/www"

            3）安装mysql和cors包（npm i mysql、npm i cors）

                    安装好后会自动添加在package.json

            4）执行 npm run start 可以在3000端口看到 express脚手架欢迎页面

            5. 导入数据库操作模块

                    将写好的db文件夹拷贝到backEnd

                    在routes/users.js中导入模块

    1. //1. 导入mysql包
    2. const mysql = require("mysql");
    3.  
    4. //2. 创建连接，数据库参数可以放到配置文件中（config/index.js）
    5. var con = mysql.createConnection({
    6.     host: "localhost",
    7.     port: 3306,
    8.     user: "root",
    9.     password: "1234",
    10.     database: "db01",
    11.     timezone: "SYSTEM",
    12. });
    13.  
    14. //3. 连接数据库
    15. con.connect();
    16.  
    17. //4. 查询所有（获取查询的数据）
    18. function getAll(sql) {
    19.     return new Promise((resolve, reject) => {
    20.       	//执行sql语句
    21.         con.query(sql, (err, data) => {
    22.             //有错，把失败的数据带回去
    23.             if (err) reject(err);
    24.  
    25.             //将获取到的数据带回去
    26.             resolve(data);
    27.         });
    28.     });
    29. }
    30.  
    31. //5. 查询一个（获取查询的数据）
    32. function getById(sql) {
    33.     return new Promise((resolve, reject) => {
    34.       	//执行sql语句
    35.         con.query(sql, (err, data) => {
    36.             //有错，把失败的数据带回去
    37.             if (err) reject(err);
    38.  
    39.             //将获取到的数据带回去
    40.             //易报错！
    41.             resolve(data[0] ? data[0] : null);
    42.         });
    43.     });
    44. }
    45.  
    46. //6. 管理（增删改）
    47. function exec(sql) {
    48.     return new Promise((resolve, reject) => {
    49.       	//执行sql语句
    50.         con.query(sql, (err, data) => {
    51.             //有错，把失败的数据带回去
    52.             if (err) reject(err);
    53.  
    54.             //将获取到的数据带回去
    55.             resolve(data);
    56.         });
    57.     });
    58. }
    59.  
    60. //导出方法
    61. /* module.exports = {
    62.     getAll:getAll,
    63.     getById:getById,
    64.     exec:exec
    65. } */
    66. //属性名和属性值相同，可简写为一个
    67. module.exports = {
    68.     getAll,
    69.     getById,
    70.     exec,
    71. };

    6. 导入跨域请求模块

            在app.js中导入 const cors = require("cors");

            在app.js中注册 app.use(cors()) 注册路由之前

    10.3 后端编写流程

    1. 在用户【路由模块】users.js下编写代码

    2. 编写获取所有用户,使用get请求,调用getAll()方法,返回所有用户的数组(data)

    3. 编写获取一个用户,使用get请求,调用getById()方法,返回指定id的用户(data)

    4. 编写新增一个用户,使用post请求,调用exec()方法,返回新增的用户(data.insertId)

    5. 编写修改一个用户,使用put请求,调用exec()方法,返回新增的用户(无需data)

    6. 编写删除一个用户,使用delete请求,调用exec()方法,设置状态码,返回空字符串(无需data)

            es.status(204).send("")

    1. var express = require('express');
    2.  
    3. //导入数据库操作模块
    4. const {getAll, getById, exec} = require("../db");
    5.  
    6. var router = express.Router();
    7.  
    8. // 获取所有用户
    9. router.get('/', async function(req, res, next) {
    10.   let sql = "select * from users";
    11.   res.send(await getAll(sql))
    12. });
    13.  
    14. // 获取一个用户
    15. router.get('/:id', async function(req, res, next) {
    16.   let sql = `select * from users where ${req.params.id} = id`;
    17.   res.send(await getById(sql))
    18. });
    19.  
    20. // 添加一个用户
    21. router.post('/', async function(req, res, next) {
    22.   let {name, age} = req.body;
    23.   let sql = `insert into users (name, age) values("${name}", ${age}) `;
    24.   let data = await exec(sql)
    25.   res.send({
    26.     id: data.insertId,
    27.     name,
    28.     age
    29.   })
    30. });
    31.  
    32. // 修改一个用户
    33. router.put('/:id', async function(req, res, next) {
    34.   let {name, age} = req.body;
    35.   let sql = `update users set name = "${name}", age = ${age} where id = ${req.params.id}`;
    36.   res.send({
    37.     id: req.params.id,
    38.     name,
    39.     age,
    40.     data: await exec(sql),
    41.   })
    42. });
    43.  
    44. // 删除一个用户
    45. router.delete('/:id', async function(req, res, next) {
    46.   let sql = `delete from users where id = ${req.params.id} `;
    47.  
    48.   let data = await exec(sql)
    49.   //设置状态码
    50.   res.status(204).send("")
    51. });
    52.  
    53. module.exports = router;

    10.4 前端编写流程

    查询（显示所有用户）

    1. 新建 fontEnd 文件夹

    2. 新建3个html页面

    3. 编写list.html页面的骨架

    4. 编写基本样式base.css

    5. 编写list页面样式style.css

    6. 引入jquery，发送ajax请求（已经引入了cors处理跨域请求）

    7. 遍历获取到的数据，动态拼接 tr 元素，追加到table下面

    1. <body>
    2.   <h1>用户列表h1>
    3.   <div class="container">
    4.     <a href="./add.html" class="add-btn">添加a>
    5.     <table class="user-list">
    6.       <tr>
    7.         <th>idth>
    8.         <th>nameth>
    9.         <th>ageth>
    10.         <th>操作th>
    11.       tr>
    12.     table>
    13.   div>
    14.  
    15.   <script>
    16.     $.ajax({
    17.       url: "http://localhost:3000/users",
    18.       type: "GET",
    19.       success: function (data) {
    20.         console.log(data); //js数组
    21.  
    22.         //遍历数组
    23.         data.forEach((item) => {
    24.           // console.log(item);
    25.           const tr = `
    26.                       ${item.id}
    27.                       ${item.name}
    28.                       ${item.age}
    29.                       
    30.                         ${item.id}" class="edit-btn">修改
    31.                         ${item.id})">删除
    32.                       
    33.                     `;
    34.           $(".user-list").append(tr);
    35.         });
    36.       },
    37.     });
    38.  
    39.     //删除
    40.     function delUser(id) {
    41.       console.log(id);
    42.       $.ajax({
    43.         url: "http://localhost:3000/users/" + id,
    44.         type: "DELETE",
    45.         success: function (res) {
    46.           console.log(res);
    47.           alert("删除成功");
    48.           location.reload();
    49.         },
    50.       });
    51.     }
    52.   script>
    53. body>

    新增

    1. 编写add.html页面骨架

    2. 在style.css中，添加add.html的样式

    3. 监听add按钮的点击，在点击事件中获取用户输入的姓名与年龄进行判断

    4. 输入为空，直接返回。否则用ajax发送post请求，提交到后台，修改数据库中数据

    5. 修改成功，弹出提示，跳转回list.html页

    1. <body>
    2.   <h1>添加用户h1>
    3.   <div class="container">
    4.     <ul>
    5.       <li>
    6.         <label for="userName">用户名label>
    7.         <input type="text" name="userName" id="userName" placeholder="请输入用户名" />
    8.       li>
    9.       <li>
    10.         <label for="userAge">年龄label>
    11.         <input type="text" name="userAge" id="userAge" placeholder="请输入年龄" />
    12.       li>
    13.     ul>
    14.     <button class="submit-btn">提交button>
    15.   form>
    16.  
    17.     <script>
    18.       $(".submit-btn").click(function () {
    19.         const name = $("#userName").val().trim()
    20.         const age = $("#userAge").val().trim()
    21.  
    22.         //判断
    23.         if (name == "" || age == "") {
    24.           alert("用户名或年龄不能为空")
    25.           return
    26.         }
    27.  
    28.         //发送异步请求
    29.         $.ajax({
    30.           url: "http://localhost:3000/users",
    31.           type: "POST",
    32.           data: { name, age },
    33.           success: function (res) {
    34.             alert("添加成功")
    35.             location.href = "./list.html";
    36.           },
    37.         });
    38.       });
    39.     script>
    40. body>

    修改

    1. 编写edit.html骨架

    2. 在list.html中为 修改a标签 的href拼接id属性

       `href="./edit.html?id=${item.id}"`

             动态绑定

    3. 在edit.html页获取路径携带的id值

        window.location.search.replace('?','').split('=')[1]

    4. 用ajax发送get请求，把根据id查找到的值回显到表单中

       $('#age').val(res.age)

    5. 为按钮添加点击事件，获取用户输入的名字年龄，为空直接返回，否则用ajax发送put请求，提交到后台 修改数据库中数据

    6. 修改成功，弹出提示，跳转到list.html页面

    1. <body>
    2. <h1>修改用户h1>
    3. <div class="container">
    4.   <ul>
    5.     <li>
    6.       <label for="userName">用户名label>
    7.       <input type="text" name="userName" id="userName" placeholder="请输入用户名" />
    8.     li>
    9.     <li>
    10.       <label for="userAge">年龄label>
    11.       <input type="text" name="userAge" id="userAge" placeholder="请输入年龄" />
    12.     li>
    13.   ul>
    14.   <button class="submit-btn">修改button>
    15.   form>
    16.  
    17.   <script>
    18.     const id = location.search.replace("?", "").split("=")[1]
    19.  
    20.     $.ajax({
    21.         url: "http://localhost:3000/users/" + id,
    22.         type: "GET",
    23.         success: function (res) {
    24.           console.log(res);
    25.           //回显数据（设置input里的值）
    26.           // alert("查找成功")
    27.           $("#userName").val(res.name)
    28.           $("#userAge").val(res.age)
    29.         },
    30.     });
    31.  
    32.     $(".submit-btn").click(function () {
    33.       const name = $("#userName").val().trim()
    34.       const age = $("#userAge").val().trim()
    35.  
    36.       //判断
    37.       if (name == "" || age == "") {
    38.         alert("用户名或年龄不能为空")
    39.         return
    40.       }
    41.  
    42.       //发送异步请求
    43.       $.ajax({
    44.         url: "http://localhost:3000/users/" + id,
    45.         type: "PUT",
    46.         data: { name, age },
    47.         success: function (res) {
    48.           console.log(res);
    49.           //回显数据（设置input里的值）
    50.           alert("修改成功")
    51.           location.href = "./list.html";
    52.         },
    53.       });
    54.     });
    55.   script>
    56. body>

    删除

    1. 在list.html页 为删除a标签 添加点击事件，传入id

    2. 弹出确认框

    3. 用ajax发送delete请求，删除数据库中数据

    4. 删除成功，刷新

  • 相关阅读:
    设计模式之责任链模式
    【手撕AHB-APB Bridge】~ AMBA总线 之 APB
    配电房智能化改造
    一份vue面试知识点梳理清单
    python小项目之利用pygame实现代码雨动画效果（附源码 可供学习）
    【羊了个羊】什么！第二关难如上青天，能不能简单版？？
    Spark之Container killed on request.Exit code is 137
    LearnOpenGL 及 ShaderToy 的 CMake 构建框架
    技术分享 | app自动化测试（Android）–显式等待机制
    leetcode 94.二叉树的中序遍历（非递归和递归遍历）
  • 原文地址：https://blog.csdn.net/weixin_43895819/article/details/126909109