教程 on RunicDolphin806

数据库系统

Sat, 14 Mar 2026 00:00:00 +0000

数据库系统研究的是：如何用计算机有效地组织和管理数据

关系数据模型

数据库与DBMS

概念
数据（Data）	数据库存储的基本对象，数字、文本、图形、音频、视频等均可看作数据
语义	数据的标签，具备语义的数据才可成为信息
数据库（Database）	长期存储在计算机内的、有组织的、可共享的数据的集合
数据库管理系统（DBMS）	位于用户与操作系统之间的一层数据管理软件，通过调用系统资源操作和管理数据

关系数据模型

概念
关系数据模型	用于描述数据的符号语言，它包括结构、操作和约束等3个部分。
关系（Relation）	二维的表格
属性（Attribute）	关系列的表头，描述了该列内容的实际含义
模式（Scheme）	关系与其属性的范式
元组（Tuples）	关系的具体内容
域（Domains）	关系的数据类型
键（Key）	关系的其中一个元素

关系数据库语言

关系代数用于在关系数据模型上查询和修改数据，它的输入和输出均为关系，因此可视为一个封闭的代数系统。

SQL语句的核心就是关系代数。

SQL的功能远低于C语言和Java，为什么使用它？

关系代数的用途十分广泛。

SQL的编译十分便捷，易于优化。

关系代数（RA）

代数（Algebra）是操作数（Operands）和运算符（Operators）的集合。

通过关系代数的运算符和各种关系相连接。可以得到关系表达式。例如：

$$ R(t,y,l,i,s,p) := \sigma_{\mathrm{length} \leqslant 100}(\mathrm{Movies}) $$

$$ S(t,y,l,i,s,p) := \sigma_{\mathrm{studioName='Fox'}}(\mathrm{Movies}) $$

$$ Answer(title, year) := \pi_{t,y}(R \cap S) $$

事实上，所有表达式都可以写成树的形式。上式即可表达为：

集合运算

集合操作	符号	作用
并（Union）	$R \cup S$	关系 $R$ 和 $S$ 中所有的内容，相同的只出现一次
交（Intersection）	$R \cap S$	关系 $R$ 和 $S$ 中共同存在的内容
差（Difference）	$R - S$	关系 $R$ 中存在但不在关系 $S$ 中

对应的SQL语言：

1(SELECT * FROM R) UNION (SELECT * FROM S);          --- 并
2(SELECT * FROM R) INTERSECT (SELECT * FROM S);      --- 交
3(SELECT * FROM R) EXCEPT (SELECT * FROM S);         --- 差

集合运算中的关系 $R$ 和 $S$ 的属性必须相同且排列顺序一致，且每个属性在两者中的域（数据类型）必须相同。

投影运算

从关系 $R$ 生成一个仅包含 $R$ 部分属性的新关系（Project），可表示为 $\pi_{A_1, A_2, \cdots, A_n}(R)$

对应的SQL语言：

1SELECT A1, A2, ..., An FROM R;

选择运算

生成关系 $R$ 满足条件 $C$ 的元组子集作为一个新关系，结果关系的模式与原关系的相同（SELECTION）。可表示为：$\sigma_{C}(R)$

用集合表示则可写作：$\sigma_{C}(R) = \{ t | t \in R \land C(t) = \mathrm{true} \}$

对应的SQL语言：

1SELECT * FROM R WHERE C;

笛卡尔积

选择关系 $R$ 的一个元素为有序对的第一个元素，关系 $S$ 的一个元素为第二个元素，以此类推形成的新关系（Cartesian Product）。可表示为：$R \times S$

对应的SQL语言：

1SELECT * FROM R CROSS JOIN S;

自然连接

设 $A_1, A_2, \cdots, A_n$ 为关系 $R$ 和 $S$ 中所有共同属性，当两者的共同属性的内容完全一致时则合并为一个关系，合并的结果应包含关系 $R$ 和 $S$ 中的所有属性（Natural Joins）。可表示为：$R \bowtie S$

对应的SQL语言：

1SELECT * FROM R NATURAL JOIN S;

$\theta$-连接

关系 $R$ 与 $S$ 先做笛卡尔积，在从中选择满足条件 $C$ 的部分（Theta-Joins）。可表示为 $ R \bowtie_{C} S $

对应的SQL语言：

1SELECT * FROM R INNER JOIN S ON C;

重命名

将关系 $R$ 重命名为关系 $S$，$R$ 中对应的属性重命名为 $A_1, A_2, \cdots, A_n$。可表示为 $\rho_{S(A_1, A_2, \cdots, A_n)}(R)$

对应的SQL语言：

1SELECT a_1 AS A_1, a_2 AS A_2, ..., a_n AS A_n FROM R AS S;

SQL语言

SQL语句分类：

分类	全称	说明
DDL	Data Definition Language	数据定义语言，用于定义数据库对象
DML	Data Manipulation Language	数据操作语言，用于数据库中数据的增删改
DQL	Data Query Language	数据查询语言，用于查询数据库中表的记录
DCL	Data Control Language	数据控制语言，用于创建数据库用户、控制数据库访问权限

SQL的数据类型

数字类型	大小	描述
`TINYINT`	1 byte	小整数集
`SMALLINT`	2 bytes	大整数集
`MEDIUMINT`	3 bytes	大整数集
`INT`	4 bytes	大整数集
`BIGINT`	8 bytes	极大整数集
`FLOAT`	4 bytes	单精度浮点数集
`DOUBLE`	8 bytes	双精度浮点数集
`DECIMAL`	依赖精度值（总数位）和标度值（小数位）	精确定点数

字符串类型	大小	描述
`CHAR()`	0-255 bytes	定长字符串
`VARCHAR()`	0-65,535 bytes	变长字符串
`TINYBLOB`	0-255 bytes	二进制数据
`TINYTEXT`	0-255 bytes	短文本字符串
`BLOB`	0-65,535 bytes	二进制长文本数据
`TEXT`	0-65,535 bytes	长文本数据
`MEDIUMBLOB`	0-16,777,215 bytes	二进制中等长度文本数据
`MEDIUMTEXT`	0-16,777,215 bytes	中等长度文本数据
`LONGBLOB`	0-4,294,967,295 bytes	二进制极大文本数据
`LONGTEXT`	0-4,294,967,295 bytes	极大文本数据

日期类型	大小	格式	描述
`DATA`	3	`YYYY-MM-DD`	日期值
`TIME`	3	`HH:MM:SS`	时间值或持续时间
`TEAR`	1	`YYYY`	年份值
`DATETIME`	8	`YYYY-MM-DD HH:MM:SS`	混合日期和时间值
`TIMESTAMP`	4	`YYYY-MM-DD HH:MM:SS`	时间戳

空值`NULL`
出现情况	值本身未知、值不适用于目标对象、用作保留值
运算法则	对`NULL`进行算术操作，结果仍为`NULL` 对`NULL`进行逻辑操作，结果为`UNKNOWN`

空值NULL不是常量，不可将其用作操作数。

布尔类型	约定值
`TRUE`	1
`FALSE`	0
`UNKNOWN`	1/2

布尔操作的法则：

AND操作符返回两者约定值较小的那个。

OR操作符返回两者约定值较大的那个。

布尔变量v反转后为1-v。

例如，若执行SQL语句
1SELECT * FROM Movies WHERE length<=120 OR length>120;
若某些元组的length值为NULL，条件的返回值则为UNKNOWN，将不会出现在结果中。

DDL

数据定义语言，用于定义数据库对象

查询

 1/* -- 数据库操作 -- */
 2-- 查询所有数据库
 3SHOW DATABASES;
 4
 5-- 查询当前数据库
 6SELECT DATABASE();
 7
 8-- 查询当前数据库中所有表
 9SHOW TABLE;
10
11
12/* -- 表操作 -- */
13-- 查询表结构
14DESC 表名;
15
16-- 查询指定表的建表语句
17SHOW CREATE TABLE 表名;

创建

 1/* -- 数据库操作 -- */
 2-- 创建数据库
 3CREATE DATABASE [IF NOT EXISTS] 数据库名 [DEFAULT CHARSET 字符集] [COLLATE 排序规则];
 4
 5-- 使用数据库
 6USE 数据库名;
 7
 8
 9/* -- 表操作 -- */
10-- 创建表
11CREATE TABLE 表名 (
12    字段1 字段1类型 PRIMARY KEY, [COMMENT '这是主键'],
13    字段2 字段2类型 [COMMENT '字段2注释'],
14    字段3 字段3类型 [COMMENT '字段3注释'],
15    ...
16) [COMMENT '表注释'];
17
18-- 示例
19CREATE TABLE movie (
20    name CHAR(30),
21    address VARCHAR(255),
22    cert INT PRIMARY KEY [COMMENT '主键'],
23    networth INT
24);
25
26CREATE TABLE studio (
27    name CHAR(50) PRIMARY KEY,
28    address VARCHAR(255),
29    presc INT,
30    FOREIGN KEY (presc) REFERENCES movie(cert) [COMMENT '外键']
31);

MySQL中建议使用字符集UTF8mb4。

参见：MySQL的数据类型

修改

 1--- 添加字段
 2ALTER TABLE 表名 ADD 字段名 类型(长度) [COMMENT '注释'] [约束];
 3
 4--- 修改数据类型
 5ALTER TABLE 表名 MODIFY 字段名 新数据类型(长度);
 6
 7--- 修改字段名和字段类型
 8ALTER TABLE 表名 CHANGE 旧字段名 新字段名 类型(长度) [COMMENT '注释'] [约束];
 9
10--- 修改表名
11ALTER TABLE 表名 RENAME TO 新表名;

删除

 1--- 删除字段
 2ALTER TABLE 表名 DROP 字段名;
 3
 4-- 删除表
 5DROP TABLE [IF EXISTS] 表名;
 6
 7-- 删除指定表，并重新创建该表
 8TRUNCATE TABLE 表名;
 9
10--- 删除数据库
11DROP DATABASE [IF EXISTS] 数据库名;

DML

数据操作语言，用于数据库中数据的增删改。

添加数据（Insertion）

 1-- 给指定字段添加数据
 2INSERT INTO 表名(字段名1, 字段名2, ...) VALUES(值1,值2,...);
 3
 4-- 给全部字段添加数据
 5INSERT INTO 表名 VALUES(值1,值2,...);
 6
 7/* -- 批量添加数据 -- */
 8-- 指定字段名添加
 9INSERT INTO 表名(字段名1,字段名2,...) VALUES(值1,值2,...),(值1,值2,...),(...);
10
11-- 全部添加
12INSERT INTO 表名 VALUES(值1,值2,...),(值1,值2,...),(值1,值2,...);

注意：

插入数据时，指定的字段顺序需要与值的顺序相对应。

字符串和日期型数据应包含在引号中。

插入数据的大小应该在字段的指定范围内。

修改数据（Updates）

1UPDATE 表名 SET 字段名1=值1,字段名2=值2,... [WHERE 条件];
2-- 作用是修改满足条件的一行数据对应字段的值，不是修改字段名
3-- 如果没有修改条件，则会修改整张表中所有数据

删除数据（Deletion）

1DELETE FROM 表名 [WHERE 条件];
2-- 如果没有修改条件，则会修改整张表中所有数据
3-- DELETE语句不能删除某一个字段的值，可以使用UPDATE将该字段值设为NONE

DQL

数据查询语言，用于查询数据库中表的记录。它完整的参数可包含如下内容：

1SELECT [字段列表] FROM [表名列表] WHERE [条件列表] GROUP BY [分组字段列表]
2HAVING [分组后筛选列表] ORDER BY [排序字段列表] LIMIT [分页参数];

基本条件查询

1SELECT L FROM R WHERE C [ORDER BY 排序规则];

它与关系代数 $\pi_{L}(\sigma_{C}(R))$ 对应。

常用运算符总结：

运算符	功能	运算符	功能
>	大于	`IN(...)`	在in之后的列表中的值（多选一）
>=	大于等于	`LIKE ' '`	模糊匹配
<	小于	`IS NULL`	数据为空
<=	小于等于	`AND` 或 `&&`	逻辑与
=	等于	`OR` 或 `\|\|`	逻辑或
<> 或 !=	不等于	`NOT` 或 `!`	逻辑非
BETWEEN…AND…	在某个范围之间（含端点）

LIKE后可接一个通配符，用于模糊匹配字段

"Star ____"将匹配字段中含有一个Star和4个字符的字符串。

%"s%将匹配包含's的字符串。

SQL允许使用ESCAPE命令来排除特定的字符，例如'x%%x%' ESCAPE 'x'将匹配以%开头和结尾的字符串。

查询结果可通过参数ORDER BY排序，默认为升序排列。可通过ORDER BY DESC指定为降序排列，ORDER BY ASC为升序排列。

多表查询

FROM后可接多个表，例如

1SELECT name FROM Movies, MovieExec WHERE title="Star Wars" AND producerC# = cert#;

其中title和producerC#位于表Movies中、cert#位于表MovieExec中，则查询结果将返回producerC#与cert#字段相同，且title为"Star Wars"的内容。

反身查询

若要在同一张表中查询元组内部元素之间的关系，则需对该表设置两个副本再进行查询。

例如，查询哪两个Star有相同的address，则输入：

1SELECT Star1.name, Star2.name 
2FROM MovieStar Star1, MovieStar Star2
3WHERE Star1.address = Star2.address AND Star1.name < Star2.name

必须设置两个副本Star1和Star2，否则条件判断将始终为TRUE。

对应的关系代数为：

$$\pi_{A_1, A_5}(\sigma_{A_2 = A_6 \ \mathrm{AND}\ A_1 < A_5}(\rho_{M(A_1, A_2, A_3, A_4)}(\mathrm{MovieStar}) \times \rho_{N(A_5, A_6, A_7, A_8)}(\mathrm{MovieStar})))$$

子查询

查询也可成为其他查询的一部分，像这样嵌套在查询内部的查询称作子查询。

子查询可返回单个常量，用于WHERE语句；也可以返回一个关系；还可以在FROM语句中后接元组变量。

这里主要展示返回标量值的子查询。

标量值（Scalar）：元组的一个组成部分。例如元组 Movies(title, year, length, genre, studioName, producerC#)中，若使用SQL查询：
1SELECT producerC# FROM Movies WHERE title='Star Wars';
返回值即为一个标量值。

示例：

1SELECT name FROM MovieExec 
2WHERE cert# = (SELECT producerC# FROM Movies WHERE title='Star Wars');

分组与聚合

聚合：将关系中的某些列合并。

聚合操作符	作用
`SUM`	对数值列求和
`AVG`	对数值列求平均值
`MIN`	数值列的最小值
`MAX`	数值列的最大值
`COUNT`	列中值的数量

分组：将元组的值分为若干组。GROUP BY后接一组分组属性，元组根据分组属性的值进行分组。

分组后筛选：HAVING后接关于组的条件。

关系数据库设计

依赖（Dependency）涉及如何构建一个良好的关系数据库模式，以及当一个模式存在缺陷时如何改进的问题，并使用“异常”来指代这些问题。

函数依赖

定义

如果两个元组在属性 $A_1, A_2, \cdots, A_n$ 上一致（即它们对应属性的分量值都相等），那么它们必定在其他属性上 $B_1, B_2, \cdots, B_m$ 上也一致。记作

$$A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$$

即 $B_1, B_2, \cdots, B_m$ 函数依赖 $A_1, A_2, \cdots, A_n$，或称 $A_1, A_2, \cdots, A_n$ 函数决定 $B_1, B_2, \cdots, B_m$。

若 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$ 成立，则以下各式均成立：
$$\begin{array}{c} A_1 A_2 \cdots A_n \rightarrow B_1 \\ A_1 A_2 \cdots A_n \rightarrow B_2 \\ \cdots \\ A_1 A_2 \cdots A_n \rightarrow B_m \end{array}$$

如果关系 $R$ 的每个实例都满足一个确定的函数依赖 $f$，那么称 $R$ 满足 函数依赖 $f$，即在 $R$ 上声明了一个约束。

关系的键

若属性集 $\{A_1, A_2, \cdots, A_n\}$ 满足：

它们决定关系的所有其他属性，即关系 $R$ 不可能存在两个不同的元组具备相同的 $A_1, A_2, \cdots, A_n$ 值。
在 $\{A_1, A_2, \cdots, A_n\}$ 的所有真子集均不能决定关系 $R$ 的所有其他属性，即键必须是最小的。

则称 $\{A_1, A_2, \cdots, A_n\}$ 是关系 $R$ 的键。

可以将关系 $R$ 中的键类比为 $n$ 维线性空间的一个 $n$ 元向量组 $[\bm{e}_1, \bm{e}_2, \cdots, \bm{e}_n]$，它可以表示该空间内的所有向量。

有时，一个关系可能会有多个可行的键，这时需指定其中一个为主键（Primary key）。

一个包含键的属性集就称为超建。

容易得出，每个键都是该关系的超键（$A \subseteq A$）

函数依赖的规则

函数依赖的规则给出了推导函数依赖的一般方法。

分解/结合规则

函数依赖 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$ 等价于下列函数依赖的集合：

$$\begin{array}{c} A_1 A_2 \cdots A_n \rightarrow B_1 \\ A_1 A_2 \cdots A_n \rightarrow B_2 \\ \cdots \\ A_1 A_2 \cdots A_n \rightarrow B_m \end{array}$$

从左到右称作函数依赖的分解规则，从右到左称作函数依赖的结合规则。

平凡函数依赖

对于函数依赖 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$，若满足

$$\{B_1 B_2 \cdots B_m\} \subseteq \{A_1 A_2 \cdots A_n\}$$

则称其为 平凡函数依赖。

若 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$，且 $\{B_1, B_2, \cdots, B_m\} - \{A_1, A_2, \cdots, A_n\} = \{C_1, C_2, \cdots, C_k\}$，则有
$$A_1 A_2 \cdots A_n \rightarrow C_1 C_2 \cdots C_k$$
这称为平凡依赖规则。如图所示：

平凡依赖规则

属性的闭包

设 $\{A_1, A_2, \cdots, A_n\}$ 是属性集合，$S$ 是函数依赖的集合，则 $S$ 下属性集合 $\{A_1, A_2, \cdots, A_n\}$ 的闭包定义为：满足 $S$ 中所有函数依赖关系的属性集合 $B$，记作 $\{A_1, A_2, \cdots, A_n\}^+$

计算属性闭包的方法：

设 $X$ 是属性集合 $\{A_1, A_2, \cdots, A_n\}$ 的闭包，首先令 $X = \{A_1, A_2, \cdots, A_n\}$。
反复寻找函数依赖 $B_1 B_2 \cdots B_n \rightarrow C$ ，使得 $B_1, B_2, \cdots, B_n$ 在 $X$ 中且 $C$ 不再 $X$ 中。然后把 $C$ 加入 $X$。
重复这个过程，直至无法再添加新的元素到 $X$ 中，计算结束，此时 $\{A_1, A_2, \cdots, A_n\}^+ = X$。

传递规则

若关系 $R$ 满足 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$ 和 $B_1 B_2 \cdots B_m \rightarrow C_1 C_2 \cdots C_k$，则有

$$A_1 A_2 \cdots A_n \rightarrow C_1 C_2 \cdots C_k$$

Armstrong公理

公理定义

自反律如果 $\{B_1 B_2 \cdots B_m\} \subseteq \{A_1 A_2 \cdots A_n\}$，那么 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$

增广律如果 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$，那么 $A_1 A_2 \cdots A_n C_1 C_2 \cdots C_k \rightarrow B_1 B_2 \cdots B_m C_1 C_2 \cdots C_k$

传递律如果 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$ 且 $B_1 B_2 \cdots B_m \rightarrow C_1 C_2 \cdots C_k$，那么 $A_1 A_2 \cdots A_n \rightarrow C_1 C_2 \cdots C_k$

公理	定义
自反律	如果 $\{B_1 B_2 \cdots B_m\} \subseteq \{A_1 A_2 \cdots A_n\}$，那么 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$
增广律	如果 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$，那么 $A_1 A_2 \cdots A_n C_1 C_2 \cdots C_k \rightarrow B_1 B_2 \cdots B_m C_1 C_2 \cdots C_k$
传递律	如果 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$ 且 $B_1 B_2 \cdots B_m \rightarrow C_1 C_2 \cdots C_k$，那么 $A_1 A_2 \cdots A_n \rightarrow C_1 C_2 \cdots C_k$

函数依赖的投影

记 $R_1 = \pi_{L} (R)$，函数依赖集合 $S$ 的投影是满足下列条件的函数依赖的集合：

从 $S$ 推断而来
只包含 $R_1$ 的属性

模式设计

关系的分解

将关系进行分解（decompose）可用来消除异常。

给定关系 $R(A_1, A_2, \cdots, A_n)$，把它分解为关系 $S(B_1, B_2, \cdots, B_m)$ 和 $T(C_1, C_2, \cdots, C_k)$，需满足：

$\{A_1, A_2, \cdots, A_n\} = \{B_1, B_2, \cdots, B_m\} \cup \{C_1, C_2, \cdots C_k\}$
$S = \pi_{B_1, B_2, \cdots, B_m} (R)$
$T = \pi_{C_1, C_2, \cdots, C_k} (R)$

BC范式

分解的目的就是将一个关系用多个不存在异常的关系替换，即在一个简单的条件下保证异常不存在，这个条件就称作BC范式（BCNF）。

定义：当且仅当如果关系 $R$ 中非平凡函数依赖 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$ 成立，则 $\{A_1, A_2, \cdots, A_n\}$ 是关系 $R$ 的超键。此时称关系 $R$ 为BC范式。

换言之，就是每个非平凡函数依赖的左侧必须包含该关系的键。

分解为BC范式

目标：将任何一个关系模式分解为带有以下性质的、具有多个属性的子集：

以这些子集为模式的关系都属于BCNF。
原始关系中的数据都被正确地反映在分解后的关系上，简单而言就是原始关系应能从分解后的几个关系实例中重构。

对于任意关系 $R$ 和函数依赖集合 $S$，有BCNF分解算法：

检验 $R$ 是否为BCNF，若是，直接返回 $R$。
如果存在违反BCNF的函数依赖，假设为 $X \rightarrow Y$。计算 $X$ 的闭包 $X^+$。选择 $R_1 = X^+$ 作为一个关系模式，并使另一个关系模式 $R_2$ 包含属性 $X$ 以及不在 $X^+$ 的属性。
计算 $R_1$ 和 $R_2$ 的函数依赖集合，记为 $S_1$ 和 $S_2$，并递归地分解 $R_1$ 和 $R_2$，返回最终分解的集合。

分解的优劣

一个分解应当具有3个性质：

性质	特点
消除异常
信息可恢复	能够从分解后的各个元组中恢复原始关系。
依赖的保持	如果函数依赖的投影在分解后的关系上成立，能确保对分解后的关系用连接重构获取原始关系仍然满足原来的函数依赖

事实上，没有一种分解能同时具备以上3个性质。

从分解中恢复信息

若可以通过分解后的各个关系重构原关系 $R$，则称该分解含有无损连接。

设关系 $R(X,Y,Z)$，且具备函数依赖 $X \rightarrow Y$，则可以依据BCNF分解算法将关系分解为 $R_1(X,Y)$ 和 $R_2(Y,Z)$，且

$$R = \pi_{X \cup Y}(R) \bowtie \pi_{Y \cup Z}(R)$$

即该分解包含无损连接。

无损连接的检验

设关系 $R$ 被分解为若干关系，它们的属性集分别为 $S_1, S_2, \cdots, S_k$，在 $R$ 上成立的函数依赖集合为 $F$。则 $\pi_{S_1}(R) \bowtie \pi_{S_2}(R) \bowtie \cdots \bowtie \pi_{S_k}(R) = R$ 成立当且仅当连接结果中的每个元组都属于 $R$。这称为无损连接的chase检验。

依赖的保持

在某些情况下，把一个关系分解为一系列BCNF关系时，无法同时拥有无损连接和依赖保持两种性质。

第三范式

定义：如果一个关系 $R$ 满足只要 $A_1 A_2 \cdots A_n \rightarrow B_1 B_2 \cdots B_m$ 是非平凡函数依赖，那么或者 $\{A_1, A_2 ,\cdots, A_n\}$ 是超键，或者每个属于 $B_1, B_2, \cdots, B_n$ 但不属于 $A$ 的属性都是某个键的成员。

如果一个属性是某个键的成员，则常被成为“主属性”。因此，3NF的条件等价于：对于每个非平凡FD，或者其左边是超键，或者其右边仅由主属性构成。

多值依赖

MySQL

MySQL是目前流行的数据库管理系统，使用SQL语法操作和管理。

准备工作

1# 安装MYSQL
2sudo apt-get install mysql-server
3
4# 启动MySQL服务
5sudo service mysql start
6
7# 登录MySQL
8mysql -u '用户名' -p '密码'

配置MySQL

首先进入MySQL界面，然后操作：

设置用户密码

1ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '你的新密码';
2FLUSH PRIVILEGES;
3EXIT;

退出后以新的密码即可登录MySQL。

允许远程访问

在Shell中输入：

1sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf

找到bind-address，将其修改为0.0.0.0或注释掉该行。

保存后重启服务：

1sudo service mysql restart

创建新用户

1CREATE USER '新用户名'@'%' IDENTIFIED BY '新密码';
2GRANT ALL PRIVILEGES ON *.* TO '新用户名'@'%' WITH GRANT OPTION;
3FLUSH PRIVILEGES;

退出后以新的用户名和密码即可登录MySQL。

通用语法

单行或多行书写，以分号结尾。
可以使用空格/缩进。
SQL语句不区分大小写，关键字建议大写。
单行注释：--注释内容或# 注释内容；多行注释：/* 注释内容 */。
其他参照SQL语言。

openGauss

数据库管理可视化

面对单调的SQL代码是非常无聊的，因此通过软件可视化管理数据库是不错的选择。

软件	介绍	版本
Navicat	Navicat是一款综合性的数据库管理软件，允许通过一个界面连接和管理多个数据库（其实这个功能大多数类似软件都有）。	Navicat提供多个版本，其中只有Navicat Premium Lite可免费使用（貌似还要注册一个账号）。
DBeaver	功能与Navicat类似	它提供免费的社区版下载，而且不用注册账号，就像JetBrain全家桶
MySQL Workbench	MySQL的官方提供的可视化管理工具	免费，但是没有中文支持。

推送制作技巧

Fri, 14 Nov 2025 00:00:00 +0000

以下推送制作方法和原则适用于宣怀X-Club

基本原则

突出有效信息。
简洁，减少“炫技”成分。

秀米操作简介

排版

基础格式
字号	16
行间距	2
字体	加粗，居中
其他	默认

若要表示强调，将字号变大并调整颜色

组件

属性	介绍
组前距和组后距	调整单个组件上下的距离。使用`%`作为单位，可以保持跨平台的观感一致性
重叠顺序	设置组件所在的图层，数值越高图层越在上方

常用组件	样式
标题
图片	只用基础格式。特别地，多张图片可以使用左右滑动格式或svg图集
分隔线

NEMU-PART III

Tue, 11 Nov 2025 00:00:00 +0000

PA3：存储管理

实现高速缓存

经过实践，高速缓存的一级和二级结构最好同时实现，否则会在分页控制中出现难以预料的bug！

定义高速缓存结构

新建文件/nemu/include/memory/cache.h，填写以下内容：

宏定义缓存块：

 1#ifndef __CACHE_H__
 2#define __CACHE_H__
 3
 4#include "common.h"
 5
 6// 定义高速缓存参数
 7#define CACHE_E_L1 8
 8#define CACHE_E_L2 16
 9#define CACHE_BLOCK 64
10#define CACHE_SIZE_L1 64*1024
11#define CACHE_SIZE_L2 4*1024*1024
12
13...
14
15#endif

缓存块的结构体定义：

 1// 定义一级缓存
 2struct cache_l1 {
 3    bool valid;
 4    int tag;
 5    uint8_t byte[CACHE_BLOCK];
 6} cache_L1[CACHE_SIZE_L1 / CACHE_BLOCK];
 7
 8// 定义二级缓存
 9struct cache_l2 {
10    bool valid;
11    bool dirty;
12    int tag;
13    uint8_t byte[CACHE_BLOCK];
14} cache_L2[CACHE_SIZE_L2 / CACHE_BLOCK];
15
16// 定义高速缓存函数
17void init_cache();
18uint32_t cache_read_L1(hwaddr_t addr);
19uint32_t cache_read_L2(hwaddr_t addr);
20void cache_write_L1(hwaddr_t addr, size_t len, uint32_t data);
21void cache_write_L2(hwaddr_t addr, size_t len, uint32_t data);

高速缓存的读写函数

新建文件/nemu/src/memory/cache.c

缓存的初始化

 1void init_cache(){
 2    int i;
 3    for(i = 0; i < CACHE_SIZE_L1 / CACHE_BLOCK; i++) {
 4        cache_L1[i].valid = false;
 5        cache_L1[i].tag = 0;
 6        memset(cache_L1[i].byte, 0, CACHE_BLOCK);
 7    }
 8    for(i = 0; i < CACHE_SIZE_L2 / CACHE_BLOCK; i++) {
 9        cache_L2[i].dirty = false;
10        cache_L2[i].valid = false;
11        cache_L2[i].tag = 0;
12        memset(cache_L2[i].byte, 0, CACHE_BLOCK);
13    }
14}

读取缓存块中的内容

 1uint32_t cache_read_L1(hwaddr_t addr) {
 2    // 取出地址中set的部分（右移block位并 & 1111111）
 3    // set = 7 byte (set = 2^s = 128)
 4    // offset = 6 byte (block = 2^e = 64)
 5    uint32_t set = (addr >> 6) & 0x7f; 
 6    bool hit = false;
 7    int i;
 8    // 一级缓存中找到相应set
 9    for(i = set * CACHE_E_L1; i < (set + 1) * CACHE_E_L1; i++) { 
10        if(cache_L1[i].tag == (addr >> 13) && cache_L1[i].valid) { // 如果tag和地址相符合并且valid == true
11            hit = true; 
12            return i;
13        }
14    }
15     
16    // 一级缓存中找空内存块
17    for(i = set * CACHE_E_L1; i < (set + 1) * CACHE_E_L1; i++) {
18        // 找到空的地方退出
19        if (!cache_L1[i].valid) {
20            break; 
21        }  
22    }
23    // 到最后仍然没有找到空的地方，执行随机替换算法
24    if(i == (set + 1) * CACHE_E_L1) { 
25        srand(0);
26        i = set * CACHE_E_L1 + rand() % CACHE_E_L1;
27    }
28    cache_L1[i].valid = true;
29    cache_L1[i].tag = addr >> 13;
30    int j = cache_read_L2(addr);;
31    memcpy(cache_L1[i].byte, cache_L2[j].byte, CACHE_BLOCK);
32    
33    return i;
34}
35
36uint32_t cache_read_L2(hwaddr_t addr){
37    uint32_t s = (addr >> 6) & ((1 << 12) - 1);
38    uint32_t block = (addr >> 6) << 6;
39    int i;
40    bool hit = false;
41    for (i = s * CACHE_E_L2; i < (s + 1) * CACHE_E_L2; i++) {
42        if (cache_L2[i].tag == (addr >> 18) && cache_L2[i].valid) {
43            hit = true;
44            break;
45        }
46    }
47    if (!hit) {
48        int j;
49        for (i = s * CACHE_E_L2; i < (s + 1) * CACHE_E_L2; i++) {
50            if (!cache_L2[i].valid)
51                break;
52        }
53        if (i == (s + 1) * CACHE_E_L2) {
54            srand(0);
55            i = s * CACHE_E_L2 + rand() % CACHE_E_L2;
56            if (cache_L2[i].dirty) {
57                uint8_t mask[BURST_LEN * 2];
58                memset(mask, 1, BURST_LEN * 2);
59                for (j = 0; j < CACHE_BLOCK / BURST_LEN; j++) {
60                    call_ddr3_write(block + j * BURST_LEN, cache_L2[i].byte + j * BURST_LEN, mask);
61                }	
62            }
63        }
64        cache_L2[i].valid = true;
65        cache_L2[i].tag = addr >> 18;
66        cache_L2[i].dirty = false;
67        for (j = 0; j < BURST_LEN; j++){
68            call_ddr3_read(block + j * BURST_LEN, cache_L2[i].byte + j * BURST_LEN);
69        }
70    }
71    return i;
72}

数据写入缓存块

 1void cache_write_L1(hwaddr_t addr, size_t len, uint32_t data) {
 2    uint32_t set = (addr >> 6) & 0x7f;
 3    uint32_t offset = addr & (CACHE_BLOCK - 1); 
 4    int i;
 5    bool hit = false;
 6    for (i = set * CACHE_E_L1; i < (set + 1) * CACHE_E_L1; i++) {
 7        if (cache_L1[i].tag == (addr >> 13) && cache_L1[i].valid) {
 8            hit = true;
 9            break;
10        }
11    }
12    // 写直通
13    if (hit) { 
14        memcpy(cache_L1[i].byte + offset, &data, len);
15    }
16    cache_write_L2(addr, len, data);
17}
18
19void cache_write_L2(swaddr_t addr, size_t len, uint32_t data) {
20    uint32_t set = (addr >> 6) & ((1 << 12) - 1); 
21    uint32_t offset = addr & 0x3f;	
22    int i;
23    bool hit = false;
24    for (i = set * CACHE_E_L2; i < (set + 1) * CACHE_E_L2; i++) {
25        if (cache_L2[i].tag == (addr >> 13) && cache_L2[i].valid) {
26            hit = true;
27            break;
28        }
29    }
30    if (!hit){
31        i = cache_read_L2(addr);
32    }
33    cache_L2[i].dirty = true;
34    memcpy(cache_L2[i].byte + offset, &data, len);
35}

修改内存读写逻辑

在/nemu/src/memory/memory.c中，修改hwaddr_read和hwaddr_write两个函数：

 1uint32_t hwaddr_read(hwaddr_t addr, size_t len) {
 2    uint32_t offset = addr & (CACHE_BLOCK - 1);
 3    uint32_t block = cache_read_L1(addr);
 4    uint8_t temp[4];
 5    memset(temp, 0, sizeof(temp));
 6    if (offset + len >= CACHE_BLOCK) {
 7        uint32_t second_block = cache_read_L1(addr + len);
 8        memcpy(temp, cache[block].byte + offset, CACHE_BLOCK - offset);
 9        memcpy(temp + CACHE_BLOCK - offset, cache[second_block].byte, len - (CACHE_BLOCK - offset));
10    } else {
11        memcpy(temp, cache[block].byte + offset, len);
12    }
13    int zero = 0;
14    uint32_t result = unalign_rw(temp + zero, 4) & (~0u >> ((4 - len) << 3));
15    return result;
16}
17
18void hwaddr_write(hwaddr_t addr, size_t len, uint32_t data) {
19    cache_write_L1(addr, len, data);
20}

实现分段机制

修改kernel

首先需要在kernel中加入切换到保护模式的代码：在kernel/include/common.h中定义宏IA32_SEG，然后重新编译kernel。

1- //#define IA32_SEG
2+ #define IA32_SEG

这一步必须完成！如果你是CV大佬，很容易漏掉这个步骤！

定义段寄存器

在CPU_state结构中添加GDTR，CR0和各种段寄存器，包括CS, DS, ES, SS, 其具体结构参考i386手册。

在libcommon/x86-inc目录下的头文件中定义了一些和x86相关的宏和结构体，你可以在NEMU中包含这些头文件来使用它们。

 1// 段寄存器
 2enum {R_ES, R_CS, R_SS, R_DS};
 3
 4// 定义段寄存器结构体
 5typedef struct {
 6    uint16_t selector;
 7    uint16_t attribute;
 8    uint32_t limit;
 9    uint32_t base;
10} Segment_Reg;
11
12...
13
14typedef struct {
15    ...
16
17    // GDTR寄存器
18    struct GDTR {
19        uint32_t base;
20        uint16_t limit;
21    } gdtr;
22
23    // CR0和CR3寄存器由 /lib-common/x86-inc/cpu.h 定义
24    CR0 cr0;
25    CR3 cr3;
26
27    // 设置段寄存器
28    union {
29        struct {
30            Segment_Reg sreg[4];	
31        };
32        struct {
33            Segment_Reg es, cs, ss, ds;
34        };
35    };
36
37} CPU_state;

完善指令集

添加lgdt指令。
添加opcode为0F 20和0F 22的mov指令，使得我们可以设置/读出CR0。
添加opcode为8E的mov指令，使得我们可以设置段寄存器。
为了设置CS寄存器, 你需要实现ljmp指令

实现段寄存器的捆绑规则

在Operand结构体中添加成员sreg，位置：/nemu/include/cpu/decode/operand.h

 1typedef struct {
 2    uint32_t type;
 3    size_t size;
 4    union {
 5        uint32_t reg;
 6-       swaddr_t addr;
 7+		struct {
 8+			swaddr_t addr;
 9+			uint8_t sreg;
10+		};
11        uint32_t imm;
12        int32_t simm;
13    };
14    uint32_t val;
15    char str[OP_STR_SIZE];
16} Operand;

修改所有调用swaddr_read()和swaddr_write()的代码，为它们添加段寄存器的参数。具体要求如下：

指令	实现要求
`opcode`为`A0`, `A1`, `A2`, `A3` 的`mov`指令	使用`DS`寄存器
一些堆栈操作指令	隐式使用`SS`寄存器
`instr_fetch()`	总是使用`CS`寄存器
`monitor`中，`x`和`p`命令读出内存时	使用`DS`寄存器
`bt`命令打印栈帧链	使用`SS`寄存器
字符串操作指令使用的段寄存器	请查阅 i386 手册

修改内存读写函数

设置CR0后，如果发现CR0的PE位为 1，则进入IA-32保护模式，从此所有虚拟地址的访问（包括swaddr_read()和 swaddr_write()）都需要经过段级地址转换。

为了实现段级地址转换，需要对/nemu/src/memory/memory.c中的swaddr_read()和swaddr_write()函数作少量修改：

1uint32_t swaddr_read(swaddr_t addr, size_t len) {
2#ifdef DEBUG
3    assert(len == 1 || len == 2 || len == 4);
4#endif
5    lnaddr_t lnaddr = seg_translate(addr, len, current_sreg);
6    return lnaddr_read(lnaddr, len);
7}
8
9// swaddr_write()函数采取类似操作

其中sreg记录了当前段级地址转换所用到的段寄存器的编码。关于段寄存器的编码，请查阅i386手册。

然后实现seg_translate()函数。再次提醒，在 NEMU 中，只有进入保护模式之后才会进行段级地址转换。

1lnaddr_t seg_translate(swaddr_t addr, size_t len, uint8_t sreg_id) {
2    if (cpu.cr0.protect_enable == 0) {
3        return addr;
4    }
5    else {
6        return cpu.sreg[sreg_id].base + addr;
7    }
8}

实现分页机制

思考题

GDT能有多大

段选择符的结构中，INDEX有13位，故GDT最大能容纳2^13个段描述符

为什么是线性地址？

不可以。虚拟地址需要经GDT中的段表翻译才能得出地址，而如果GDTR中存放虚拟地址则找不到GDT在哪里了。

如何提高寻找段描述符的效率

可以按照高速缓存的思想，建立类似cache 和 TLB 的结构来提高寻找效率。

段式存储管理的缺点

分段管理要求分配一大段连续的存储空间，难以实现并且容易造成大量的外部碎片出现。

页式存储管理的优点

没有外部碎片，并且不再需要大段连续的存储空间，提高了内存的利用率。

一些问题

Q：为什么页表表项中的基地址信息只有20位而不是32位

A：分页基地址有20位是8086的传统，在8086的分段机制中，每个段的基地址由seg_reg（即段寄存器的值）«4得到，而段寄存器是16位的，左移4位得到20位的基地址。

Q：表项和CR3中的基地址都是物理地址，这是必须的吗？能否采用虚拟地址或者线性地址？

A：是必须的，如果cr3中的基地址是虚拟地址，则无从寻找页表翻译成物理地址，进入鸡生蛋蛋生鸡的死循环。至于其他表项的虚拟地址与线性地址问题同理。

Q：为什么不采用一级页表？采用一级页表会有什么缺点？

A：多级页表可以有效地节约内存空间，如果仅采用一级页表，将可能导致较大的页表长期驻留在内存中。

空指针是“空”的吗？

空指针只是未分配或者未指向内存任何位置的指针，并不是“NULL”的。

在扁平模式下如何进行保护

对于数据有不同的访问权限，未达到需要的权限时不能进行写操作

地址映射
分页机制

因为这里定义的ｘ生成的地址是虚拟地址，超过了物理地址的界限，报错0xc014a000 outside of the physical memory。而kvm.c中的虚拟地址都经过了va_to_pa的转换，在物理地址范围之内。

进行反汇编后，其地址如下：

c01003d6: e8 65 09 00 00 call c0100d40

该call指令的opcode为e8，实现的是跳转到：该条指令的下一条指令的首地址+偏移量的位置。由于未进行寻址，故不需要进行虚实地址转化。

分页的环境下，在没有初始化页表时，0～128M的虚拟地址到物理地址的映射相当于一个简易的页表，使得高位的地址可以通过该虚拟地址（即经过va_to_pa）访问到物理地址，从而进行初始化页表的操作。

init_mm()函数执行退出时。该函数将nemu映射到了高位地址并且将之前的PDE全部置为无效，此时返回main.c时，栈中保存的返回地址需要经过虚实转换，可由于页面被置为了无效，所以报错。查看汇编代码，直接调用此函数时，nemu运行在物理地址上，由于在init_mm中将之前的PDE都置为无效，所以在loader()函数寻址时页面无效，导致报错。

Tex排版

Wed, 29 Oct 2025 00:00:00 +0000

排版与排版工具

排版是指对文字、图片等元素的布局处理，使之符合我们的阅读习惯。

排版工具	特点
Word	所见即所得
方正书版	暂时未知（没用过）
$\LaTeX$	使用 $\TeX$ 语句编辑

TeX环境配置

本文使用Tex Live为例。

TeXLive介绍

TeXLive 是目前 Windows 平台和 Linux 平台上最主流的 $\LaTeX$ 发行版。

$\LaTeX$ 发行版，是指将 $\LaTeX$ 编译引擎（如 pdflatex、xelatex、lualatex 等）、宏包（如 beamer、pgf/tikz 等）、模板（比如一些学校的毕业论文模板）、字体、配套工具（如 tlmgr、texworks 等）打包在一起的、开箱即用的 $\LaTeX$ 套件。

下载TeXLive镜像

到某个国内的 CTAN 镜像站下载最新版的 TeXLive 镜像，比如：清华大学开源软件镜像站。

目前最新的 TeXLive 版本为 2025，该文件夹下包含3个.iso文件，它们仅有文件名不同，内容完全相同，可以任选一个下载。该文件夹下还包含有md5摘要文件，也可以下载下来以备校验。

校验安装镜像（可选）：

进入到 TeXLive 和md5文件所在的文件夹，执行命令

Windows系统：

1certutil -hashfile texlive2025.iso md5

Linux系统：

1md5sum texlive2025.iso

你应该可以得到 TeXLive 2025 镜像文件的md5值：69b4a8882983d9ea521730b5f42175e7。

挂载镜像并启动安装程序

Windows系统

找到 TeXLive 文件，右击并选择“挂载”选项，可以看到磁盘管理器中出现新的盘符（如E:）。

然后打开PowerShell或cmd，运行：

1Z:\install-tl-windows.bat --no-gui

或者直接点击install-tl-windows.bat启动安装程序。

Linux系统

在Shell中执行

1sudo mkdir /mnt/texlive
2sudo mount "TeXLive文件位置" /mnt/texlive

安装TeXLive

TeX语法

宏包

$\TeX$ 中的宏包类似于“扩展组件”，提供原生 $\TeX$ 中没有的功能。

文档元素

NEMU-PART II

Wed, 17 Sep 2025 00:00:00 +0000

PA2：指令系统

实验目的：

掌握i386（IA-32）指令格式。
掌握NEMU平台的指令周期。

运行用户程序

任务：编写几条指令的helper函数, 使得第一个简单的C程序可以在NEMU中运行起来。

流程：

make run运行NEMU。
按c执行程序。
查看报错信息，观察出现未知指令的内存地址和对应操作码。
编写对应的指令文件xxx-template.h，xxx.h，xxx.c。
在all-instr.h中添加对应的头文件。
在exec.c中对应位置添加操作名称。

添加call指令

查找call指令对应的Opcode等信息，可知操作码为e8。

call指令

编写call-template.h

 1#include "cpu/exec/template-start.h"
 2
 3#define instr call
 4
 5// call + 相对偏移量（视为一个立即数）
 6make_helper(concat(call_i_, SUFFIX)) {
 7    // 解码偏移量（立即数）
 8    int len = concat(decode_i_, SUFFIX)(cpu.eip + 1); 
 9    // 压栈操作 (push)
10    reg_l(R_ESP) -= DATA_BYTE; 
11    // eip寄存器的下一位地址写入esp (mov)
12    MEM_W(reg_l(R_ESP), cpu.eip + len + 1); 
13    // 加上立即数偏移量，实现跳转
14    cpu.eip += (DATA_TYPE_S)op_src->val; 
15    // 更新eip寄存器
16    print_asm("call: 0x%x", cpu.eip + len + 1); 
17    return len + 1;
18}
19
20// call + 寄存器
21make_helper(concat(call_rm_, SUFFIX)) {
22    // 解码寄存器/内存
23    int len = concat(decode_rm_, SUFFIX)(eip + 1);
24    reg_l(R_ESP) -= DATA_BYTE;
25    MEM_W(reg_l(R_ESP), cpu.eip + len + 1);
26    cpu.eip = (DATA_TYPE_S)op_src->val - len - 1;
27    print_asm("call: %s", op_src->str);
28    return len + 1;
29}
30
31#include "cpu/exec/template-end.h"

call指令示意

编写call.c

 1#include "cpu/exec/helper.h"
 2
 3#define DATA_BYTE 1
 4#include "call-template.h"
 5#undef DATA_BYTE
 6
 7#define DATA_BYTE 2
 8#include "call-template.h"
 9#undef DATA_BYTE
10
11#define DATA_BYTE 4
12#include "call-template.h"
13#undef DATA_BYTE
14
15make_helper_v(call_i)
16make_helper_v(call_rm)

编写call.h

1#ifndef __CALL_H__
2#define __CALL_H__
3
4make_helper(call_i_v);
5make_helper(call_rm_v);
6
7#endif

在nemu/src/cpu/exec/all-instr.h中包含call.h，并在nemu/src/cpu/exec/exec.c中的opcode_table中填写相应的helper函数。

添加test指令

test指令

test指令其实相当于进行AND按位与操作，但是test是不会改变操作数的，只会改变EFLAGS寄存器中的标志位。

标志位	名称	功能
CF	进位标志	如果运算的结果最高位产生了进位或借位，其值为1，否则为0。
PF	奇偶标志	计算运算结果里1的奇偶性，偶数为1，否则为0。
ZF	零标志	相关指令结束后判断是否为0，结果为0，其值为1，否则为0。
SF	符号标志	相关指令结束后判断正负，结果为负，其值为1，否则为0。
I	中断使能标志	表示能否响应外部中断，若能响应外部中断，其值为1，否则为0。
DF	方向标志	当DF为1，ESI、EDI自动递减，否则自动递增。
OF	溢出标志	反映有符号数运算结果是否溢出，如果溢出，其值为1，否则为0。

编写test-template.h

 1#include "cpu/exec/template-start.h"
 2
 3#define instr test
 4
 5static void do_execute() {
 6    // 两个操作数进行与运算
 7    DATA_TYPE result = op_dest->val & op_src->val;
 8
 9    cpu.eflags.CF = 0;
10    cpu.eflags.OF = 0;
11
12    // 在/nemu/src/cpu/eflags.c中定义的函数
13    // 可根据结果自动修改eflags寄存器的值
14    update_eflags_pf_zf_sf((DATA_TYPE_S)result);
15    print_asm_template1();
16}
17make_instr_helper(i2a)
18make_instr_helper(i2rm)
19make_instr_helper(r2rm)
20
21#include "cpu/exec/template-end.h"

程序中经常使用一些缩写，并已成为约定俗成的惯例。

例如，为了方便理解，通常把to用2代替。因此i2rm表示立即数传到寄存器/内存中，r2rm表示寄存器传到寄存器/内存中。

i18n与此类似，是internationalization的缩写，表示“国际化”。

编写test.c

 1#include "cpu/exec/helper.h"
 2
 3#define DATA_BYTE 1
 4#include "test-template.h"
 5#undef DATA_BYTE
 6
 7#define DATA_BYTE 2
 8#include "test-template.h"
 9#undef DATA_BYTE
10
11#define DATA_BYTE 4
12#include "test-template.h"
13#undef DATA_BYTE
14
15make_helper_v(test_i2a)
16make_helper_v(test_i2rm)
17make_helper_v(test_r2rm)

编写test.h

 1#ifndef _TEST_H_
 2#define _TEST_H_
 3
 4make_helper(test_i2a_b);
 5make_helper(test_i2rm_b);
 6make_helper(test_r2rm_b);
 7
 8make_helper(test_i2a_v);
 9make_helper(test_i2rm_v);
10make_helper(test_r2rm_v);
11
12#endif

添加je指令

je指令

添加je指令有两种方法，一种是参考普通指令的执行方式，用static void do_execute创建函数并使用make_instr_helper()；另一种是直接定义一个新的make_jcc_helper()宏。这里采用后者，因为这样所有条件跳转如jne，jg，jge等都可以用make_jcc_helper()的宏实现。

 1#include "cpu/exec/template-start.h"
 2 
 3// 条件跳转指令译码过程复杂，make_instr_helper无法使用，需要重新定义
 4#define make_jcc_helper(cc) \
 5    make_helper(concat4(j, cc, _, SUFFIX)) { \
 6        int len = concat(decode_si_, SUFFIX)(eip + 1); \
 7        print_asm(str(concat(j,cc)) " %x",cpu.eip+op_src->val+1+len+(DATA_BYTE == 4)); \
 8        if (concat(check_cc_, cc)()) { \
 9            cpu.eip += op_src->val; \
10        } \
11        return len + 1; \
12    }
13
14#include "cpu/exec/template-end.h"

在include/cpu/eflags.h中定义比较函数：

1static inline bool check_cc_e() {
2    return cpu.eflags.ZF == 1;
3}

这样在调用make_je_helper时就会使用check_cc_e函数判断是否更新eflags寄存器的值。

添加其他指令

push指令

push指令

操作流程：
① esp寄存器值减4，表示栈顶指针下移一个地址的长度。
② 将读入的数据写入地址中，表示数据入栈。

cmp指令

cmp指令

操作流程：
① 记录源操作数-目标操作数的值。
② 用所得的值更新eflags寄存器。

pop指令

pop指令

操作流程：
① 向译码出的对象操作数中写入栈顶数据。
② 栈顶指针加4，回到push前的状态。

ret指令

ret指令

操作流程：
① 使eip跳转到esp中存放的地址处。
② 栈顶指针加4。

实现更多指令

jbe指令

在jcc-template.h指令中添加be字段，并在eflags.h中补充check_cc_be函数。

leave指令

leave指令

操作流程：
① 使esp指向ebp（栈底）所指的位置。
② ebp指向esp所存的地址。
③ 栈顶指针加4。

add指令

实现浮点数定点化

什么是定点化

我们约定最高位为符号位，接下来的15位表示整数部分，低16位表示小数部分，即约定小数点在第15和第16位之间（从第0位开始）。从这个约定可以看到，FLOAT类型其实是实数的一种定点表示。

更通俗的解释是：定点化数的小数点位置是固定的；或者说，定点化数的小数位数是确定的。

定点数

由这个定义，可以得出以下结论：

对于一个实数a，它的FLOAT类型表示A = a * 2^16 = a << 16。

定点数的运算

在lib-common/FLOAT.h中定义定点数与整型的基本运算：

 1static inline int F2int(FLOAT a) {
 2	// 将定点数转换为整型
 3	return (a >> 16);
 4}
 5
 6static inline FLOAT int2F(int a) {
 7	// 将整型转换为定点数
 8	return (a << 16);
 9}
10
11static inline FLOAT F_mul_int(FLOAT a, int b) {
12	// 定点数与整型相乘
13	return a * b;
14}
15
16static inline FLOAT F_div_int(FLOAT a, int b) {
17	// 定点数与整型相除
18	return a / b;
19}

在lib-common/FLOAT/FLOAT.c中定义浮点数到定点数的转化和定点数的运算：

定义浮点数结构

1// 接收IEEE编码的浮点数
2typedef union {
3	struct {
4		uint32_t m : 23;	// 尾数位
5		uint32_t e : 8;		// 指数位
6		uint32_t s : 1;		// 符号位
7	};
8	uint32_t val;
9} Float;

将浮点数转化为定点数

回忆浮点数的计算公式：对于一段32位长的浮点数编码，它对应的浮点数值为：$V = (-1)^s \times M \times 2^E$

其中 $E = 1 - bias$，$M = 1 + f$

 1FLOAT f2F(float a) {
 2	/* You should figure out how to convert `a' into FLOAT without
 3	 * introducing x87 floating point instructions. Else you can
 4	 * not run this code in NEMU before implementing x87 floating
 5	 * point instructions, which is contrary to our expectation.
 6	 *
 7	 * Hint: The bit representation of `a' is already on the
 8	 * stack. How do you retrieve it to another variable without
 9	 * performing arithmetic operations on it directly?
10	 */
11
12	Float f;
13	void *temp = &a;
14	f.val = *(uint32_t *) temp;     // 联合体val接收IEEE编码
15
16	uint32_t m = f.m | (1 << 23);	// 为尾数位添加1
17	// 计算偏移量
18	int shift = (int)f.e - (127+23-16);
19	
20	// 对m执行偏移操作
21	if(shift > 0) {
22		m <<= shift;
23	}
24	else {
25		m >>= (-shift);
26	}
27
28	return (__sign(f.val) ? -m : m);
29}

浮点数转定点数

实现定点数的运算
运行integral和quadratic-eq，补充缺失指令

为简易调试器增加变量支持

在nemu/src/monitor/debug/elf.c文件中：

 1//sym是我们需要匹配的符号名称，success指针用于设置是否匹配成功
 2uint32_t look_up_symtab(char *sym){
 3    int i;
 4    //遍历符号表逐个匹配符号
 5    for(i=0;i < nr_symtab_entry;i++){
 6        //逐个提取符号信息中的符号类别
 7        uint8_t type = ELF32_ST_TYPE(symtab[i].st_info);
 8        //当遇到类别为FUNC或者OBJECT时候匹配符号名
 9        if((type == STT_FUNC || type == STT_OBJECT) && strcmp(strtab + symtab[i].st_name, sym) == 0){
10        //匹配成功后返回符号的地址
11        return symtab[i].st_value;
12        }
13    }
14    printf("No sym found");
15    return 0;
16}

实现kernel加载

kernel/src/elf/elf.c

 1...
 2	/* TODO: fix the magic number with the correct one */
 3    //修改为elf文件的魔数
 4	const uint32_t elf_magic = 0x464c457f;
 5	uint32_t *p_magic = (void *)buf;
 6	nemu_assert(*p_magic == elf_magic);
 7 
 8	/* Load each program segment */
 9    //初始化ph指向program header开头，buf指向elf文件的开头，e_phoff为program header偏移量
10    ph = (void *)buf + elf->e_phoff;
11    //eph指向program header的末尾，e_phnum为program header中segment的数量
12    //遍历program header表，加载需要加载的segment
13	for(Elf32_Phdr *eph = ph + elf->e_phnum;ph < eph;ph++) {
14		/* Scan the program header table, load each segment into memory */
15		if(ph->p_type == PT_LOAD) {
16            uint32_t addr = ph->p_vaddr; //存储segment加载到的目标地址
17			/* TODO: read the content of the segment from the ELF file 
18			 * to the memory region [VirtAddr, VirtAddr + FileSiz)
19			 */
20            //利用函数从当前segment中读取filesiz大小的数据到目标地址
21         ramdisk_read((void *)addr, ELF_OFFSET_IN_DISK + ph->p_offset,ph->p_filesz);
22			
23			/* TODO: zero the memory region 
24			 * [VirtAddr + FileSiz, VirtAddr + MemSiz)
25			 */
26         //通过函数将未初始化的数据置0
27         memset((void *)addr + ph->p_filesz,0,ph->p_memsz - ph->p_filesz);
28...

进入PA3 →

NEMU-PART II Pre

Tue, 16 Sep 2025 00:00:00 +0000

磨刀不误砍柴工！！！

实验目的：

掌握i386（IA-32）指令格式。
掌握NEMU平台的指令周期。

切换用户程序

修改工程目录下的Makefile文件，更换NEMU的用户程序：

1- USERPROG := obj/testcase/mov
2+ USERPROG := obj/testcase/mov-c

同理，将mov-c更换为testcase/src目录下的其他文件，例如add、bubble-sort等，即可执行对应的用户程序。

了解NEMU的指令集

X86系列处理器采用变长指令字结构，各种指令长度随指令功能而异。

要实现一条指令，首先你需要知道这条指令的格式和功能。格式决定如何解释，功能决定如何执行。这些信息都在 instruction set page（i386 手册第17 章）。

i386 手册中的汇编语言格式都是 Intel 格式，而 objdump（反汇编）的默认格式是 AT&T 格式，两者的源操作数和目的操作数位置不一样，千万不要把它们混淆了！

指令格式

x86指令的一般格式如下：

x86指令的一般格式

Opcode（操作码）必定出现，其余组成部分可能不出现。Opcode决定是否出现ModR/M；SIB、Displacement、Immediate由ModR/M决定。
对于某些组成部分，其长度并不是固定的。
给定一条具体指令的二进制形式，其组成部分的划分是有办法确定的，不会产生歧义

例如对于以下指令：

指令示例

它的划分如下：

示例指令划分

ModR/M部分为什么解析出了disp32[--][--]？

ModR/M内部这一个字节的组成，分为了三个部分，具体每个部分的编码都对应着右边表内的含义，以ModR/M内的编码为基准进行查表就能够解析出对应的含义。

例如例子中的ModR/M部分编码是84（十六进制），对应二进制就是10000100，对应回格式中的部分就是Mod部分为10，R/M部分为100，二者在右边表中可以对应出一行，这一行的对应指令就是disp32[--][--]。disp32代表偏移量（displacement）为32位的，两个[--][--]就代表我们需要解析SIB中的编码部分才能得到偏移量的具体数值。

阅读Opcode Table

以mov指令的第一种形式为例：

mov指令

列数	具体含义
Description	将一个8位寄存器中的数据传送到8位的寄存器或者内存中，其中`r/m`表示“寄存器或内存”。
Opcode	88表示这条指令的`opcode`的首字节是`0x88`，`/r`表示后面跟一个`ModR/M`字节，并且 `ModR/M`字节中的`reg/opcode`域解释成通用寄存器的编码。
Instruction	`r8`表示8位寄存器；`r/m8`表示8位寄存器或内存，具体由`mod`字段决定。

通用寄存器编码

接下来的两种形式也就不难看懂了：但这两种形式的Opcode都是一样的，难道不会出现歧义吗？

x86是通过指令一般格式中的 operand-size prefix来区分上面这两种形式的。

Operand-size prefix的编码是0x66，作用是指示当前指令需要改变操作数的长度。在 IA-32 中，通常如果这个前缀没有出现，操作数长度默认是 32 位；当这个前缀出现的时候，操作数长度就改变成16位。

换句话说，如果把一个开头为89 ...的比特串解释成指令，它就应该被解释成MOV r/m32, r32的形式；如果比特串的开头是66 89...，它就应该被解释成MOV r/m16, r16。

C语言宏定义

在C语言中，可以使用命令#define来定义宏。宏不负责检查语法的正确性。

1// 常规的宏
2#define PI 3.1415926
3// 带参数的宏
4#define putchar(x) putc(x, stdout)
5
6// 使用宏进行连接
7#define concat(x, y)   x ## y

例如：

1#define make_helper(name) int name(swaddr_t eip)

这个宏定义就代表了以下的两行代码是同一个代码，我们使用的时候看到的是上面部分函数，但是程序执行的时候实际上是在执行下面的函数（实际上就是同一个函数）：

1make_helper(exec)
2int exec(swaddr_t eip)

在C语言中，宏必须定义在一行中。

若需通过换行提高代码可读性，可使用\附在每行末尾。

NEMU的指令周期

取指

核心流程

 1void cpu_exec(volatile uint32_t n) {
 2    ...
 3
 4    for(; n>0; n--) {
 5        int instr_len = exec(cpu.eip);  // 执行当前%eip所指向的指令
 6        cpu.eip += instr_len;           // %eip指向下一条指令
 7    }
 8
 9    ...
10}

函数exec：

1make_helper(exec) {     //等价于 int exec(swaddr_t eip)
2    ops_decoded.opcode = instr_fetch(eip, 1);       // 表示读取一个字节的操作码
3    return opcode_table[ops_decoded.opcode](eip);   // 返回一个函数 
4}

其中，函数instr_fetch()负责取指：

1static inline uint32_t instr_fetch(swaddr_t addr, size_t len) {
2    return swaddr_read(addr, len);
3}

instr_fetch()从eip处提取Opcode，存储到ops_decoded.opcode中。

译码

所有指令的规则如下：

内容	规则
指令	指令名称，具体由i386手册确定
形式	`i2r`，将立即数移动到寄存器 `i2rm`，将立即数移动到寄存器或内存 `r2rm`，将寄存器移动到寄存器或内存
操作数后缀	`b`表示操作数长度为8，`v`表示无法确定操作数长度，可能是16或32

通过opcode_table，根据提取到的Opcode找到对应的指令处理函数（如mov_i2r_v）。

执行

对于同一指令的不同形式，它们的执行阶段是相同的。如mov_i2rm和mov_rm2r，它们的执行阶段都是将源操作数存储到目标操作数中。
对于不同指令的同一种形式，它们的译码阶段是相同的。如mov_i2rm和sub_rm2r，它们的译码阶段都是识别出一个立即数和一个rm操作数。
对于同一条指令同一种形式的不同长度，它们的译码阶段和执行阶段都非常类似。如mov_i2rm_b，mov_i2rm_w和mov_i2rm_l。它们都是识别出一个立即数和一个rm操作数，然后把立即数存入rm操作数。

访存

访存指令

写回

指令执行完后，eip指向下一条指令。

编写指令的流程

编写指令模板文件xxx-template.h
① 在文件头尾分别包含cpu/exec/template-start.h和cpu/exec/template-end.h。
② 定义宏instr为指令名称。
③ 定义函数static void do_execute()，实现该指令的通用执行过程。
④ 定义helper函数
（1）若指令的译码方式在nemu/include/cpu/decode/decode.h中已经存在，那么可以考虑使用宏 make_instr_helper()来构造helper函数（大部分 helper 函数都可以通过这种方式构造）。
（2）否则可以考虑添加相应的译码函数或者不使用make_instr_helper(), 而是直接使用make_helper()来定义helper函数，在函数体中直接进行译码，并调用do_execute()（可以参考nemu/src/cpu/exec/data-mov/xchg-template.h中的xchg_a2r指令类型。
编写指令实例化文件xxx.c
① 包含cpu/exec-helper.h。
② 通过分别将宏DATA_BYTE定义成 1, 2, 4, 分别对指令模板文件xxx-template.h进行实例化。
③ 若一个helper函数只会在某些操作数长度中用到，可以在xxx-template.h中通过条件编译的功能来指定（可以参考nemu/src/cpu/exec/data-mov/xchg-template.h中的xchg_a2r指令类型）。
④ 必要时通过宏make_helper_v()定义相应的重载函数，根据指令的操作数长度前缀确定调用哪一个helper函数。
编写指令头文件xxx.h，声明helper函数的原型。
在nemu/src/cpu/exec/all-instr.h中包含xxx.h。
在nemu/src/cpu/exec/exec.c中的opcode_table中填写相应的helper函数

编写指令的流程

进入PA2 →

NEMU-PART I

Mon, 08 Sep 2025 00:00:00 +0000

你说得对，但是NEMU是一个基于X86-64处理器模拟的IA-32操作系统。NEMU运行在一个被称作Docker的容器，在这里，被容器选中的人将被授予gcc，导引C语言之力。你将扮演一位名为Debug的神秘用户，编写众多C语言程序，在调试中找出FAIL的原因，同时逐步发掘Hit Bad Trap的真相。

目标：制作一个32位的操作系统

什么是NEMU

在X86-64处理器的机器上模拟一个32位操作系统（一个用来执行其它程序的程序！），它包括4个连贯的实验内容：

阶段	任务
PA1	简易调试器
PA2	指令系统
PA3	存储管理
PA4	中断与I/O

认识NEMU

NEMU的结构

调试器操作指令集

在nemu/src/monitor/debug/ui.c中定义了调试器的结构：

 1static struct {
 2    char *name;
 3    char *description;
 4    // 函数指针，可指向*name，*description
 5    int (*handler) (char *);     
 6} cmd_table [] = {
 7    { "help", "Display informations about all supported commands", cmd_help },
 8    { "c", "Continue the execution of the program", cmd_c },
 9    { "q", "Exit NEMU", cmd_q },
10
11    /* TODO: Add more commands */
12    /* 接下来若想定义新的操作，格式为
13    { "name", "description", function},
14    */
15};

几个有用的函数

函数	作用
`Log()`	`printf()`的升级版，专门用来输出调试信息，同时还会输出使用`Log()`所在的源文件，行号和函数，当输出的调试信息过多的时候，可以很方便地定位到代码中的相关位置
`Assert()`	`assert()`的升级版，当测试条件为假时，在`assertion fail`之前可以输出一些信息
`panic()`	用于输出信息并结束程序，相当于无条件的`assertion fail`
`swaddr_read()` / `swaddr_write()`	访问模拟的内存
`strtok()`	一个简单的字符串分割工具，用于解析命令
`sscanf()`	可以从字符串中读入格式化的内容, 使用它有时候可以很方便地实现字符串的解析

PA1：简易调试器

机器永远是对的！

未经过测试的每行代码永远是错误的！

RTFM！（阅读手册！）

实现正确的寄存器结构体

寄存器

在/nemu/include/cpu/reg.h中，原寄存器结构体定义为：

 1typedef struct {
 2    struct {
 3        uint32_t _32;
 4        uint16_t _16;
 5        uint8_t _8[2];
 6    } gpr[8];
 7
 8    /* Do NOT change the order of the GPRs' definitions. */
 9    uint32_t eax, ecx, edx, ebx, esp, ebp, esi, edi;
10    ... 
11} CPU_state;

使用结构体，每一个寄存器均独立存在，而X86系统的寄存器是共享的，例如 %eax 的后16位即为 %ax。因此应使用联合体的形式定义寄存器，这样对 %ax 操作时也会相应地改变 %eax 的值。

 1typedef struct {
 2    union {
 3        union {
 4            uint32_t _32;
 5            uint16_t _16;
 6            uint8_t _8[2];
 7        } gpr[8];
 8
 9        /* Do NOT change the order of the GPRs' definitions. */
10        struct {
11            uint32_t eax, ecx, edx, ebx, esp, ebp, esi, edi;
12        };	
13    };
14    ...
15} CPU_state;

实现调试器的功能

回顾nemu/src/monitor/debug/ui.c中对调试器的定义，需增加新的操作指令。

指令名	示例	功能
`si`	`si 10`	单步执行
`info`	`info r`	打印寄存器状态
	`info w`	打印监视点状态
`x`	`x N EXPR`	扫描内存
`p`	`p EXPR`	表达式求值
`w`	`w EXPR`	设置监视点
`d`	`d N`	删除监视点

 1static struct {
 2    char *name;
 3    char *description;
 4    int (*handler) (char *);
 5} cmd_table [] = {
 6    ...
 7    // 定义单步执行操作，关键字为 si，以此类推
 8    { "si", "Single step execution", cmd_si },
 9    { "info", "Show register or monitor's infomation", cmd_info },
10    { "x", "Scan Memory", cmd_x },
11    ...
12};

单步执行

在nemu/src/monitor/debug/ui.c中定义新的操作函数：

 1static int cmd_si(char *args) {
 2    char *arg = strtok(NULL, " ");  // 获取第二个字符
 3    int step = 0;   // 待操作步数
 4    int i = 0;
 5   
 6    if (arg == NULL) {
 7        cpu_exec(1);
 8    }
 9    else {
10        sscanf(arg, "%d", &step);  // 将arg转换为整型数
11        if (step <= 0) {
12            printf("Illegal input!");
13        }
14        else {
15            for(; i<step; i++) {
16                cpu_exec(1);
17            }
18        }
19    }
20    return 0;
21}

报错请查看：

使用循环时，循环变量的初始化应在循环结构之前，否则会报错：

1nemu/src/monitor/debug/ui.c:55: error: 'for' loop initial declarations are only allowed in C99 mode
2nemu/src/monitor/debug/ui.c:55: note: use option -std=c99 or -std=gnu99 to compile your code

读取函数应使用 sscanf。

打印寄存器状态

同理，定义操作函数cmd_info

 1static int cmd_info(char *args) {
 2    char *arg = strtok(NULL, " ");  // 获取第二个字符
 3    int i = 0;
 4
 5    if (*arg == 'r') {    // 参数为'r'时打印寄存器的值
 6        for(; i<8; i++) {
 7            // 打印eax, ecx, edx, ebx, esp, ebp, esi, edi 8个寄存器
 8            printf("%s\t\t", regsl[i]);     // 打印寄存器名称
 9            // 先打印16进制值，再打印10进制值（仿GDB）
10            // "\t" 为制表符，让输出更美观
11            printf("0x%08x\t\t%d\n", cpu.gpr[i]._32, cpu.gpr[i]._32);
12        }
13        // 打印%eip 寄存器
14        printf("eip\t\t0x%08x\t\t%d\n", cpu.eip, cpu.eip);  
15    }
16    else {
17        printf("Illegal input!\n");
18    }
19
20    return 0;
21}

扫描内存

 1static int cmd_x(char *args) {
 2    char *arg_1 = strtok(NULL, " ");    // 获取第1个参数 N
 3    char *arg_2 = strtok(NULL, " ");    // 获取第2个参数 EXPR
 4    int i = 0;
 5    int j = 0;
 6
 7    int N;
 8    swaddr_t address;	
 9
10    sscanf(arg_1, "%d", &N);
11    sscanf(arg_2, "%x", &address);	// 获取起始内存地址
12    
13    for(; i<N; i++) {
14        // 每行打印4个值
15        if (j%4 == 0) {
16            printf("0x%x:", address);
17        }
18
19        // 每4字节打印一个值
20        printf("0x%08x ", swaddr_read(address, 4));
21        address += 4;
22        j++;
23
24        // 4个值后换行
25        if (j%4 == 0) {
26            printf("\n");
27        }
28    }
29
30    printf("\n");
31    return 0;
32}

表达式求值

阶段1：词法分析

定义token

在/nemu/src/monitor/debug/expr.c中，观察token结构体，它包含两个数据type和str：

1typedef struct token {
2    int type;       // 记录token的类型
3    char str[32];   // 记录token的具体数据
4} Token;

容易发现，当token为+, -, &等单运算符时，只需要记录它的type即可，因为它们的type唯一标识了各自的具体数据。

在/nemu/src/monitor/debug/expr.c的列举类中，定义token的类型。

 1enum {
 2    NOTYPE = 256,
 3    NUM = 1,        // 10进制数
 4    REGISTER = 2,   // 寄存器
 5    HEX = 3,        // 16进制数
 6    EQ = 4,         // 相等
 7    NOTEQ = 5,      // 不相等
 8    OR = 6,         // 或运算
 9    AND = 7,        // 与运算
10    POINT,          // 指针
11    NEG
12
13    /* TODO: Add more token types */
14
15};

定义了枚举类后，相应的字段和数字就确定了唯一对应的关系。例如，type = NUM和type = 1均表示10进制整数。

定义正则表达式

在/nemu/src/monitor/debug/expr.c中，定义正则表达式：

 1static struct rule {
 2    char *regex;
 3    int token_type;
 4} rules[] = {
 5
 6    /* TODO: Add more rules.
 7     * Pay attention to the precedence level of different rules.
 8     */
 9
10    {" +",	NOTYPE},                // spaces 空格
11
12    {"\\+", '+'},                   // plus 运算符
13    {"\\-", '-'},
14    {"\\*", '*'},
15    {"\\/", '/'},
16
17    {"\\$[a-z]+", REGISTER},        // 数据
18    {"0x[0-9a-fA-F]+", HEX},
19    {"[0-9]+", NUM},
20
21    {"==", EQ},                     // equal
22    {"!=", NOTEQ},
23
24    {"&&", AND},                    // 逻辑运算符
25    {"\\|\\|", OR},
26    {"!", '!'},
27
28    {"\\(", '('},                   // 括号
29    {"\\)", ')'},
30};

正则表达式的作用是识别当前表达式的具体内容。例如，对于表达式4 + 3 * ( 2 - 1 )，正则表达式的识别结果应为：

识别token

识别token

在/nemu/src/monitor/debug/expr.c中的make_token函数可以帮助我们实现这一工作。

 1static bool make_token(char *e) {
 2    ...
 3    while(e[position] != '\0') {
 4        ...
 5        for(i = 0; i < NR_REGEX; i ++) {
 6            ...
 7            // 清空token值，防止每次运算相互干扰
 8            int j = 0;
 9            for(; j < 32; j++) {
10                tokens[nr_token].str[j] = '\0';
11            }
12            
13            // tokens.type的赋值函数
14            switch(rules[i].token_type) {
15                case 256: 
16                    break;
17
18                // 输入10进制数、寄存器、16进制数
19                case NUM:
20                    tokens[nr_token].type = NUM;
21                    strncpy(tokens[nr_token].str, &e[position - substr_len], substr_len);
22                    nr_token++;
23                    break;
24
25                // REGISTER，HEX，EQ，NOTEQ，AND，OR与之类似
26
27                ...
28                
29                // 输入单运算符
30                case '+':
31                    tokens[nr_token].type = '+';
32                    nr_token++;
33                    break;
34
35                // -, *, /, !, (, ) 与之类似
36
37                ...
38
39                default: 
40                    assert(0);
41            }
42            break;
43        }
44    }
45}

以其中一个为例：

1case NUM:
2    // token的类型为NUM
3    tokens[nr_token].type = NUM;
4    // 将sub_strlen长度的值存储到tokens.str
5    strncpy(tokens[nr_token].str, &e[position - substr_len], substr_len);
6    // 开始读取下一个token
7    nr_token++;
8    // 跳出switch循环
9    break;

阶段2：表达式求值

判断表达式括号匹配

 1bool check_parentheses(int p, int q) {
 2    int a = 0;          // 记录表达式token下标
 3    int i = 0, j = 0;   // 分别记录左、右括号总数
 4
 5    // 检查表达式首尾是否为括号
 6    if(tokens[p].type == '(' || tokens[q].type == ')') {
 7        for(a = p; a<=q; a++) {
 8            if(tokens[a].type == '(') {
 9                i++;
10            }
11            if(tokens[a].type == ')') {
12                j++;
13            }
14            if(a != q && i == j) {
15                // 排除例如 (a+b)) 这种情况
16                return false;
17            }
18        }
19
20        if(i == j) {
21            // 左右括号数量相等，正确
22            return true;
23        } 
24        else {
25            // 数量不等，错误
26            return false;
27        }
28    }
29
30    return false;
31}

寻找主操作符

dominant operator（主操作符）是表达式中最后参与运算的运算符，根据运算符优先级可知：

非运算符的token不是dominant operator。
出现在一对括号中的token不是dominant operator。注意到这里不会出现有括号包围整个表达式的情况，因为这种情况已经在check_parentheses()相应的if块中被处理了。
dominant operator的优先级在表达式中是最低的。这是因为dominant operator是最后一步才进行的运算符。
当有多个运算符的优先级都是最低时，根据结合性，最后被结合的运算符才是dominant operator。一个例子是1 + 2 + 3，它的dominant operator应该是右边的+。

找到主操作符后，表达式的运算可归结为主操作符两侧数的运算。这也就意味着该问题满足了分治的基本条件：一个问题可分解为若干个与原问题结构相同的子问题。

参阅此处：分治法

 1int dominant_operator(int p, int q) {
 2    int step = 0;
 3    int op = -1;
 4    int i = 0;  	// 记录token下标
 5    int pri = 0; 	// 记录当前操作符优先级
 6
 7    for(i = p; i <= q; i++) {
 8        if(tokens[i].type == '(') {
 9            step ++;
10        }
11        else if(tokens[i].type == ')') {
12            step --;
13        }
14
15        if(step == 0) {
16            if(tokens[i].type == OR) {
17                if(pri < 51) {
18                    op = i;
19                    pri = 51;
20                }
21            }
22            else if(tokens[i].type == AND) {
23                if(pri < 50) {
24                    op = i;
25                    pri = 50;
26                }
27            }
28            else if(tokens[i].type == EQ || tokens[i].type == NOTEQ) {
29                if(pri < 49) {
30                    op = i;
31                    pri = 49;
32                }
33            }
34            else if(tokens[i].type == '+' || tokens[i].type == '-') {
35                if(pri < 48) {
36                    op = i;
37                    pri = 48;
38                }
39            }
40            else if(tokens[i].type == '*' || tokens[i].type == '/') {
41                if(pri < 46) {
42                    op = i;
43                    pri = 46;
44                }
45            }	
46        }
47        else if(step < 0) {
48            return -2;
49        }
50    }
51    return op;
52}

递归计算表达式的值

这里运用的就是分治算法。

  1uint32_t eval(int p, int q) {
  2    int result = 0;
  3    int op = 0;
  4    int val1, val2;
  5
  6    // 表达式左侧超过右侧，错误
  7    if (p > q) {
  8        assert(0);
  9    }
 10
 11    // 表达式左侧等于右侧，说明为单个数字
 12    else if (p == q) {
 13        // 处理10进制数
 14        if (tokens[p].type == NUM) {
 15            sscanf(tokens[p].str, "%d", &result);
 16            return result;
 17        } 
 18
 19        // 处理16进制数
 20        else if (tokens[p].type == HEX) {
 21            int i = 2;
 22            while(tokens[p].str[i] != 0) {
 23                result *= 16;
 24                if (tokens[p].str[i] <= '9') {
 25                    // 16进制为0-9
 26                    result += tokens[p].str[i] - '0'; 	
 27                }
 28                else {
 29                    // 16进制为a-f
 30                    result += tokens[p].str[i] - 'a' + 10;	
 31                }
 32                i++;
 33            }
 34            return result;
 35        } 
 36
 37        // 处理寄存器
 38        else if (tokens[p].type == REGISTER) {
 39            if (!strcmp(tokens[p].str, "$eax")) {
 40                return cpu.eax;
 41            } 
 42
 43            // 剩下的寄存器使用相同的处理办法
 44            
 45            ...
 46
 47            else {
 48                return 0;
 49            }
 50        } 
 51        else {
 52            assert(0);
 53        }
 54    }
 55
 56    // 表达式两侧不等，但是括号匹配，去掉括号
 57    else if (check_parentheses(p, q) == true) {
 58         return eval(p + 1, q - 1);
 59    }
 60
 61    // 正常表达式
 62    else {
 63        // 寻找主操作符
 64        op = dominant_operator(p, q);
 65
 66        if (op == -2) {
 67            assert(0);
 68        } 
 69
 70        // 处理一元运算符
 71        else if (op == -1) {
 72            // 处理逻辑非运算，如 !1
 73            if (tokens[p].type == '!') {
 74                sscanf(tokens[q].str, "%d", &result);
 75                return !result;
 76            }
 77
 78            // 之后将在此处实现负数运算和指针解引用
 79
 80        }
 81
 82        // 计算主操作数两侧表达式值
 83        
 84        val1 = eval(p, op - 1);     // 计算主操作数左侧表达式
 85        val2 = eval(op + 1, q);     // 计算主操作数右侧表达式
 86
 87        switch (tokens[op].type) {
 88            case '+' : 
 89                return val1 + val2;	
 90
 91            // -, *, / , OR, AND, EQ, NOTEQ运算以此类推 
 92             
 93            ...
 94
 95            default : 
 96                assert(0);
 97        }
 98    }
 99    return 0;
100}

举例：

分治法求表达式的值

expr函数

 1uint32_t expr(char *e, bool *success) {
 2    if(!make_token(e)) {
 3        *success = false;
 4        return 0;
 5    }
 6
 7    /* TODO: Insert codes to evaluate the expression. */
 8
 9    int i;
10    for (i = 0; i < nr_token; i++){
11        if (tokens[i].type == '*' && (i == 0 || (tokens[i - 1].type != NUM && tokens[i - 1].type != HEX && tokens[i - 1].type != ')'))){
12            tokens[i].type = POINT;
13        }
14        if (tokens[i].type == '-' && (i == 0 || (tokens[i - 1].type != NUM && tokens[i - 1].type != HEX && tokens[i - 1].type != ')'))){
15            tokens[i].type = NEG;
16        }
17    }
18    return eval(0, nr_token - 1);
19
20    // panic("please implement me");
21    return 0;
22}

最终实现

在/nemu/src/monitor/debug/ui.c中写入cmd_p函数：

1static int cmd_p(char *args) {
2    bool *success = false;
3    int result = 0;
4    result = expr(args, success);
5    if(!success) {
6        printf("%d\n", result); 
7    }
8    return 0;
9}

表达式求值功能正式实现。

选做任务：实现负数运算和指针解引用

在eval函数中加入以下内容：

 1uint32_t eval(int p, int q) {
 2
 3    ...
 4
 5    // 正常表达式
 6    else {
 7       // 处理一元运算符
 8        else if (op == -1) {
 9
10            ...
11
12            // 处理带负数的表达式，如 1+ -1
13            if (tokens[p].type == NEG) {
14                sscanf(tokens[q].str, "%d", &result);
15                return -result;
16            }
17
18            // 实现指针解引用
19            else if (tokens[p].type == POINT) {
20                if (!strcmp(tokens[p + 2].str, "$eax")){
21                    result = swaddr_read(cpu.eax, 4);
22                    return result;
23                }
24
25                // 其余寄存器采用类似操作
26
27                ...
28            }
29        } 
30    }  
31}

监视点

新建监视点

在nemu/src/monitor/debug/watchpoint.c中，定义函数new_wp()：

 1// 从free_链表中返回一个空闲监视点
 2WP* new_wp() {
 3    WP *temp;
 4    temp = free_;           // free_链表的头节点作为返回值
 5    free_ = free_->next;    // free_链表的下一个节点成为头节点
 6    temp->next = NULL;      // 空闲监视点为head链表的尾节点
 7
 8    // 若head链表为空，返回的节点成为头节点
 9    if(head == NULL) {
10        head = temp;
11    }
12    // head链表不为空，寻找其尾节点
13    else {
14        WP *p;
15        p = head;
16        // 将返回的节点插入head链表的尾部
17        while (p->next != NULL) {
18            p = p->next;
19        }
20        p->next = temp;
21    }
22    return temp;
23}

示意图如下：

监视点链表

释放监视点

同理，在nemu/src/monitor/debug/watchpoint.c中定义：

 1// 释放监视点至free_链表
 2void free_wp(WP *wp) {
 3    if(wp == NULL) {
 4        assert(0);   // 返回节点为空
 5    } 
 6    else if (wp == head) {
 7        head = head->next;
 8    }
 9    else {
10        WP* temp = head;
11        // 找到head链表待删除节点的前一个节点
12        while(temp != NULL && temp->next != wp) {
13            temp = temp->next;
14        }
15        // 取消待删除节点与其后节点的连接
16        temp->next = wp->next;
17    }
18
19    // 待删除节点成为free链表的头节点
20    wp->next = free_;
21    free_ = wp;
22
23    // 清空待删除节点的内容
24    wp->result = 0;
25    wp->expr[0] = '\0';
26}

释放监视点实际上就是新建监视点的逆操作，换言之，就是将head链表待删除的节点变成free链表的头节点。

判断监视点是否触发

在nemu/src/monitor/debug/watchpoint.c中定义：

 1// 判断监视点是否触发
 2bool checkWP() {
 3    bool check = false;	 // 最终返回值
 4
 5    bool *success = false;  
 6    WP *temp = head;    // 从head链表的头节点开始遍历
 7    int expr_temp;
 8
 9    while(temp != NULL) {
10        expr_temp = expr(temp->expr, success);
11        if (expr_temp != temp->result){
12            check = true;
13            printf ("Hint watchpoint %d at address 0x%08x\n", temp->NO, cpu.eip);
14            temp = temp->next;
15            continue;
16            // 检测到监视点对应的值发生变化
17        }
18        temp->result = expr_temp;
19        temp = temp->next;
20    }	
21    return check;
22}

在/nemu/src/monitor/cpu-exec.c中加入以下内容：

1/* TODO: check watchpoints here. */
2
3// 链接外部函数
4extern bool checkWP();
5bool change = checkWP();
6if (change) {
7    nemu_state = STOP;
8}

打印监视点和删除监视点

 1// 打印所有监视点
 2void printf_wp(){
 3    WP *temp = head;
 4    if (temp == NULL){
 5        printf("No watchpoints\n");
 6    }
 7    while (temp != NULL){
 8        printf("Watch point %d: %s\n", temp->NO, temp->expr);
 9        temp = temp->next;
10    }
11}
12
13// 删除监视点
14WP* delete_wp(int p, bool *key){
15    WP *temp = head;
16    while (temp != NULL && temp->NO != p){
17        temp = temp->next;
18    }
19    if (temp == NULL){
20        *key = false;
21    }
22    return temp;
23}

加入调试器指令

最后在/nemu/src/monitor/debug/ui.c中加入指令函数：

 1// 打印监视器的值
 2static int cmd_info(char *args) {
 3	char *arg = strtok(NULL, " ");  // 获取第二个字符
 4
 5	...
 6
 7	else if(*arg == 'w') {
 8		extern void printf_wp();
 9		printf_wp();
10	}
11
12	...
13
14	return 0;
15}
16
17// 设置监视点
18static int cmd_w(char *args) {
19
20    extern WP* new_wp();
21    WP* temp = new_wp();
22
23    bool *success = false;
24    int result = 0;
25    result = expr(args, success);
26
27    if(!success) {
28        // 若表达式合法，将对应的值赋给temp这个新监视点
29        temp->result = result;
30        strcpy(temp->expr, args);
31    }
32
33    return 0;
34}
35
36// 删除监视点
37static int cmd_d(char *args) {
38    int p = 0;
39    bool key = true;
40    sscanf(args, "%d", &p);
41
42    // 记得链接外部函数
43    extern WP* delete_wp();
44    extern void free_wp();
45    WP *q = delete_wp(p, &key);
46
47    if (key){
48        printf("Delete watchpoint %d: %s\n", q->NO, q->expr);
49        free_wp(q);
50        return 0;
51    } 
52    else {
53        printf("No found watchpoint %d\n", p);
54        return 0;
55    }
56
57    return 0;
58}

思考题

思考题1：opcode_table到底是一个什么类型的数组？

解答

opcode_table数组是一个函数指针数组。

思考题2（1）：在cmd_c()函数中, 调用cpu_exec()的时候传入了参数-1 , 你知道为什么吗?

解答

-1是无符号类型最大的数字，所以函数里的for循环可以执行所有指令。

思考题2（2）：框架代码中定义wp_pool等变量的时候使用了关键字static，static在此处的含义是什么? 为什么要在此处使用它?

解答

static在此处的含义是静态全局变量，该变量只能被本文件中的函数调用，并且是全局变量，而不能被同一程序其他文件中的函数调用，使用static是为了避免它被误修改。

思考题3-1：EFLAGS寄存器中的CF位是什么意思?

解答

i386手册里P34页中和参阅附录c提到，CF是进位标志。

EFLAGS寄存器

思考题3-2：ModR/M字节是什么?

解答

P241-243页。ModR/M 由 Mod，Reg/Opcode，R/M 三个部分组成。 Mod 是前两位，提供寄存器寻址和内存寻址， Reg/Opcode为3-5位，如果是Reg表示使用哪个寄存器，Opcode表示对group属性的Opcode进行补充； R/M为6-8位，与mod结合起来会得到8个寄存器和24个内存寻址。

ModR/M

思考题3-3：mov指令的具体格式是怎么样的?

解答

P345页，格式是DEST ← SRC。

mov指令

思考题3-4：完成 PA1 的内容之后, nemu目录下的所有.c和.h和文件总共有多少行代码? 你是使用什么命令得到这个结果的？和框架代码相比, 你在PA1中编写了多少行代码？你可以把这条命令写入Makefile中, 随着实验进度的推进, 你可以很方便地统计工程的代码行数, 例如敲入 make count就会自动运行统计代码行数的命令。再来个难一点的, 除去空行之外, nemu目录下的所有.c和.h文件总共有多少行代码？

解答

通过find . -name "*[.h/.c]" | xargs wc -l命令，得到4376行。和框架代码4197行相比, 我在 PA1中编写了606行代码。

通过find . -name "*[.h/.c]" | xargs grep "^." | wc -l命令计算去除空行的所有.c .h文件得到了3900行代码。

make count指令如下：

make count

@find nemu/ -name “.c” -o -name “.h” | xargs cat | grep -v ^$$ | wc -l

思考题3-5：打开工程目录下的Makefile文件, 你会在CFLAGS变量中看到 gcc 的一些编译选项。请解释 gcc 中的-Wall和-Werror有什么作用? 为什么要使用-Wall和-Werror？

解答

-Wall使GCC编译后显示所有的警告信息。-Werror会将将所有的警告当成错误进行处理，并且取消编译操作。使用-Wall和-Werror就是为了找出可能存在的错误，尽可能地避免程序运行出错，优化程序。

至此，PA1全部完成

PA2预备知识

APlayer

Sun, 17 Aug 2025 00:00:00 +0000

以下由Hugo的stack主题演示，其他的可作为参考。

修改方法来源：莱特雷-letere

引入APlayer

在Hugo工作文件夹的layouts/partials/footer文件夹中新建一个文件，命名为 aplayer.html。
在 aplayer.html中输入以下内容：

 1<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/aplayer/dist/APlayer.min.css">
 2<div id="aplayer"></div>
 3<script src="https://cdn.jsdelivr.net/npm/aplayer/dist/APlayer.min.js"></script>
 4
 5<script>
 6    const ap = new APlayer({
 7        container: document.getElementById('aplayer'),
 8        fixed: true,
 9        listFolded: true,
10        lrcType: 3,
11        audio: [{
12            name: 'example',
13            artist: 'example',
14            url: 'https://example.mp3',
15            lrc: 'example.lrc',
16            cover: 'example.png'
17        }]
18    });
19</script>

在layouts/partials/footer中新建一个文件夹，命名为custom.html，在其中输入：

1{{ partialCached "footer/aplayer.html" . }}

这样，aplayer就成功导入到网页中了。

修改APlayer样式

实现播放进度保存

 1<script>
 2    /**
 3    * 页面销毁前监听
 4    */
 5    window.onbeforeunload = () => {
 6        // 将播放信息用对象封装，并存入到localStorage中
 7        const playInfo = {
 8            index: ap.list.index,
 9            currentTime: ap.audio.currentTime,
10            paused: ap.paused
11        };
12        localStorage.setItem("playInfo", JSON.stringify(playInfo));
13    };
14
15    /**
16        * 页面加载后监听
17        */
18    window.onload = () => {
19        // 从localStorage取出播放信息
20        const playInfo = JSON.parse(localStorage.getItem("playInfo"));
21        if (!playInfo) {
22            return;
23        }
24        // 切换歌曲
25        ap.list.switch(playInfo.index);
26        // 等待500ms再执行下一步(切换歌曲需要点时间，不能立马调歌曲进度条)
27        setTimeout(() => {
28            // 调整时长
29            ap.seek(playInfo.currentTime);
30            // 是否播放
31            if (!playInfo.paused) {
32                ap.play()
33            }
34        }, 500);
35    };
36</script>

实现隐藏播放器图标

 1<style>
 2    .aplayer-fixed.aplayer-narrow .aplayer-body {
 3        left: -70px !important;
 4        /* 默认情况下缩进左侧70px，只留一点箭头部分 */
 5    }
 6
 7    .aplayer-fixed.aplayer-narrow .aplayer-body:hover {
 8        left: 0 !important;
 9        /* 鼠标悬停是左侧缩进归零，完全显示按钮 */
10    }
11</style>

导入pjax实现音乐不间断播放

pjax是一项页面切换不加载技术，可实现切换网页后音乐不间断。

导入pjax

在layouts/partials/footer中新建文件，命名为pjax.html.
在文件中写入代码：

1<script src="https://cdn.jsdelivr.net/npm/pjax/pjax.min.js"></script>
2<script>
3    var pjax = new Pjax({
4        selectors: [
5            ".main-container"
6        ]
7    })
8</script>

这样pjax就成功导入网页中了。

修复网页样式

在pjax.html中加入以下内容：

 1<script>
 2    pjax._handleResponse = pjax.handleResponse;
 3    pjax.handleResponse = function(responseText, request, href, options) {
 4        if (request.responseText.match("<html")) {
 5            if (responseText) {
 6                // 将新页面的html字符串解析成DOM对象
 7                let newDom = new DOMParser().parseFromString(responseText, 'text/html');
 8                // 获取新页面中body的className，并设置回当前页面
 9                let bodyClass = newDom.body.className;
10                document.body.setAttribute("class", bodyClass)
11                // 放行，交给pjax自己处理
12                pjax._handleResponse(responseText, request, href, options);
13            }
14        } else {
15            // handle non-HTML response here
16        }
17    }
18</script>

修复主题切换

在pjax.html中加入以下内容。

1<script>
2    document.addEventListener('pjax:complete', () => {
3        // Stack脚本初始化
4        window.Stack.init();
5    })
6</script>

修复搜索

修改assets/ts/search.tsx代码，封装方法并export

 1/**
 2 * 记得把window.addEventListener('load' ...这部分代码注释掉
 3 * 初始化工作交给Stack.init()处理了，不需要这个了
 4 */  
 5...
 6function searchInit() {
 7    let search = document.querySelector('.search-result');
 8    if (search) {
 9        const searchForm = document.querySelector('.search-form') as HTMLFormElement,
10            searchInput = searchForm.querySelector('input') as HTMLInputElement,
11            searchResultList = document.querySelector('.search-result--list') as HTMLDivElement,
12            searchResultTitle = document.querySelector('.search-result--title') as HTMLHeadingElement;
13
14        new Search({
15            form: searchForm,
16            input: searchInput,
17            list: searchResultList,
18            resultTitle: searchResultTitle,
19            resultTitleTemplate: window.searchResultTitleTemplate
20        });
21    }
22}
23
24export {
25    searchInit
26}

修改assets/ts/main.ts，引入搜索初始化方法并调用

1...
2import { searchInit } from "ts/search";
3let Stack = {
4    init: () => {
5        ...
6        // 调用search脚本初始化方法
7        searchInit();
8    }
9}

tsx 类型的文件引入方式有点特殊，需要我们修改main.ts的引入方式，修改layouts/partials/footer/components/script.html，改法参考layouts/page/search.html，把JSXFactory，createElement补充上就好
修改assets/ts/search.tsx，在动态渲染数据方法末尾让pjax重新解析文档

1private async doSearch(keywords: string[]) {
2    ...
3    /* 
4    方法末尾，让pjax重新解析文档数据，识别动态渲染的数据
5    虽然当前文件没有pjax对象，但最后静态页面会生成一个整体的js文件
6    pjax对象那时就能识别到，就可成功调用
7    */
8    pjax.refresh(document);
9}

修复Latex

修改layouts/partials/article/components/math.html，添加一个元素标签，便于判断文档是否使用了KaTeX

1<div class="math-katex"></div>

在layouts/partials/footer/custom.html中引入以下代码：

 1<script>
 2    async function renderKaTeX() {
 3        // 判断当前页面是否有KateX
 4        let katex = document.querySelector(".math-katex");
 5        if (!katex) {
 6            return;
 7        }
 8        // 等待函数加载成功后，再执行渲染方法
 9        while (typeof renderMathInElement !== 'function') {
10            await delay(500);
11        }        
12        // KaTeX渲染方法
13        renderMathInElement(document.body, {
14            delimiters: [
15                { left: "$$", right: "$$", display: true },
16                { left: "$", right: "$", display: false },
17                { left: "\\(", right: "\\)", display: false },
18                { left: "\\[", right: "\\]", display: true }
19            ],
20            ignoredClasses: ["gist"]
21        });
22    }
23    
24    /**
25     * 同步延迟
26     */
27    function delay(time) {
28        return new Promise(resolve => {
29            setTimeout(resolve, time)
30        })
31    }
32
33    document.addEventListener('pjax:complete', () => {
34        renderKaTeX();
35    })
36</script>

取消pjax的时间戳

pjax会默认给网页加上时间戳，具体为表现为?t=1724141234567的样式，这样会使页面间的跳转出现问题，建议关闭。

在pjax.html中引入：

1<script>
2    document.addEventListener('DOMContentLoaded', function () {
3        if (window.pjax) {
4            window.pjax.options.cacheBust = false; // 关闭时间戳参数
5        }
6    });
7</script>

Windows系统安装与修复

Sun, 17 Aug 2025 00:00:00 +0000

系统直接安装到U盘

在微软官网找到Windows系统下载，选择需要安装的系统。
准备一个U盘（容量大于8GB），并插入电脑。
选择“创建Windows10安装媒体”，点击立即下载，将下载启动文件。
打开启动文件，同意用户协议后，选择“直接安装到U盘”，再选择安装位置，等待系统安装完成。这时系统就在U盘中，可直接启动。

注意：安装到U盘会将U盘格式化。

下载系统镜像

在上述方法的第4步，选择“下载系统镜像”，即可下载系统镜像文件。这样U盘不会格式化，仍可以储存其他文件。

系统镜像文件不是完整系统，无法直接从U盘启动。但是通过Rufus烧录的镜像则可以选择直接从U盘启动。

微PE工具箱

若只是进行系统修复而不需要重装系统，可选择使用PE系统U盘。这里推荐使用“微PE工具箱”。

什么是PE？

PE简单而言就是一个极简的Windows系统，通常无法联网，但保留了系统的基本操作功能。在PE模式下，原系统的所有文件都相当于普通硬盘的文件，可以任意删除（包括Windows\System！）。

在微PE工具箱官网下载微PE工具箱。
准备一个U盘（容量大于8GB），并插入电脑。
打开微PE工具箱，选择右下角的安装到U盘，将打开设置界面。

“格式化”如果勾选，则U盘会格式化。

“U盘卷标”表示安装后U盘的名称。

设置完成后点击安装，等待片刻后PE系统就会安装到U盘中。此时查看“此电脑”，通常会出现一个“EFI”和另一个空盘。“EFI”盘是PE系统，另一个空盘可以作为普通U盘使用，可以储存系统镜像文件。

参考视频：

提示：为了获取更好的视频观看体验，请从PC端访问或在手机上开启电脑模式。

安装系统

微PE

Termux使用小技巧

Sun, 10 Aug 2025 00:00:00 +0000

Termux简介

Termux是Android系统上的Linux终端模拟器，能够让用户在未获取root权限的情况下运行Linux虚拟机，并可以安装多个Linux发行版。

Termux下载Linux发行版

方法1：使用TMOE工具

TMOE是GitHub的2moe大佬制作的容器一键安装脚本（目前不再更新，但仍可继续使用，最新支持Ubuntu 24.04 (LTS) 和Debian 13）

输入curl -LO https://gitee.com/mo2/linux/raw/2/2.awk && awk -f 2.awk下载TMOE工具，之后默认全输入Y。
在语言选择界面使用小键盘的“↑”、“↓”键选择所需语言。

语言选择界面

选择第一个proot容器，模拟root环境，按回车继续。

环境选择

选择终端配色和字体，看个人喜好。
是否创建termux.properties，看个人喜好。
选择DNS解析地址，建议选择阿里（Ali）

DNS设置

是否需要启用“一言”，看个人喜好。

启用“一言”可以让终端界面出现颜文字、古诗句、名言警句等，很有意思，建议开启。

选择时区，默认选“Yes”。
选择共享sd目录，这个需要慎重考虑，它关系到你的Linux发行版的用户文件目录。尽量不要共享整个sd目录，建议选择自定义路径。

共享sd目录

到此为止，TMOE的配置工作全部结束，接下来就可以安装自己喜欢的Linux发行版了。

方法2：古法装机

Termux启动SSH功能

Termux配置SSH功能后，可以搭配Serverbox软件实现监测Android系统运行状态的功能，还是挺有用的。

安装并启动 SSH 服务打开 Termux，依次执行以下命令：

1pkg update && pkg upgrade -y    # 更新软件包列表
2pkg install openssh -y          # 安装 OpenSSH
3sshd                            # 启动 SSH 服务（默认端口为 8022）

注意：Termux 的 SSH 服务默认监听端口是 8022，不是常见的 22。

查看用户名和 IP 地址

1whoami      # 查看用户名（后续连接用）
2ifconfig    # 查看本机 IP 地址（需在局域网内）

记下类似 192.168.x.x 的 IP 地址和用户名（如 u0_a123）。

设置登录密码（可选）

1passwd

输入两次密码即可设置完成。

Termux 默认仅支持密钥登录，密码登录需额外配置。

接下来就可以使用SSH连接工具连接Termux了。

Linux系统小技巧

Mon, 04 Aug 2025 00:00:00 +0000

Linux发行版

发行版名称	基础系统	特点	适用场景	推荐用户群体
Ubuntu	Debian	易用性高、软件生态丰富、社区支持强大	桌面、服务器	初学者、开发者、企业用户
Linux Mint	Ubuntu/Debian	界面友好、预装丰富软件、高度易用	桌面	从 Windows 转过来的新用户
Fedora	独立开发	新技术前沿、更新频繁、适合尝鲜	桌面、服务器	开发者、技术爱好者
Zorin OS	Ubuntu	类似 Windows 的 UI、预装丰富软件	桌面	初学者、Windows 迁移用户
Debian	独立开发	稳定性高、自由软件精神、适合服务器	服务器、桌面	高级用户、企业用户
AlmaLinux	RHEL	免费、与 RHEL 高度兼容	服务器	企业用户、开发者
Ubuntu LTS	Debian	长期支持、稳定性高	服务器、桌面	企业用户、个人用户
Kali Linux	Debian	安全测试、渗透测试、内置大量安全工具	安全测试、渗透测试	安全专家、渗透测试人员
Raspberry Pi OS	Debian	针对 Raspberry Pi 优化、适合嵌入式设备	教育、DIY、物联网	学生、爱好者
Arch Linux	独立开发	滚动更新、高度定制、适合高级用户	桌面、服务器	高级用户、开发者
Manjaro	Arch Linux	滚动更新、优化安装和配置	桌面	中级用户、开发者

Linux系统命令

文件操作

命令	作用	示例
`ls`	列出目录内容	`ls -l`（详细信息）
`cd`	切换目录	`cd /home/user`
`pwd`	显示当前路径	`pwd`
`mkdir`	创建目录	`mkdir new_folder`
`touch`	创建空文件	`touch file.txt`
`cp`	复制文件/目录	`cp file.txt backup.txt`
`mv`	移动或重命名	`mv old.txt new.txt`
`rm`	删除文件/目录	`rm -r folder`（递归删除）
`cat`	查看文件内容	`cat file.txt`
`less`/`more`	分页查看文件	`less file.txt`
`head`/`tail`	查看文件开头/结尾	`tail -n 50 file.log`

搜索与查找

命令	作用	示例
`find`	查找文件	`find / -name "*.conf"`
`grep`	文本搜索	`grep "error" log.txt`
`which`	查找命令路径	`which python3`
`locate`	快速查找文件（需`updatedb`）	`locate bashrc`

系统信息

命令	作用	示例
`top`/`htop`	实时进程监控	`htop`（需安装）
`ps aux`	查看进程	`ps aux	grep nginx`
`df -h`	磁盘空间	`df -h`
`free -h`	内存使用	`free -h`
`uname -a`	内核信息	`uname -a`
`uptime`	系统运行时间	`uptime`

权限与用户

命令	作用	示例
`chmod`	修改权限	`chmod +x script.sh`
`chown`	修改所有者	`chown user:group file`
`sudo`	以管理员权限运行	`sudo apt update`
`adduser`	添加用户	`sudo adduser alice`
`passwd`	修改密码	`passwd`

网络操作

命令	作用	示例
`ping`	测试网络连通性	`ping google.com`
`curl`	发送HTTP请求	`curl -I https://example.com`
`wget`	下载文件	`wget https://file.tar.gz`
`ssh`	远程登录	`ssh user@192.168.1.100`
`scp`	远程复制文件	`scp file.txt user@host:/path`
`netstat`/`ss`	查看网络连接	`ss -tuln`

软件包管理（根据发行版选择）

系统	命令	示例
Debian/Ubuntu	`apt`	`sudo apt install nginx`
CentOS/RHEL	`yum`/`dnf`	`sudo dnf install nginx`
Arch Linux	`pacman`	`sudo pacman -S nginx`

其他实用命令

命令	作用	示例
`tar`	压缩/解压	`tar -xzf file.tar.gz`
`zip`	ZIP格式压缩	`unzip archive.zip`
`unzip -d`	解压到指定目录	`unzip archive.zip`
`history`	查看命令历史	`history grep ssh`
`alias`	设置命令别名	`alias ll='ls -la'`
`wc`	统计行数/单词数	`wc -l file.txt`
`diff`	比较文件差异	`diff file1.txt file2.txt`

文本编辑器

Nano

功能	命令	说明
启动 Nano	`nano [文件名]`	打开一个新文件或已存在的文件。如果文件不存在，将创建一个新文件。
保存文件	`Ctrl + O`	保存当前文件，按 `Enter` 确认保存路径和文件名。
退出 Nano	`Ctrl + X`	退出 Nano。如果文件有未保存的更改，会提示是否保存。
撤销更改	`Ctrl + U`	撤销最近的更改。
跳到文件顶部	`Ctrl + _`	跳到文件的第一行。
跳到文件底部	`Ctrl + Shift + _`	跳到文件的最后一行。
跳到指定行	`Ctrl + _`，输入行号，`Enter`	跳到指定的行号。
删除字符	`Backspace`	删除光标所在位置的字符。
删除光标前字符	`Ctrl + Backspace`	删除光标前的字符。
剪切到行尾	`Ctrl + K`	剪切从光标位置到行尾的内容。
粘贴	`Ctrl + U`	粘贴剪切的内容。
查找文本	`Ctrl + W`	查找文本，输入要查找的内容后按 `Enter`。
替换文本	`Ctrl + \`	替换文本，输入要查找的内容，按 `Enter`，再输入要替换的内容，按 `Enter`。
自动缩进	`Ctrl + I`	在新的一行中自动缩进。
显示帮助菜单	`Ctrl + G`	显示 Nano 的帮助菜单。
切换拼写检查	`Ctrl + T`	切换拼写检查功能（需要安装拼写检查工具）。
显示行号	`nano -l [文件名]` 或 `Ctrl + C`	启动时加上 `-l` 参数显示行号，或在编辑时按 `Ctrl + C` 显示当前行号和列号。

Vim

功能	命令模式	说明
启动 Vim	`vim [文件名]`	打开一个新文件或已存在的文件。如果文件不存在，将创建一个新文件。
模式切换	`i`	切换到插入模式（可以输入文本）。
	`Esc`	从插入模式返回到命令模式。
	`v`	切换到可视模式（逐字符选择）。
	`V`	切换到可视行模式（逐行选择）。
	`Ctrl + v`	切换到可视块模式（逐列选择）。
保存和退出	`:w`	保存文件。
	`:wq` 或 `ZZ`	保存并退出 Vim。
	`:q`	退出 Vim（如果文件有未保存的更改，会提示）。
	`:q!` 或 `ZQ`	强制退出 Vim，不保存更改。
光标移动	`h`、`j`、`k`、`l`	左、下、上、右移动光标。
	`gg`	跳到文件顶部。
	`G`	跳到文件底部。
	`:行号`	跳到指定行号。
	`Ctrl + f`	向下翻页。
	`Ctrl + b`	向上翻页。
编辑操作	`x` 或 `Del`	删除光标所在位置的字符。
	`dd`	删除光标所在的整行。
	`yy` 或 `Ctrl + y`	复制光标所在的整行。
	`p`	粘贴复制的内容（粘贴到光标下方）。
	`P`	粘贴复制的内容（粘贴到光标上方）。
	`u`	撤销最近的更改。
	`Ctrl + r`	重做撤销的更改。
查找和替换	`/搜索内容`	向下查找指定的文本。
	`?搜索内容`	向上查找指定的文本。
	`n`	查找下一个匹配项。
	`N`	查找上一个匹配项。
	`:%s/旧内容/新内容/g`	替换文件中所有匹配的文本。
其他功能	`:help`	显示帮助文档。
	`:set number` 或 `:set nu`	显示行号。
	`:set nonumber` 或 `:set nonu`	隐藏行号。
	`:set ignorecase` 或 `:set ic`	在查找时忽略大小写。
	`:set noignorecase` 或 `:set noci`	在查找时区分大小写。

SSH连接Linux系统

参见：SSH配置简介

Hugo-stack主题装饰

Sat, 02 Aug 2025 00:00:00 +0000

基本原理

Hugo的stack主题提供了自定义样式的接口，主要在layouts/partials/footer/custom.html和assets/scss/custom.scss中
Hugo的文件可以实现文件覆盖。只要文件位置与themes文件夹中的相同，就会先加载自定义文件。

页面布局

首页文章样式

在/assets/scss/custom.scss加入

 1/*主页文章图片样式*/
 2$image-scale: 1.2;
 3.article-list article .article-image img {
 4    width: 100%;
 5    height: 150px;
 6    object-fit: cover;
 7    //不同显示器（手机，小屏幕电脑，大屏幕电脑）显示的图片高度大小
 8    @include respond(sm) {
 9        height: 305px;
10    }
11    
12    @include respond(md) {
13        height: 305px;
14    }
15    @include respond(xl) {
16        height: 325px;
17    }
18}
19
20/*主页文章图片圆角*/
21.article-list article {
22    --card-border-radius: 24px;
23}
24
25/*文章标签圆角*/
26.article-category a, .article-tags a {
27    border-radius: 11px;
28}
29
30
31/*鼠标移动到文章图片放大*/
32.article-list article .article-image {
33    position: relative;
34    overflow: hidden; //不显示超出的部分
35}
36
37.article-list article .article-image img:hover {
38    transform: scale($image-scale); //放大尺寸
39}
40
41.article-list article .article-image img {
42    transition: transform 0.85s ease-in-out;//持续时间
43}

修改归档和友链界面

修改assets/scss/custom.scss文件，引入以下css样式代码：

 1@media (min-width: 1024px) {
 2    .article-list--compact {
 3        display: grid;
 4        // 目前是两列，如需三列，则后面再加一个1fr，以此类推
 5        grid-template-columns: 1fr 1fr;
 6        background: none;
 7        box-shadow: none;
 8        gap: 1rem;
 9
10        article {
11            background: var(--card-background);
12            border: none;
13            box-shadow: var(--shadow-l2);
14            margin-bottom: 8px;
15            margin-right: 8px;
16            border-radius: 16px;
17        }
18    }
19}

代码块样式

代码块行标设置

在config.yaml中找到highlight部分：

1highlight:
2    noClasses: false
3    codeFences: true
4    guessSyntax: true
5    lineNoStart: 1
6    lineNos: true                   # 是否显示行号
7    lineNumbersInTable: false       # 行号是否独立成列
8    tabWidth: 4

MacOS风格图标

准备一张macOS代码块的红绿灯图片放到static/icons文件夹下，或者将以下代码写入code-header.svg文件中：

1<svg xmlns="http://www.w3.org/2000/svg" version="1.1"  x="0px" y="0px" width="450px" height="130px">
2    <ellipse cx="65" cy="65" rx="50" ry="52" stroke="rgb(220,60,54)" stroke-width="2" fill="rgb(237,108,96)"/>
3    <ellipse cx="225" cy="65" rx="50" ry="52"  stroke="rgb(218,151,33)" stroke-width="2" fill="rgb(247,193,81)"/>
4    <ellipse cx="385" cy="65" rx="50" ry="52"  stroke="rgb(27,161,37)" stroke-width="2" fill="rgb(100,200,86)"/>
5</svg>

将以下代码复制进assets/scss/custom.scss文件中。

 1.highlight {
 2    border-radius: var(--card-border-radius);
 3    max-width: 100% !important;
 4    margin: 0 !important;
 5    box-shadow: var(--shadow-l1) !important;
 6}
 7
 8.highlight:before {
 9    content: "";
10    display: block;
11    // 这里填图片地址
12    background: url(../icons/macOS-code-header.svg) no-repeat 0;
13    background-size: contain;
14    height: 18px;
15    margin-top: -10px;
16    margin-bottom: 10px;
17}

复制不显示行号

在assets/ts/main.ts中找到copyButton项，修改为以下内容：

 1copyButton.addEventListener('click', () => {
 2    // 创建一个临时容器来克隆代码块的内容
 3    const tempCodeBlock = codeBlock.cloneNode(true) as HTMLElement;
 4
 5    // 删除行号，行号的元素是 <span class="ln">
 6    const lineNumbers = tempCodeBlock.querySelectorAll('.ln');
 7    lineNumbers.forEach(lineNumber => lineNumber.remove());
 8
 9    // 获取没有行号的纯文本内容
10    const codeText = tempCodeBlock.textContent;
11
12    navigator.clipboard.writeText(codeText || '')
13    // navigator.clipboard.writeText(codeBlock.textContent)
14        .then(() => {
15            copyButton.textContent = copiedText;
16
17            setTimeout(() => {
18                copyButton.textContent = copyText;
19            }, 1000);
20        })
21        .catch(err => {
22            alert(err)
23            console.log('Something went wrong', err);
24        });
25});

可视化加载条

下载【文件】，并将压缩包中的topbar.min.js移动至assets/js中。
在layouts/partials/footer/custom中加入以下代码：

 1{{ with resources.Get "js/topbar.min.js" }}
 2    <!-- 引入本地JS脚本 -->
 3    <script src={{ .Permalink }}></script>
 4{{ end }}
 5<script>
 6    // 修改进度条颜色
 7    topbar.config({
 8        barColors: {
 9            '0': 'rgba(255,  255, 255, 1)', // 进度0%白色
10            '1.0': 'rgba(0, 149, 234,  1)' // 进度100%蓝色
11        }
12    })
13	
14    document.addEventListener('pjax:send', () => {
15        // 显示顶部进度条
16        topbar.show();
17    })
18	
19    document.addEventListener('pjax:complete', () => {     
20        // 隐藏顶部进度条
21        topbar.hide();
22    })
23</script>

网页组件

若想在网页中加入自定义内容，一种方法是在模版中写入.html源码；另一种方法是将代码封装成组件（widget），再以链接的方式引入模板中。

后者可以方便地实现代码复用，对原模版的改动也最小。实际上，每个组件本质上就是一个网页文件（.html），然后放入模版文件中即可实现在网页上加载。

以下提供了几个示例，供您参考。

首页欢迎栏

在/layouts/partial/widget/中新建文件welcome-bar.html，写入以下内容：

 1<!-- 首页欢迎字幅 -->
 2<div class="welcome">
 3    <p style="font-size: 2rem; text-align: center; font-weight: bold">
 4        <span class="shake">👋</span>
 5        <span class="jump-text1" > Welcome</span>
 6        <span class="jump-text2"> To </span>
 7        <span class="jump-text3" style="color:#e99312">Wei Qi</span>
 8        <span class="jump-text9" style="color:#e99312">Blog</span>
 9    </p>
10</div>
11<!-- 首页欢迎字幅 -->

在/assets/scss/custom.scss里加入：

 1//首页欢迎板块样式
 2.welcome {
 3    color: var(--card-text-color-main);
 4    background: var(--card-background);
 5    box-shadow: var(--shadow-l2);
 6    border-radius: 30px;
 7    display: inline-block;
 8}
 9
10// 👋emoji实现摆动效果
11.shake {
12    display: inline-block;
13    animation: shake 1s;
14    animation-duration: 1s;
15    animation-timing-function: ease;
16    animation-delay: 0s;
17    animation-iteration-count: 1;
18    animation-direction: normal;
19    animation-fill-mode: none;
20    animation-play-state: running;
21    animation-name: shake;
22    animation-timeline: auto;
23    animation-range-start: normal;
24    animation-range-end: normal;
25    animation-delay: 2s;
26    @keyframes shake {
27        0% {
28            transform: rotate(0);
29        }
30        25% {
31            transform: rotate(45deg) scale(1.2);
32        }
33        50% {
34            transform: rotate(0) scale(1.2);
35        }
36        75% {
37            transform: rotate(45deg) scale(1.2);
38        }
39        100% {
40            transform: rotate(0);
41        }
42    }
43}
44
45// 实现字符跳动动画
46.jump-text1 {
47    display: inline-block;
48    animation: jump 0.5s 1;
49}
50.jump-text2 {
51    display: inline-block;
52    animation: jump 0.5s 1;
53    animation-delay: 0.1s;
54}
55.jump-text3 {
56    display: inline-block;
57    animation: jump 0.5s 1;
58    animation-delay: 0.2s;
59}
60.jump-text9 {
61    display: inline-block;
62    animation: jump 0.5s 1;
63    animation-delay: 0.9s;
64}   
65
66@keyframes jump {
67    0% {
68        transform: translateY(0);
69    }
70    50% {
71        transform: translateY(-20px);
72    }
73    100% {
74        transform: translateY(0);
75    }
76}

实际上，这些css代码也可以直接写在welcome-bar.html的<style></style>标签中，在以下组件中同理。

随机文字卡片

随机效果

随机效果依赖javascript脚本：

 1// 获取并展示文字内容
 2function showQuotes() {
 3    // 随机文字
 4    index = Math.floor(Math.random() * quotes.length);
 5    const quote = quotes[index];
 6        
 7    // 获取文字和作者信息
 8    const textElement = document.querySelector(".quote-text");
 9    const authorElement = document.querySelector(".quote-author");
10
11    textElement.innerText = quote.quote;
12    authorElement.innerText = `—— ${quote.author}`;
13
14    // 渲染数学公式（可选）
15    renderMathInElement(textElement, {
16        delimiters: [
17            {left: '$$', right: '$$', display: true},
18            {left: '$', right: '$', display: false},
19            {left: '\\[', right: '\\]', display: true},
20            {left: '\\(', right: '\\)', display: false}
21        ]
22    });
23};

完善实现事件还需要增加一个按钮，实现点击就能随机显示文字。

1<button id="new-quote">Random</button>

然后赋予其点击事件：

1<script>
2    document.querySelector("#new-quote").addEventListener("click", showQuotes);
3</script>

设置配置文件

如果将文字内容写在.html文件内部，可配置性不佳，而且会使代码臃肿。因此，可以将随机文字的内容写入json文件并放入static/文件夹中。

为什么放入static文件夹？

static文件夹存放网页的静态内容，通俗点就是其中的内容就在站点目录之下。例如站点名为https://www.example.com，那么static/quotes.json就在https://www.example.com/quote.json处，在寻找时可以直接输入/quotes.json。

密码栏

在网页中显示组件

主页显示

在index.html中加入：

1<section class="article-list">
2    ...
3    {{ partial "widget/你的组件名.html" . }}
4    ...
5</section>

侧边栏

1page:
2    - type: toc
3    - type: 你的组件名

使用Hugo搭建网站

Sat, 02 Aug 2025 00:00:00 +0000

Hugo环境配置

点击进入Hugo下载地址，下载最新的release文件。

创建博客网站

准备步骤

在hugo对应的文件夹内打开cmd，输入hugo new site 你的文件夹名，可以看到多出一个新的空文件夹。

进入空文件夹，在cmd中输入hugo service build。可以看到网站在localhost:1313转发，在浏览器中输入该网址即可看到当前网站的内容。

下载Hugo主题

在Hugo官网上进入Theme，下载需要的主题文件，解压后放入网站文件夹的theme子文件夹。

接着在下载的主题文件夹中复制content文件夹和hugo.yaml（或hugo.toml）文件，粘贴到你的网站文件夹中。

打开主题的配置文件，找到theme: hugo-theme-stack一行，这里标明所使用主题的名称，须保持名称与主题文件夹的名称相同，否则要修改其一。再次执行hugo service build，即可看到使用了主题的网站。

创建自定义内容

Hugo网站的文章内容均在content文件夹中，每篇文章对应一个子文件夹。

每篇文章均采用Markdown语法书写，通常在文章开头有类似的配置文字：

1---
2title: xxxxx            # 文章的标题
3description: xxxxx      # 文章的副标题
4date: xxxxx             # 文章的日期
5slug: xxxxx             # 文章在静态页面所属的文件夹
6categories:
7    - xxxxx             # 文章所属类别
8---

必须包含这些内容网站才会显示对应文章。

文章正文参照Markdown语法规则。

Hugo构建命令

完成网页的编辑后，需执行Hugo的构建命令，方能生成网页文件。

1hugo server -D    #构建本地网页
2hugo              #构建在线网页
3hugo --cleanDestinationDir  #清理构建文件夹

注意事项

使用hugo server -D命令构建的是本地网页，遇到超链接时会重定向到localhost:1313/xxx，不能直接部署到GitHub等服务器上，必须再执行一次hugo命令清除本地链接的内容之后，才能正确部署。

参考视频：

在Github上托管网页

Github网站提供了“Github Pages”功能，允许用户为自己的项目部署一个静态网页。

创建网站仓库

注册Github账号，并创建一个新仓库，命名为你的用户名.github.io。

为什么命名为你的用户名.github.io？

Github的Pages分为两种，一种为用户Pages，另一种为项目Pages。用户Pages每个账号只能拥有一个，域名为https://你的用户名.github.io；项目Pages数目不限，域名为https://你的用户名.github.io/你的项目名.

因此，设置仓库名为你的用户名.github.io可以使网站地址更简洁。

生成静态网页文件

在命令行中执行

1hugo

执行完成后会在工作区文件夹中出现一个public文件夹，进入该文件夹。

上传文件至Github

参见：玩转Github

参考视频：

插入其他资源

插入图片

1{{< figure src="图片路径" width="宽度" height="高度" title="图片标题" >}}

插入视频

1<!-- 插入Bilibili视频 -->
2{{/* < bilibili bv号 分p(可选) */>}}

Hugo网站搭建内部链接

使用相对路径链接

相对路径是根据当前页面的位置来定位目标页面的路径。这是最简单且常用的方式之一。

假设你的网站目录结构如下：

1content/
2├── about.md
3├── blog/
4│   ├── post1.md
5│   └── post2.md
6└── projects.md

在about.md中链接到 blog/post1.md：

1[访问博客文章](blog/post1)

在 blog/post1.md 中链接到projects.md：

1[查看项目](../projects)

在 blog/post1.md 中链接到同级的post2.md：

1[查看另一篇文章](post2)

使用绝对路径链接

绝对路径是从网站的根目录开始的完整路径。这种方式的好处是不受当前页面位置的影响。

假设你的网站根目录是 https://example.com ，目录结构同上。

在about.md中链接到 blog/post1.md：

1[访问博客文章](/blog/post1)

在 blog/post1.md 中链接到projects.md：

1[查看项目](/projects)

使用 Hugo 的 ref 和 relref 短代码

Hugo 提供了 ref 和 relref 短代码，可以更智能地处理内部链接。这些短代码会根据页面的路径自动解析链接。

ref 短代码：生成绝对路径链接。

1[访问博客文章]({{< ref "blog/post1.md" >}})

relref 短代码：生成相对路径链接。

1[访问博客文章]({{< relref "blog/post1.md" >}})

链接到页面的特定部分

如果你希望链接到页面的某个特定部分（例如某个标题），可以通过锚点（anchor）来实现。

假设post1.md中有一个标题：

1## 我的博客文章内容 {#my-section}

你可以通过以下方式链接到这个部分：

1[查看博客文章的特定部分](/blog/post1#my-section)

链接到页面的别名

如果某些页面有别名（例如在 frontmatter 中定义了 aliases），你可以直接使用别名来链接。

假设post1.md的 frontmatter 中定义了别名：

1---
2title: "我的博客文章"
3aliases:
4  - "/old-post1"
5---

你可以通过以下方式链接到它：

1[访问旧的博客文章](/old-post1)

SSH配置简介

Thu, 31 Jul 2025 00:00:00 +0000

选择SSH应用程序

Visual Studio Code

这是目前为止最强大的SSH应用，只需下载VScode并安装Remote-ssh插件，写好配置文件后就能连接。

全程免费，而且附带端口转发、文件编辑、下载等功能，绝对好用！

Tabby

Tabby是一款现代的终端应用，界面简洁。

Tabby的Github仓库

ServerBox

ServerBox是一款国产的远程服务器监控和操作应用，支持Windows、Linux、Android、MacOS等操作系统。优点是可以监测服务器实时运行状态（包括CPU、内存、温度、网络、硬盘等）。

注意，Serverbox自带的脚本只支持监控Linux系统的运行数据，对于WSL系统，只能监控部分数据。

ServerBox的Github仓库

以下是各ssh应用程序的功能比较：

应用	特点	平台
VScode	功能最强大	Windows/Linux/MacOs
Tabby	界面简洁美观	Windows/Linux/MacOS
Serverbox	可以监控服务端的运行	Windows/Android

配置 SSH

连接到远程主机的原理与连接MC服务器类似，关键在于确定远程主机的IP地址和端口。

Windows系统

安装 SSH 服务

首先在要连接的主机上打开设置，搜索“可选功能”，在“添加可选功能”中搜索“OpenSSH服务器”，下载该功能。

启动并配置 SSH 服务

管理员权限打开Powershell，输入：

1Start-Service sshd
2Set-Service -Name sshd -StartupType 'Automatic'

然后开放防火墙端口（默认22）：

1New-NetFirewallRule -Name sshd -DisplayName 'OpenSSH Server' -Enabled True -Direction Inbound -Protocol TCP -Action Allow -LocalPort 22
2
3# 其中'OpenSSH Server'是协议的名称，可自行修改
4# 这样默认同时开启IPV4和IPV6的端口，即“127.0.0.1:22”和“[0:0:0:0]:22”

还可以通过以下方法实现：

步骤	操作
①	打开防火墙高级设置：控制面板 > Windows Defender 防火墙 > 高级设置（或`win+R`输入`wf.msc`）
②	新建入站规则：右键“入站规则” > 新建规则。
③	选择规则类型：选择“端口” > 下一步。
④	指定端口和协议：协议类型：选择 TCP（或 UDP，视应用而定）；特定本地端口：输入 22 > 下一步。
⑤	选择操作：选择“允许连接” > 下一步。
⑥	选择配置文件：默认全选（域、专用、公用）> 下一步。
⑦	指定规则名称：如“允许 IPv6 22222 端口” > 完成。

如果有时开放了防火墙但仍无法连接，可尝试重启电脑（我就是这样解决的……）

Linux系统

安装 OpenSSH Server

1sudo apt update
2sudo apt install openssh-server

启动 SSH 服务

1sudo systemctl start ssh
2sudo systemctl enable ssh   # 设置开机自启
3sudo systemctl status ssh   # 检查ssh运行状态

输出中应显示active (running)。

配置防火墙

允许 SSH 默认端口（22）：

1sudo ufw enable  # 如果防火墙未启用
2sudo ufw allow ssh

获取服务器的IP地址

1ip a  # 或 hostname -I

找到类似 192.168.x.x 的局域网 IP 或公网 IP（如果适用）。

WSL系统

安装 OpenSSH Server

打开 WSL 中的 Ubuntu 终端，执行：

1sudo apt update
2sudo apt install openssh-server

配置 SSH

编辑配置文件：

1sudo nano /etc/ssh/sshd_config

确保以下配置项存在且未被注释：

1...
2Port 22
3...
4PasswordAuthentication yes
5PermitRootLogin yes

如果要启用IPV6的SSH连接，还应该保持以下内容未被注释：

1Port 22
2AddressFamily any
3ListenAddress 0.0.0.0
4ListenAddress ::

启动 SSH 服务

在 WSL 中，不能使用 systemctl，请使用：

1sudo service ssh start

验证服务是否运行：

1sudo service ssh status
2# 或使用
3ps aux | grep sshd

注意事项:

必须保证Windows防火墙的22端口已被放行；

WSL系统是Windows的子系统，在Windows开机时，WSL的ssh功能默认并不能开启，此时需要将WSL的ssh注册为系统服务实现Windows开机时启用WSL的ssh功能。

下面给出使用任务计划程序（无需第三方程序）的方法：点击展开

打开任务计划程序 Win+R → taskschd.msc

创建任务：

选项	操作
名称	StartWSL
触发器	选择「计算机启动时」
操作	新建 →程序/脚本：`wsl.exe`，参数：`-d Ubuntu-22.04 -u root /usr/sbin/service ssh start`（或 `-d Ubuntu-22.04 true` 单纯启动实例）
设置	勾选「允许任务按需运行」

保存时输入管理员密码。重启测试即可。

Termux

参见：Termux启动SSH功能

连接 SSH

在 Windows 本地测试：

1ssh 用户名@localhost

从局域网其他设备连接：

1ssh 用户名@<Windows主机IP>

VScode的SSH配置文件:

1Host xxxx                       # Host的名称，可自定义
2    HostName xxx.xxx.xxx.xxx    # SSH服务端的IP地址
3    User xxxxx                  # 登录的用户名
4    Port xxxxx                  # SSH服务端的IP端口

注意：VScode的Host名会绑定远程主机的操作系统（Windows、Linux、MacOS）。如果使用同一个Host名连接不同操作系统的主机，需要在设置中修改，否则会报错。（就因为这个，让我花了近1小时）

修改方法：打开设置 → 搜索Remote Platform → 修改相应项的值

HarmonyOS入门

Mon, 14 Jul 2025 00:00:00 +0000

鸿蒙项目结构

 1entry
 2├── preview
 3├── src
 4    ├── main
 5        ├── ets         # 存放代码文件
 6            ├── entryability
 7            ├── entrybackupability
 8            ├── pages
 9                ├── Index.ets
10        ├── resources   # 存放资源文件

示例文件Index.ets

 1@Entry          // Index文件入口
 2@Component      // 声明以下为组件
 3struct Index {
 4    @State message: string = 'Hello World';
 5
 6    build() {
 7        RelativeContainer() {
 8            Text(this.message)    // 系统组件
 9                .id('HelloWorld')
10                .fontSize($r('app.float.page_text_font_size'))
11                .fontWeight(FontWeight.Bold)
12                .alignRules({
13                    center: { anchor: '__container__', align: VerticalAlign.Center },
14                    middle: { anchor: '__container__', align: HorizontalAlign.Center }
15                })
16                .onClick(() => {
17                    this.message = 'Welcome';
18                })
19        }
20            .height('100%')
21            .width('100%')
22    }
23}

变量和数据类型

一般变量

信息类型	数据类型
文字信息	字符串类型（string）
数字信息	数字类型（number）
状态信息	布尔类型（boolean）

声明变量：

1let parameter: type = value

数组

数组是一种容器，用来存储多个同类型数据。数组中元素的索引从0开始。

声明数组：

1let array: type[] = [data1,data2,data3,...]

对象

对象可以一次性存储多个不同类型的数据。在HarmonyOS中，使用接口约定对象的结构和类型。

声明对象：

 1interface Interface {
 2    parameter1: type1
 3    parameter2: type2
 4    ...
 5    parametern: typen
 6}
 7
 8// 约定接口后相应对象中应包含接口中的所有数据类型
 9let object: Interface = {
10    parameter1: data1,
11    parameter2: data2,
12    ...
13    parametern: datan
14}
15
16// 访问方法
17fun(object.data1)

函数

普通函数

定义函数

1function fun (parameter1: type1, parameter2: type2,...) {
2    ...
3    return value
4}

调用函数

1fun(parameter1, parameter2,...)
2
3//可以使用变量接收函数返回值
4let text: string = fun()

箭头函数

1// 定义函数
2let fun = (parameter1: type1, parameter2: type2, ...) => {
3    ...
4    return value
5}
6
7// 调用函数
8fun(parameter1, parameter2)

自定义构建函数

可以将组件的构建函数封装到@Builder中。

 1@Entry
 2@Component
 3struct Index {
 4    // 定义自定义构建函数
 5    @Builder
 6    name (parameterList) {
 7        component
 8    }
 9    
10    build() {
11        Column() {
12            // 使用自定义构建函数
13            this.name(parameterList)
14        }
15    }
16}

组件

ArkUI（方舟开发框架）：构建鸿蒙应用界面的框架

组件：界面构建与显示的最小单位

两类基本组件

容器组件：控制布局

1// 写法：组件名() {}
2
3Cloumn() {}   // 内容竖排
4Row() {}      // 内容横排

build() {} 中只允许存在一个根组件，但组件允许嵌套使用。

内容组件：内容

1// 写法：组件名()
2
3Text('内容')    // 文本组件
4Button()       // 按钮组件
5Image(url)     // 图像组件
6List()         // 可滚动组件

通用属性

属性名	作用	属性值
`width`	宽度	数值（默认单位vp）
`height`	高度	数值（默认单位vp）
`backgroundColor`	背景色	色值（内置颜色或16进制色值）

给组件添加属性：

 1struct Index {
 2    build() {
 3        Column() {
 4        Text('text')
 5            .width(100)     // 宽度设为100vp
 6            .height(50)     // 高度设为50vp
 7            .backgroundColor(Color.Orange)    // 背景色设为橙色
 8            /*
 9            HarmonyOS的满屏尺寸：
10            .width(360)
11            .width('100%')
12            */
13        }
14    }
15}

文本属性

属性名	作用	属性值
`fontsize`	字体大小	数值（默认单位fp）
`fontColor`	文本颜色	色值（内置颜色或16进制色值）
`fontWeight`	字体粗细	100~900

示例：

 1struct Index {
 2    build() {
 3        Column() {
 4        Text('text')
 5            .fontSize(30)
 6            .fontColor(Color.Red)
 7            .fontWeight(400)    // 默认粗细为400
 8        }
 9    }
10}

图像属性

图片路径

1// 本地路径：设图片在entry/src/main/resource/media文件夹中
2Image($r('app.media.xx'))
3
4// 网络路径
5Image(www.example.com)

图片样式

可使用通用属性。

内外边距属性

内边距：padding，拉开内容与组件边缘的距离。

外边距：margin，拉开两个组件之间的距离。

1// 四个方向间距相同
2component()
3    .padding(10)
4    .margin(10)
5
6// 间距不同
7component()
8    .padding({top: 10, bottom: 20, left: 30, right: 40})
9    .margin({top: 10, bottom: 20, left: 30, right: 40})

示例：

 1struct Index {
 2    build() {
 3        Column() {
 4            Button('登录') 
 5                .width('100%')
 6                .margin(10)
 7            Button('注册')
 8                .width('100%')
 9        }
10            .backgroundColor('#DDDDDD')
11            .padding({
12                top: 10, 
13                bottom: 20, 
14                left: 30, 
15                right: 30
16            })
17    }  
18}

边框属性

1component() 
2    .border({
3        width:    // 粗细
4        color:    // 颜色
5        style:    // 线条样式
6        radius:   // 圆角
7    })

实例：歌曲列表

 1@Entry
 2@Component
 3
 4struct Index {
 5    build() {
 6        Column() {
 7            Text('猜你喜欢')
 8                .fontColor('#fff')
 9                .width('100%')
10                .margin({bottom: 10})
11
12            List() {
13                // 音乐卡片1
14                ListItem() {
15                    Row() {
16                        // 音乐封面
17                        Image($r('app.media.1'))
18                            .width(80)
19                            .border({radius: 8})
20                            .margin({right: 10})
21
22                        // 音乐信息
23                        Column() {
24                            Text('xxx')
25                                .fontColor('#F3F3F3')
26                                .width('100%')
27                                .fontWeight(700)
28                                .margin({bottom: 15})
29                            Row() {
30                                Text('VIP')
31                                    .fontColor('#9ABE28')
32                                    .border({
33                                        width: 1, color: '#9ABE28', radius: 12
34                                    })
35                                    .padding({
36                                        left: 5, right: 5, top: 3, bottom: 3
37                                    })
38                                    .margin({right: 10})
39
40                                Text('Singer')
41                            }
42                                .width('100%')
43                        }
44                            .layoutWeight(1)    // 占用所有剩余空间
45
46                        // 更多信息
47                        Image($r('app.media.ic_more'))
48                            .width(24)
49                            .fillColor('#FEFEFE')
50
51                    }
52                        .width('100%')
53                        .height(80)
54                        .backgroundColor(Color.Pink)
55                        .margin({bottom: 10})
56                    }
57                }
58            }
59                .width('100%')
60                .height('100%')
61                .backgroundColor('#131313')
62                .padding({left: 10, right: 10})
63                /* 扩充安全区
64                .expandSafeArea(
65                    [SafeAreaType.SYSTEM], 
66                    [SafeAreaType.TOP, SafeAreaType.BOTTOM]
67                ) 
68                */
69    }
70}

控制结构

分支语句

if分支语句

1if (condition1) {
2    code
3} else if (condition2) {
4    code
5} else {
6    code
7}

条件表达式

 1condition ? code1 : code2
 2
 3/* 等价于
 4if (condition) {
 5    code1
 6} else {
 7    code2
 8}
 9
10可用变量接收：let num: number = a>b ? a : b
11*/

条件渲染

实现满足某个条件再渲染组件的功能。

1if (condition1) {
2    component1()
3} else if (condition2) {
4    component2()
5} else {
6    component3()
7}

循环渲染

1ForEach(array, (item: type, index: number) => {
2    component
3})
4
5// item为数组中的元素，index为数组元素下标

示例：

 1let name: string[] = ['text1', 'text2', 'text3']
 2
 3@Entry
 4@Component
 5
 6struct Index {
 7    build() {
 8        Column() {
 9            ForEach(name, (item: string, index: number) => {
10                Text(item)     
11            })
12        }
13    }
14}

状态管理

应用的运行时状态是参数，当参数改变时，UI渲染刷新。

状态变量：使用装饰器修饰，状态变量数据改变会引起UI的渲染刷新。

1component
2    // 为组件添加事件
3    .event(() => {
4        code
5    })

示例：

 1// 启用HarmonyOS的V2状态管理
 2@ComponentV2
 3
 4struct Index {
 5    @Local num: number = 1
 6    // 状态必须设置数据类型
 7    // 状态必须设置初始值
 8    ...
 9        // 定义事件
10        Text(this.num.toString())
11            // 添加点击事件
12            .onClick(() => {
13                this.num ++
14            })
15    ...
16}

玩转Github

Mon, 04 Nov 2024 00:00:00 +0000

git简介

git 是一个开源的分布式版本控制系统（VCS），用于高效、快速地处理从小型到大型项目的所有内容管理。它由 Linus Torvalds（Linux 之父）于 2005 年创建，最初是为了更好地管理 Linux 内核开发。

git基本概念

术语	含义
仓库（Repository）	存储项目所有文件和历史记录的地方
工作区（Working Directory）	你电脑上实际看到的项目文件夹
暂存区（Index/Stage）	准备提交的更改区域，介于工作区和仓库之间
提交（Commit）	保存项目当前状态为一个版本
分支（Branch）	从主线上分出来的独立开发线，不影响主线
合并（Merge）	将分支的更改整合到另一个分支
远程仓库（Remote）	托管在网络上的仓库，如 GitHub、GitLab

git基本操作

克隆（clone）远程仓库到本地

1git clone https://github.com/user/repo.git

在工作区中修改文件。
暂存（add）更改到暂存区

1git add .

提交（commit）更改到本地仓库

1git commit -m "描述信息" 
2
3# 若提交时无文件更改
4git commit -m "描述信息" --allow-empty

推送（push）到远程仓库

1git push 分支名

拉取（pull）获取他人更新

1git pull origin main

变更分支

若更改未push到远程仓库中，默认保存在本地工作文件夹的.git文件夹中，此时可以对分支进行任意的修改操作。

进入工程文件夹，在终端中输入

1git log

此命令可以查看当前所有提交的具体信息，包括提交时间、作者、提交ID等。可以使用键盘的“↑”、“↓”键滚动，按q键退出。

选择需要更改的提交，复制它的ID。
退出log，在终端中输入

1git rebase -i 复制的提交ID

这样会打开一个Nano编辑器（Linux环境下），在要删除的提交前加上#，然后Ctrl+O写入、回车、Ctrl+X保存。系统会自动变更分支结构。

继续提交新的更改，变更完成。

若要更改的提交已经push到远程仓库，则只需在最后push时输入

1git pull <分支名> --force

强制变更。

注意：强制变更时应保证此时没有其他人员的提交，否则会导致分支出错。

Github使用教程

Github是当前世界最大的开源网站库，使用git操作管理所有文件。

注册一个Github账号后即可在Github上免费创建和使用仓库，也可以加入其他开源项目的开发。

添加 SSH 密钥

一些情况下，使用git push时会提示网络连接超时。这时可以尝试使用SSH协议，为你的Github账户添加 SSH 密钥。

以下操作均在Linux系统下进行。

生成SSH密钥（如果尚未生成）：

1ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
2# 引号中填写注册Github时的邮箱地址。

将公钥添加到GitHub账户：

复制公钥内容：

1cat ~/.ssh/id_rsa.pub

登录GitHub，进入Settings → SSH and GPG keys → New SSH key，粘贴公钥并保存。

更新Git远程仓库地址为SSH格式：

1git remote set-url origin git@github.com:USERNAME/REPOSITORY.git

替换USERNAME和REPOSITORY为你的GitHub用户名和仓库名。

如果是Windows系统，则需要首先安装Git Bash，然后在Git Bash中执行上述操作。

正则表达式

Thu, 10 Oct 2024 00:00:00 +0000

VScode配置C/C++运行环境

Mon, 16 Sep 2024 00:00:00 +0000

下载C/C++编译器

当前主流的C/C++编译器是gcc/g++，可以通过MinGW下载。

MinGW有32位和64位版本，推荐使用64位版，因为32位的gcc/g++版本较低，且会在VScode的调试界面出现bug。

在MinGW-64下载地址查找符合自己版本的MinGW下载（默认是Linux系统）。

对于Windows系统，推荐在对应的Github页面下载x86_64-15.2.0-release-win32-seh-ucrt-rt_v13-rev0.7z版本。下载完成后解压。

另一种获取编译器的方法是先下载一个IDE，如Dev-C++，小熊猫C++等。在其程序目录下通常会有编译器文件，可之后直接使用。

IDE附赠的编译器

配置环境变量

环境变量是计算机中的一个重要参数，它指明了在终端中输入命令的来源和功能。若缺少对应的环境变量，一些命令会显示“无法识别”。

找到并记住g++.exe文件所在目录，通常为.\mingw64\bin。

g++.exe文件地址

Win11系统下打开 设置→系统→系统信息，在“相关信息”中打开“高级系统设置”
在弹出窗口中选择“环境变量”，在新窗口中选择系统变量→Path→编辑，再在新窗口中选择新建，粘贴g++.exe文件所在的地址。之后一直点击“确定”关闭所有窗口。
在cmd窗口中输入g++ --version，若显示版本等信息则表示环境变量配置成功。

环境变量

注意：配置完 Windows 中的环境变量之后，必须重启 cmd 之后才会在 cmd 中生效。

配置VScode

了解配置原理

这部分会比较抽象，省时间可以跳过。

VScode默认有3套配置文件，均位于文件夹.vscode下。

可以通过打开设置看到：用户区、工作区、SSH。

区域	特点
用户区	可看作“全局配置”，在整个用户计算机（就是你的电脑上）均生效
工作区	仅在当前打开的文件夹内有效
SSH	当且仅当连接到SSH远程计算机时才会出现，实际上就是远程计算机的用户区配置文件

因此，若要配置运行环境，应当先创建一个文件夹作为“工作区”，然后将配置文件、源代码等文件全部放入。此后写代码和调试时都应在此文件夹中进行。

配置运行环境

创建新文件夹workspace作为工作区，在workspace文件夹内再创建文件夹.vscode和bin
在.vscode文件夹内再创建文件，分别命名为tasks.json和launch.json

文件名	作用
`tasks.json`	终端任务文件，定义在终端执行的任务。在这里用于C/C++可执行文件的构建和运行
`launch.json`	运行任务文件，定义按`F5`调试时的任务。在这里用于C/C++可执行文件的调试

也就是说，如果只是要构建和运行C/C++程序，可以只用写tasks.json。

tasks.json文件写入以下内容：

 1{
 2    "version": "2.0.0",     // 版本号，建议保持不变
 3    "tasks": [
 4        {
 5            "label": "构建C/C++文件",   // 任务名称，选择任务时将会看到
 6            "type": "shell",           // 任务类别，shell表示在终端运行
 7            "command": "g++",          // 命令名称
 8            "args": [                  // 命令参数（可自行修改）
 9                // 表示将会被替换为所操作的.cpp文件
10                "${file}",
11                "-o",
12                // 可执行文件生成的位置
13                "${workspaceFolder}\\bin\\${fileBasenameNoExtension}.exe",
14                "-g",
15                "-Wall",
16                "-static-libgcc",
17                // 编码，默认为UTF-8
18                "-fexec-charset=UTF-8",
19                // 构建的C++标准
20                "-std=c++14"
21            ],
22            "group": "build",
23            "presentation": {
24                "echo": true,
25                "reveal": "always",
26                "focus": false,
27                "panel": "new"
28            },
29            "detail": "生成可执行文件",     // 任务注释，显示为任务名称的下行小字
30            "problemMatcher": "$gcc"
31        },
32
33        {
34            "label": "构建并运行C/C++文件",
35            "type": "shell",
36            "dependsOn": "构建C/C++文件",
37            "command": "${workspaceFolder}\\bin\\${fileBasenameNoExtension}.exe",
38            "group": {
39                "kind": "build",
40                "isDefault": true   // 设置为默认操作
41            },
42            "presentation": {
43                "echo": true,
44                "reveal": "always",
45                "focus": true,
46                "panel": "new"
47            },
48            "detail": "调试器生成的任务",
49            "problemMatcher": []
50        }
51    ]
52}

在.json文件中，所有的\都应输入成\\，这一过程称为转译。

配置完成后，点击 终端→运行任务→选择所需的任务 即可构建或运行程序。或直接按Ctrl+Shift+B运行默认任务，上例中为"构建并运行C/C++文件"，相当于在终端中执行命令：

1g++ file.cpp -o file.exe -g -Wall -static-libgcc -fexec-charset=UTF-8 -std=c++14
2file.exe

构建并运行C++程序

launch.json文件（可选）写入以下内容：

 1{
 2    "version": "0.2.0",
 3    "configurations": [
 4        { 
 5            // 单文件调试
 6            "name": "Debug for one file",
 7            "type": "cppdbg",   // cppdbg对应cpptools提供的调试功能；只能是cppdbg
 8            "request": "launch",
 9            // 这里program指编译好的exe可执行文件的路径，与tasks中要对应
10            "program": "${workspaceFolder}\\bin\\${fileBasenameNoExtension}.exe",
11            "args": [],
12            "stopAtEntry": false,   // 是否在main处打断点    
13            "cwd": "${fileDirname}",    // 调试程序时的工作目录
14            "environment": [],
15            "externalConsole": false,               // 改为true时为使用cmd终端
16            "internalConsoleOptions": "neverOpen",  // 设为true为调试时聚焦调试控制台
17            "MIMode": "gdb",
18            // 指定调试器所在路径，注意间隔是\\，请修改为你的路径
19            "miDebuggerPath": "D:\\Developer\\mingw64\\bin\\gdb.exe",
20            // 调试开始前执行的任务，必须与tasks.json的label相对应
21            "preLaunchTask": "构建C/C++文件" 
22        }
23    ]
24}

配置完成后，点击 运行→启动调试 即可开始调试。或直接按F5运行。

之后，所有新建的C++文件都应在有配置文件的工作区中，这样可以直接在VScode中测试。

如果按照以上方法配置，工作区的文件结构应该如下所示：

 1workspace/
 2├── .vscode/            # 存放配置文件
 3│   ├── launch.json
 4│   └── tasks.json
 5│
 6├── bin/                # 存放构建的exe文件
 7│   ├── HelloWorld.exe
 8│   ├── Number.exe
 9│   └── {name}.exe
10│
11├── HelloWorld.cpp      # 存放源代码
12├── Number.cpp
13└── {name}.cpp

Minecraft教程

Sat, 10 Aug 2024 00:00:00 +0000

认识Minecraft

Minecraft（简称MC），作为全球销量第一的游戏，深受众多玩家喜爱。

MC分为Java版、基岩版、主机板（Xbox版）和网易版。

下载Minecraft

正版和离线版

MC的正版与否取决于你的微软账号上有没有MC。换句话说，无论是否购买正版，你都可以下载到MC的游戏文件并启动游玩。唯一的区别在于非正版玩家无法进入开启了正版验证的服务器，因此MC中的“非正版”也被称之为“离线版”。

离线版依然可以进入未开启正版验证的服务器

MC Java版启动器

MC Java版本身没有.exe之类的文件，必须得有一个启动程序才能运行。

启动器	支持系统
Minecraft Launcher （官方启动器）	Windows/MacOS
Plain Craft Launcher 2（PCL2）	Windows
Hello Minecraft Launcher （HMCL）	Windows/Linux

也有部分发烧友喜欢在Android平台上启动MC Java版。目前，Android系统流行的启动器主要是Fold Craft Launcher和ZalitLauncher

注意：千万不要指望Android平台上MC Java版的表现和Windows系统的一样。

启动器的原理就是整合了启动游戏核心 .jar文件的功能。因此如果愿意，也可以使用IntelliJ IDEA启动。

MC基岩版

MC基岩版则相对简单很多。只需要在相应的平台里下载MC基岩版即可。

平台	下载地点
Windows	Microsoft Store
Android	Google Play
iOS	Apple Store

鉴于国内通常无法打开Google网站，如果想体验Minecraft基岩版，可以在苦力怕论坛下载。

注意，论坛中下载的并非正版，请于下载体验后24小时内删除！

Minecraft Java版进阶

Java版游戏文件

Minecraft Java版对玩家文件管理的要求较高，因此需先了解其文件结构。

1.minecraft           # 游戏文件根目录
2├── assets           # 游戏资源文件夹
3├── global           # 全局配置
4├── libraries        # 加载库文件
5├── versions         # 版本文件夹（开启版本隔离后生效）
6├── …

其中versions文件夹是我们进行操作的主要位置。

版本隔离

版本隔离是MC Java版独特的功能，它使得每个Java游戏版本都相互独立，互不影响。

注意：版本隔离选项默认是关闭的，第一次使用应当在启动器设置内将“版本隔离”设置成“各版本相互独立”。

安装 MOD

Java版的优势之一就是能方便自由地安装mod、材质和光影等。

安装mod的前提是安装mod加载器，这是绝大多数mod的加载环境。常用mod加载器如下：

名称	版本支持	特点
Forge	1.5.2 - 最新	最流行，支持大量模组
Fabric	1.14 - 最新	轻量加载器，提供快照版本
NeoForge	1.20.1 - 最新	新兴加载器，由Forge发展而来，极具潜力

mod加载器一般互不兼容，只能选择其中一个。

当安装了mod加载器后，下载适配当前加载器的模组并放到对应游戏版本的/versions/你的游戏版本/mods文件夹中，启动游戏即可畅玩！

以下提供mod加载器的安装方法。

启动器内安装

PCL2、HMCL等第三方启动器内置了mod加载器下载方式，在安装新版本时即可选择是否安装mod加载器。

通用安装方法

在mod加载器相应的官网下载文件，并按说明安装。

以Forge为例进行说明：

进入Forge官网，选择需要下载的MC版本。
点击Installer，此时将跳转到广告界面。若你的网络状况较好，应当会在界面右上角出现“SKIP”按钮，点击“SKIP”即可下载Forge文件。
定位到文件所在位置，双击打开.jar文件，稍等一会儿就会打开安装界面，选择“Install client”，再选择安装位置，点击确定即可安装成功。

Forge

此时打开启动器，应当能在版本列表中看到刚安装的Forge版本。

安装材质和光影

安装材质的方法较为简单，直接下载好需要的材质文件（通常是压缩包的形式），将其放入/versions/你的游戏版本/resourcepacks文件夹即可。

安装光影则需要MOD的前置支持，安装好对应MOD后，将下载的光影文件放入/versions/你的游戏版本/shaderpacks文件夹。

模组加载器	对应MOD
Forge	1.12.2 以下：Optifine；1.16.5 以上：Oculus
Fabric	Iris

导入地图

地图（实际上就是一个存档）的导入就是将该地图文件夹全部放入/versions/你的游戏版本/saves文件夹中即可。

MC联机

MC的联机是一项复杂且具有挑战性的操作。学习MC的联机，您将了解并掌握《计算机网络》50% 以上的内容！

局域网联机

这是最简单的联机方式，需要房主和玩家在同一个局域网下，也就是连接同一个Wifi。

遗憾的是，校园网等大型局域网可能不支持这种方式。因为即使连接到同一个Wifi，ipv4地址的第3个十进制数（也就是网关）可能不相同，这样就无法通过 ipv4:端口号的方式联机。

幸运的是，现在一些大型局域网已经支持了ipv6。这时，可以使用[ipv6]:端口号的方式启动局域网联机。

选做：使用Radmin VPN创建虚拟局域网

不过，使用Radmin VPN创建虚拟局域网可以解决ipv4地址网关不同的问题。只需要双方同时下载Radmin VPN，由其中一方创建虚拟局域网，然后同时连接到该局域网下，即可联机成功。

之所以称之为局域网联机，是因为在这种联机操作下，服务端就是房主的客户端（也就是房主的电脑就是服务器，所以房主必须上线）。与之相对应的就是服务器联机。

服务器联机

详见：“Minecraft服务器——开服经历回顾”

常见问题

微软账号无法登录

有时网络运营商的 DNS 可能无法很好地解析微软的验证服务器地址，导致微软账号的登录界面无法进入，无法与小伙伴愉快游玩Hypixel。解决方法为更换更可靠的公共 DNS。

进入设置 > 网络和 Internet，点击正在连接的 Wi-Fi 或以太网的 “属性”。
找到 “DNS 服务器分配”，点击“编辑”。
将其更改为“手动”，然后打开 IPv4 开关。在“首选 DNS”中输入 8.8.8.8，在“备用 DNS”中输入 8.8.4.4。（这是 Google 的公共 DNS，非常稳定）。
保存设置，重新登录。

以上解决办法来源此处

更改DNS服务器后可能会影响其他网站的访问速度。当登录微软账号成功后，最好立即切换回自动DNS。

链接网站

网站	内容
MC百科	下载MC Java版mod，整合包等资源。
苦力怕论坛	下载MC基岩版资源包、行为包、材质、光影、地图等。
LittleSkin皮肤站	托管MC皮肤文件。
Minecraft捆绑包商店	购买Minecraft正版。
Modrinth	下载MC和MC服务器资源。

Markdown语法

Mon, 11 Mar 2019 00:00:00 +0000

本文提供了可用于 Hugo 内容文件的基本 Markdown 语法示例，还显示了 Hugo 主题中的基本 HTML 元素是否使用 CSS 进行修饰。

标题

如下的 <h1>—<h6> 显示了标题的6个级别， <h1> 级别最高， <h6> 级别最低.

1# H1
2## H2
3### H3
4#### H4
5##### H5
6###### H6

文本类型

加粗与斜体

加粗：**文本** → 文本

斜体：*文本* → 文本

下划线

<span style="text-decoration: wavy underline;"> 天津大学是中国第一所现代大学。 </span> → 天津大学是中国第一所现代大学。

<u> 2025年将迎来天津大学130周年校庆。 </u> → 2025年将迎来天津大学130周年校庆。

上下标

H<sub>2</sub>O → H₂O

X<sup>n</sup> + Y<sup>n</sup> = Z<sup>n</sup> → Xⁿ + Yⁿ = Zⁿ

方框与高亮显示

按下 <kbd>CTRL</kbd> + <kbd>ALT</kbd> + <kbd>Delete</kbd> 以结束段落。 → 按下 CTRL + ALT + Delete 以结束段落。

<mark>兴学强国</mark>的使命，<mark>实事求是</mark>的校训，<mark>严谨治学</mark>的校风，<mark>矢志创新</mark>的追求。 → 兴学强国的使命，实事求是的校训，严谨治学的校风，矢志创新的追求。

段落

普通段落

马克思主义者认为，只有人们的社会实践，才是人们对于外界认识真理性的标准。实际的情形是这样的，只有在社会实践过程中（物质生产过程中，阶级斗争过程中，科学实验过程中），人们达到了思想中所预想的结果时，人们的认识才被证实了。人们要想得到工作的胜利即得到预想的结果，一定要使自己的思想合于客观外界的规律性，如果不合，就会在实践中失败。人们经过失败之后，也就从失败取得教训，改正自己的思想使之适合于外界的规律性，人们就能变失败为胜利，所谓“失败是成功之母”，“吃一堑长一智”，就是这个道理。

段落类型

首行缩进：<p style="text-indent: 2em;margin-top: 0;margin-bottom: 0;"> 文本 </p>，其中margin-top: 0表示忽略段前空行，margin-bottom: 0表示忽略段后空行。

示例：

君子曰：学不可以已。

青，取之于蓝而青于蓝；冰，水为之而寒于水。木直中绳，輮以为轮，其曲中规。虽有槁暴，不复挺者，輮使之然也。故木受绳则直，金就砺则利，君子博学而日参省乎己，则知明而行无过矣。

吾尝终日而思矣，不如须臾之所学也；吾尝跂而望矣，不如登高之博见也。登高而招，臂非加长也，而见者远；顺风而呼，声非加疾也，而闻者彰。假舆马者，非利足也，而致千里；假舟楫者，非能水也，而绝江河。君子生非异也，善假于物也。

积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里；不积小流，无以成江海。骐骥一跃，不能十步；驽马十驾，功在不舍。锲而舍之，朽木不折；锲而不舍，金石可镂。蚓无爪牙之利，筋骨之强，上食埃土，下饮黄泉，用心一也。蟹六跪而二螯，非蛇鳝之穴无可寄托者，用心躁也。

居中：<div style="text-align: center;"> 文本 </div>或<center> 文本 </center>
左对齐：默认
右对齐：<div style="text-align: right;"> 文本 </div>

引用

引用元素表示从另一个来源引用的内容，可以选择引用必须在footer或cite元素内，也可以选择内联更改，如注释和缩写。

不含注解的引用

Tiam, ad mint andaepu dandae nostion secatur sequo quae. Note that you can use Markdown syntax within a blockquote.

包含注解的引用

不积跬步，无以至千里；不积小流，无以成江海。
——— 荀子¹

表格

表格不是Markdown语法的核心功能，但是Hugo同样为其提供了支持。

姓名	年级	专业
张三	2024级	计算机科学与技术
李四	2023级	软件工程

行内列表

斜体	加粗	代码
italics	bold	`code`

A	B	C	D	E	F
Lorem ipsum dolor sit amet, consectetur adipiscing elit.	Phasellus ultricies, sapien non euismod aliquam, dui ligula tincidunt odio, at accumsan nulla sapien eget ex.	Proin eleifend dictum ipsum, non euismod ipsum pulvinar et. Vivamus sollicitudin, quam in pulvinar aliquam, metus elit pretium purus	Proin sit amet velit nec enim imperdiet vehicula.	Ut bibendum vestibulum quam, eu egestas turpis gravida nec	Sed scelerisque nec turpis vel viverra. Vivamus vitae pretium sapien

代码块

使用三个竖撇号包裹

 1<!doctype html>
 2<html lang="en">
 3<head>
 4  <meta charset="utf-8">
 5  <title>Example HTML5 Document</title>
 6</head>
 7<body>
 8  <p>Test</p>
 9</body>
10</html>

使用Tab缩进表示

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Example HTML5 Document</title>
</head>
<body>
  <p>Test</p>
</body>
</html>

自动代码高亮

 1<!doctype html>
 2<html lang="en">
 3<head>
 4  <meta charset="utf-8">
 5  <title>Example HTML5 Document</title>
 6</head>
 7<body>
 8  <p>Test</p>
 9</body>
10</html>

代码比较

1[dependencies.bevy]
2git = "https://github.com/bevyengine/bevy"
3rev = "11f52b8c72fc3a568e8bb4a4cd1f3eb025ac2e13"
4- features = ["dynamic"]
5+ features = ["jpeg", "dynamic"]

列举类

有序列举

11. 项目一
22. 项目二
33. 项目三

效果：

项目一
项目二
项目三

无序列举

1* 项目
2* 另一个项目
3* 再一个项目

效果：

项目
另一个项目
再一个项目

嵌套列举

1* Fruit
2  * Apple
3  * Orange
4  * Banana
5* Dairy
6  * Milk
7  * Cheese

效果：

Fruit
- Apple
- Orange
- Banana
Dairy
- Milk
- Cheese

在Markdown中使用Tex

在Markdown文件中，Tex文本须使用 $…$ （行内文本）或$$…$$（行间文本）包裹.

注意：若要在行内文本中显示行间文本的样式，须加上\displaystyle.

数学符号

符号	语法	示例
空格	`a\ b`	$a\ b$
小于	`a < b` 空格不能少	$a < b$
大于	`a < b` 空格不能少	$a > b$
小于等于	`\leqslant`	$a \leqslant b$
大于等于	`\geqslant`	$a \geqslant b$
点乘	`\cdot`	$A \cdot B$
叉乘	`\times`	$ A \times B $
正负号	`\pm`	$ \pm a $
角	`\angle`	$\angle ABC $
三角形	`\triangle`	$\triangle ABC $
向量	`\overrightarrow{}`	$\overrightarrow{AB}$
推出	`\Rightarrow`	$A \Rightarrow B$
等价于	`\Leftrightarrow`	$ A \Leftrightarrow B $
粗体	`\boldsymbol{}`	$\boldsymbol{a}$
正体	`\mathrm{}`	$\mathrm{d}x$

字母	LaTeX 命令	字母	LaTeX 命令	字母	LaTeX 命令	字母	LaTeX 命令
α	`\alpha`	ν	`\nu`	Α	`\Alpha`	Ν	`\Nu`
β	`\beta`	ξ	`\xi`	Β	`\Beta`	Ξ	`\Xi`
γ	`\gamma`	ο	`\omicron`	Γ	`\Gamma`	Ο	`\Omicron`
δ	`\delta`	π	`\pi`	Δ	`\Delta`	Π	`\Pi`
ε	`\epsilon`	ρ	`\rho`	Ε	`\Epsilon`	Ρ	`\Rho`
ζ	`\zeta`	σ	`\sigma`	Ζ	`\Zeta`	Σ	`\Sigma`
η	`\eta`	τ	`\tau`	Η	`\Eta`	Τ	`\Tau`
θ	`\theta`	υ	`\upsilon`	Θ	`\Theta`	Υ	`\Upsilon`
ι	`\iota`	φ	`\phi`	Ι	`\Iota`	Φ	`\Phi`
κ	`\kappa`	χ	`\chi`	Κ	`\Kappa`	Χ	`\Chi`
λ	`\lambda`	ψ	`\psi`	Λ	`\Lambda`	Ψ	`\Psi`
μ	`\mu`	ω	`\omega`	Μ	`\Mu`	Ω	`\Omega`

公式	语法	示例
分式	`\frac{a}{b}`	$\displaystyle \frac{a}{b}$
幂	`a^{m}`	$ a^{m} $
根式	`\sqrt{2}`	$\sqrt{2}$
高次根式	`\sqrt[n]{m}`	$\sqrt[n]{m}$
下标	`a_{n}`	$ a_{n} $
方程组	`\left\{ \begin{array}{c} \end{array} \right.`	$$\left\{ \begin{array}{c} F(x,y,u,v) = 0 \\ G(x,y,u,v) = 0 \end{array} \right.$$

导数与微分

公式	语法	示例
极限	`\lim_{x \to 0}`	$\displaystyle \lim_{x \to 0}$
二重极限	`\lim_{\substack{\Delta x \to 0 \\ \Delta y \to 0}}`	$$\lim_{\substack{\Delta x \to 0 \\ \Delta y \to 0}} f(x,y)$$
导数	`f \'(x)`	$ f'(x) $
	`\frac{\mathrm{d}y}{\mathrm{d}x}`	$\displaystyle \frac{\mathrm{d}y}{\mathrm{d}x} $
	`f^{(n)}(x)`	$f^{(n)}(x)$
偏导	`\partial`	$\displaystyle \frac{\partial z}{\partial x}$

求和与积分

公式	语法	示例
求和	`\sum_{i=0}^{n}`	$\displaystyle \sum_{i=0}^{n} a_i$
求积	`\prod_{i=0}^{n}`	$\displaystyle \prod_{i=0}^{n} a_i $
积分	`\int_{a}^{b}`	$\displaystyle \int_{a}^{b} f(x) \mathrm{d}x$
	`\iint\limits_D`	$\displaystyle \iint\limits_D f(x,y) \mathrm{d}x \mathrm{d}y$
	`\oint_{L}`	$\displaystyle \oint_{L} f(x,y,z) \mathrm{d}l$
	`\oiint\limits_{\varSigma}`	$\displaystyle \oiint\limits_{\varSigma} f(x,y,z) \mathrm{d}S$

行列式与矩阵

矩阵：

1\left[
2\begin{matrix}
3a & a+b \\    # '&'是占位符，'\\'是换行符
4c+d & d \\
5\end{matrix}
6\right]

效果：

$$\left[\begin{matrix} a & a+b \\ c+d & d \\ \end{matrix} \right]$$

在等号处对齐

使用{align*}环境，在每一行公式后加上\\；在要对齐的等号前加上&。

1$$ 
2\begin{align*} 
3x_1+x_2 &= \frac{-b+\sqrt{b^{2}-4ac}}{2a} + \frac{-b-\sqrt{b^{2}-4ac}}{2a} \\ &= -\frac{b}{a}
4\end{align*}
5$$

效果：

$$ \begin{align*} x_1+x_2 &= \frac{-b+\sqrt{b^{2}-4ac}}{2a} + \frac{-b-\sqrt{b^{2}-4ac}}{2a} \\ &= -\frac{b}{a} \end{align*}$$

其他

隐藏内容

1<details>
2      <summary>点击展开隐藏内容</summary>
3      
4隐藏内容
5</details>

效果：

点击展开隐藏内容

隐藏内容

参考资料

1[图片文件](网址)

→

荀子，中国古代哲学家。 ↩︎

数学公式输入

Fri, 08 Mar 2019 00:00:00 +0000

Hugo项目中的数学符号可以通过使用第三方JavaScript库来启用。

这个例子中将会使用 KaTeX

如何使用

在 /layouts/partials/math.html 下创建文件。
使用在线JS库： Auto-render Extension 或在本地创建。
在文件中使用以下字段:

1{{ if or .Params.math .Site.Params.math }}
2{{ partial "math.html" . }}
3{{ end }}

若要在全局文件中使用KaTex，请在配置文件中将 math 设为 true .
若只在单个文件中使用KaTex，请在文件开头设置 math: true .

Note: 查询在线帮助： Supported TeX Functions

1{{< math.inline >}}
2{{ if or .Page.Params.math .Site.Params.math }}
3<!-- KaTeX -->
4<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.css" integrity="sha384-n8MVd4RsNIU0tAv4ct0nTaAbDJwPJzDEaqSD1odI+WdtXRGWt2kTvGFasHpSy3SV" crossorigin="anonymous">
5<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.js" integrity="sha384-XjKyOOlGwcjNTAIQHIpgOno0Hl1YQqzUOEleOLALmuqehneUG+vnGctmUb0ZY0l8" crossorigin="anonymous"></script>
6<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous" onload="renderMathInElement(document.body);"></script>
7{{ end }}
8{{</ math.inline >}}

举例

行内公式: $\varphi = \dfrac{1+\sqrt5}{2}= 1.6180339887…$

行间公式:

$$ \varphi = 1+\frac{1} {1+\frac{1} {1+\frac{1} {1+\cdots} } } $$

Emoji Support

Tue, 05 Mar 2019 00:00:00 +0000

Hugo 构建的网页中，有多种方式使用表情。

The emojify function can be called directly in templates or Inline Shortcodes .

To enable emoji globally, set enableEmoji to true in your site’s configuration and then you can type emoji shorthand codes directly in content files; e.g.

🙈 :see_no_evil: 🙉 :hear_no_evil: 🙊 :speak_no_evil:

The Emoji cheat sheet is a useful reference for emoji shorthand codes.

N.B. The above steps enable Unicode Standard emoji characters and sequences in Hugo, however the rendering of these glyphs depends on the browser and the platform. To style the emoji you can either use a third party emoji font or a font stack; e.g.

1.emoji {
2  font-family: Apple Color Emoji, Segoe UI Emoji, NotoColorEmoji, Segoe UI Symbol, Android Emoji, EmojiSymbols;
3}

I :heart: Hugo!