YokumiのBlog

BUPT计科专业生存不完全指北

Wed, 26 Jun 2024 09:06:00 GMT

写在前面#

关于自己为什么要写这篇博客的一些碎碎念。首先在个人进行课程学习以及期末复习的过程中，历届学长的博客都起到了非常大的帮助。主要是 19 级和 21 级，22 级似乎断代了，没有找到什么学长的博客。总之，既然自己已经整理了一些内容，也就顺便写了。至于有没有帮助，那只能说仅供大家参考，毕竟楼主的水平在计科属实蒟蒻。也欢迎后来者在评论区补充。

楼主还整理了一些有关专业分流和转专业的相关情况。

楼主的所有课程笔记在我的 Wiki 网站上，博客上也散落了一些，欢迎访问。

Warning

纯主观感受，课程情况可能与实际存在差距，请以你自己的培养方案为准，楼主参考的是 23 级计科培养方案。（听说 24 级培养方案大改，因此笔者这篇文章可能也没啥用了）。

大一上学期#

不完全按照学分顺序。

数学分析（上）#

23 级数分和高数还是二选一，24 级据我所知是只有数分了，不过话又说回来，工科数学分析的难度其实和高数没差多少。学就完了，无论对考研党还是保研党（毕竟 6 + 5 = 11 学分）都很重要。好好学之后还可以参加全国大学生数学竞赛有保研分加（当然也有很多考研党在考研前去参加，屠新手村了属于是）。

线性代数#

对工科来说也叫较水，做做往年题就行。但是其实挺重要的。

计算导论与程序设计#

基本都是计算机导论，但夹杂着少部分的 C 语言教学，高达 4.5 的学分，甚至大于 408 的专业课。平时会在 PTA （浙大的sb OJ 平台）布置 OJ 题，不过似乎不占平时分（可能和具体老师有关），不过刷刷还是有帮助的。3 次上机考试和期中期末考试也通过 PTA 的 OMS 监考系统进行。我们当时第二次机考和期中安排在一起，考了整整一上午。

机考一般是 5 道大题（共 500 分），有时候会比较恶心；期中期末有选择和填空和简答，以及根据题目要求编写程序（不用过测试样例），得背背概念。总之，学分高事也多，挺烦的，不过对大一如果之前没怎么接触过计算机的确实得好好打基础。

创新创业实践课#

培养方案里标的是指选，但事实上是必修。不同教学班的任务不太一样，笔者当时好像是一个大数据一个移动 APP 开发（可以看看笔者的轮子）。水。

习近平新时代中国特色社会主义思想概论#

印象里当时布置了一个模拟政协提案报告。期末的话，我只能说珍惜开卷时光吧。

军事理论#

水。期末有题库。好像还有篇小论文。

大一下学期#

数学分析（下）#

已经在数学分析（上）部分说了，数分下会难一些。

大学物理 C#

计院的大学物理压缩在一学期，从力学一直到光学，内容比较多，但讲的都不是很深。你说的对，但是我们那年期末考了一堆光学，服了。期中的话好像是 4 道大题，另外老师会隔几周安排小测（具体视老师而定）。这里有一些往年题；还是得花点时间，毕竟到大一下高中的物理水平已经退化的差不多了。

离散数学（上）#

人已经学的离散了。总之学的很杂，楼主已经基本忘记上册学了什么了。不过期中期末也基本都是套路题。

注意是英文教学（指 PPT 、教材、作业题和考试是英文），需要能基本知道基本概念的英文名词，能看懂。

电路与电子学基础#

首先，如果你和楼主是老乡且高中选了技术，我只能说可以少花很多精力。主要就是一些模拟电路的内容，比如二极管、三极管，电容、电感和一些元器件以及模拟电路中的数值计算。2 学分，做做作业和往年题就能学会，这里有一些参考资料。

二选一#

没什么很强烈的推荐倾向，如果你有算法竞赛基础，那推荐后者。否则的话选前者锻炼一下语言和开发基础也不错。

计算导论与程序设计课程设计#

Warning

注意，这门课在 24 级改名了，在前面加了个什么“项目制课程设计阶段一”。

我们这届做的是模拟麦当劳点餐系统，工作量还是比较大的。分为 OJ 版本和 GUI 版本。

OJ 版本强制 C 语言，并要求你的程序有一定的优化，否则通不过全部测试点。GUI 版本是组队完成（当然，你觉得一个人足够也可以一个人干，不过并不推荐，因为那时候已经临近期末了），老师一般推荐 C 自带的 EasyX 等库，楼主一个人库库干了很久并推翻了之前写的全部 C 怒转 Cpp 用 Qt 卷了个还可以的 GUI 版本。

最后 GUI 版本在线下由老师和助教一起验收，一般会看功能实现，问用了什么平台或库开发，分工，代码行数等。

24 级做俄罗斯方块，只能说很难评。甚至还有逆天助教爆了个大的。

另外，课上还是教一些 C 语言剩余的链表、文件操作等内容，也有一些 OJ 题，教的和考的，关系不大我只能说。

程序设计竞赛基础#

没选。校队✌️似乎是直接不用上给满，哎哎。期末是老师提前给一些题目，考试随机抽几道。（类似于背板子）

另外，24 级这门课安排到了大一下结束的小学期（6月底7月初）。

物理实验 A#

每个教学班具体安排的实验不太一样，一共好像是 6 个，每个一份报告。

中国近代史纲要#

哎思政课，记得签到我只能说，另外即使签到了也谨防某些老师背刺。期末开卷，且行且珍惜。

四史#

选哪个都无所谓，差不太多。记得之前论坛看到有人推荐一个老师的，具体忘了。

军训#

Warning

注意，24 级的军训安排在入学前（8月下旬）。之后不知道还会变吗。

23 级的军训安排在大一下结束（7月5号～ 19号）。夏天的北京一晒一个不吱声。

如果你参加国旗护卫队，军训成绩直接给满。不过评价是真没必要，没事给自己找罪受。

大二上学期#

这学期期中长达 1 个月，考完就差不多期末了，太 TM 逆天了。

数据结构#

408 之一。不过还是挺简单的，OJ 题 + 3 次实验，不过每年实验似乎安排的不太一样。另外，期中期末都是纸质版考试，要手写代码，可以参考往年题。

数字逻辑与数字系统#

也就是数电，东西是真的多，不过方维老师真的很好。平常作业和期中考试都是在 PTA 上布置，后期还会有一些 Verilog 的内容，期末也需要手写 Verilog 代码，所以也需要好好学，对下学期的课程设计也有帮助。

同时，有 6 次实验，后面 2 次需要用到 Verilog 编程实现。

个人的一些参考资料。

离散数学（下）#

主要是群论、图论的内容。群论看着比较难，但是考试题型固定，所以会做作业题就行。其他注意事项见离散数学（上）。

往年题。

计算机系统基础#

也就是大名鼎鼎的 CMU 的 CSAPP 课程，不过北邮做了很大程度的压缩（同时也体现在 PPT 上，对原版的 PPT 做了删减，导致看起来十分奇怪），同时压缩到了 4 个实验（2 个是照搬的 CMU 的，剩下 2 个挺简单）。

搬的 CMU 的两个实验，炸弹和缓冲区溢出攻击还是挺有意思的，可以做做，对熟悉汇编语言也有帮助。

知识点较为重要，不过如果你遇上一节课翻三位数 PPT 并且听不太懂在讲什么的老师，建议看书或者看网课自学。

个人的一些习题解答。

概率论二选一#

如果是考研党，那无脑选前者吧。

概率论与数理统计#

需要花点时间背公式（特别是假设检验部分，那真是一大坨），再做做往年题，一般也没什么问题。

概率论与随机过程#

没选，身边选的人也很少，好像整个年级选的人就一个班的人数。会讲一些马尔可夫随机过程部分的内容，对以后科研兴许有帮助？

四选一#

推荐《矩阵理论与方法》或者《数学建模与模拟》。更有甚者为了刷分，四选四或者四选三。

矩阵理论与方法#

李昊辰老师，不和分数过不去的无脑冲即可。每节课前有签到，作业一般是手抄一些定理或者完成一些代码（老师会提供参考程序）。期末是一篇大论文，老师会给出一个模版和目录，根据目录往里面填东西即可，他会要求放一些平时作业中手抄的定理等内容。

参考资料在这里。

数学建模与模拟#

听人说期末好像是一周时间完成一份卷子？总之给分也挺高。

运筹学#

不太清楚，不过好像平时作业挺多，期末是随堂开卷。

组合数学#

几乎没人选，更不清楚了。

马克思主义基本原理#

闭卷喽，一些背诵资料。

大二下学期#

我 TM 实在是懒得喷了，根据楼主自己的情况和“身边统计学”，计科大概率是被狠狠压分了（不一定完全准确，只能说大概率是。至于实际情况自己看吧，反正楼主已经在前面说明了，这篇博客纯主观）。就 byd 这个绩点计算规则你还压分，你存心不想让人保外了是吧。

计算机网络#

网络这块知识点特别细和多。计院使用的教材是 “自下往上” 的方法，并且可能是由于北邮通信的特色，又花了较多的笔墨讲物理层，不过大头还是在网络层和传输层，即 TCP/IP 部分，应用层似乎每年都是因为课时来不及直接让看的网课，不过本身考试也不涉及多少。一般期中的范围是物理层 + 数据链路层，由任课老师自行命题，卷面一般有英文以及对应中文翻译，期末是所有内容，并且卷面全英文，作答可用中文，且题量较大，题型可参考样题。是需要花不少精力学的一门课。

作业的话，每年都差不多，可以找到参考答案，不过最好得先自己完成。另外有 2 个实验，第一个数据链路层实验一般在 4 月中旬布置，5 月中旬由助教线下验收，一般会问你 GBN/SR 原理，你的具体代码实现并记录一个你当场跑的协议效率；第二个网络抓包实验只需要提交报告，无需验收。好好做，对课程理解还是有一定的帮助的。

张冬梅老师讲的还是非常不错的，并且线下、线上答疑都非常及时和耐心。至于最后给分，楼主只能说可能是整个课程组对计科都压分了，老师人还是很好的。

Warning

你猜我什么只说计科呢？按网工舍友的身边统计学，有高分，不过存在一定的方差（93 94 95 80-85 75）。我请问计科怎么你了呢？那我不得不劝人都去小专业了。

计算机组成原理#

同样是 4 学分的课，前置课程有数字逻辑与数字系统（数电）和计算机系统基础（CSAPP），虽然楼主不是很懂为什么计科要把计算机组成原理分成 4 + 2 + 4 学分的课上。楼主对于硬件并不是很擅长，CSAPP 学的更是一坨，计组学的也是没好到哪里去，关键是这期末还出一堆硬件。总之还是有难度并且需要花精力好好复习的一门课。

除作业外，类似数电，有 6 个线下实验，最后 2 个比较恶心。不过做完实验对课程知识的理解有较大的帮助。

周锋老师讲得也不错，平常有签到。至于最后给分，也是一言难尽，按照身边统计学，3 个班没有问到上 90 的，大部分都是 70 多。

形式语言与自动机#

看着有些难但实际教的和考的都不算太难？感觉期末多刷刷往年题就能基本掌握。

有 2 次实验，组队完成，不难，推荐用 Python ，做图形化比较方便，内置库的数据结构比较好用。

石川老师，属于是你院学术顶梁柱，治学严谨，不过课上有时候会点名。给分还行。

三选二#

计算机网络课程设计#

用 C 语言做个 DNS 中继服务器，已经是不知道迭代多少届的传统了，有往届代码可以直接复用，不过验收老师会问的非常细，并提了一些奇怪的问题，不过并没有说的现场让你改 BUG 那么夸张。

至于给分，懒得喷了已经。我们小组哈希、LRU 缓存、多线程高并发都做了，测试 QPS 6000+ ，验收和报告也没什么问题，结果给分都没上 90 ，纯恶心人。

数据结构课程设计#

3 人组队。23 级的题目是个性化旅游系统，布置完就不上课自己做了，和上学期的数据结构课程也一点关系没有。最多就是一些排序和图算法。评价是纯卷 GUI 就行，有中期验收和期末验收，助教验收，全是不问你具体实现，纯看你前端功能有没有实现，最多问你一下用到了什么数据结构和算法，你乱说都没关系，完全不看代码。

要写的文档也是又臭又长，每周要提交周报，除此之外还有总报告、需求分析报告等将近 10 个文档。

做完了也是浪费时间，很难有收获，并且没有正常人队友不推荐选。

最后给分还行。

数据库系统原理课程设计（大三下）#

在大三下学期开设，问了 2022 级的题目如下：

题目1：基于 MiniOB 的数据库管理系统设计与实现
- 基于开源数据库内核 MiniOB ；
- 源于 OceanBase 数据库；
- 侧重于“造数据库”，了解 DBMS 内部查询处理、事务管理机制；
题目2：TPC Benchmark 电商数据管理系统
- 侧重于“使用数据库”，基于现有 DBMS 平台，开发数据库应用系统（原型）
- 目标：初步了解、掌握数据库应用系统开发；熟悉 TPC-H、TPC-C 数据库测试基准；

学长的评价是不用 AI 就能写出来的起码有 icpc 金牌和两年以上数据库开发经验，验收结束，某老师发的要求原话如下：

@所有人今天验收已结束。大家写报告的时候增加一个“ AI 使用说明”的章节。强调下课设任务完成过程中是否使用 AI 大模型辅助完成，如何使用的。强调清楚 AI 的贡献和大家各自的贡献。没有使用 AI 的也显式说明没有使用。

哈哈，这下真 AI 也来抢贡献度了。

二选一#

差不多，体感没什么太大区别，也有不少人为了卷绩点全选的。

面向对象程序设计实践（Java）#

老师是吴起凡老师，课很抽象，而且教的还是 Java8 的内容，基本没人听，到后面基本上全跑了，签过一两次到，不过似乎签不签都无所谓，上课有几次抽人回答问题过。

有 2 次 OJ 和 2 次小作业，OJ 上的题大模型基本都能速通，2 次小作业一般安排在临近期末由助教验收（助教一般会抽几题问你具体实现，看看你代码）。

大作业是典中典多人聊天室，4 ～ 6 人一组，这届又新加了一些小组聊天、语音通话等功能，由老师验收，一般是你简单演示功能，然后他会问一下具体的问题，包括用了设计模式诸如此类问题，还会重点关注你文档中的时序图、UML 图等。

最后给分还不错，没有计网课设给分如此抽象。

面向对象程序设计实践（C++）#

好像是做个电商平台？另外要求好像也不少，不过同样不考勤，水。

二选一#

数字逻辑与数字系统课程设计#

基础任务是电子钟 + 药片装瓶系统，往届代码一堆，VHDL/Verilog 实现。除基本的硬件平台（就是数电和计组实验用的那个箱子）之外，还提供一些别的企业的开发板。如果选择拓展的板子，优点是体积小巧，不需要来实验室调试，可以带回去；缺点同样明显，这些板子缺乏参考资料，并且与之适配的开发平台同样缺少参考资料，在连接和调试的过程中，遇到玄学甚至无法解决的问题肯定是在所难免的。至于选拓展板子有无隐式加分，这个没有调研过，不是很清楚，只能说想卷的可以卷。

有中期验收和期末验收，中期验收无所谓，主要是看一下进度。期末验收除了演示功能的实现外，老师还会问你一些设计思路等问题，杨秦老师还是很友善的。

除完成 2 个基础任务外，你可以自己选择拓展任务做，像贪吃蛇、俄罗斯方块这种。能卷出一个不错的分数，但即使累死累活调板子一学期，最后的给分也和网工只做基础的没区别。

这届出分是真的晚，6.3 验收，7.16 才出成绩（怀疑是和计组课设一起出的）。至此，随着最后一门课出完，楼主的大二生涯也正式结束了。

计算机组成原理课程设计#

没选，这门课安排在小学期，并且由于 2023 级刚好赶上教二装修，实验室搬到沙河去了，所以得乘班车去沙河上课。

毛泽东思想和中国特色社会主义理论体系概论#

这可不敢乱评价（）。个人感觉比马原难背，不过楼主就花了一天时间背，因为这学期排考太逆天了。

但是事情太多了，有期中微电影，小组展示和一个实践部分的调查报告，难评。

大三上学期#

Warning

大三上是为数不多总体给分都很高（对大部分人）的学期了。

操作系统#

408的最后一块拼图，但是考的内容不难，作业题和往年题会做就行，考研题没啥作用。

孟xw教的，根据之前学长的描述早闻大名，“幸”得一见。实际上完也没有说的那么夸张，除了每节课基本都要小测以及及其复古的PPT，最后给分也还行。另外只有 2 次实验，只需提交报告。

数据库系统原理#

内容多，且考试英文题面（但还是操作系统的英文更抽象），是需要花较多时间复习的一门课。不过考试的题型也比较公式。有 7 次实验，需要使用华为云的 GaussDB，也是纯屎。

邓芳老师，讲得非常不错，顺便推荐一下疫情期间她的网课数据库系统原理北京邮电大学 2022 邓芳。

编译原理与技术#

课程内容及其抽象，并且个人感觉用处不大。好在考试依旧比较公式，不会考非常阴间的点，和往年题差不太多。有 4 次实验，包含词法分析和语法分析，对理解和做题有一定的帮助，可以好好做做。

算法设计与分析#

内容本身对打算法竞赛意外以外的是比较有难度的，但是期末考的也越来越简单了，划定范围后甚至直接背那几个算法都行，有些甚至都不考代码。有 4 次实验。

专业选修课#

计算机网络技术实践#

推荐，不过事比较多。给分可以，具体内容可以参考博客。不过每个老师用的仿真平台都不一样。

程序设计实践#

推荐。做一个 DSL 脚本解释器实现的客服机器人，放在大模型时代更是及其水，想办法卷一个好看的功能齐全的前端应该就能有个不错的分数。并且提早验收有加分。

Python程序设计#

推荐。有几次 OJ 作业和实验。大作业是爬链家数据并分析，这个如果自己实打实爬会比较费力，这么多届都是爬的链家已经把现在的网站反爬养蛊了，有些固定风控基本没法避开。

网络存储技术#

推荐。5篇小论文 + 1篇大论文，下次还填非常简单。

人工智能原理#

期末开卷考试。

大三下学期#

计算机系统结构#

体感上并没有前人传的那么恐怖，内容确实比较多，知识点比较细。不过事实证明面向 PPT 和作业题复习基本没什么问题，往年题感觉过于古早了参考价值不如作业题。今年似乎也没有刻意压分的情况。至于 4 次小实验没什么意思和帮助，依旧用古早的 Win XP 软件仿真软件。

现代交换原理#

古代交换原理确实名不虚传，即使每年考纲确实都在变化，像今年基本大题完全没有 2G/3G 了，以 4G/5G 为主，甚至在实验里还加了 AI for network 的内容，不过依旧不改变只是表面工程。首先依旧很多内容还是老古董，而且完全搞不懂这门课对计算机科学与技术专业的意义是什么；其次即使强行违和地添加了也已经是四五年前的时间序列预测实验复现，但也只是个实验，课堂内容就是发个视频自学。

不过往年题确实没什么参考价值了，建议面向作业题复习，题型也是比较固定的。

软件工程#

纯纯的文科课，软工也许有用但以考试的形式出现绝对没用，大作业依旧典中典充电桩系统，好在期中期末终于都争取到开卷了，因此只需要对概念有基本印象，然后掌握那几个图怎么画就行了（其实也没几个，面向对象明确不考了）。

二选一#

编译原理与技术课程设计#

依旧 Pascal-S 编译器，to C 或者 to 汇编，真是一场酣畅淋漓的调库啊。

wwf 老师给分也是顶级啊。

操作系统课程设计#

没选，不清楚。

专业选修课#

机器学习#

2 次云平台上布置的课前选择题 + 1 次线下计算题（最好去线下），1 次学术论文阅读笔记，然后 1 个大作业（两个赛道，分类/时间序列，感觉都是非常的水啊，满分不难）。水，推荐。

下一代 Internet 技术与协议#

1 次实验 + 1 次报告，有时候会签到（会提前通知）。水，推荐。

信息与知识获取#

1 次报告 + 2 次大作业（信息检索/抽取系统），大作业一起验收。有时候会突然课后纸质签到，要注意。总体水，但老师比较难评。

大数据技术基础#

第一节课去了，看到一堆小组作业直接劝退了，而且今年又强行搞一堆所谓与时俱进的操作，什么部署🦞，实验指导书都一眼 AI 生成，事不少反正。

不得不提的是 ehh 在某方面也是声名远扬（你自己理解，不要仅凭给本科生上课被骗了）。

无线传感器网络（高新标杆课）#

水确实水，就 1 次要验收的实验和一个个人的报告，平常也没签到。不过给分很难评，并且年年容易引发争议且老师官回让有异议去申请查卷。

Linux 开发环境及应用#

要考试，没选。

专业实习#

最出生的课，把你拉到校外没空调的小教室坐牢三周，交通吃饭自行解决，占用周末时间，内容也是计算机网络技术实践的完全复刻，纯赤石。

其他必修/选修课#

院级双创课程#

Warning

注意仔细研读自己的培养方案，区分校级和院级双创学分，区分课程和实践学分，明确要求，年年有人错。

按照培养方案的要求选 2 门即可（当然也可以通过科研训练等形式拿到学分），需要抢，建议尽早修满吧，但是会保证给即将毕业的学生选上。

智能车实践训练#

刁婷老师，人很好。任务是让智能车避障/寻线等，自行选择，难度不大，不过需要废点时间去实验室调车子，还有一篇调研报告。给分不错，推荐！

另外似乎有祖传代码，不过笔者当时是和组员慢慢调的。

智能机器人实践训练#

李晶老师，任务是用机械臂去抓指定颜色的方块，难度也不大。实验室和智能车在一起（外训楼301）。

大数据技术实践训练#

用 nm 中国移动的梧桐大数据开发平台，纯狗屎，不超过 5 分钟用户 Token 就过期一次，并且跑得很慢（甚至怀疑偷了本机的算力）。最后验收是线下 PPT 答辩。给分还不错。

移动应用开发实践训练#

没选，不清楚。

机器学习实践训练#

同样没选，不清楚。

大学英语#

第三学期（视听说英语）#

如果你是 B 班或者 C 班，第三学期是视听说英语，期末有口语考试，使用 iTEST 平台，对哑巴英语来说简直灾难，建议提前练练。

第四学期#

第四学期的选课需要抢，推荐以下课程：

英美文化概况（推荐，如果是张爱阳老师，那推荐++）；
- 平时课上会互动，会请人发言，不过你回答不出来也没事，老师很和蔼；
- 云平台和灯塔的一些阅读作业 + 小组展示（表演一个英美影视片段）+ 短视频（介绍一个西方哲学家）+ 期末考试（2 篇阅读 + 3 篇作文）；
- 期末考试开卷，可以准备些作文素材，但作文太阴间了，楼主水平也是稀烂，最后给分也不奢求了；
实用英汉翻译（韩凌老师，听舍友评价也不错）；
- 期末考的翻译较难；
思辨阅读与写作（穆婕老师，似乎也不错，给分不知）；

体育课#

体育课除了大一，后面都是自选，但每学期不能重复，楼主运动能力属于还过得去，最后给分都是 90+，因此可能不太具有参考价值，1 学分的课也无所谓，因此建议选点喜欢的就可以。

体育基础（太极拳）#

北邮经典 16 式太极拳，能打下来就行，有空多打打哈哈哈哈。

田径#

刘利老师，人很好，别看是田径但课上强度并不大，期末考 50m + 立定跳，平时课上还能刷一点校园跑。给分是如实给分，并且会在最后一节课左右全班公示，不过最后大家对分数都挺高的。（总之对楼主这种体育渣渣非常友好）

篮球#

考核是 4次罚篮 + 2 次三步上篮共 10 分 + 技评 90 分，最后按 50 分折算计入总成绩，还有个折返跑。

羽毛球#

应该也许是最难抢的。期末考核是对角线发高远球（两边各 5 次） + 击打高远球，分别占 30% 和 20%，击打到后场指定区域的成功率占一定比例，不过大头是技评。剩下的是 50m + 校园跑 + 课堂表现。

专业分流#

Warning

24 级在大一下学期（五一左右）已经进行了分流。

计算机类会在大二上学期的中期，大概是 10 ～ 11 月份，进行专业分流。人数一般为计算机科学与技术：网络工程：数据科学与大数据技术 = 400 ： 60 ： 60 。网工和大数据一般会有一些高年级的留级下来，同时也有本年级的留下去。

关于建议，楼主只能说，论坛基本都是烟雾弹，年年都说博弈，但年年头部都在计科，所以小专业基本都稳赚不赔。不过具体选网工和大数据，这个确实有点博弈。

23级的分流情况是前20都在计科，网工第一21名，大数据第一39名。（没记错的话）

不过到24级网工和大数据又对调了，并且非常离谱。网工第一120名，大数据第一9名。

总之，保研基本不看你专业名称，所以想保外校大可以冲小专业。

Warning

笔者的建议仅供参考，请以实际情况和自身情况为准，笔者对任何后果不负责。

转专业#

北邮有 2 次转专业的机会。分别在大一上结束和大一下结束。一般大一上结束名额多并且更容易。

转计院和 AI 院都需要机试和面试，具体可参考计算机类转专业指导。

2026.5 Live Repo

Fri, 29 May 2026 12:49:00 GMT

5月小结#

5.1 上海梅赛德斯-奔驰文化中心 2026明日方舟音律联觉-昔时我见
5.24 北京蛙厂RMMF·北京798店 ChiliChill乐团「混入人类计划II：方街」巡演-北京站

翻了翻相册才发现上一次已经是去年 9 月的羊文学了，哎gszm坏事做尽。

音律联觉#

依旧每年五一保留节目，这次还好二开抢到了。

音律前: 北京 to 上海#

这回的出行方式是经典京沪高铁二等座，去年锅贴得意之作绿皮 D9 真给我坐麻了，这次果断 G 系列。不过被课表背刺，本来还可以买早一班（），结果就是快 0 点才到虹桥。好像是第一次这么晚到沪国。

晚上六点多出发，地铁上已经挤的挂门了，夸张哦。不过快速进展厅是好文明啊😋，虽然人流也爆了。

一上车就听见了经典的沪上雅言，路上无话，不过因为节假日抢票时没法指定静音车厢，二等座还有销售在谈生意（

幽默锅贴，这下彻底不用赶最后一班 2 号线了：

其实截图的时候还没停下，依旧偷偷摸摸装自己正点，懒得喷。

从来没有这么晚到虹桥，没想到迎接我的是附近 200+ 打车，实际感觉远超，具体可见下图：

不过好在等了 10 分钟也是终于给我滴上了（高德打车屁用没有），在司机的指示下通过过街天桥到了对面的马路边，也是解锁新上车点了，依旧全是打车的，甚至马路边，交警也拦不住只能引导。甚至有乡毋宁电瓶车拉客的，真绷不住了。

另外等的时候已经看到不少背痛包的🪳了（笑）。

附一张从外面看虹桥枢纽：

到酒店进去前面一个人背的就是新能痛包，神了兄弟。

音律入场前#

没有提前到很久（经典地图了属于是），卡着点进的，拍了点外围：

来点 C 挡 522 区直拍，因为有点高且有点侧导致大屏上方会被阵列音箱挡住，PV 经常看不到人头（

音律中#

由于众所周知的原因，演出肯定是 no japanese 的了，导致一些经典曲目都被拿下了，不过这回有很多多曲混编、或者改编，还是比较惊喜的，4 首新曲也很不错，个人比较喜欢戏中身：

1
乱↑成线↓
2
不过山茶花落地→
3
三～菩～↓提↑
4
无意识而无依…如是→
5
我闻↑过…如是→
6
一花一木 皆成↑因↓
7
梦化成现实困住我↑↓
8
无所从 又无所去躲～
9
梦化！成现实困住我，
10
万生皆因果↓
11
惦↑朝↑↑霞↑↑↑
12
乱↑↑成↓麻～～
13
非以身普渡 又何渡泞路？
14
兀自聊以束 亦是空和无。
15
不知何求 与执念为谋，
16
贪和念无谓是色，即空——
17
非 空！！——
18
无知所故 与执念为伍，
19
淘尽灰↑色↓泥泞路——！
20
固执…（一段优雅的吟唱）
21
（一长段激烈的吟唱）
22
虔～诚如一↑
23
将往事送菩提！
24
无所依 无往 无妨且听着哭啼
25
走～进雾↑里↑
26
穿到界外断了人↑间↓雨～
27
我～盼↑如一 往事能送菩提
28
无所依 无往 无妨且走一遭
29
让那褪去的 如泡影般惨白的
30
化成儿时听说，
31
随↑花骨朵↓而～掉落——

展开收起

（转载的），国风带点电就是🧊啊，加上 PV 质量依旧无敌。

哭狼也是超大杯，念诗那段也很震撼。Mili 稳定发挥。

另外利刃行动合约曲返场，也算是一个惊喜，希望之后也能像去年这种形式保留一定数量的经典曲目返场吧，以及小剧场环节。

来点可拍摄部分，看来塔子姐是要上岛了：

音箱挡脸真的红温（

🥺已经在戒断了

音律后#

散场又是经典的大批人流涌入中华艺术宫，依旧多走点到耀华路回去取行李然后赶高铁，好在这回并不是很极限。

事已至此，先吃饭吧😋：

确实是很美味且性价比在联动产品里算高的了，爽吃，不过上海没得是真的快。

ChiliChill「混入人类计划II：方街」#

混入前#

还是第一次来看 ChiliChill，之前错估了抢票难度导致等想起来的时候已经售罄了（很🔥，老师

798 这块也是很早就听说但第一次来，不得不说确实充满艺术气息（

另外人真的多，按取号情况来看，应该 1200+，疯狂的厚嘴唇星人（

另外，蛙厂在我看过的所有 livehouse 里感觉能排到夯（综合音响/舞美/灯光/场地大小），个人感觉是 > 疆进酒 > 东三 > 福浪。

线上取号是好文明啊，不用提前来排队，这回也是拼手速拿下：

不过秀动这个取号需要先刷新再取号，多次 UI 交互一言难尽，一坨屎简直。

最后选择了第三排靠右狙击于老师，等演出开始发现看小伍会有点挡（

来点群友无料：

笑飞了，群友创意这一块，导播也是会配合的。

混入中#

开场真的难绷，方街设备故障，然后爽听 2 遍开场曲《混入人类计划》😋

这辈子也是见到环卫工唱歌，空姐弹琴，医生弹吉他，建筑工人打鼓和女仆弹贝斯了。

女仆小伍无敌，扫地僧小夏真有活人感吧：

下等马，最喜欢的一集，荣登去年年度歌单，一！身！素！青！纱！

后面就不一点点放了，终于给我听上 Live 版的《衡山路宛平路》了，泪目

真夫妻就是好磕啊：

以及于老师又又又唱少男了，而且这回没有少男转少女，吃的真好罢😋

夏老师小巧思环节：

这期神了，恍然大悟啊（笑）

安可飞鸟说，好耶

金色的雨（bushi）

回去发现袋子里也喷进一堆

混入后#

感谢七里秋收容不安灵魂！今天过得也很愉快👏👏👏

又要当个人继续和生活对线了，好想一起继续当厚嘴唇星人混入人类啊。

MCP vs. Skill 旧瓶装新酒这一块

Sat, 10 Jan 2026 13:03:00 GMT

MCP#

我在之前对 MCP 的学习中简单提到过当时 MCP 的一些痛点，不过发展到现在 MCP 这套通信协议已经被 Anthropic 搞得相当完善，MCP Server 也能快速适配到不同 Client。

从本质上来说，MCP 的功能侧重于包装了 Function Calling（函数调用），用户不需要具体 Tool 的逻辑。比如 Context7，封装了抓取网页、读文档等工具，LLM 在其加持下，引入并使用这些工具。

值得注意的是，作为 Agent 重点关注的 Context，MCP 的做法是将所有工具都放入上下文，

上图是通过 Claude Code 的 /context 得到的上下文占用情况，可以看到，MCP tools 会固定占用一定的空间，即，LLM 每次都会携带完整的工具，包括具体的调用参数、方法等。LLM 正是通过这种方式，能根据用户输入判断是否需要进行工具调用，以及如何调用，并直接调用 MCP Tools，如下图所示：

Skill#

Anthropic 可能是看到了 MCP 占用大量 Context 的问题，又提出了一个新的概念“Progressive Disclosure”（渐进式披露）以及 Agent Skill，如下图：

简单来说，技能就是打包好的程序性知识，本质上就是文件夹。例如，Claude Code 中，每个 Skill 有一个 Skill.md：

它包含了提示词（Prompts）、脚本（Scripts）和说明文件等。看起来和 MCP 差不多，但两者真正的区别在运行时机制上。

Skill 在运行时，一开始只暴露元数据（Metadate），对应到图中的 YAML 中前置配置，用于提供简要的工具信息，同时避免工作时占用过多 Context。
接下来，当用户指令或 LLM 发现请求与 Skill 的描述部分匹配时，就会触发并加载对应 Skill 的 Skill.md，此时包含详细信息的工具说明才进入上下文窗口。
如果文件目录下还有其他资源和代码，在调用工具时也会进行按需加载；

因此，从本质上来说，Skill 就是按需暴露工具，从而不一次性并持久的占用上下文空间，从而节省了上下文窗口。

End#

之所以个人认为它是旧瓶装新酒，是因为本质上只是对 Agent 运行时使用和加载工具的时机进行了对 Context 进行优化，从功能上看没什么区别。并且，直接将 MCP 按照渐进式披露的思路进行转换，说不定更好，例如有一个类似的 MCP 工具 mcp__pdf，我们同样不加载一些具体的 Tool，一开始只告诉 LLM 有这个工具及其功能描述，当需要使用时，在通过类似 mcp_pdf --help 自行查看和加载需要的方法。甚至避免了在脚本上操作读取存在的安全性问题。

不过脚本由于其轻量且易于共享，因此个人认为 Skill 的出现还是属于进步的。把 Skill 认为是渐进加载的 MCP 也好，多个 MCP Tool 的整合或包装也好，现在都只需要写个通用提示词就能实现工具的选择和调用了。

浅谈编译原理——语法制导翻译篇

Sat, 06 Dec 2025 08:57:00 GMT

Note

尝试在抽象中建立一些理解。（起码对我来说很抽象）

概述#

语法制导翻译的功能#

对于编译器，一般不能只判断输入的语言是否符合语法规则。以算术表达式为例，还需要能确定最后的结果，即翻译目标为计算表达式的值。

语法制导就是如此，根据翻译目标，

为上下文无关文法的每个符号设置语义属性（例如一个变量的属性有类型，层次，存储地址，一个表达式的属性有类型和值等）；
给每条产生式规则附加一个语义动作（本质上是一个代码片段，用于计算或输出语义属性的值），相当于对文法进行了拓广。

语法制导翻译过程就是根据语法分析过程中所使用的产生式，在适当的时机执行与之相应的语义规则，完成符号属性值的计算，从而完成翻译。

语法制导定义（SDD）#

语法制导定义：

将文法符号和某些属性相关联
通过语义规则描述如何计算属性的值

可以简单将语法制导定义理解为产生式 + 语义规则，例如：

语义规则的制定由翻译目标 →\rightarrow→ 决定产生式的含义 →\rightarrow→ 决定文法符号属性 →\rightarrow→ 决定产生式的语义规则。

需要注意的是，SDD 本身还无法给出语义规则的具体计算顺序。

对应题型：写出语法制导定义。

语法制导翻译（SDT）#

相较于 SDD，SDT 在上下文无关文法的产生式右部嵌入了程序片段，即语义动作，一个语义动作在产生式中的位置决定了这个动作的执行时间。

这样，编译器在语法分析过程中，在适当的时候执行这些语义动作，完成语义分析和检查。例如：

以第一条插入的语义动作为例，它表示当分析出T之后，就可以使用 T 的 type 属性的值来计算 L 的 in 属性值。

因此，SDT 可以视为对 SDD 的一种补充，是 SDD 的具体实施方案。

对应题型：设计翻译方案。

语法制导定义#

产生式与语义规则#

对于每一个文法产生式 A→X1X2⋯XnA\rightarrow X_1X_2\cdots X_nA→X1X2⋯Xn，都有与之相联系的语义规则：

b=f(c1,c2,⋯ ,ck)b=f(c_1,c_2,\cdots,c_k)b=f(c1,c2,⋯,ck)

其中：

b,c1,c2,⋯ ,ckb,c_1,c_2,\cdots,c_kb,c1,c2,⋯,ck 都是某文法符号的属性；
fff 是函数，比如具体的计算操作。

文法属性#

属性文法扩展了上下文无关文法的定义，将文法符号与额外的属性（常见的包括值、类型等）建立了联系，具体又分为：

综合属性#

综合属性：通过子节点符号的属性或通过自身的属性计算得到。

通常用于从下往上传递信息。
bbb 是 AAA 的一个综合属性，且 c1,c2,⋯ ,ckc_1,c_2,\cdots,c_kc1,c2,⋯,ck 为产生式右部符号的属性（即 AAA 的子节点的属性），或 AAA 的继承属性；
向上看继承，向下看子节点

Warning

注意：你可能有以下疑惑，终结符是叶子节点，没有孩子了，可以有综合属性吗？答案是可以的，终结符可以有综合属性，词法分析程序提供的就是综合属性值，并且不能有继承属性。例如，digit.lexval，通常是一个常量。

还有一类比较特殊的属性，一般用于拓广文法的起始符号 S′S^\primeS′，其不依赖任何属性，仅用于在属性计算完成后输出某个值或完成一项功能，例如 Print(E.val)，所以称其为虚拟综合属性。

继承属性#

继承属性：某节点的继承属性由它兄弟、父亲或者自己的属性计算得到。

通常用于自上而下，或横向传递信息。
如果 bbb 是产生式右部某个符号 XiX_iXi 的一个继承属性，那么 c1,c2,⋯ ,ckc_1,c_2,\cdots,c_kc1,c2,⋯,ck 是 AAA（它爹）或任何产生式右部符号 XjX_jXj（兄弟或它自己）的属性；
属性 bbb 依赖于属性 c1,c2,⋯ ,ckc_1,c_2,\cdots,c_kc1,c2,⋯,ck；

注释分析树#

一般默认约定：继承属性写文法符号的左边，综合属性写在右边。

计算次序#

依赖图#

分析树中不同的节点间的属性存在依赖关系，可以用依赖图表示。

表示方法：

分析树中，为符号的每个属性设置一个结点，一般画在符号旁边
如果属性 b 依赖于 c，那么存在一条 c -> b 的有向边（被依赖者指向依赖者，因为只有 c 先算了才能算 b）；

因此，属性的计算次序可以由依赖图的拓扑排序确定。

引入 2 种特殊的语法制导定义，这两种 SDD 的依赖图一定无环，因此可以通过拓扑排序计算出所有属性的属性值。

S属性定义#

即语法制导定义的所有属性都是综合属性，因此属性的计算过程就是自底向上的。因此可以配合自底向上的语法分析过程中实现。一般可以在进行归约时，按照语义规则计算归约得到的符号的属性值。

从依赖图来看，综合属性的边都是从下往上的。

L属性定义#

既有综合属性又有继承属性，但要求继承属性满足特定条件，即对于任意产生式 A→X1X2⋯XnA\rightarrow X_1X_2\cdots X_nA→X1X2⋯Xn 以及继承属性 Xi.aX_i.aXi.a，其只能依赖于：

AAA 的继承属性（父亲的继承属性）；
- 这里之所以只能依赖父亲的继承属性，是因为如果依赖父亲的综合属性，但父亲的综合属性又依赖子节点的属性，就会产生环路；
X1,X2,⋯ ,Xi−1X_1,X_2,\cdots,X_{i-1}X1,X2,⋯,Xi−1 的属性（左边兄弟的属性）；

因此，从依赖图上来看，就是只允许：

继承属性：从左向右，或从上到下的边；
综合属性：同 S 属性定义，从下到上的边；

显然，每一个 S 属性定义都是 L 属性定义。

构造依赖图#

在已经画出分析树的基础上，假如有产生式 A→XYA\rightarrow XYA→XY，对应的语义规则为 A.a=f(X.x,Y.y) 和 X.i=g(A.a,Y.y)。

计算次序#

计算顺序是有向非循环图的拓扑排序。

即必须按依赖图中箭头指向的方向进行排序。

语法制导翻译#

翻译方案：把 SDD 的语义规则改写为计算属性值的程序片段，语义动作括在 {} 中，并插入到产生式右部某个合适的位置上。例如：

基本实现方法如下：

建立语法分析树；
将语义动作看作是虚拟的结点；
从左到右，深度优先地遍历分析树，在访问虚拟结点时执行相应语义动作；

翻译方案的设计#

S属性定义翻译#

为每一个语义规则建立一个包含赋值的动作；
把这个动作放在相应的产生式右边末尾；

这是比较显然的，因为都是综合属性，而父节点的综合属性依赖于子节点，因此需要等子节点先都分析完才能计算。例如，以产生式 T→T1∗FT\rightarrow T_1*FT→T1∗F 和语义规则 T.val=T1.val∗F.valT.val=T_1.val*F.valT.val=T1.val∗F.val 为例，将语义动作如下插入：

T→T1∗F{T.val=T1.val∗F.val}T\rightarrow T_1*F\{T.val=T_1.val*F.val\}T→T1∗F{T.val=T1.val∗F.val}

S 属性定义的基础文法是 LR 文法，其与 LR 分析过程是兼容的，当归约发生时，即可执行对应语义动作。

L属性定义翻译#

L 属性定义既有综合属性又有继承属性，因此需要遵守以下原则：

一个动作不能引用这个动作右边的文法符号的综合属性；
- 因为是处理过程是从左到右的，右边文法符号的综合属性还没有计算出来；
对于产生式左部符号的综合属性：
- 只有在它所引用的所有属性都计算出来之后才能计算；
- 因此放在产生式右端末尾；（与 S 属性文法要求一致）
对于产生式右部符号的继承属性：
- 必须在这个符号以前的动作中计算出来；
- 因此放在该文法符号前面；
- 即对于右部符号 AAA 的继承属性的动作，插入到右部紧靠 AAA 之前的位置上（AAA 的左边）；

S属性定义的自底向上翻译#

语法树 vs. 分析树#

具体语法树 vs. 抽象语法树 vs. 分析树：

抽象语法树将节点按照以下操作抽象：

对于叶子节点：用一个附加域存储此叶子结点的词法值/符号表入口
- makeleaf(id, entry)：建立一个标识符节点，标号为 id，附加域指向该标识符在符号表中条目的入口；
- makeleaf(num, val)：建立一个数节点，标号为 num，附加域直接存词法值；
对于内部节点：附加字段数量等于结点的子结点数量，通过构造函数连接子节点
- makenode(op, left, right)：op 表示运算操作，left/right 分别指向左右孩子；

构造 AST 及其语法制导定义#

对于 AST，产生式的语义应该是创建与产生式左部符号代表的子表达式对应的子树，即创建子树的根结点。

因此，文法符号的属性应包括 nptr 表示指向创建的子树的根节点，例如，对于产生式 E→E1+TE\rightarrow E_1+TE→E1+T，对应的语义规则为：

E.nptr=makenode(′+′,E1.nptr,T.nptr)E.nptr = makenode('+',E_1.nptr, T.nptr)E.nptr=makenode(′+′,E1.nptr,T.nptr)

分析和翻译过程形如：

有向非循环图dag#

简单来说，在语法树的基础上，公共表达式可以有多个父亲节点，节省了存储开销。

自底向上的翻译过程实现（LR）#

修改分析栈：使其能保存综合属性。

改写语义规则：使之变成具体可执行的栈操作。

简单来说，当要执行归约操作 A→XYZ⋅A\rightarrow XYZ\cdotA→XYZ⋅前，执行对应代码，先改写对应的符号栈，然后计算对应的综合属性栈。然后在执行归约操作，将 AAA 入栈，X,Y,ZX,Y,ZX,Y,Z 出栈，栈顶变化为 top→top−2top\rightarrow top - 2top→top−2。因此，综合属性刚好在每次归约前计算。

对于终结符，其在移进时，综合属性值（由词法分析程序提供）随状态一起入栈。

L属性的自底向上翻译#

主要介绍以下 4 种方法：

1. 移走翻译方案中嵌入的语义规则#

只要把嵌入（除产生式右部最右侧）在产生式右部之中的语义动作想办法移动到最右边，那么之后的分析思路与 S属性的翻译过程就类似了。

因此，针对嵌入在产生式右部的语义规则，例如 R→+T{print(′+′)}RR\rightarrow +T\{print('+')\}RR→+T{print(′+′)}R：

引入一个新的非终结符 MMM；
以及对应产生式 M→ε{print(′+′)}M\rightarrow\varepsilon\{print('+')\}M→ε{print(′+′)}

2. 直接使用分析栈中的继承属性#

使用该方法的前提是：

继承属性在栈中
位置已知

3. 变换继承属性的计算规则#

前一种方法中，虽然我们知道 LR 分析过程中，属性值都放在分析栈 val 中，但是无法知道继承属性的值在栈中的位置。

例如，如果同时包含产生式 A→aXZA\rightarrow aXZA→aXZ 和 A→bXYZA\rightarrow bXYZA→bXYZ，对应的语义动作均为 Z.i=X.sZ.i = X.sZ.i=X.s，即继承属性 Z.iZ.iZ.i 依赖之前的 XXX，当问题是，在到达 ZZZ 并使用 Z→zZ\rightarrow zZ→z 进行归约时，无法知道 Z.iZ.iZ.i 该取 val[top-1] 还是 val[top-2]，即无法知道 ZZZ 离 XXX 有多远。

个人理解，解决的思路是想办法区分语义动作相同的产生式，例如如果产生式 A→aXZA\rightarrow aXZA→aXZ 以及语义动作均不变，我们在希望使用它时，Z.iZ.iZ.i 需要的就是 val[top-1]。而对于产生式 A→bXYZA\rightarrow bXYZA→bXYZ，我们引入一个新的符号，并中转属性的继承关系：

在 ZZZ 前面添加一个非终结符 MMM 及产生式 M→εM\rightarrow\varepsilonM→ε，使之紧挨着 ZZZ；
产生式 A→bXYMZA\rightarrow bXYMZA→bXYMZ 对应的语义规则修改为 M.i=X.s,Z.i=M.sM.i=X.s,Z.i=M.sM.i=X.s,Z.i=M.s；
产生式 M→εM\rightarrow\varepsilonM→ε 对应的语义规则为 M.s=M.iM.s = M.iM.s=M.i；

因此，如果我们希望 Z.iZ.iZ.i 继承自 val[top-2]，进行上述修改后，分析过程变成：当分析到 MMM 之前，让 M.iM.iM.i 去接收本来要继承给 ZZZ 的 X.sX.sX.s，分析到 MMM 时，计算 M.s=M.iM.s = M.iM.s=M.i，接下来分析到 ZZZ，此时 M.sM.sM.s 就位于 val[top-1]，Z.iZ.iZ.i 能确定继承 M.sM.sM.s。

上面只是针对“复制规则”，即直接等于，进一步可以考虑对所有继承属性的“非复制规则“进行改造，将其改造为复制规则，考虑：

A→aXY,Y.i=f(X.s)A \rightarrow a X Y,Y.i = f(X.s)A→aXY,Y.i=f(X.s)（非复制规则）
Y→y,Y.s=g(Y.i)Y → y,Y.s = g(Y.i)Y→y,Y.s=g(Y.i)

同样，引入非终结符 NNN 和对应产生式 N→εN\rightarrow\varepsilonN→ε，将以上文法改写为：

A→aXNY,N.i=X.s,Y.i=N.sA → a X N Y,N.i = X.s,Y.i = N.sA→aXNY,N.i=X.s,Y.i=N.s
N→ε,N.s=f(N.i)N\rightarrow\varepsilon,N.s = f(N.i)N→ε,N.s=f(N.i)
Y→y,Y.s=g(Y.i)Y → y,Y.s = g(Y.i)Y→y,Y.s=g(Y.i)

和复制规则基本一致，只是 N→εN\rightarrow\varepsilonN→ε 中执行的计算改变。

在归约 N→εN\rightarrow\varepsilonN→ε 前，栈中状态形如：

1
a       X(top)
2
a.lex   X.s

当归约 N→εN\rightarrow\varepsilonN→ε 时，N 入栈，且 N.iN.iN.i 来自当前栈顶 XXX 对应的综合属性值处，因此 N.s: val[top+1]=f(val[top])。栈中状态变为：

1
a       X     N
2

3
a.lex   X.s   N.s

yyy 入栈：

1
a       X     N(top-1)  y(top)
2

3
a.lex   X.s   N.s       y.lex

随后归约 Y→yY\rightarrow yY→y，yyy 出栈而 YYY 入栈，Y.iY.iY.i 来自于 N.sN.sN.s，因此对应的执行过程为 Y.s: val[top]=g(val[top-1])。栈中状态变为：

1
a       X     N     Y
2

3
a.lex   X.s   N.s   Y.i

事实上按照上述方法构造，基本可以得出以下归约时执行动作的结论：

归约	栈顶状态	语义本质	赋值位置
N → ε	top 是 X.s	N.s = f(X.s)	val[top+1] = f(val[top])
Y → y	top 是 y，top-1 是 N.s	Y.s = g(N.s)	val[top] = g(val[top-1])

4. 改写语法制导定义为S属性定义#

改写文法
让信息传递方向与 LR 归约方向一致

😄依旧似懂非懂。

第一台 VPS 折腾小记

Sun, 30 Nov 2025 04:23:00 GMT

人生的意义在于折腾。

宇宙级安全声明#

在使用本项目/教程/脚本之前，请务必仔细阅读以下声明。一旦您开始使用、复制或修改相关内容，即视为您已完全接受并同意本免责声明的所有条款。

用途说明
- 本项目涉及的所有脚本、代码、配置文件及教程仅供 资源共享、技术研究和学术交流 使用。
- 本文作者对其中包含的信息的合法性、准确性、完整性和有效性 不作任何保证。用户应根据自身情况自行判断并承担相应风险。
免责条款
- 任何用户（包括但不限于个人、组织或自动化程序）间接使用本项目代码（包括但不限于建立 VPS、服务器配置或网络代理服务），或在违反其所在国家/地区法律法规的情况下进行传播和使用，本文作者对于由此引起的任何隐私泄漏、数据丢失、设备损坏或其他任何形式的后果概不负责。
- 作者不对任何脚本在使用过程中可能出现的问题负责，包括但不限于由脚本错误、逻辑漏洞或兼容性问题导致的任何直接或间接损失。
禁止行为
- 严禁将本项目内的任何内容用于 商业用途 或 非法目的。
- 不得利用本项目进行任何形式的网络攻击、非法入侵、绕过监管或其他违反当地法律法规的行为。
- 若用户利用本项目从事任何违法行为，一切法律后果由用户 自行承担，与本文作者无关。
知识产权与侵权处理
- 本项目均来自网络收集或个人学习总结。如果任何单位或个人认为该项目的脚本或内容可能涉嫌侵犯其合法权益，请及时通知并提供有效的身份证明、所有权证明及侵权情况说明。
- 作者在收到上述法律文件并核实后，将会在第一时间删除相关内容。
条款变更
- 本文作者保留在不预先通知的情况下，随时更改、补充或解释本免责声明的权利。
- 请用户定期查看本声明，以确保了解最新的条款内容。

请谨记：使用技术时请务必遵守您所在国家和地区的法律法规。

0. 参考#

使用 IPv6-only VPS 低成本独享家宽，解锁 ChatGPT 不风控

年轻人的第一台 VPS 代理服务器

1. VPS 选择#

这里不做推荐，我用的是 ipv6-only，一年 15 刀乐，折算一下的话一个月 9 块（加上域名也没多贵），在家宽里算很便宜了，而且可以通过 warp 获得 ipv4 地址，所以问题不是很大。这里先贴一张节点质量：

可以看到，非常纯净，一些服务有屏蔽是因为网站不支持纯 v6 访问，问题不大。

2. VPS 搭建#

2.1 连接并安装基础工具#

Terminal window

1
ssh user@hostname

连接成功后，安装：

Terminal window

1
sudo apt update && sudo apt-get install -y curl vim ufw

安装 Docker：

Terminal window

1
sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release -y
2
# 创建 keyrings 目录
3
sudo mkdir -p /etc/apt/keyrings
4
# 下载并添加 GPG 密钥
5
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
6
# 添加 Docker 仓库
7
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
8

9
sudo apt update
10
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

2.2 安全性防护#

虽然 vps 厂商本身就提供了一定的安全保障措施，不过防人（爆破）之心的不可无。

2.2.1 创建用户组和用户#

将以下命令中的 username 和 passwd 自行替换即可：

Terminal window

1
getent group 1001 || groupadd -g 1001 vps \
2
    && getent passwd username || useradd -ms /bin/bash -u 1001 -g 1001 -G sudo username \
3
    && echo "username:passwd" | chpasswd

创建用户组，创建用户并拉入附加组 sudo，并设置密码。

2.2.2 修改 ssh 端口#

Terminal window

1
sudo nano /etc/ssh/sshd_config

找到被注释掉的 Port 22 并修改为：

Terminal window

1
Port 11451

记住这里你修改的端口号，如果你启动了防火墙需要进行对应的放行：

Terminal window

1
sudo ufw allow
2
ssh sudo ufw enable
3
sudo ufw allow 11451

请务必在确认端口放行后再重启 ssh 服务：

Terminal window

1
sudo systemctl restart ssh
2
sudo ufw deny 22

2.2.3 禁用 root 用户远程登录#

1
sudo nano /etc/ssh/sshd_config

找到 PermitRootLogin 并修改为 no。

2.2.4 RSA 密钥登录验证#

略。

2.2.5 Fail2ban 工具#

Fail2ban 工具用于对于密码连续输错三次封 IP：

Terminal window

1
sudo apt install -y fail2ban
2
sudo nano /etc/fail2ban/jail.local

输入以下内容：

1
[DEFAULT]
2
bantime = 1h
3
findtime = 10m
4
maxretry = 3
5

6
[sshd]
7
enabled = true
8
port = 11451
9
filter = sshd
10
logpath = /var/log/auth.log
11
backend = systemd

保存并重启 fail2ban：

Terminal window

1
sudo systemctl restart fail2ban
2
sudo systemctl enable fail2ban

2.3 通过 Warp 获取 ipv4 地址#

如果你和我一样是 v6-only 的 vps，那么可以通过套一层的 warp 来获得 ipv4 地址，这样后续在使用代理服务时，也能正常访问 github.com 等不支持 v6 的网站（虽然速度比较慢）。

Terminal window

1
wget -N https://gitlab.com/fscarmen/warp/-/raw/main/menu.sh && bash menu.sh

如果分配不到 ipv4 地址，可以修改 DNS 为：

Terminal window

1
sudo nano /etc/resolv.conf
2

3
nameserver 2606:4700:4700::1111
4
nameserver 2001:4860:4860::8888
5
nameserver 2001:4860:4860::8844
6
nameserver 1.1.1.1
7
nameserver 8.8.8.8
8
nameserver 8.8.4.4

你可以通过 Cloudflare 的测试端点再次查看给你分配的地址：

Terminal window

1
curl -4 https://www.cloudflare.com/cdn-cgi/trace

3. 域名配置#

3.1 域名购买#

略。

3.2 域名托管#

将域名从你的购买处托管到 Cloudflare，具体步骤略，在 Cloudflare 控制面板添加你的域名时已经提供了相当详细的步骤。

3.3 申请 TLS 证书#

这里使用 acme.sh 开源工具，用来自动获取和管理 SSL/TLS 证书，自动续签，非常方便。

3.3.1 创建令牌#

该工具使用 Cloudflare DNS 验证的模式申请泛域名证书，因此需要：

Zone ID
Account ID
API Token

前两个分别在“域->Overview”右下角即可找到，令牌进入 API令牌获取，选择 编辑区域 DNS 模版：

选择对应域名，以及选择自己 VPS 的 IP 地址作为白名单（有 v4 和 v6 的话都写上）：

继续，注意保存生成的 Token。

3.3.2 安装脚本#

Terminal window

1
su
2
# 脚本需要的定时服务
3
sudo apt update
4
sudo apt install -y cron
5
sudo systemctl enable cron
6
sudo systemctl start cron
7
sudo apt install socat -y
8

9
# 安装脚本并设置邮箱
10
curl https://get.acme.sh | sh -s email=your@email.com
11
# 将 CA 服务器改成 Let’s Encrypt
12
~/.acme.sh/acme.sh --set-default-ca --server letsencrypt
13
source ~/.bashrc
14
# 开启自动更新
15
acme.sh --upgrade --auto-upgrad

其中，email=xxxx 用来设置向证书颁发机构注册时使用的邮箱，请填写为你实际使用的邮箱，用来接受 Let’s Encrypt 的邮件通知。

3.3.3 配置环境变量#

Terminal window

1
vim ~/.bashrc
2

3
export CF_Token="<Your API Token>"
4
export CF_Account_ID="<Your Account ID>"
5
export CF_Zone_ID="<Your Zone ID>"
6

7
source ~/.bashrc

3.3.4 签发证书#

Terminal window

1
acme.sh --issue --dns dns_cf -d yourdomain.com -d *.yourdomain.com

-d 之后接上你需要签发的域名。如果成功，会在最后输出证书的位置。具体包括：

yourdomain.com.cer：只有域名的叶子证书。
ca.cer：中间证书，用来构建完整的信任链。
fullchain.cer：由域名证书与中间证书组合而成的完整证书链文件，配置服务器时常用此文件以确保客户端能正确验证证书链。

通过以下命令，可以验证自动签发是否正确工作：

Terminal window

1
$ crontab -l
2
2 13 * * * "/root/.acme.sh"/acme.sh --cron --home "/root/.acme.sh" > /dev/null

例如，2 13 * * * 表示每天的 13<02> 执行一次。或者通过以下命令手动签发：

Terminal window

1
acme.sh --cron --home /root/.acme.sh

3.3.5 使用证书#

通常，采用 fullchain.cer 作为网站证书的配置。密钥只有一个，例如 yourdomain.com.key，对应域名证书的私钥，直接输入就行。

如需让 root 外用户能访问证书，还需要：

1
mkdir -p /home/username/cert
2
cp /root/.acme.sh/yourdomain.com_ecc/yourdomain.com.key /home/username/cert/yourdomain.com.key
3
cp /root/.acme.sh/yourdomain.com_ecc/fullchain.cer /home/username/cert/fullchain.cer
4
sudo chmod 644 /home/username/cert/yourdomain.com.key
5
sudo chmod 644 /home/username/cert/fullchain.cer

Warning

注意：如果你在后面搭建节点或其他服务时，采用了 Docker 部署，容器是看不到宿主机的文件系统的，还需要移动到正确的映射路径。

4. 节点搭建#

4.1 Hysteria#

参考：https://v2.hysteria.network/zh/docs/getting-started/Installation

Hysteria2 基于 UDP，在网络环境较差时表现优异。

4.1.1 安装并运行官方脚本#

Terminal window

1
su
2
bash <(curl -fsSL https://get.hy2.sh/)

观察到输出 Congratulation! Hysteria 2 has been successfully installed on your server. 则证明安装成功。

如果提示 useradd: command not found，说明环境变量缺失。请先执行 export PATH=$PATH:/usr/sbin 后再次运行安装命令。

4.1.2 创建配置文件#

我们需要手动创建配置文件。这里，我已经将证书文件移动到 /home/username/cert/fullchain.cer 和 /home/username/cert/private.key。

Terminal window

1
vi /etc/hysteria/config.yaml

粘贴并修改以下内容：

1
listen: :8443 # 监听端口，需防火墙放行
2

3
# 使用之前申请的 CA 证书
4
tls:
5
  cert: /home/username/cert/fullchain.cer
6
  key: /home/username/cert/yourdomain.com.key
7

8
auth:
9
  type: userpass
10
  userpass:
11
    # 修改这里：自定义用户名和密码
12
    myuser1: password123
13
    myuser2: password456
14

15
masquerade:
16
  type: proxy
17
  proxy:
18
    url: https://bing.com # 伪装网址
19
    rewriteHost: true
20
  listenHTTP: :80
21
  listenHTTPS: :8443
22

23
trafficStats: # 流量统计接口
24
  listen: :22222
25
  secret: trafficStats_passwd
26

27
bandwidth:
28
  # 修改这里：根据你VPS的实际带宽调整，不要填满，留有余地
29
  up: 100 mbps
30
  down: 200 mbps

展开收起

保存并退出，同时在 Cloudflare 控制面板添加对应的 A/AAAA 记录，指向你的服务器 IP，不要开启代理（云朵）。

Terminal window

1
systemctl enable hysteria-server.service --now
2
systemctl status hysteria-server.service

启动并验证状态，如果观察到 active (running) 则证明配置并运行成功，否则请自行参照 Hysteria 官网检查。

注意如果有 ufw 还需要放行对应端口：

Terminal window

1
sudo ufw allow 8443

如有问题，可通过以下命令观察调试信息：

Terminal window

1
# 启动 Hysteria2
2
systemctl start hysteria-server.service
3
# 重启 Hysteria2
4
systemctl restart hysteria-server.service
5
# 查看 Hysteria2状态
6
systemctl status hysteria-server.service
7
# 停止 Hysteria2
8
systemctl stop hysteria-server.service
9
# 设置开机自启
10
systemctl enable hysteria-server.service
11
# 查看日志
12
journalctl -u hysteria-server.service

4.1.3 配置端口跳跃#

Hysteria 是基于 UDP 的，为了防止运营商针对单一 UDP 端口的阻断，我们需要利用 iptables 做端口转发。这意味着客户端连接 50000-50100 端口时，VPS 会自动转给 8443 处理。

确认网卡名称：输入 ip addr 查看，通常是 eth0，但也可能是 ens3 等。将下令中的 eth0 替换为你的真实网卡名。
执行转发规则：

Terminal window

1
# 放行对应端口
2
sudo ufw allow 50220:50959/udp
3
sudo ufw allow 60133:60968/udp
4

5
# 允许 UDP 端口段
6
iptables -t nat -A PREROUTING -i eth0 -p udp --dport 50220:50959 -j REDIRECT --to-ports 8443
7
iptables -t nat -A PREROUTING -i eth0 -p udp --dport 60133:60968 -j REDIRECT --to-ports 8443
8

9
# 对应的 IPv6 规则 (如果不需要 IPv6 可跳过)
10
ip6tables -t nat -A PREROUTING -i eth0 -p udp --dport 50220:50959 -j REDIRECT --to-ports 8443

4.1.4 代理软件使用配置#

这里以 V2RayN 为例，其他软件类似，只要核心支持 Hysteria2 协议即可。点击”Configuration”->“Add[Hysteria2]“，配置如下，请修改为你自己的实际值：

如果能连通，说明上述配置成功。

4.1.5 配置流量统计服务#

这里我偷懒了，建议在配置完 Nginx 之后在进行这一步骤。

安装一些所需依赖：

Terminal window

1
sudo apt update apt install jq bc -y

创建查询脚本：

Terminal window

1
vim /root/check_traffic.sh

写入并修改以下内容，域名和 API 地址也可以根据需要自行修改：

1
#!/bin/bash
2
green='\033[0;32m'
3
cyan='\033[0;36m'
4
NC='\033[0m' # No Color
5

6
# 请修改这里：你的域名
7
DOMAIN="sub.yourdomain.com"
8
# 请修改这里：你的 config.yaml 里设置的 secret
9
SECRET="passwd"
10

11
# API 地址 (走 HTTPS)
12
TRAFFIC_URL="https://${DOMAIN}/hy-stats/traffic"
13
ONLINE_URL="https://${DOMAIN}/hy-stats/online"
14
AUTH_HEADER="Authorization: ${SECRET}"
15

16
# 函数：将字节转换为可读格式
17
bytes_to_readable() {
18
    local bytes=$1
19
    if (( bytes < 1024 )); then
20
        printf "%d B" "$bytes"
21
    elif (( bytes < 1024**2 )); then
22
        printf "%.2f KB" "$(echo "scale=2; $bytes / 1024" | bc)"
23
    elif (( bytes < 1024**3 )); then
24
        printf "%.2f MB" "$(echo "scale=2; $bytes / (1024^2)" | bc)"
25
    else
26
        printf "%.2f GB" "$(echo "scale=2; $bytes / (1024^3)" | bc)"
27
    fi
28
}
29

30
echo -e "${green}=== Hysteria2 流量与在线用户统计 ===${NC}"
31
echo
32

33
# 1. 获取在线用户数
34
echo -n "正在获取在线用户..."
35
online_resp=$(curl -s -H "$AUTH_HEADER" "$ONLINE_URL")
36
# 简单的整数判断，如果返回不是数字可能是认证失败
37
if [[ "$online_resp" =~ ^[0-9]+$ ]]; then
38
    echo -e "\r当前在线用户数: ${cyan}${online_resp}${NC}"
39
else
40
    echo -e "\r${cyan}获取在线用户失败 (可能是密钥错误或 Nginx 配置问题)${NC}"
41
    # echo "Debug: $online_resp" # 调试用
42
fi
43

44
echo "-----------------------------------"
45

46
# 2. 获取流量统计
47
response=$(curl -s -w "HTTPSTATUS:%{http_code}" -H "$AUTH_HEADER" "$TRAFFIC_URL")
48
body=$(echo "$response" | sed -e 's/HTTPSTATUS\:.*//g')
49
status_code=$(echo "$response" | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
50

51
if [ "$status_code" -eq 200 ]; then
52
    # 使用 jq 解析 JSON
53
    # 格式: 用户名 上传 下载
54
    echo "$body" | jq -r 'to_entries[] | "\(.key) \(.value.tx) \(.value.rx)"' | while read -r key tx rx; do
55
        readable_tx=$(bytes_to_readable "$tx")
56
        readable_rx=$(bytes_to_readable "$rx")
57
        echo -e "用户 ${green}$key${NC}: 上传 ${cyan}${readable_tx}${NC} | 下载 ${cyan}${readable_rx}${NC}"
58
    done
59
else
60
    echo "流量请求失败，状态码：$status_code"
61
    echo "请检查密钥或 HTTPS 连接。"
62
fi
63
echo

展开收起

4.2 Xray#

4.2.1 安装面板#

可以选择 x-ui 或者一个大佬魔改的 x-panel，没区别，x-panel 加了一些付费的一键配置等功能，对新手可能更友好吧。

如果安装 x-panel：

Terminal window

1
vim docker-compose.yml

将以下内容添加进去：

1
services:
2
  x-panel:
3
    image: xeefei/x-panel:latest
4
    container_name: x-panel
5
    restart: unless-stopped
6
    network_mode: host
7
    volumes:
8
      - ./db/:/etc/x-ui/
9
      - ./cert:/root/cert/
10
    environment:
11
      XRAY_VMESS_AEAD_FORCED: "false"
12
      XUI_ENABLE_FAIL2BAN: "true"

启动容器：

Terminal window

1
sudo docker compose up -d

本地建立连接：

Terminal window

1
ssh -L 13688:127.0.0.1:13688 user@host

然后在本机访问 127.0.0.1<13688> 进行配置即可，默认用户名和密码均为 admin，登录后记得修改并重启面板。

如果你不想用 x-panel 或者不想用 docker 部署，可以参考大佬的这篇文章中的步骤年轻人的第一台 VPS 代理服务器，思路都是大差不差的。

4.2.2 面板设置#

点击面板设置中，找到 面板证书公钥文件路径 和 面板证书密钥文件路径，分别填入 /root/cert/fullchain.cer 和 /root/cert/yourdomain.com.key，注意这里跟前面的容器设置有关，如果按照我的设置，宿主机目录 ./cert，即 home/username/cert 被映射到容器目录 root/cert，可通过以下命令验证：

Terminal window

1
sudo docker exec -it x-panel ls /root/cert

设置完成后，你就可以通过 ip:port （如果是 ipv6 地址请用 [] 括起来）的方式访问面板了，不过浏览器会提示不安全，如下图：

这是因为证书中认证的域名并不符合 ip，请在 Cloudflare 控制面板再次添加对应的 A/AAAA 记录，指向你的服务器 IP，不要开启代理（云朵），若名为 xui，则在之后 Nginx 也配置完成后，你可以通过 xui.yourdomain.com 访问面板。

4.2.3 搭建节点#

这里提供目前 Xray-core 中比较顶尖和主流的抗干扰配置，VLESS + Vision + TLS 和 VLESS + Reality + xhttp，简单来说：

对于前者，Vision 专门用于解决“TLS in TLS”特征和流量指纹问题。它能极其逼真地模拟正常的 HTTPS 网页浏览流量，让防火墙认为你正在访问一个正常的加密网站，不过由于基于 TLS，因此必须拥有一个真实的域名和 SSL 证书。

对于后者，Reality 协议会通过中间人攻击的方式，偷取别的网站（如 Apple, Microsoft, Amazon 等）的 TLS 握手特征。因此不需要域名和证书。同时，xhttp 在 packet 层面做了更精细的 Padding 和头部处理，使得流量特征更像现代浏览器访问网站的行为，配合 Reality 使用效果极佳。

这里给出 Gemini 总结的两者的区别（我也不是特别懂）：

特性	VLESS + Vision + TLS	VLESS + Reality + xhttp
域名 (Domain)	必须拥有 (每年需付费或申请免费)	不需要 (直接使用 IP)
证书 (Cert)	需要管理 (需申请并续期，如 acme.sh)	不需要 (模拟目标网站 SNI)
CDN 支持	支持 (但在 Vision 下不建议开启 CDN)	不支持 (绝对无法套 CDN)
抗封锁能力	极高 (只要域名干净，IP 正常)	极高 (专门针对主动探测优化)
配置难度	中等 (需解析域名、配置 Nginx/回落)	简单 (填入 IP 和目标 SNI 即可)
端口要求	通常占用 443 端口	任意端口 (但推荐 443 以模拟真实)
适用场景	长期稳定使用，不怕麻烦，有建站需求	快速部署，不想买域名，IP 经常变动

这里因为我有域名，所以选择更稳定的“VLESS + Vision + TLS”，入站规则的创建我就省略了，基本都按照默认，记得在 SNI (域名) 处填写你的自己的三级域名，同时在证书设置部分填写之前准备好的证书路径，flow 记得选择 xtls-rprx-vision。

然后放行对应的端口。同理，在 Cloudflare 控制面板添加对应的 A/AAAA 记录，指向你的服务器 IP，不要开启代理（云朵），名字和你入站规则中的域名一致。

搞完之后可以在 V2rayN 中先测一下，没问题的话再继续。

5. 订阅服务搭建#

这里暂时先不折腾了。

Warning

由于 VPS 大部分是小内存机器（例如 512MB 或 1GB），且此时已经运行了 Hysteria、Nginx 等服务，在进行 Sub-Store 的安装和配置时极有可能导致内存溢出，进程被强行杀死，如果遇到这种情况，可以尝试从硬盘上划分一部分空间当作“虚拟内存”来使用，防止内存不足导致程序崩溃：

Terminal window

1
# 创建一个 1GB 的文件用于 swap
2
dd if=/dev/zero of=/swapfile bs=1M count=1024
3
# 设置权限，确保安全
4
chmod 600 /swapfile
5
# 将其标记为 swap 空间
6
mkswap /swapfile
7
# 启用 swap
8
swapon /swapfile
9
# (可选) 写入系统配置，确保重启后依然有效
10
echo '/swapfile none swap sw 0 0' | tee -a /etc/fstab
11
# 查看是否生效
12
free -h

如果配置正确，应该能看到 Swap: 这一行有了 1.0Gi 左右的空间。

5.1 安装基础组件与 FNM#

Terminal window

1
# 更新并安装 unzip 等工具
2
sudo apt update -y && sudo apt install unzip curl wget git -y
3

4
# 安装 FNM
5
curl -fsSL https://fnm.vercel.app/install | bash
6

7
# 让 FNM 生效
8
source /root/.bashrc

5.2 安装 Node.js v20.18.0#

Terminal window

1
fnm install v20.18.0

5.3 安装 PNPM#

Terminal window

1
curl -fsSL https://get.pnpm.io/install.sh | sh -
2
# 同样让它生效
3
source /root/.bashrc

5.4 安装 Sub-Store#

Terminal window

1
mkdir -p /root/sub-store
2
cd /root/sub-store
3

4
# 下载后端
5
curl -fsSL https://github.com/sub-store-org/Sub-Store/releases/latest/download/sub-store.bundle.js -o sub-store.bundle.js
6

7
# 下载前端并解压
8
curl -fsSL https://github.com/sub-store-org/Sub-Store-Front-End/releases/latest/download/dist.zip -o dist.zip
9
unzip dist.zip && mv dist frontend && rm dist.zip

5.5 配置 Sub-Store 系统服务#

5.5.1 配置密钥#

随便生成一个密钥并记下：

Terminal window

1
openssl rand -hex 16

5.5.2 创建服务文件#

Terminal window

1
vim /etc/systemd/system/sub-store.service

写入并修改以下内容：

1
[Unit]
2
Description=Sub-Store
3
After=network-online.target
4
Wants=network-online.target systemd-networkd-wait-online.service
5

6
[Service]
7
LimitNOFILE=32767
8
Type=simple
9

10
# 修改这里：这一串随机字符就是你以后访问 Sub-Store 的路径
11
Environment="SUB_STORE_FRONTEND_BACKEND_PATH=/你的随机密钥"
12

13
Environment="SUB_STORE_BACKEND_SYNC_CRON=0 0 * * *"
14
Environment="SUB_STORE_FRONTEND_PATH=/root/sub-store/frontend"
15
Environment="SUB_STORE_FRONTEND_HOST=0.0.0.0"
16
# 前端运行在 3001 端口
17
Environment="SUB_STORE_FRONTEND_PORT=3001"
18
Environment="SUB_STORE_DATA_BASE_PATH=/root/sub-store"
19
Environment="SUB_STORE_BACKEND_API_HOST=127.0.0.1"
20
Environment="SUB_STORE_BACKEND_API_PORT=3000"
21

22
# 启动命令 (确保路径正确)
23
ExecStart=/root/.local/share/fnm/fnm exec --using v20.18.0 node /root/sub-store/sub-store.bundle.js
24

25
User=root
26
Group=root
27
Restart=on-failure
28
RestartSec=5s
29
ExecStartPre=/bin/sh -c ulimit -n 51200
30
StandardOutput=journal
31
StandardError=journal
32

33
[Install]
34
WantedBy=multi-user.target

展开收起

5.5.3 启动服务#

Terminal window

1
systemctl daemon-reload
2
systemctl enable sub-store.service --now

如出现错误请使用以下命令打印调试信息自行调试：

Terminal window

1
systemctl start sub-store.service     # 启动服务
2
systemctl enable sub-store.service    # 设置为开机自启
3
systemctl status sub-store.service    # 查看服务状态
4
systemctl stop sub-store.service      # 停止服务
5
systemctl restart sub-store.service   # 重启服务

6. Nginx 配置#

由于上述服务暴露在公网，因此暴露端口有一定的安全隐患，采用 Nginx 进行反代，将 443 加密流量在 Nginx 内部分流到不同的本地端口，本地端口不需要暴露。

6.1 安装#

Terminal window

1
sudo apt update
2
sudo apt install nginx libnginx-mod-stream -y

6.2 配置 Stream 分流#

Terminal window

1
vim /etc/nginx/nginx.conf

在 http 块外部添加我们即将要引入的分流规则：

1
include /etc/nginx/vps.conf;

配置 Stream 分流 (vps.conf)：

Terminal window

1
vim /etc/nginx/vps.conf

填入以下内容（注意修改域名和端口为你实际需要使用的）：

1
stream {
2
    # 1. 域名识别区 (SNI Map)
3
    map $ssl_preread_server_name $backend {
4
        hostnames;
5
        # 修改这里：你的 Sub-Store 域名 -> 转发给 sub 后端
6
        sub.yourdomain.com    sub;
7
        # 修改这里：你的 X-UI 面板域名 -> 转发给 xui 后端
8
        xui.yourdomain.com    xui;
9
        # 默认情况（比如直接访问 IP 或 hy2 域名） -> 转发给 hysteria
10
        default          hysteria;
11
    }
12

13
    # 2. 后端定义区 (Upstreams)
14

15
    # Sub-Store 后端：转发给 Nginx 自己的 8444 端口 (处理 SSL 后再给 Sub-Store)
16
    upstream sub {
17
        server 127.0.0.1:8444;
18
    }
19

20
    # X-UI 面板后端：直接转发给 X-UI 面板端口
21
    upstream xui {
22
        server 127.0.0.1:13688;
23
    }
24

25
    # Hysteria 后端：转发给 Hysteria 的 HTTP 伪装端口
26
    upstream hysteria {
27
        server 127.0.0.1:8443;
28
    }
29

30
    # 3. 监听服务区
31
    server {
32
        listen 443 reuseport;
33
        listen [::]:443 reuseport;
34
        proxy_pass $backend;
35
        ssl_preread on; # 开启 SNI 预读，否则无法识别域名
36
    }
37
}

展开收起

6.3 配置 Sub-Store 反代#

Stream 模块只是把流量扔过来了，对于 Sub-Store，我们还需要 Nginx 帮忙处理 HTTPS 加密（卸载证书），然后以 HTTP 协议传给 Sub-Store 程序（默认运行在 3001 端口）。

Terminal window

1
vim /etc/nginx/sites-enabled/vps.conf

写入并修改以下内容：

Terminal window

1
server {
2
    # 监听 8444，接收来自 Stream 模块分流过来的 sub 流量
3
    listen 8444 ssl http2;
4
    listen [::]:8444 ssl http2;
5

6
    # 修改这里：你的 Sub-Store 域名
7
    server_name sub.yourdomain.com;
8

9
    # 修改这里：你的证书绝对路径
10
    ssl_certificate /home/username/fullchain.cer;
11
    ssl_certificate_key /home/username/private.key;
12

13
    location / {
14
        # 转发给 Sub-Store 默认端口 3001
15
        proxy_pass http://127.0.0.1:3001;
16
        proxy_set_header Host $host;
17
        proxy_set_header X-Real-IP $remote_addr;
18
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
19
    }
20

21
    # Hysteria 流量统计反代，访问 https://sub.yokumi.cn/hy-stats/traffic 就会被转到 http://127.0.0.1:22222/traffic
22
    location /hy-stats/ {
23
        proxy_pass http://127.0.0.1:22222/;
24
        proxy_set_header Host $host;
25
        proxy_set_header X-Real-IP $remote_addr;
26
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
27
    }
28
}

6.4 启动服务#

先删除默认配置（防止占用端口或冲突）：

Terminal window

1
rm /etc/nginx/sites-enabled/default

在启动前测试一下配置是否有误：

Terminal window

1
$ nginx -t
2
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
3
nginx: configuration file /etc/nginx/nginx.conf test is successful

启动服务：

Terminal window

1
sudo systemctl restart nginx
2
sudo nginx -s reload
3
sudo systemctl status nginx

TODO#

目前的所有配置之后基本已经能正常使用了，至于问题等后续慢慢发现吧，前前后后加起来花了差不多一天，还是比较折腾的。

PT/BT 配置；
整台🇭🇰双栈中转机搞链式代理（等有米了）；
后续迁移考虑整成一键脚本；

在 Linux 下编译安装 Dynamips 和 Dynagen 搭建 Cisco 实验环境

Fri, 31 Oct 2025 12:54:00 GMT

写在前面#

最终还是花了一点时间把计网实践的实验平台搞到 Linux 下实现了，相比于 Windows，同样配置的路由器，Linux 下 CPU 占用可降低 50% 以上，应该也会更加稳定吧。

本文将详细介绍如何在 Linux (Ubuntu/Debian) 系统下（macOS 等也是类似的，一些依赖的安装略有不同罢了）从源码编译安装最新版 Dynamips，并配合经典的 Dynagen 0.11.0 （停止维护了，后来基本都用 GNS3，但 BUPT 要求，没办法）搭建完整的 Cisco 实验环境。

1. 环境准备#

1.1 系统信息#

这里贴一个我自己的，内存越大越好。

配置项	参数
操作系统	Ubuntu 20.04.6 LTS
Architecture	x86_64
CPU	Intel(R) Xeon(R) Platinum 8369HC
内存	22G

1.2 安装依赖#

在开始编译 Dynamips 之前，需要安装必要的编译工具和开发库：

Terminal window

1
sudo apt-get update
2
sudo apt-get install -y build-essential cmake git
3
sudo apt-get install -y libelf-dev libpcap-dev

2. 编译和安装 Dynampis#

2.1 下载源代码#

Dynamips 是目前仍在维护的项目，我们从 GitHub 获取最新版本：

Terminal window

1
git clone https://github.com/GNS3/dynamips.git
2
cd dynamips

2.2 配置编译选项#

Dynamips 支持两种代码版本：

stable（稳定版）：推荐大多数用户使用，兼容性好（推荐）
unstable（开发版）：包含更多优化，但在某些平台可能不稳定

创建 build 目录并运行 CMake：

Terminal window

1
mkdir -p build
2
cd build
3
cmake ..
4

5
# 推荐编译稳定版
6
cmake .. -DDYNAMIPS_CODE=stable
7

8
# 如需自定义安装路径（可选）
9
cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local

2.3 编译和安装#

Terminal window

1
# 编译
2
make
3

4
# 编译（使用多核加速）
5
make -j$(nproc)
6

7
# 安装到系统
8
sudo make install

2.4 验证安装#

Terminal window

1
which dynamips
2
dynamips -h

输出形如：

3. 安装 Dynagen#

Dynagen 是 Dynamips 的前端管理工具，虽然已经不再维护，但仍是管理 Dynamips 最简单高效的工具之一。我将安装最后的稳定版本 0.11.0。

3.1 下载 Dynagen#

Terminal window

1
cd ~/downloads
2
wget https://sourceforge.net/projects/dyna-gen/files/dynagen/dynagen-0.11.0/dynagen-0.11.0.tar.gz

或者使用其他下载方式获取 dynagen-0.11.0.tar.gz。反正我只找到了这个软件源。

3.2 解压和安装#

Terminal window

1
# 解压
2
tar -zxvf dynagen-0.11.0.tar.gz
3
cd dynagen-0.11.0

Dynagen 0.11.0 是纯 Python 脚本，不需要编译。我们将其复制到系统目录：

Terminal window

1
# 复制到 /opt
2
sudo cp -r ~/downloads/dynagen-0.11.0 /opt/dynagen
3

4
# 设置权限
5
sudo chmod +x /opt/dynagen/dynagen
6
sudo chmod 644 /opt/dynagen/*.py
7

8
# 创建软链接
9
sudo ln -s /opt/dynagen/dynagen /usr/local/bin/dynagen

3.3 验证安装#

Terminal window

1
which dynagen
2
# 查看帮助
3
dynagen -h

4. 配置实验环境#

4.1 创建目录结构#

为了更好地组织文件，我创建一个专门的实验环境目录（仿照学校提供的 Windows 版的结构）：

Terminal window

1
mkdir -p cisco-lab/{ios,net,configs,working}

说明如下：

Terminal window

1
.
2
├── configs   # 路由器配置文件自动保存位置
3
├── ios       # 存放 Cisco IOS 镜像文件
4
├── net       # 存放网络拓扑配置文件（.net 文件）
5
└── working   # Dynamips 运行时工作目录

4.2 准备 IOS 镜像#

将 Cisco IOS 镜像文件复制到 ~/cisco-lab/ios/ 目录下。我直接使用学校提供的镜像：

c2600-i-mz.121-3.T.bin - Cisco 2600
c2691-advsecurityk9-mz.124-11.T2.bin - Cisco 2691
c3640-js-mz.124-10.bin - Cisco 3640
c7200-is-mz.122-37.bin - Cisco 7200

注：Cisco IOS 镜像受版权保护，请确保您有合法的使用权限。可以通过从 Cisco 官方网站下载等渠道获取。

4.3 配置防火墙（可选）#

如果需要远程访问实验环境，需要开放相应端口：

Terminal window

1
# 安装 iptables-persistent
2
sudo apt-get install -y iptables-persistent
3

4
# 编辑防火墙规则
5
sudo nano /etc/iptables/rules.v4

添加以下规则（在 *filter 部分的 COMMIT 之前）：

1
# Dynamips 端口
2
-A INPUT -p tcp -m multiport --dports 7200:7201 -j ACCEPT
3
-A INPUT -p udp -m multiport --dports 7200:7201 -j ACCEPT
4
# 路由器控制台端口
5
-A INPUT -p tcp -m multiport --dports 2000:2100 -j ACCEPT
6
# Dynamips 通信端口
7
-A INPUT -p udp -m udp --dport 10000 -j ACCEPT

重启防火墙：

Terminal window

1
sudo service iptables-persistent restart
2
# 或
3
sudo systemctl restart netfilter-persistent

浅谈编译原理——语法分析篇

Sun, 19 Oct 2025 02:35:00 GMT

1. 语法分析简介#

语法分析程序的地位：

语法分析程序的地位

词法分析程序接受字符流（即源程序），输出记号流，作为语法分析程序的输入（按照自左向右的顺序扫描输入的记号序列），语法分析程序会根据语法规则，判断输入的记号流是否合法，并输出分析树。

分析方法包括：自顶向下分析和自底向上分析。

2. 自顶向下分析方法#

2.1 递归下降分析#

核心思想是：

对每一个非终结符构造一个分析函数
用前看符号指导产生式规则的选择

由于上下文无关文法（CFG）中所有的产生式左边只有一个非终结符，所以我们在调用产生式规则的函数后，就分为两种情况：

遇到终结符，则直接把这个终结符和句子中对应位置的 token 进行比较，判断是否符合即可；符合就继续，不符合就返回（回溯）；
遇到非终结符，则调用这个非终结符对应的函数（可能会递归的调用，所以叫递归下降文法）；

以一个简单的文法为例，分析 aab 是否为该文法的句子：

1
S –> AB
2
A –> aA | ε
3
B –> b | bB

从起始状态 SSS 开始，调用 SSS 的函数，得到非终结符 A,BA,BA,B；
调用 AAA 的函数，得到 a,Aa,Aa,A，由于 aaa 为终结符，则取句子中的 token aaa 进行比较，符合，继续；
继续递归调用 AAA 的函数，得到 a,Aa,Aa,A，取句子中的 token bbb 进行比较，不符合，回溯；
调用 AAA 的另一个函数，得到 ε\varepsilonε，符合，继续；
调用 BBB 的函数，由于前面都是终结符 bbb，但产生式 1 已经到达结尾，所以选择第二个产生式并调用，得到 b,Bb,Bb,B，继续递归调用 BBB 的函数，后略；

显然，这种方法不好：

如果语法存在左递归（形如 A⇒+Aβ,A∈NA\Rightarrow^+ A\beta,A\in NA⇒+Aβ,A∈N 的推导），则会导致递归调用无限进行下去，使得分析过程陷入死循环；
通过回溯不断试探，效率低；

2.2 递归调用预测分析#

从递归下降分析方法的问题来看，优化的点就在于解决回溯，实现一种确定的、不带回溯的方法 —— 递归调用预测分析。

如何克服回溯？能够根据所面临的输入符号准确地指派一个候选式去执行任务。因此通常需要对文法进行改造，以满足自顶向下的分析方法的要求，具体包括：

消除文法的二义性
消除左递归
提取左公共因子
非终结符号 AAA 的所有候选式的开头终结符号集两两互不相交；
- 即 FIRST(αi)∪FIRST(αj)=∅(i≠j)FIRST(\alpha_i)\cup FIRST(\alpha_j)=\emptyset (i\ne j)FIRST(αi)∪FIRST(αj)=∅(i=j)

注：一般情况下，消除左递归和提取左公共因子后的文法无二义性。

Note

FIRST(αi)FIRST(\alpha_i)FIRST(αi): 由 αi\alpha_iαi 开始推导，可以推导出的所有开头终结符号的集合（得出的句子开头的所有可能终结符的集合）。

求解 First 集合的方法：对于产生式 A→β1β2⋯βnA\rightarrow \beta_1\beta_2\cdots\beta_nA→β1β2⋯βn，根据开头的 β1\beta_1β1 分情况讨论：

β1\beta_1β1 是终结符，则 β1∈FIRST(A)\beta_1\in FIRST(A)β1∈FIRST(A)；
β1\beta_1β1 是非终结符，则 FIRST(β1)⊆FIRST(A)FIRST(\beta_1)\subseteq FIRST(A)FIRST(β1)⊆FIRST(A)

注：针对考虑 ε\varepsilonε 产生式的 FIRST 集合，还需要处理：

如果 A→εA\rightarrow\varepsilonA→ε 也是产生式，则 ε∈FIRST(A)\varepsilon\in FIRST(A)ε∈FIRST(A)；
如果 A→β1⋯βi−1βi⋯βnA\rightarrow\beta_1\cdots\beta_{i-1}\beta_i\cdots\beta_nA→β1⋯βi−1βi⋯βn，其中 FIRST(β1)−FIRST(βi−1)FIRST(\beta_1)- FIRST(\beta_{i-1})FIRST(β1)−FIRST(βi−1) 均含有 ε\varepsilonε，则将 FIRST(βi)⊆FIRST(A)FIRST(\beta_i)\subseteq FIRST(A)FIRST(βi)⊆FIRST(A)；
同理如果 FIRST(β1)−FIRST(βn)FIRST(\beta_1)-FIRST(\beta_n)FIRST(β1)−FIRST(βn) 均含有 ε\varepsilonε，则 ε∈FIRST(A)\varepsilon\in FIRST(A)ε∈FIRST(A)；

这里的额外处理事实上是有一个专门的术语：NULLABLE 集合，即所有可直接或间接推导出空串的集合：

NULLABLE 集合的构造方法：对于非终结符 XXX，若满足 X⇒∗εX\Rightarrow^*\varepsilonX⇒∗ε，则 X∈NULLABLEX\in NULLABLEX∈NULLABLE。

上述对 ε\varepsilonε 产生式的处理可以简化为：如果 A→XYA\rightarrow XYA→XY 且 X∈NULLABLEX\in NULLABLEX∈NULLABLE，则 FIRST(A)=FIRST(X)∪FIRST(Y)FIRST(A)=FIRST(X)\cup FIRST(Y)FIRST(A)=FIRST(X)∪FIRST(Y)；

显然，这个过程是一个当任何集合有变化就要检查其他集合的动态更新过程。

对于 FIRST 集合的理解？FIRST 集合是后续用来构造分析表的，这里构建一个个人的理解视角，给定输入的记号流 S=abcS = abcS=abc：

假如推导的第一步是 S→ABCS\rightarrow ABCS→ABC，而 FIRST 集合的作用就是用于判断该推导能否满足文法要求，判断方式就是输入的字符 aaa 是否在 FIRST(A)FIRST(A)FIRST(A) 中，那么这一步推导是可以接受的，推导变为 S→aBCS\rightarrow aBCS→aBC，之后同理。

并且，由于前面对于文法的要求，非终结符号 AAA 的所有候选式的开头终结符号集两两互不相交，所以有且只有这种选择，避免了回溯。

预测分析程序的转换图构造方法#

1. 消除左递归

这里主要以消除直接左递归为主，实际题目中很少出现间接左递归。

消除直接左递归：假如有 Ai→Aiα∣βA_i\rightarrow A_i\alpha\mid \betaAi→Aiα∣β，则引入一个新的非终结符 Ai′A^\prime_iAi′，并添加产生式：

Ai→βAi′Ai′→αAi′∣ε\begin{aligned} A_i&\rightarrow \beta A^\prime_i\\ A^\prime_i&\rightarrow \alpha A^\prime_i\mid\varepsilon \end{aligned}AiAi′→βAi′→αAi′∣ε

消除间接左递归：在消除 AiA_iAi 后面的 AjA_jAj 的直接左递归之前，发现有 Aj→AiγA_j\rightarrow A_i\gammaAj→Aiγ，则用所有已经在新文法产生式中的 Ai→δA_i\rightarrow \deltaAi→δ 替换 AiA_iAi，即将产生式 Aj→AiγA_j\rightarrow A_i\gammaAj→Aiγ 替换为：

Aj→δγA_j\rightarrow \delta\gammaAj→δγ

直至 δ\deltaδ 最前面为终结符或大于等于 AjA_jAj 的非终结符。

2. 提取左公因子

如果有产生式形如：A→αβ1∣αβ2A\rightarrow\alpha\beta_1\mid\alpha\beta_2A→αβ1∣αβ2，则提取左公因子 α\alphaα，将产生式替换为：

A→αA′A′→β1∣β2\begin{aligned} A&\rightarrow\alpha A^\prime\\ A^\prime&\rightarrow\beta_1\mid\beta_2 \end{aligned}AA′→αA′→β1∣β2

3. 绘制转换图

对于每一个非终结符号 AAA，创建一个初态和终态，对于每个产生式 A→X1X2⋯XnA\rightarrow X_1X_2\cdots X_nA→X1X2⋯Xn 构造一条创建一条从初态到终态的路径，有向边依次为 Xi,i=1,2,⋯ ,nX_i,i=1,2,\cdots,nXi,i=1,2,⋯,n。

4. 化简状态转换图

总之就是反复代入化简。

5. 预测分析程序的实现

以下图为例：

1
void procE(void) {
2
  procT();
3
  if (char == '+') {
4
    forward pointer;
5
    procE();
6
  }
7
}

简单来说：

对于 ε\varepsilonε 的有向边一般不做任何处理；
遇到终结符则移动记号流的指针指向后一个待读如的字符；
遇到非终结符则调用它的对应函数；

2.3 非递归预测分析/LL(1) 分析算法#

分析过程#

上面的方法中，虽然不存在回溯和死循环，但函数的调用还是存在嵌套的，所以引入非递归预测分析方法，它通过分析表和分析栈联合控制，消除递归。

按照网上的说法，似乎基本鲜有关于递归调用预测分析的介绍，而是直接介绍 LL(1) 分析算法，对应我们教材上的非递归预测分析。

预测分析程序模型

按照个人理解，分析表是用来解决回溯的，而符号栈则是用来解决函数的递归调用的。

输入：符号串 ω\omegaω（词法分析输出的记号流）；文法的预测分析表 MMM（手动构造，方法见下/通过语法分析器自动生成）；

初始化：

将符号串 ω\omegaω 放入输入缓冲区，注意后面要添加一个 $；
将 $ 放入符号栈，再将文法的起始符号 SSS 入栈，此时栈顶元素 X=SX=SX=S；
pointer 指向输入缓冲区的第一个符号，代表当前输入符号 aaa；

执行分析：

根据符号栈栈顶元素 XXX 和输入符号 aaa 执行如下循环过程：

若 X=a=X=a=X=a= $，则分析成功，停止；
若 X=a≠X=a\neX=a= $，说明当前栈顶的终结符命中输入，匹配成功，将 XXX 弹出，同时 pointer 前移指向下一个输入符号；
若 X∈VT,X≠aX\in V_T,X\ne aX∈VT,X=a，说明发现错误；
若 X∈VNX\in V_NX∈VN，则访问分析表 M[X,a]M[X,a]M[X,a]，即找到对应的需要被调用的产生式，根据产生式分情况执行：
1. 若 M[X,a]=X→Y1Y2⋯YnM[X,a]=X\rightarrow Y_1Y_2\cdots Y_nM[X,a]=X→Y1Y2⋯Yn，则将 XXX 弹栈，然后按照 Yn,⋯ ,Y2,Y1Y_n,\cdots,Y_2,Y_1Yn,⋯,Y2,Y1 的顺序压入栈（YnY_nYn 显然是被最后调用的，所以先入栈，放在底下），
2. 若 M[X,a]=X→εM[X,a]=X\rightarrow \varepsilonM[X,a]=X→ε，则将 XXX 弹栈；
3. 若 M[X,a]=X→errorM[X,a]=X\rightarrow errorM[X,a]=X→error，即分析表中没有任何内容，出错；

输出：每次命中分析表对应的产生式时，输出产生式，最终结果为依次调用的产生式序列，相当于一个最左推导的过程。

预测分析表的构造#

1. 改写文法：消除左递归 + 消除左公因子；（见前面）

2. 构造 FIRST 集合：使用前面提到的方法；

3. 构造 FOLLOW 集合：

Note

FOLLOW 集合的定义：假定 SSS 是文法 GGG 的开始符号，对于 GGG 的任何非终结符号 AAA，集合 FOLLOW(A)FOLLOW(A)FOLLOW(A) 是在所有句型中，紧跟 AAA 之后出现的终结符号或 $ 组成的集合，即所有可以合法的站在此非终结符后面的终结符（可以包括结束符 $ ，但不包括 ε\varepsilonε ）的集合。

FOLLOW(A)={a∣S⇒∗⋯Aa⋯ ,a∈VT}FOLLOW(A)=\{a\mid S\Rightarrow^* \cdots Aa\cdots,a\in V_T\}FOLLOW(A)={a∣S⇒∗⋯Aa⋯,a∈VT}

特别地，若有 S⇒∗⋯AS\Rightarrow^*\cdots AS⇒∗⋯A，则规定 $ ∈FOLLOW(A)\in FOLLOW(A)∈FOLLOW(A)。

FOLLOW 集合的构造方法：

对于起始符号 SSS，$ ∈FOLLOW(S)\in FOLLOW(S)∈FOLLOW(S)；
若有 A→αBβA\rightarrow\alpha B\betaA→αBβ，则 FIRST(β)⊆FOLLOW(B)FIRST(\beta)\subseteq FOLLOW(B)FIRST(β)⊆FOLLOW(B)，注意除去 ε\varepsilonε；
若有 A→αBA\rightarrow\alpha BA→αB 或 A→αBβ,β⇒∗εA\rightarrow\alpha B\beta,\beta\Rightarrow^*\varepsilonA→αBβ,β⇒∗ε，则 FOLLOW(A)⊆FOLLOW(B)FOLLOW(A)\subseteq FOLLOW(B)FOLLOW(A)⊆FOLLOW(B)；

FOLLOW 集合的意义？确定某个非终结符可能出现在产生式右侧的上下文环境。举个例子，当栈顶为 XXX ，读入的符号为 aaa，但 aaa 不在任何 FIRST 集合中，如果有 X→εX \rightarrow\varepsilonX→ε，那么 aaa 必须是 XXX 的后继字符才能保证最终句子是一个符合语法的句子，即此时调用 FOLLOW 集合。

4. 预测分析表的构造：对于每条产生式 A→αA\rightarrow \alphaA→α：

对所有终结符 a∈FIRST(α)a\in FIRST(\alpha)a∈FIRST(α)，{A→α}⊆M[A,a]\{A\rightarrow\alpha\}\subseteq M[A,a]{A→α}⊆M[A,a]；
对 ε∈FIRST(α)\varepsilon\in FIRST(\alpha)ε∈FIRST(α)，则对所有 b∈FOLLOW(A)b\in FOLLOW(A)b∈FOLLOW(A)，{A→α}⊆M[A,b]\{A\rightarrow\alpha\}\subseteq M[A,b]{A→α}⊆M[A,b]；

最终留空处均为 error。

LL(1) 文法#

可以用上述方法解析的文法称之为 LL(1) 文法，即从左 (L) 向右读入一个程序，最左 (L) 推导，采用一个 (1) 前看符号。要求对应的预测分析表不含多重表项，也就是要求：对所有产生式 A→u1∣u2∣⋯∣unA\rightarrow u_1\mid u_2\mid \cdots\mid u_nA→u1∣u2∣⋯∣un，有：

FIRST(u1)∩⋯∩FIRST(un)=∅,即 FIRST 集合互不相交ui⇒∗ε,FIRST(ui)∩FOLLOW(A)=∅,i=1,2,⋯ ,n,即 FOLLOW(A) 与所有 FIRST 集合互不相交\begin{aligned} &FIRST(u_1)\cap \cdots \cap FIRST(u_n)=\emptyset,\text{即 FIRST 集合互不相交}\\ u_i\Rightarrow^*\varepsilon,&FIRST(u_i)\cap FOLLOW(A)=\emptyset,i=1,2,\cdots,n,\text{即 FOLLOW(A) 与所有 FIRST 集合互不相交} \end{aligned}ui⇒∗ε,FIRST(u1)∩⋯∩FIRST(un)=∅,即 FIRST 集合互不相交FIRST(ui)∩FOLLOW(A)=∅,i=1,2,⋯,n,即 FOLLOW(A) 与所有 FIRST 集合互不相交

3. 自底向上分析方法#

LL(1) 分析法的优点是不需要回溯，构造方法较简单，且分析速度非常快，每读到第一个符号就可以预测出整个产生式来。缺点是对语法的限制太强，能满足此要求的语法相当少，而将一个不满足此要求的语法改写到满足要求也相当不容易。因此， LL(1) 分析法目前已经应用的比较少了。基于此，我们引入现在被广泛使用的自底向上分析方法。

对输入串的扫描：自左向右；
分析树的构造：自底向上；
分析过程：
- 从输入符号串开始分析
- 查找当前句型的“可归约串”
- 使用规则，把它归约成相应的非终结符号
- 重复

以下列文法为例，输入串为 id + id * id：

1
E → E + T | T
2
T → T * F | F
3
F → (E) | id

一种自底向上的过程如下：

步骤	当前句型	可归约串	使用的产生式	归约结果
1	id + id * id	id	F → id	F
2	F + id * id	F	T → F	T
3	T + id * id	id	F → id	F
4	T + F * id	F	T → F	T
5	T + T * id	id	F → id	F
6	T + T * F	T * F	T → T * F	T
7	T + T	T	E → T	E
8	E + T	E + T	E → E + T	E
9	E	-	-	结束

从上述例子可见，分析过程的关键在于如何找出“可归约串”。

3.1 “移进-归约”分析方法#

“移进-归约”分析过程#

把输入符号逐个地移进符号栈中；（即“移进”，把下一个输入符号移入栈顶）
当栈顶的符号串形成某个产生式的一个候选式（右部）时，在一定条件下，把该符号串替换（归约）为该产生式的左部符号；（即“归约”）
重复步骤 2 直到栈顶符号串不再是“可归约串”为止；
重复步骤 1 ～ 3 直到归约出文法起始符号 SSS；
接收：宣布分析成功，停止分析；
错误处理：调用错误处理程序进行诊断和恢复；

简单来说，“移进”相当于“往栈里装符号，等待形成句法单位”，“归约”相当于“识别出一个语法成分，用它的非终结符替代”。通过不断循环“读符号 + 识别结构”，最终构建整个语法树。

规范归约#

假定 α\alphaα 为文法 GGG 的一个句子，若右句型序列 αn,αn−1,⋯ ,α1,α0\alpha_n,\alpha_{n-1},\cdots,\alpha_1,\alpha_0αn,αn−1,⋯,α1,α0 满足：

αn=α\alpha_n=\alphaαn=α，α0=S\alpha_0=Sα0=S；
∀0<i≤n\forall 0<i\le n∀0<i≤n，αi−1\alpha_{i-1}αi−1 是经过把 αi\alpha_iαi 的句柄替换为相应产生式的左部符号而得到的；

规范归约相当于最右推导的逆过程，每次只归约当前句型中的句柄（handle），也就是恰好能还原出上一步最右推导的右部的那一部分。

3.2 LR 分析方法#

LR 分析是移进-归约分析的一种规范化、自动化的实现方法。即从左 (L) 向右扫描输入符号串，为输入符号串构造一个最右 (R) 推导的逆过程，采用 k 个前看符号。

LR 分析法的基本思想是在归约的过程中，一方面记住移入和归约的整个符号串（历史信息），另一方面通过产生式推测未来可能碰到的输入符号（预测信息）。在分析的每一步，只须根据分析栈当前已移进和归约出的全部文法符号，并至多再向前查看 k 个输入符号，就能确定栈顶的符号串是否构成相对于某一产生式的句柄，从而确定当前所应采取的分析动作（是移进还是按某一产生式进行归约等）。

LR 分析程序的模型及工作过程#

LR分析程序模型

栈包括：（两者同步变化）

状态栈 S；
符号栈 X；

分析表包括：

动作表 action：用于指导分析器在遇到不同输入符号时应采取的动作；
- action[Sm,ai]action[S_m,a_i]action[Sm,ai]：SmS_mSm 遇到输入符号 aia_iai （包括终结符和非终结符）时的动作；
  - shift SSS（移进）：将当前输入符号 aia_iai 和状态 S=goto[Sm,ai]S=goto[S_m,a_i]S=goto[Sm,ai] 压入栈；
  - reduce by A→βA\rightarrow\betaA→β（归约）：若 ∣β∣=r\left|\beta\right|=r∣β∣=r，则从栈中弹出 rrr 项，栈顶变为 Sm−rS_{m-r}Sm−r，然后把 AAA 和状态 S=goto[Sm−r,A]S=goto[S_{m-r},A]S=goto[Sm−r,A] 压入栈；
  - accept：宣布分析成功，停止分析；
  - error：调用出错处理程序，进行错误恢复；
状态转移表 goto：用于指导分析器在采取归约动作后应转移到的新状态。
- goto[Sm,X]goto[S_m,X]goto[Sm,X]：SmS_mSm 经过 XXX 的后继状态；

工作过程如下，初始二元式为 (S_0,a_1a_2\cdots a_n\)，分析过程中的每步的结果均可以表示为，分析过程中的每步的结果均可以表示为，分析过程中的每步的结果均可以表示为(S_0S_1\cdots S_m,a_ia_{i+1}\cdots a_n$)$：

若 action[Sm,ai]=shift S,S=goto[Sm,ai]action[S_m,a_i]=shift\space S,S=goto[S_m,a_i]action[Sm,ai]=shift S,S=goto[Sm,ai]，则二元式变为 (S_0S_1\cdots S_mS,a_{i+1}\cdots a_n\)$；
若 action[Sm,ai]=reduce by A→βaction[S_m,a_i]=reduce\space by\space A\rightarrow\betaaction[Sm,ai]=reduce by A→β，则二元式变为 (S_0S_1\cdots S_{m-r}S,a_ia_{i+1}\cdots a_n\)$；
若 action[Sm,ai]=acceptaction[S_m,a_i]=acceptaction[Sm,ai]=accept，则分析成功；
若 action[Sm,ai]=erroraction[S_m,a_i]=erroraction[Sm,ai]=error，则调用错误处理程序；

Note

活前缀：一个规范句型的一个前缀，如果不含句柄之后的任何符号，则称它为该句型的一个活前缀。

同样，分析方法的核心在于构造分析表，不同 LR 算法构造方法不同，下文将具体展开介绍。

LR(0) 算法#

关键概念#

Note

形态/LR(0) 项目：一个产生式的解析程度，用一个产生式加一个位置黑点 ⋅\cdot⋅ 来表示，黑点左边表示已解析的部分，右部表示待解析的部分，一般也称为 LR(0) 项目。

产生式 A→XYZA\rightarrow XYZA→XYZ 有 4 种 LR(0) 项目：

A→⋅XYZA\rightarrow\cdot XYZA→⋅XYZ：起始形态，
A→X⋅YZA\rightarrow X\cdot YZA→X⋅YZ；
A→XY⋅ZA\rightarrow XY\cdot ZA→XY⋅Z；
A→XYZ⋅A\rightarrow XYZ\cdotA→XYZ⋅：已完成形态/可折叠/形态，即归约项目；
- 文法起始符号 SSS 的归约项目又称之为接收项目；

注：产生式 A→εA\rightarrow\varepsilonA→ε 只有一个归约项目 A→⋅A\rightarrow\cdotA→⋅。

前三种根据圆点 ⋅\cdot⋅ 后的第一个符号为终结符/非终结符又可以分为：

移进项目：圆点后第一个符号为终结符号的 LR(0) 项目；
待约项目：圆点后第一个符号为非终结符号的 LR(0) 项目；

Note

拓广文法：是对原始文法的一种扩展，通过在原始文法中添加一个新的开始符号 S′S^\primeS′ 和产生式 S′→SS^\prime\rightarrow SS′→S，使得文法开始符号仅出现在一个产生式的左边，从而使分析器只有一个接受状态。（接收项目唯一）

教材上还讲了有效项目的定义，但没什么用，直接略去。

Note

闭包 closure(I)closure(I)closure(I) 的定义和构造：设 III 是文法 GGG 的一个 LR(0) 项目集合，则 closure(I)closure(I)closure(I) 是从 III 出发，并使用以下方法构造的项目集合：

III 中的每一个 LR(0) 项目均属于 closure(I)closure(I)closure(I)；
若 A→α⋅Bβ∈closure(I)A\rightarrow\alpha\cdot B\beta\in closure(I)A→α⋅Bβ∈closure(I)，且有产生式 B→ηB\rightarrow \etaB→η，若 B→⋅η∉closure(I)B\rightarrow\cdot\eta\notin closure(I)B→⋅η∈/closure(I)，则将 B→⋅ηB\rightarrow\cdot\etaB→⋅η 加入 closure(I)closure(I)closure(I)；
重复步骤 2 直至 closure(I)closure(I)closure(I) 不再增大；

注：B→⋅ηB\rightarrow\cdot\etaB→⋅η 称之为 A→α⋅BβA\rightarrow\alpha\cdot B\betaA→α⋅Bβ 的延伸形态，延伸的方向是单向的。

上述过程就是把集合 III 里所有形态的所有延伸形态全部添加进这个集合。

Note

状态：设 III 是文法 GGG 的一个 LR(0) 项目集合，状态即为 closure(I)closure(I)closure(I)，即状态是进行过闭合操作的 LR(0) 项目（形态）集合。

Note

转移函数 go：若 III 是文法 GGG 的一个 LR(0) 项目集，XXX 是一个文法符号，定义

go[I,X]=closure(J)go[I,X]=closure(J)go[I,X]=closure(J)

其中，J={A→αX⋅β∣当 A→α⋅Xβ∈I 时}J=\{A\rightarrow\alpha X\cdot\beta\mid\text{当 }A\rightarrow\alpha\cdot X\beta\in I\text{ 时}\}J={A→αX⋅β∣当 A→α⋅Xβ∈I 时}。

A→αX⋅βA\rightarrow\alpha X\cdot\betaA→αX⋅β 为 A→α⋅XβA\rightarrow\alpha\cdot X\betaA→α⋅Xβ 遇到符号 XXX 时的后继形态，

构造文法 G 的 LR(0) 项目集规范族#

输入为文法 GGG，输出为 GGG 的 LR(0)LR(0)LR(0) 项目集规范族 CCC：

构造文法 GGG 的拓广文法 G′G^\primeG′；
C={closure({S′→⋅S})}C=\{closure(\{S^\prime\rightarrow\cdot S\})\}C={closure({S′→⋅S})}；
对于 CCC 中的每一个项目集 III 和每一个文法符号 XXX，如果 go[I,X]go[I,X]go[I,X] 不为空且不在 CCC 中，则将 go[I,X]go[I,X]go[I,X] 加入 CCC；
重复步骤 2 直至 CCC 不再更新；

简单来说，就是从初始项目集 I0=closure({S′→⋅S})I_0 = closure(\{S^\prime\rightarrow\cdot S\})I0=closure({S′→⋅S}) 开始（事实上 I0I_0I0 就是起始状态），按以上方法，不断的生成新的项目集（状态），直到不再出现新的项目集（状态）。

如上图所示，这个状态转移图和有限状态自动机的运行图很相似，一般称之为识别文法 G′G^\primeG′ 所有活前缀的 DFA。不过解析过程并不能按照 DFA 运行，上下文无关文法需要下推自动机来进行识别。

LR(0) 项目集中的冲突及解决#

Note

可折叠形态：某状态/项目集中，只有一个项目，且该项目为归约项目。

语法分析中，如果遇到不可折叠状态，就会发生冲突，即：

一个项目集 III 中，既包含 X→α⋅bβX\rightarrow\alpha\cdot b\betaX→α⋅bβ，又存在 A→α⋅A\rightarrow\alpha\cdotA→α⋅，即既包含不可折叠形态，又包含可折叠形态（归约项目）；
- 这会造成“移进-归约”冲突，也就是无法判断出应该 shift，还是应该 reduce；
一个项目集中，既包含 A→α⋅A\rightarrow\alpha\cdotA→α⋅，又包含 B→β⋅B\rightarrow\beta\cdotB→β⋅，即包含多条可折叠形态（归约项目）；
- 这会造成“归约-归约”冲突，也就是无法判断出应该采用哪条产生式来归约；

解决方法见下，即 SLR(1) 算法。

判断某文法是否属于 LR(0) 文法#

一个文法是LR(0)文法，每个状态/项目集中：

要么所有 LR(0) 项目都是“移进-待约项目”；（即不能同时含有可折叠和不可折叠形态）
要么只含有唯一的归约项目（可折叠形态）；
起始符号不出现在任何产生式右部（一般通过拓广文法已经解决了）；

SLR(1) 算法#

LR(0) 冲突的解决#

由于 LR(0) 不向前看下一个符号，大大增加了冲突的可能，因此这种冲突通过向前看若干个输入符号或许能够解决。

还是考虑上面的冲突场景，即 I={X→α⋅bβ,A→α⋅,B→β⋅}I=\{X\rightarrow\alpha\cdot b\beta,A\rightarrow\alpha\cdot,B\rightarrow\beta\cdot\}I={X→α⋅bβ,A→α⋅,B→β⋅}。现在，如果下一个要读入的符号为 xxx，假设此时允许使用 B→β⋅B\rightarrow\beta\cdotB→β⋅ 进行归约，那么进行归约后，符号 xxx 紧随 BBB 之后，即 X∈FOLLOW(B)X\in FOLLOW(B)X∈FOLLOW(B)。

所以，当

FOLLOW(A)∩FOLLOW(B)=∅FOLLOW(A)\cap FOLLOW(B)=\emptysetFOLLOW(A)∩FOLLOW(B)=∅；
终结符号 b∉FOLLOW(A),b∉FOLLOW(B)b\notin FOLLOW(A),b\notin FOLLOW(B)b∈/FOLLOW(A),b∈/FOLLOW(B)；

则上述冲突全部消失，决策如下：

当下一个读入符号 x=bx=bx=b 时，用 X→α⋅bβX\rightarrow\alpha\cdot b\betaX→α⋅bβ 移进 bbb，即将 bbb 入栈；
当下一个读入符号 x∈FOLLOW(A)x\in FOLLOW(A)x∈FOLLOW(A) 时，用 A→αA\rightarrow\alphaA→α 归约；
当下一个读入符号 x∈FOLLOW(B)x\in FOLLOW(B)x∈FOLLOW(B) 时，用 B→βB\rightarrow\betaB→β 归约；

上述思路即为 SLR(1) 分析表构造的形式化描述。SLR(Simple LR) 算法的核心思想是利用“FOLLOW集”来解决冲突。

SLR(1) 分析表的构造算法#

输入：拓广文法 G′G^\primeG′；输出：G′G^\primeG′ 的 SLR 分析表

构造 G′G^\primeG′ 的 LR(0) 项目集规范族 C={I0,I1,⋯ ,In}C=\{I_0,I_1,\cdots,I_n\}C={I0,I1,⋯,In}；
对于状态 IiI_iIi 的分析动作如下：
1. 若 A→α⋅aβ∈IiA\rightarrow \alpha\cdot a\beta\in I_iA→α⋅aβ∈Ii，且 go(Ii,a)=Ijgo(I_i,a)=I_jgo(Ii,a)=Ij，则 action[i,a]=Sj(shift Ij)action[i,a]=S_j(shift\space I_j)action[i,a]=Sj(shift Ij)；
2. 若 A→α⋅∈IiA\rightarrow \alpha\cdot\in I_iA→α⋅∈Ii，则对 ∀a∈FOLLOW(A)\forall a\in FOLLOW(A)∀a∈FOLLOW(A)，则 action[i,a]=R A→αaction[i,a]=R\space A\rightarrow\alphaaction[i,a]=R A→α；
3. 若 S′→S⋅∈IiS^\prime\rightarrow S\cdot\in I_iS′→S⋅∈Ii，则 action[i,\]=accept$，表示分析成功；
若 go(Ii,A)=Ijgo(I_i,A)=I_jgo(Ii,A)=Ij，AAA 为非终结符，则 goto[i,A]=jgoto[i,A]=jgoto[i,A]=j；
剩余空白项均置为 error；
分析程序的初态为包含 S′→⋅SS^\prime\rightarrow\cdot SS′→⋅S 的有效项目集/状态；

判断某文法是否属于 SLR(1) 文法#

法一（一般用于证明是）：若文法 G 的 SLR(1) 分析表中没有多重定义项，则该文法是 SLR(1) 文法。

法二（一般用于证明不是）：不一定要全部计算出 SLR 分析表，可以挑选状态中存在“移进-归约”冲突的，计算一下应用 FOLLOW 集合后是否能解决冲突，如果仍存在冲突（即对应的动作表位置存在多重表项），则该文法不是 SLR(1) 文法。

定理：每一个 SLR(1) 文法都是无二义的文法，但并非无二义的文法都是 SLR(1) 文法。

LR(1) 算法#

SLR(1) 算法向前查看下一个符号，并利用 FOLLOW 集进行识别，但这样仍然不准确（不能确保一定能归约），仍会导致冲突。

而 LR(1) 算法更加强大，利用了下一个读入的符号的信息（lookahead，展望符），或者也被称为预测先行（预测下一个应该出现的输入符号）。

关键概念#

Note

LR(1) 项目：[A→α⋅β,a][A\rightarrow\alpha\cdot\beta,a][A→α⋅β,a]，aaa 即为展望符，表示在当前处理到 A→α⋅βA\rightarrow\alpha\cdot\betaA→α⋅β 时，下一个读入的终结符必须是 aaa 才能进行正确归约。

由于项目引入了展望符，后续的一些计算也发生了一些改变，但构造过程基本一致。

Note

后继形态：形态/项目 C=[A→X⋅YZ,a]C=[A\rightarrow X\cdot YZ,a]C=[A→X⋅YZ,a] 遇到符号 YYY 转移到后继形态 C′=[A→XY⋅Z,a]C^\prime=[A\rightarrow XY\cdot Z,a]C′=[A→XY⋅Z,a]。（这里的区别只是 LR(1) 项目的变化）

Note

转移函数 go：若 III 是文法 GGG 的一个 LR(1) 项目集，XXX 是一个文法符号，定义

go[I,X]=closure(J)go[I,X]=closure(J)go[I,X]=closure(J)

其中，J={[A→αX⋅β,a]∣当 [A→α⋅Xβ,a]∈I 时}J=\{[A\rightarrow\alpha X\cdot\beta,a]\mid\text{当 }[A\rightarrow\alpha\cdot X\beta,a]\in I\text{ 时}\}J={[A→αX⋅β,a]∣当 [A→α⋅Xβ,a]∈I 时}。

Note

延伸形态：若一个形态的黑点后是非终结符，形如 C=[A→α⋅Bβ,a]C=[A\rightarrow\alpha\cdot B\beta,a]C=[A→α⋅Bβ,a]，且有 B→η,b∈FIRST(βa)B\rightarrow\eta,b\in FIRST(\beta a)B→η,b∈FIRST(βa)，则 C′=[B→⋅η,b]C^\prime=[B\rightarrow\cdot\eta,b]C′=[B→⋅η,b] 是 CCC 的延伸形态。

简单记忆的话，延伸形态的产生式左部是黑点后的非终结符 BBB，展望符是非终结符 BBB 之后的符号串 β\betaβ + 原展望符 aaa 的 FIRST 集合。

为什么呢？形态 C=[A→α⋅Bβ,a]C=[A\rightarrow\alpha\cdot B\beta,a]C=[A→α⋅Bβ,a] 表示，当前符号栈为 α\alphaα，期待遇到符号 BBB，再遇到符号串 β\betaβ，最后遇到 aaa 才能进行归约。我们现在准备“识别”非终结符 BBB，接下来要读入能推导出 BBB 的符号串，即对 BBB 的每个产生式建立相应的“延伸形态”。

当我们识别完 B 后，会继续识别 β\betaβ，所以延伸形态的展望符号应该是 FIRST(β)FIRST(\beta)FIRST(β)，不过由于 FIRST(β)FIRST(\beta)FIRST(β) 可能包含 ε\varepsilonε，那么再后面就是 aaa 了，所以展望符号即为 BBB 的后继终结符集合，即 FIRST(βa)FIRST(\beta a)FIRST(βa)。

同理闭包的构造方法也进行微调即可：

Note

闭包的定义及构造方式：

III 中的每一个 LR(1) 项目均属于 closure(I)closure(I)closure(I)；
若 [A→α⋅Bβ,a][A\rightarrow\alpha\cdot B\beta,a][A→α⋅Bβ,a]，且有产生式 B→ηB\rightarrow \etaB→η，且 b∈FIRST(βa)b\in FIRST(\beta a)b∈FIRST(βa)，若 [B→⋅η,b]∉closure(I)[B\rightarrow\cdot\eta,b]\notin closure(I)[B→⋅η,b]∈/closure(I)，则将 [B→⋅η,b][B\rightarrow\cdot\eta,b][B→⋅η,b] 加入 closure(I)closure(I)closure(I)；
重复步骤 2 直至 closure(I)closure(I)closure(I) 不再增大；

构造文法 G 的 LR(1) 项目集规范族#

输入为文法 GGG，输出为 GGG 的 LR(1)LR(1)LR(1) 项目集规范族 CCC：

构造文法 GGG 的拓广文法 G′G^\primeG′；
C=\{closure(\{[S^\prime\rightarrow\cdot S,\]})}$；
对于 CCC 中的每一个项目集 III 和每一个文法符号 XXX，如果 go[I,X]go[I,X]go[I,X] 不为空且不在 CCC 中，则将 go[I,X]go[I,X]go[I,X] 加入 CCC；
重复步骤 2 直至 CCC 不再更新；

这里和 LR(0) 项目集规范族的构造过程是完全一致的（除了项目的表示形式不同）。同理，识别文法所有活前缀的 DFA 的构造方法也是一致的。

LR(1) 分析表的构造算法#

输入：拓广文法 G′G^\primeG′；输出：G′G^\primeG′ 的 SLR 分析表

构造 G′G^\primeG′ 的 LR(1) 项目集规范族 C={I0,I1,⋯ ,In}C=\{I_0,I_1,\cdots,I_n\}C={I0,I1,⋯,In}；
对于状态 IiI_iIi 的分析动作如下：
1. 若 [A→α⋅aβ,b]∈Ii[A\rightarrow \alpha\cdot a\beta,b]\in I_i[A→α⋅aβ,b]∈Ii，且 go(Ii,a)=Ijgo(I_i,a)=I_jgo(Ii,a)=Ij，则 action[i,a]=Sj(shift Ij)action[i,a]=S_j(shift\space I_j)action[i,a]=Sj(shift Ij)；
2. 若 [A→α⋅,a]∈Ii[A\rightarrow \alpha\cdot,a]\in I_i[A→α⋅,a]∈Ii，且 A≠S′A\ne S^\primeA=S′，则 action[i,a]=R A→αaction[i,a]=R\space A\rightarrow\alphaaction[i,a]=R A→α；
3. 若 [S^\prime\rightarrow S\cdot,\]\in I_i，则，则，则action[i,$]=accept$，表示分析成功；
若 go(Ii,A)=Ijgo(I_i,A)=I_jgo(Ii,A)=Ij，AAA 为非终结符，则 goto[i,A]=jgoto[i,A]=jgoto[i,A]=j；
剩余空白项均置为 error；
分析程序的初态为包含 [S^\prime\rightarrow\cdot S,\]$ 的有效项目集/状态；

相较于 SLR(1) 分析表，LR(1) 分析表的状态数量和每个状态中包含的项目数量都是及其恐怖的。不过状态数的增加带来的是分析能力的提升。

LR(1) 文法#

Warning

不要求。

相比于 LR(0) 文法，LR(1) 文法允许：

一个状态/项目集中同时出现可折叠状态和不可折叠状态；
- 只要可折叠形态的展望符不和不可折叠形态中黑点后面的符号冲突，不然遇到该输入，又分不清该移进还是归约了；
也可以含有多条可折叠状态（归约状态）；
- 这些可折叠状态的展望符也不能冲突；

即要求：

起始符号 S 不能位于任何产生式的右边；(一般通过拓广文法来解决)
要求每个状态中：
1. 不能同时含有 [A→α⋅aβ,b][A\rightarrow\alpha\cdot a\beta,b][A→α⋅aβ,b] 和 [B→η⋅,a][B\rightarrow\eta\cdot,a][B→η⋅,a]；
  - 否则会引起“移进-归约”冲突；
2. 不能同时含有 [A→α⋅,a][A\rightarrow\alpha\cdot,a][A→α⋅,a] 和 [B→β⋅,a][B\rightarrow\beta\cdot,a][B→β⋅,a]；
  - 否则会引起“归约-归约”冲突；

解决冲突的一种方法是利用符号的优先级，不过此处略。

LALR(1) 算法#

前面已经提到，LR(1) 构造算法复杂且状态、形态数量多。而 LALR(1) 算法对此进行了一定的优化，其基本思想是将一些相似的状态进行 merge。一种 merge 方法是将 LR(1) 项目集规范族中的所有同心状态集合并，合并时，对应项目的搜索符（展望符）也会合并。原先各自接收的有向边，都改为由合并后的项目集接收；原先各自发出的有向边，都改为由合并后的项目集发出。

关键概念#

Note

同心集：如果两个 LR(1) 项目集去掉搜索符号（展望符）之后是相同的，则称这两个项目集具有相同的心（core），即这两个项目集是同心集。

Note

项目集的核（kernal）：除去初态项目集外，一个项目集的核（kernel）是由该项目集中那些圆点不在最左边的项目组成。

其中，初态项目集的核只有 [S^\prime\rightarrow\cdot S,\]$。

LALR(1) 的项目集规范族#

先得到 LR(1) 的项目集规范族；
合并 LR(1) 项目集规范族中的同心集；（减少分析表状态数）
用核代替项目集；（减少项目集的存储空间）
转移函数 go 同样进行合并修改；

LALR(1) 项目集中的冲突#

合并可能导致“归约-归约”冲突，但不会引入新的“移进-归约”冲突，因为：

如果合并后产生“移进-归约”冲突，例如 [A→α⋅aβ,b][A\rightarrow\alpha\cdot a\beta,b][A→α⋅aβ,b] 和 [B→η⋅,a][B\rightarrow\eta\cdot,a][B→η⋅,a] 被合并到一个项目集中，这说明原来 [B→η⋅,a][B\rightarrow\eta\cdot,a][B→η⋅,a] 所在的项目集中还含有形如 [A→α⋅aβ,c][A\rightarrow\alpha\cdot a\beta,c][A→α⋅aβ,c] 的项目，而这两者原来存在于一个项目集，即原来已经存在“移进-归约”冲突。

LALR(1) 分析表的构造算法#

输入：拓广文法 G′G^\primeG′；输出：G′G^\primeG′ 的 SLR 分析表

构造 G′G^\primeG′ 的 LR(1) 项目集规范族 C={I0,I1,⋯ ,In}C=\{I_0,I_1,\cdots,I_n\}C={I0,I1,⋯,In}；
合并同心集。得到 C′={J0,J1,⋯ ,Jm}C^\prime=\{J_0,J_1,\cdots,J_m\}C′={J0,J1,⋯,Jm}；
- 分析程序的初态为包含 [S^\prime\rightarrow\cdot S,\]的的的J_k$；
构造 action 子表，对于状态 JiJ_iJi 的分析动作如下：
1. 若 [A→α⋅aβ,b]∈Ji[A\rightarrow \alpha\cdot a\beta,b]\in J_i[A→α⋅aβ,b]∈Ji，且 go(Ji,a)=Jjgo(J_i,a)=J_jgo(Ji,a)=Jj，则 action[i,a]=Sj(shift Jj)action[i,a]=S_j(shift\space J_j)action[i,a]=Sj(shift Jj)；
2. 若 [A→α⋅,a]∈Ji[A\rightarrow \alpha\cdot,a]\in J_i[A→α⋅,a]∈Ji，则 action[i,a]=R A→αaction[i,a]=R\space A\rightarrow\alphaaction[i,a]=R A→α；
3. 若 [S^\prime\rightarrow S\cdot,\]\in J_i，则，则，则action[i,$]=accept$，表示分析成功；
构造 goto 子表：设合并后 Jk={Ii1,Ii2,⋯ ,Iit}J_k=\{I_{i1},I_{i2},\cdots,I_{it}\}Jk={Ii1,Ii2,⋯,Iit}，原来这些 IiI_iIi 是同心集，那么显然 go(Ii1,X),go(Ii2,X),⋯ ,go(Iit,X)go(I_{i1},X),go(I_{i2},X),\cdots,go(I_{it},X)go(Ii1,X),go(Ii2,X),⋯,go(Iit,X) 也是同心集，把后继状态组成的同心集合并后的集合记为 JiJ_iJi，那么go(Jk,X)=Jigo(J_k,X)=J_igo(Jk,X)=Ji。
- 若 go(Jk,A)=Iigo(J_k,A)=I_igo(Jk,A)=Ii，AAA 为非终结符，则 goto[k,A]=igoto[k,A]=igoto[k,A]=i；
- 其实就是前面用文字描述的，原先各自接收的有向边，都改为由合并后的项目集接收；原先各自发出的有向边，都改为由合并后的项目集发出。
剩余空白项均置为 error；

基本与 LR(1) 分析表的构造算法一致，只需对同心集和对应的后继状态组成的同心集进行合并。

LALR(1) 文法#

先判断是否属于 LR(1) 文法。（构造 LR(1) 分析表，采用前面的方法判断是否有冲突）
如果不存在冲突，则是 LR(1) 文法，继续判断：
1. 如果不存在同心集，即不用合并，那么显然也还是 LALR(1) 文法；
2. 如果存在，则先进行合并，再检查合并后是否有冲突（即判断是否有“归约-归约”冲突）；
  1. 无冲突，是 LALR(1) 文法；
  2. 有冲突，不是 LALR(1) 文法；

LALR(1) vs. LR(1)#

形式上与 LR(1) 相同；
大小上与 SLR(1)/LR(0) 相当；
分析能力介于 SLR(1) 与 LR(1) 之间；

3.3 LR 分析的错误处理与恢复#

略。

4. 总结#

文法分类

“二义性文法”表示那些无论如何都无法消除二义性的文法，它们不可能被任何确定性分析方法识别。我们在上面介绍的均为确定性分析方法，即左侧这些。

左侧的分析方法又可以分为左侧（自顶向下）和右侧（自底向上），其中越外层表示的能处理的文法范围越大，分析能力越强，越内层针对文法的限制越多。

TMD，很久没碰上这么一坨大的了💩。

BUPT 计网实践不完全指北

Fri, 03 Oct 2025 01:20:00 GMT

写在前面#

计算机网络实践这门课每个老师使用的仿真器并不相同，如果你有幸选了张海旸老师的课，那么恭喜你，你将穿越回 2007 年，和 BUPT 的历届计算机学子一起，使用原本在 Windows XP 系统上构建的仿真器 Dynamips 进行实验，由于年代久远，实验中发生不稳定现象也是常有的事。

这篇文章主要是记录一下实验过程（前三次实验应该不用交报告，所以这里只是不正式的记录一下）。

实验环境配置#

简介#

Dynamips 是一个 Cisco 路由器模拟软件。它可以模拟 Cisco 2600，2691，3620，3640，3660，3725，3745 和 Cisco7206 硬件平台，而且可以运行标准的 Cisco IOS 文件。
Dynagen 是 Dynamips 的一个基于文本的前端控制系统，它采用“Hypervisor”超级监控模式和 Dynamips 通信。Dynagen 简化了虚拟网络的创建和工作，主要用于模拟网络拓扑。

你可以简单理解为后端和前端的区别，以下是我的实验环境，之后在老师退休前的若干年使用的仿真器也大抵如此：

配置项	参数
操作系统	Windows 10 22H2 (OS Build 19045.2965)
网络模拟器	Dynamips 0.2.7 By N.L.F.E（后端） Dynagen 0.11.0（前端）

为了不污染本地环境，我装了个 Windows 10 的虚拟机，网卡选择的是桥接模式，这样不用额外配置端口映射等，便于远程连接。另外如果你在后续操作中找不到 telnet 命令，请通过以下方式启用 Windows 内置 Telnet 客户端

在 Windows 里打开 控制面板 → 程序和功能 → 启用或关闭 Windows 功能
勾选 Telnet 客户端
确定后等待安装完成

安装 WinPcap#

WinPcap，一个底层驱动，用于捕捉数据包和绕过协议栈方式来进行数据传输，通过运行 setup 目录下的 1.安装Win_Pcap.cmd 是无法直接在 Windows10 系统上进行安装的，你可以运行老师发的 WinPcap_4_1_3.exe，或者将脚本中的可执行文件版本替换成以下内容再通过脚本安装：

Terminal window

1
@echo off
2
call ../bin/script/copyright.cmd
3
echo * 按任意键开始安装WinPcap                                                     *
4
echo *=============================================================================*
5
cd ..
6
cd bin
7
cd winpcap
8
WinPcap_4_1_3.exe
9
exit

安装过程一路 next 就行。

设置网卡参数#

这步直接在 setup 目录下运行 2.修改网卡参数.cmd 大概率得不到输出的网卡参数，通过该脚本得知其通过调用 /bin/script/get_para.php 获取网卡参数，而 get_para.php 又是通过调用 bin/dynamips/dynamips-wxp.exe 获取网卡信息并通过正则表达式提取的。

直接运行 bin/dynamips/dynamips-wxp.exe 可以正确得到网卡信息：

问题大概率是在正则表达式上，但是尝试修改仍有问题，所以干脆直接把上面的信息复制下来，即 \Device\NPF_{xxxxxx} 就是网卡参数，你也可以通过在终端运行：

Terminal window

1
getmac

得到：

将上面内容中的 Tcpip 改为 NPF 也还是一样的。

实验一：基本交换机配置#

1. 启动前后端#

运行 0.虚拟服务XP&2003.exe 启动后端；

其中有用的事实上就以下 2 句：

Terminal window

1
cd tmp
2
start /belownormal /B /wait "Dynamips" "../bin/dynamips/dynamips-wxp.exe" -H 7200

其中：

tmp 一般用来存放 Dynamips 的临时文件或运行环境，比如 idlepc 数据库；
启动 dynamips-wxp.exe 程序：
- H 7200 表示 Dynamips 将监听 7200端口，用于和前端软件（如 Dynagen）通信；
- /belownormal 让进程以较低优先级运行，避免占用过多 CPU；
- /B 表示不打开新的命令窗口，在后台运行；
- /wait 表示等待进程结束后才返回；
- "Dynamips" 是启动窗口的标题；

运行 bupt_sw.cmd 启动交换机实验环境（前端）；

该脚本有用的内容也只有以下内容：

Terminal window

1
cd tmp
2
"../bin/dynagen/dynagen.exe" ..\net\bupt_sw.net

即运行 dynagen.exe 并把 ..\net\bupt_sw.net 作为输入拓扑文件。

2. 实验用拓扑#

bupt_sw.net 文件内容如下：

1
autostart = False
2

3
[localhost]
4
    port = 7200
5
    udp = 10000
6
    workingdir = ..\tmp\
7

8
    [[router SW1]]
9
        image = ..\ios\unzip-c3640-js-mz.124-10.bin
10
        model = 3640
11
        console = 3003
12
        ram = 128
13
        confreg = 0x2142
14
        exec_area = 64
15
        mmap = False
16
        slot1 = NM-16ESW
17
        f1/1 = SW2 f1/2
18
        f1/2 = SW2 f1/1
19

20
        f1/11 = PC1 f0/0
21
        f1/12 = PC2 f0/0
22

23
    [[router SW2]]
24
        image = ..\ios\unzip-c3640-js-mz.124-10.bin
25
        model = 3640
26
        console = 3004
27
        ram = 128
28
        confreg = 0x2142
29
        exec_area = 64
30
        mmap = False
31
        slot1 = NM-16ESW
32
        f1/11 = PC3 f0/0
33

34

35
    [[router PC1]]
36
  model = 2621
37
  ram = 20
38
  image = ..\ios\unzip-c2600-i-mz.121-3.T.bin
39
  mmap = False
40
  confreg = 0x2142
41
  console = 3006
42

43
    [[router PC2]]
44
  model = 2621
45
  ram = 20
46
  image = ..\ios\unzip-c2600-i-mz.121-3.T.bin
47
  mmap = False
48
  confreg = 0x2142
49
  console = 3007
50

51
    [[router PC3]]
52
  model = 2621
53
  ram = 20
54
  image = ..\ios\unzip-c2600-i-mz.121-3.T.bin
55
  mmap = False
56
  confreg = 0x2142
57
  console = 3008

展开收起

其中：

autostart = False 表示 Dynagen 载入拓扑后 不会自动启动设备，需要在 Dynagen 控制台中手动启动；
localhost：指 Dynagen 要连接的 Dynamips 服务端运行在本机上。

port = 7200：对应前一个脚本里 Dynamips 启动参数 -H 7200。Dynagen 会通过 TCP 7200 端口控制 Dynamips。
udp = 10000：设置 Dynamips 实例的起始 UDP 端口（用于设备之间的帧交换通信）。
workingdir = ..\tmp\**：Dynagen 会把各个设备的启动配置、NVRAM、快照等文件存放在这个路径中。

1
[[router SW1]]
2
        image = ..\ios\unzip-c3640-js-mz.124-10.bin
3
        model = 3640
4
        console = 3003
5
        ram = 128
6
        confreg = 0x2142
7
        exec_area = 64
8
        mmap = False
9
        slot1 = NM-16ESW
10
        f1/1 = SW2 f1/2
11
        f1/2 = SW2 f1/1
12
        f1/11 = PC1 f0/0
13
        f1/12 = PC2 f0/0

表示一台 Cisco 3640 路由器，加载了一个带交换模块的 IOS。
slot1 = NM-16ESW 表示插入了一块 16端口交换模块。
console = 3003 表示可通过 TCP 3003 端口连接控制台（例如用 telnet）。
ram = 128 设置虚拟机内存大小（单位 MB）。
image 指向 IOS 文件路径。
端口连接如下：
- SW1 的 FastEthernet1/1 ↔ SW2 的 FastEthernet1/2
- SW1 的 FastEthernet1/2 ↔ SW2 的 FastEthernet1/1（即双链路连接）
- SW1 的 FastEthernet1/11 ↔ PC1 的 FastEthernet0/0
- SW1 的 FastEthernet1/12 ↔ PC2 的 FastEthernet0/0

SW1 和 SW2 介绍略。

1
[[router PC1]]
2
    model = 2621
3
    ram = 20
4
    image = ..\ios\unzip-c2600-i-mz.121-3.T.bin
5
    mmap = False
6
    confreg = 0x2142
7
    console = 3006

模型：Cisco 2621（轻量路由器）
RAM 仅 20 MB
IOS 文件：unzip-c2600-i-mz.121-3.T.bin
可以通过 Telnet 连接相应端口访问（例如 telnet localhost 3006）。

对应的拓扑图如下：

3. 启动设备#

启动 SW1：

Terminal window

1
start SW1

设置 idlepc（该设备的 CPU 占用率）：

Terminal window

1
idlepc get SW1

等待一段时间后，选择具有 * 号且括号中数值最大项的序号作为 idlepc 值（如果都没有 * 可以再重新统计一次），例如：

保存：

Terminal window

1
idlepc save SW1 db

由于 PC 和 SW 使用的是不同的设备，所以也要在启动 PC1 时按照上述方法配置以下，演示略。

配置设备；

在新的 cmd 窗口中输入：

1
telnet localhost 3006

输入 en 进入配置权限（show running-config 用于查看当前配置内容）：

输入 conf t 进入配置命令行；

通过 interface fx/y 配置指定端口，通过 ip add x.y.z.w 255.0.0.0 添加端口对应的 IP 地址。

比如为该接口分配一个 IPv4 地址：

IP 地址：1.1.1.1
子网掩码：255.0.0.0（即 /8）

这意味着 PC1 所在的网络为 1.0.0.0/8。

本实验需要配置的内容如下：

Terminal window

1
# start and configure SW1
2
start SW1
3

4
# start and configure PC1
5
start PC1
6
telnet localhost 3006
7
en
8
conf t
9
interface f0/0
10
ip add 1.1.1.1 255.0.0.0
11
no shutdown # 开启接口（Cisco 默认接口是 shutdown 的）
12
exit
13
no cdp run # CDP 是 Cisco 的邻居发现协议，一般在“PC 模拟设备”上没必要运行。关闭它可以减少不必要的控制流量
14
exit
15

16
# configure PC2
17
start PC2
18
telnet localhost 3007
19
en
20
conf t
21
interface f0/0
22
ip add 1.1.1.2 255.0.0.0
23
no shutdown # 开启接口（Cisco 默认接口是 shutdown 的）
24
exit
25
no cdp run # CDP 是 Cisco 的邻居发现协议，一般在“PC 模拟设备”上没必要运行。关闭它可以减少不必要的控制流量
26
exit

以 PC2 为例：

配置完后，网络的拓扑如下：

此时 PC1 和 PC2 互 Ping，Ping 通即说明成功：

启用并配置剩余的节点：

Terminal window

1
# start and configure SW2
2
start SW2
3

4
# start and configure PC1
5
start PC1
6
telnet localhost 3008
7
en
8
conf t
9
interface f0/0
10
ip add 1.1.1.3 255.0.0.0
11
no shutdown # 开启接口（Cisco 默认接口是 shutdown 的）
12
exit
13
no cdp run # CDP 是 Cisco 的邻居发现协议，一般在“PC 模拟设备”上没必要运行。关闭它可以减少不必要的控制流量
14
exit

配置完后拓扑结构如下：

此时 PC1 和 PC3 互 Ping，Ping 通即说明成功：

实验二：路由器的简单配置#

1.说明#

本实验用到的网络拓扑结构如下，配置见 net/bupt_RT.net：

2. 配置步骤#

在 Dynamips 中启动：

Terminal window

1
start R1
2
start R2
3
start PC1
4
start PC2

配置 R1 和 R2 间的连接

Terminal window

1
# R1
2
telnet localhost 3001
3
R1>en
4
R1#conf t
5
R1(config)#interface s1/1
6
R1(config-if)#clock rate 115200
7
R1(config-if)#ip add 1.1.1.1 255.0.0.0
8
R1(config-if)#encapsulation PPP
9
R1(config-if)#no shutdown
10
# 注意这里会观察到 s1/1 未启动，这是因为点对点(PPP)链路需要两端串口均配置完毕，等 R2 配置完就能观察到输出 s1/1 正确启动了
11

12
# R2
13
telnet localhost 3002
14
R2>en
15
R2#conf t
16
R2(config)#interface s1/0
17
R2(config-if)#ip add 1.1.1.2 255.0.0.0
18
R2(config-if)#encapsulation PPP
19
R2(config-if)#no shutdown
20

21
# 这里可以先测试一下 R1 和 R2 链路是否能 Ping 通

配置 R1 与 PC1，R2 与 PC2 连接

Terminal window

1
# PC1
2
telnet localhost 3003
3
PC1>en
4
PC1#cont
5
PC1(config)#interface f0/0
6
PC1(config-if)#ip add 2.1.1.2 255.0.0.0
7

8
# R1
9
R1(config)#interface f0/0
10
R1(config-if)#ip add 2.1.1.1 255.0.0.0
11

12
# PC2
13
telnet localhost 3004
14
PC2>en
15
PC2#cont
16
PC2(config)#interface f0/0
17
PC2(config-if)#ip add 3.1.1.2 255.0.0.0
18

19
# R2
20
R2(config)#interface f0/0
21
R2(config-if)#ip add 3.1.1.1 255.0.0.0
22

23
# 此时可以测试一下 PC1 和 R1，PC2 和 R2 之间的链路是否能 Ping 通
24
# 需要注意的是此时 PC1 和 R2，PC1 和 PC2 之间还是无法 Ping 通的，因为还没有配置路由表

配置路由表

Terminal window

1
# R1
2
R1(config)#ip route 3.0.0.0 255.0.0.0 serial 1/1
3

4
# R2
5
R2(config)#ip route 2.0.0.0 255.0.0.0 serial 1/0
6

7
# PC1
8
PC1(config)#ip route 0.0.0.0 0.0.0.0 F 0/0
9

10
# PC2
11
PC2(config)#ip route 0.0.0.0 0.0.0.0 F 0/0

3. 实验结果#

Ping 一下 PC1 和 PC2

1
PC1>ping 3.1.1.2
2
PC2>ping 2.1.1.2

注：如果是第一次 Ping，你基本可以重复复现第一次失败，即（4/5），这是因为当主机/路由器第一次向目标 IP 发送报文时，若本地 ARP 缓存没有目标 IP 对应的 MAC 地址，会先发出 ARP 请求（广播）等待 ARP 回复。第一个 ICMP echo 请求要等到 ARP 完成才能被正确封装并发送出去，因此第一个请求常常“超时/丢失”。随后 ARP 被学到，后面的包就能成功到达。

你可以通过在第一次 Ping 前后分别运行 show ip arp 查看 ARP 解析表验证这一点。

查看一下路由表

常用 Dynagen 命令速查表#

命令	作用	示例
list	显示当前拓扑中所有设备及状态	list
start <设备名>	启动指定设备	start SW1
start /all	启动所有设备	start /all
stop <设备名>	停止指定设备	stop SW1
stop /all	停止所有设备	stop /all
console <设备名>	连接到设备的控制台（telnet 到对应端口）	console SW1
reload <设备名>	重启指定设备（相当于reload命令）	reload PC1
telnet <地址> <端口>	连接到地址对应的设备控制台	telnet localhost 3001

常用 Dynamips 命令速查表#

命令	作用	示例
	用户模式	提示符形如：`PC1>`
en	特权模式	提示符形如：`PC1#`
conf t	全局配置模式	提示符形如：`PC1(config)#`
interface fx/y 或 interface sx/y	接口配置模式	提示符形如：`PC1(config-if)#`
exit	退出当前配置模式返回上一级
(`PC1#`) hostname othername	改名	提示符变为：`othername#`
(`PC1#`) show ip route	显示当前的路由表信息
(`PC1#`) show ip arp	显示当前 ARP 解析信息
(`PC1(config)#`) no cdp run	CDP 是 Cisco 的邻居发现协议，一般在“PC 模拟设备”上没必要运行。关闭它可以减少不必要的控制流量
(`PC1(config)#`) ip route 0.0.0.0 0.0.0.0 f0/0	配置默认路由，如果路由表中没有匹配到其他更具体路由，就把包交给 FastEthernet 0/0接口发出去。
(`R1(config)#`) ip route 3.0.0.0 255.0.0.0 serial 1/1	配置静态路由，如果要去往 3.0.0.0/8 网络的数据包，就从 Serial 1/1 接口发出去。
(`PC1(config-if)#`) ip add <ip addr> <mask>	配置接口的 IP 地址	ip add 2.1.1.1 255.0.0.0
no <instruction>	撤回配置错误的指令	no ip add 2.1.1.1 255.0.0.0
(`R1(config-if)#`) clock rate <clockrate>	配置路由器 DCE 串口的时钟速率，单位为 kbps（DTE 端不要配置）	clock rate 115200
(`R1(config-if)#`) encapsulation PPP	配置路由器的串口的数据链路层协议（默认为 HDLC）	encapsulation PPP
(`PC1(config-if)#`) no shutdown	启动当前接口

Python 套件管理器 uv 使用介绍

Fri, 05 Sep 2025 11:56:00 GMT

写在前面#

Python 生态得益于大数据时代和大模型时代蓬勃发展，相应的包管理工具也不断涌现，这篇文章简单记录一下个人上手 Astral 团队开发的 uv 的一些基操和使用一段时间后的体验。当然其实官方文档¹已经很详细了。

Warning

如有错误，欢迎指正！

1. What’s uv?#

Note

An extremely fast Python package manager. —— 开发者原话

一款现代化的 Python 包管理暨打包（packing）工具；
高性能，安装依赖速度比传统工具提升几十倍（得益于 Rust）；
一大特色，或者说最大优点是对 Python 版本的管理，不必再搭配 pyenv 等工具；
跨平台支持，适用多种开发环境
热 Cache 机制设计，二次构建快

2. Why uv ?#

下表转载自 Shoukai Huang 大佬的博客² 整理的横向对比：

功能特性	UV	pip+virtualenv	Conda	Poetry
实现语言	Rust	Python	Python	Python
速度	比pip快10-100倍	基准线	慢于pip	快于pip
内存使用	非常高效	较高	高	中等
环境管理	内置	需要单独工具	内置	内置
依赖解析	快速、现代解析器	基础	全面	现代解析器
非Python包支持	否	否	是	否
锁文件	是	否(基本requirements.txt)	是	是
项目结构化	是	否	否	是
包发布	是	是(需要twine)	是	是
兼容性	与现有pip生态系统兼容	标准Python工具	自有生态系统	更固执己见的方法
错误处理	清晰的错误信息	基本	良好	良好
资源占用	最小	中等	重	中等
科学计算焦点	否	否	是	否
跨平台一致性	是	有限	优秀	良好

总而言之：

uv vs. pip + virtualenv
- 快，跨环境
uv vs. Conda
- 太臃肿了 Conda 我说，而且环境一多比较慢
uv vs. Poetry
- 常用指令少且简洁，相比之下 Poetry 的学习成本就有点偏高了
- 内建了对 Python 的版本管理功能
- 兼容 pip, pip-tools
uv vs. pyenv
- 并非竞品，pyenv 只是用于管理多个 Python 版本的工具（一般是 Poetry + pyenv 组合），与 uv 的不同是以源码编译的方式安装 Python

如果你还在使用 pip，那我觉得针对大型项目，亦或是中小型项目，不妨跳出舒适圈，试试更舒适（纯主观）的 uv 吧？

3. How to use uv?#

3.1 Installation#

以下内容在 macOS 系统上进行。

Terminal window

1
# On macOS and Linux.
2
curl -LsSf https://astral.sh/uv/install.sh | sh
3
# or use Homebrew on macOS
4
brew install uv

使用 Python 的第三方库 pypi 安装当然也没问题：

Terminal window

1
pip install uv
2
# Or pipx.
3
pipx install uv

如需更新：

Terminal window

1
uv self update

安装成功！

3.2 Use#

常用指令：

uv help

以搭建一个 Python 项目环境为例：

uv python install 安装 Python （系统已安装跳过即可）；
uv python list 查看已安装的 Python 版本；

Python List

uv init 在新项目的根目录下执行，初始化新项目；

可以观察到其贴心的给你生成了以下文件，并自动使用 git 进行版本管理：

1
.
2
├── .git
3
├── .gitignore
4
├── .python-version
5
├── main.py
6
├── pyproject.toml
7
└── README.md

创建虚拟环境；

你可以直接 uv run main.py 执行示例文件，uv 会自动为你创建虚拟环境：

uv run

通过 uv venv --python=3.10 手动创建并指定版本当然也没问题，然后激活 source .venv/bin/activate 一下。

安装依赖；

直接看下文的速查表吧。

3.3 速查表#

3.3.1 环境管理#

操作	UV 命令
创建虚拟环境	`uv venv`
创建指定 Python 版本的虚拟环境	`uv venv --python=3.12`
激活虚拟环境	`source .venv/bin/activate`

3.3.2 包管理#

操作	UV 命令
安装单个包	`uv pip install pandas`
从 requirements.txt 安装	`uv pip install -r requirements.txt`
安装当前项目	`uv pip install -e .`
安装开发依赖	`uv pip install -e ".[dev]"`
生成锁文件	`uv pip compile requirements.in -o requirements.txt`
升级单个包	`uv pip install --upgrade pandas`

3.3.3 项目管理#

操作	UV 命令
添加依赖	`uv add pandas`
移除依赖	`uv remove pandas`
同步环境	`uv sync`
升级特定包	`uv sync --upgrade-package pandas`
升级所有包	`uv lock --upgrade`
运行脚本	`uv run python main.py`
构建项目	`uv build`
查看项目依赖关系树	`uv tree`

其中，管理依赖可以通过 group 参数来区分开发和生产环境，例如：

Terminal window

1
uv add --group dev pandas
2
uv add --group production requests

3.3.4 工具管理#

uvx，即 uv tool run 的简写，顾名思义是用于调用 Python 工具，是 pipx 的替代品。

4. 参考资料#

Footnotes#

uv 官方文档, https://docs.astral.sh/uv/ ↩
UV：下一代Python包管理工具的全面指南, https://apframework.com/blog/essay/2025-06-07-Python-UV ↩

日笠佐仓闲话免谈 talk live vol. 2.5 个人 repo

Sat, 23 Aug 2025 12:49:00 GMT

第一次接触到“佐仓绫音”这个名字应该源起至《Charlotte》，大法配的友利奈绪，当时还在可惜为什么不做成季度番，看完意难平遂补了声优广播节目（今年也是夏洛特广播十周年🥹，本人没抢到隔壁 PPP 的票，不过感觉看完昼场的樱已经心满意足了，b 站还刷到夜场有人当场把 afterglow 法批换成 ppp 去赶场然后被樱出警的，也是很有效果了），没想到成了罪恶的 dd nsy 的开始（笑）。想当年还是内山和松冈五五开，不知道 25 年了还有人看内山樱吗hhhhh。

写一点 repo，看的时候太兴奋了以至于看完已经快大脑空空了，昼场位置绝佳，樱打招呼以及展示周边和打太极环节真的就在眼前几米，后悔没填线夜场了。

先放点群友的花篮图，太好看了。

开场稍微晚了几分钟（中途还有迟到的观众结果被两人点名还说欢迎光临的，这下羡慕迟到了），不过两人最后聊到 14<15> 左右才结束，聊嗨了属于是，现场观众也很给力和有活，乐得不行，谢谢两位和群友们，感觉很久没笑这么开心了。

开场两人身着汉服出场（后来读信环节，hrk解释了一下是魏晋时期的），美得无敌，主办方微博和青二都有返图。

青二的返图

仔细观察一下发饰和演出的时候不太一样，另外好像这个窗户外面就是警察局，聊天的时候还提了一下hhhh。

然后是拷打观众日语水平，得知现场人均 N1/N2 水平后就放开聊了，hrk 最清闲的一集，有时看她想说话但是说到一半完全插不上嘴，两人高强度输出，还问了有没有霓虹金来看，我看一层大概有六七个举手的。

阳子太太比阿樱早到沪国，主办方陪同吃了一顿，阳子大胃袋说是，学会了一句“鱼好吃”的中文。

佐仓由于档期安排，凌晨 3 点多才落地浦东，佐餐落地后吃的第一餐是全家的荔枝三明治（一开始没理解，以为是两个东西）和罗森的酱油猪肉饭团：

佐餐同款饭团说是

二遍：此事在之后发的 ins 上亦有记载。全家买的，还买了一堆小零食。好像今天一点多的飞机回日本，工作狂魔了属于是，希望阿樱注意身体。

另外还提到了看到包装上的热量吓了一跳（日本一般是大卡，国内是千焦，差了 4 倍）。

接下来到了喜闻乐见的观众周边展示环节，太有活了，看到一个穿着“我的日语全是从女声优学的”的衣服的（典），以及邦的各种周边和娃娃（佐仓还q了一句好多娃娃自己都没见到过），穿法批的，一排还有一个拿着自制的“我是佐仓绫音的狗的”团扇的，还有一个一排粉毛群友被佐仓说像佐久间大介君的，等等，毕竟大法配的角色太多了。

感觉献宝环节持续了得有几十分钟，观众都非常给力。哦对，有一个一排拿望远镜的老哥被佐仓问是不是来看她们的毛孔的了。

来信环节，有打鼓求建议的，也有社畜“感觉自己成了工作机器”求鼓励的。对于打鼓，两位给出的建议竟是先组个乐队，然后就开始统计观众的乐器水平，最后得出结论是现场的观众能凑 20 支乐队，不过至于乐队间的成员关系…此事在邦多利中亦有记载（我看着hrk也是个顶级串子）。另一个给出的回答是一个日本搞笑艺人的梗，这边真不懂，然后问大家都看谁，结果全是 nsyc 平常没空看别的，我喊了个马池口还被听见了，佐仓：马池口是 nsy 不是搞笑艺人！（并非不是，笑），甚至还有拷打翻译环节，不过阳子高情商圆场hhhh。

还有就是推荐马面裙的，佐仓说想买阿迪达斯的一件盘扣来着，结果真有观众拿出来了（押题是真的充分，笑）。

还有一位女粉写了想看两位跳舞，结果最后两位直接开始打太极，自己打了一遍（阿樱完全在抄阳子hhhh） + 看教程打了一遍，有模有样，对的对的。

答题环节，第一个问题比较典，老婆在日文里是老婆婆的意思，中文里是什么意思，佐仓拔得头筹，原因是之前有一个人在 ins 用中文给樱发私信说“可爱”“喜欢你”，后面突然变成了“老婆”，还以为是粉转黑了，后来去查了中文以为是“好看的小姐姐”类似的意思，翻译提醒后才知道。

原来樱真的会看私信啊！这下不得不发了。

还有个问题是猜“水泥“对应的日语单词，阳子在观众的提醒下猜对了。

后面还有小色狼环节，就是我前面提到的要放开聊之前，提到了旁边就是公安局，吓得佐仓阳子马上终止话题：别搞的我们回不去日本了（乐）。不过夜场好像放的更开了。

最后是一个奶茶排序，分别是喜茶（椰椰芒芒）、沪上阿姨、霸王茶姬和蜜雪冰城（珍珠奶茶），喜茶甚至姗姗来迟，两位觉得每一杯都很好喝，特别是后来合影环节，staff 来收奶茶时佐仓还在护食（可爱捏），霸王茶姬樱觉得茶味有点重。盲猜点的都是全糖hhhh。

佐仓一下就排出了喜茶和雪王是最贵的和最便宜，中间两杯在反复试探观众后也排对了，不愧是专业的不喝水人士。

输了的阳子太太的惩罚游戏是要用中文模仿一句当下很火的中文流行梗，昼场是“你是谁？！请支持 XXX”（不过我寻思这不是小高和刚的吗，严格来说不算中文梗？）。

你是谁？！请支持 YODAN！

合影，散场感言。两位向观众席告别了好久。

活动评价的话，比一般 nsy fmt 强太多了，得益于台本的缘故，而且两位是真的能说且有梗，去之前还担心翻译会不会打断对谈，去完发现完全不坐牢，虽然有些是后知后觉，感觉总体来说完全不懂日语都能连蒙带猜听懂大半，就像阳子在来之前说的：”大家看到我们说不定就很幸福了“。

我永远不会忘记823了，目前为止声优 event 的顶点！当一辈子的佐佐人。

浅谈大型项目的模块化开发(Based on Python)

Tue, 05 Aug 2025 09:12:00 GMT

写在前面#

最近在进行大型项目开发时，自行实现的一些公共模块，包括工具库、API 客户端等，都被扔在一个文件夹下，需要时由该项目的控制代码进行调用，不过因为水平之菜，经过测试没什么问题的代码 PR 上去之后经常会出现需要反复修改的情况。而且另一方面，这些公共模块具有一定的可移植性，但只被一个项目使用，没什么性价比，肯定是需要进一步考虑能够在多个项目实现复用的。

一种好的管理方式（至少是大部分大型开源项目都在使用的方式）是将公共模块单独管理，模块可以独立更新，不必和主项目的提交历史绑在一起，也利好多人协作开发。具体方法包括 Git 的 Submodule 和打包为 Python Package 进行导入两种。

一、Git Submodule#

1.1 简介#

Git submodule 是 git 原生引用和管理第三方资源的方法。

假如你的项目结构如下：

1
Main Project
2
└── src/
3
└── module/
4
  └── module_1/

如果用 Git submodule 实现对 module_1 的管理，那么主项目 Git 仓库显然作为父仓库 (Superproject)，而 module_1 就作为子模块 (Submodule)，父仓库只记录子模块的 Git 仓库地址 和当前的 提交哈希，不会直接存储子模块的代码历史。

1.2 操作步骤#

食用方法也很简单，子模块和父模块都先建立一个单独的 Git 仓库，git add/commit/push 这些我就不细说了，现在假设两者的仓库都已经建立了，接下来就是 git submodule 的操作了：

在父仓库中添加子模块：

Terminal window

1
git submodule add <子模块的仓库地址> <子模块在父模块中的相对路径>

e.g.

Terminal window

1
git submodule add https://github.com/user/module_1.git module/module_1
2

3
# 等价于
4
git submodule add https://github.com/user/module_1.git module/

那么父仓库具体是如何记录这一信息的呢？在执行上述操作后，可以看到在父仓库根目录会生成一个 .gitmodules 文件，内容形如：

1
[submodule "module/module_1"]
2
    path = module/module_1
3
    url = https://github.com/user/module_1.git

也可以通过以下命令查看子模块信息：

Terminal window

1
git submodule status
2
git submodule foreach "git status"

初始化子模块：当协作者或其他用户克隆你的父仓库，即主项目时，默认子模块的目录是空的，需要手动拉取子模块代码：

Terminal window

1
git submodule init
2
git submodule update

当然，Git 也提供了在克隆时就一步到位的选项：

Terminal window

1
git clone --recurse-submodules <父仓库地址>

更新子模块：当子模块仓库有新提交时，你可以进入子模块目录拉取最新代码（当然，回退版本也同理）：

Terminal window

1
cd module/module_1
2
git pull origin main
3

4
# 如果是回退，则执行
5
git checkout <子模块需要回退到的某个commit或分支>

我们前面提到过，两者的提交历史是独立的，父仓库只记录子模块的当前提交哈希，子模块仓库的更新并不会同步到父仓库中，所以父仓库还需要手动提交：

Terminal window

1
cd ../..
2
git add module/module_1
3
git commit -m "Update submodule module_1 to latest version"

这时候，父仓库记录的才是子模块的最新提交哈希。

删除子模块：删除步骤稍复杂，需要手动清理：

Terminal window

1
git submodule deinit -f module/module_1
2
git rm -f module/module_1
3
rm -rf .git/modules/module/module_1

1.3 好处#

Git Submodule 将公共库抽离成单独 Git 仓库，父项目通过 Submodule 管理这些模块，保持版本可控。如需自动拉取子模块代码，也可以在 Github Action 等 CI/CD 工具中执行：

Terminal window

1
git submodule update --init --recursive

从而自动进行构建。

二、Python Package#

2.1 简介#

Python Package 也是一种常见方式，经常会用到的 Numpy 等就是 Package。这些第三方库能直接通过 pip 安装，分发、复用于各种项目中，虽然你用起来大道至简，但是这是 Package 的维护者在背后为你负重前行，也就是“打包”的过程，具体的打包过程可以从内到外分为三层，下图源自 Python Packaging 的官方文档，非常直观：

.py 独立模块（Standalone Modules）：可以直接导入，但无法通过 pip install 方式分发；
sdist 源码分发包（Source Distribution Package）：通过 setup.py、pyproject.toml 等安装元数据，打包成压缩文件（.tar.gz、.zip）；
wheel 预编译包（Built Distribution Package）：属于 binary package（二进制分发），简单来说就是预编译好的轮子，可以直接安装，例如 pip install my_package.whl ；

2.2 操作步骤#

以下以一个简单的例子为例，简单过一下打包步骤：

假如原始的代码结构如下：

1
my_package/
2
  └── src/
3
    └── module_a/
4
      ├── __init__.py
5
        └── module_a.py
6
    └── module_b/
7
      ├── __init__.py
8
          └── module_b.py

准备项目信息：如果 Package 想要发布，还需要添加一些基本的信息，一般通过 setup.py 或 pyproject.toml ；

1
my_project/
2
├── LICENSE   # 授权
3
├── setup.py   # 安装设定
4
├── pyproject.toml   # 安装设定
5
├── README.md
6
├── src/   # 包源码
7
    └── my_package/
8
        ├── __init__.py
9
        └── ...
10
└── test/   # 测试程序

编写元数据：一个基本的 setup.py 和 pyproject.toml 示例如下：

1
from setuptools import setup, find_packages
2

3
setup(
4
    name="my_package",
5
    version="0.1.0",
6
    description="A useful Python package",
7
    author="Your Name",
8
    author_email="you@example.com",
9
    packages=find_packages(where="src"),
10
    package_dir={"": "src"},
11
    install_requires=[
12
        "numpy>=1.19.0",
13
        "requests"
14
    ],
15
    python_requires='>=3.7',
16
)

1
[build-system]
2
requires = ["setuptools>=61.0"]
3
build-backend = "setuptools.build_meta"
4

5
[project]
6
name = "my_package"
7
version = "0.1.0"
8
authors = [
9
  { name="Your Name", email="you@example.com" },
10
]
11
description = "A useful Python package"
12
readme = "README.md"
13
requires-python = ">=3.7"
14
classifiers = [
15
    "Programming Language :: Python :: 3",
16
    "License :: OSI Approved :: MIT License",
17
    "Operating System :: OS Independent",
18
]

基本要素是类似的，也可以混用，现代打包一般采用后者，当然也有很多其他工具，这两种属于是最主流的了。

构建包：这一步是可选的，但是一般如果想要发布都会进行 build，提供更快速的安装；

Terminal window

1
python -m build

2.3 发布到 PyPI#

PyPI，即 Python Package Index，是 Python 官方的第三方软件存储库，账号注册就不赘述了，下面简单讲一下上传步骤：

1
pip install twine
2
twine upload dist/*

上传成功后，别人就可以直接使用 pip install my_package 来安装你发布的 Package 了。

很多 Package 一般都自动构建并上传，你可以随便找一个开源项目并在里面看到：

1
.github/
2
└── workflows/
3
    └── publish.yml

完全可以学学它们的 publish.yml 以及项目结构，这里给出一个简单的示例：

1
name: Publish Python Package
2

3
on:
4
  push:
5
    tags:
6
      - 'v*'   # 当你创建 v1.0.0 这种 tag 时自动触发
7

8
jobs:
9
  build-and-publish:
10
    runs-on: ubuntu-latest
11

12
    steps:
13
    - name: Checkout code
14
      uses: actions/checkout@v4
15

16
    - name: Set up Python
17
      uses: actions/setup-python@v5
18
      with:
19
        python-version: '3.11'
20

21
    - name: Install build dependencies
22
      run: |
23
        python -m pip install --upgrade pip
24
        pip install build twine
25

26
    - name: Build package
27
      run: python -m build
28

29
    - name: Publish to PyPI
30
      env:
31
        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
32
        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
33
      run: |
34
        twine upload dist/*

展开收起

Token 需要你自行在 PyPI 中获取并在 Github 中的项目仓库 →\rightarrow→ Settings →\rightarrow→ Secrets and variables →\rightarrow→ Actions →\rightarrow→ 点击 New repository secret ，创建 PYPI_USERNAME 和 PYPI_PASSWORD，注意千万不要显式写在工作流中！

完成后，当提交代码并推送 Tag 时：

Terminal window

1
git tag v1.0.0
2
git push origin v1.0.0

GitHub Actions 会自动运行 workflow，构建 wheel 和 sdist 包，并上传到 PyPI。

也可以替换为：

1
on:
2
  release:
3
    types: [published]

这样就是在发布 Release 后自动触发。

参考资料#

使用 Cloudflare R2 + WebP Cloud + PicGo 搭建你的图床

Tue, 29 Jul 2025 06:20:00 GMT

写在前面#

一开始使用了 jsDelivr 加速 Github 图床，但是实际使用中发现有时国内到 jsDelivr 的网络质量仍不稳定，或是存在 DNS 污染，并且使用 Github 作为图床容易污染 commit 记录。于是打算放弃这种依赖纯 CDN 的方式，转向 OSS ，加上刚好有优化博客访问的需求，以及赛博活菩萨 Cloudflare 提供的 10GB/月的免费对象存储服务，最终参考了几篇教程，冻手！

一、Cloudflare R2 有关配置#

1.1 账号注册相关#

Cloudflare 的账号注册我就不多说了，如果要开启 R2 服务，在注册完毕后移步左侧栏的“R2 对象存储”，需要有信用卡或者通过 Palpal（支持国内信用卡/借记卡），Cloudflare 对国内是非常友好的，支持银联和国内手机号，所以这一步基本没什么难度。只要不超出限额就不会扣费，免费容量个人使用的话狠狠造一般都超不了。

1.2 创建 Bucket#

点击“+创建 Bucket”，设置有关内容，区域根据实际需求选择，这里与之后的 WebP Cloud 保持一致，均选择美西节点。注意实际位置不一定完全保证 Cloudflare 就把该桶分配到该区域。

创建成功；

现在可以直接往里面上传文件了，对于写作博客这种需求，不可能每次手动打开在线页面往里面扔东西，这里通过继续配置 S3 API ，使之支持通过 PicGo 工具自动上传至 Bucket（见后文）。

1.3 配置域名#

首先，你需要启用 Bucket 的公共开发 URL，启用后你上传的图片就有公网链接了，设置 →\rightarrow→ 公共开发 URL →\rightarrow→ 点击“启用” →\rightarrow→ 键入“allow”以确认；

启用成功后会显示一个 r2.dev 结尾的公网地址，至于速率限制，如果你有自定义域名则不必担心；

1.4 自定义域名（可选）#

它提供的公网地址太长且杂乱无章不方便记忆，如果你有自己的域名也可以在设置 →\rightarrow→ 自定义域 →\rightarrow→ 点击“添加” →\rightarrow→ 输入你的自定义域名 →\rightarrow→ 等待 DNS 解析完成。

举个例子，比如你的域名是 xiaoming.com ，那么自定义域名可以设置为其下的如 test-r2.xiaoming.com 。

等待一段时间后就能生效了，最终的效果应该如下，即公开访问已启用并且公网地址为你的自定义域：

1.5 配置 S3 API#

R2 提供的 S3 API 为客户端工具提供了方便的上传/删除操作，配置步骤如下：

回到概述页面，点击“{}API” →\rightarrow→ 管理 API 令牌；

创建 API 令牌，注意这里选择 Account API 或者 User API 都可以，没有很大区别；

输入名称，权限选择“对象读和写”，指定你刚才创建的存储桶，保证数据安全性；

创建后会显示令牌凭据，出于安全原因，这些令牌值不会再次显示，务必做好保存，关闭该页面后无法再查看只能重新创建！

二、PicGo 客户端配置#

2.1 插件安装#

PicGo 本身不支持 S3 对象存储图床，这里通过 PicGo Amazon S3 上传插件解决，直接在 GUI 界面搜索“S3”即可，如果你遇到搜索插件不显示的情况，请参考ISSUE。

如果你安装 s3 没有成功，可以考虑安装 s3-lls ，笔者也没有安装成功，所以以下使用 s3-lls 进行演示，区别是不大的。

2.2 插件配置#

安装成功后，进入“图床设置”，会发现新增了 Amazon S3 选项，点击进入配置：

逐个填入内容，对应关系如下：

应用密钥 ID ↔\leftrightarrow↔ 访问密钥 ID
应用密钥 ↔\leftrightarrow↔ 机密访问密钥
自定义节点 ↔\leftrightarrow↔ 为 S3 客户端使用管辖权地特定的终结点
桶 ↔\leftrightarrow↔ 桶名
文件路径随你自己喜好，我使用的是：{year}/{month}/{fileName}.{extName}
自定义域名：Cloudflare 默认分配的或者你的自定义域名
权限：private ；

其余不填或保持默认即可。

配置完成后，你可以随便上传一张图片测试一下。也可以从 Cloudflare 后台验证上传结果：，顺便验证文件的存储路径是否符合自己的要求，如果你和我一样设置，那么图片的链接应该是：https://自定义域名/2025/07/文件名.png 。

Warning

注：虽然 PicGo 有将图片从相册中删除的功能，但事实上并不会对 Cloudflare 图床中存储的内容进行实际删除。

2.3 安装/配置/上传 FAQ#

笔者在上述过程中事实上也遇到了很多问题，不过最终还是成功解决了。

安装问题：包括 PicGo 下载已损坏，插件列表搜索无结果，插件安装不成功等。

个人感觉问题主要集中在 Mac 且为苹果系列的 CPU 上。具体请查阅 PicGo 官方的 FAQ 以及被关闭的 issues。

插件配置问题：picgo-plugin-s3 的作者提供了详细的配置示例；
图片上传问题：包括图片上传不成功，路径错误等；

笔者在这部分遇到的问题主要是 Nodejs 的一些库的版本问题，升级至对应版本即可解决。并且遇到的问题在 ISSUE 里也没有，所以此处不给出统一解答。如遇上传失败，请截图日志文件，尝试自己解决或者善用 AI 工具，也可以在ISSUE查找是否有类似问题。我如果看到评论区留言也会及时答复。

三、WebP Cloud 配置（可选）#

3.1 WebP Cloud 介绍#

WebP Cloud简单来说这是一个类 CDN 的图片代理 SaaS 服务，可以把图片转换为 WebP/AVIF 格式，减小图像体积，加快网页中图片的加载速度。

你的网站不直接提供原图 URL，而是把 URL 交给 WebP Cloud；
WebP Cloud 服务器代理请求原图 → 转换为 WebP/AVIF → 进行缓存；
用户访问时从其分布式节点快速获得优化后的图片；
类似 CDN，但专注于图片优化分发，而非全站加速；

首先通过 Github 授权登陆该平台，这里就不演示了。其中，免费版本每日提供 3000 个请求额度（相当于能够代理 3000 次图片访问请求），每日签到还有额外额度领！并提供 200M 的图片缓存，这对个人用户完全够用了，而且升级订阅也不算太贵，可以说非常良心了。

如果超出了请求额度也不用担心，访客对博客中图片的访问会被 301 转发到源站图片地址（即你图片的 Cloudflare 公网地址），不经 WebP Cloud 服务压缩，但依然可用；

如果超过 200M 的缓存则会按照 LRU 算法清理。所以不必担心。

具体而言，你可以根据 WebP Cloud 仪表盘的每日统计，选择合适自己的订阅。

3.2 创建代理#

在主页找到并点击“创建代理”：

3.3 配置代理#

代理区域：和 Cloudflare 统一，这里选择美西节点；
代理名称：随便取；
源站地址：与你的 Cloudflare 的自定义域名保持一致；

创建完成后，点击刚才创建的内容，进入基本信息页：

其中，代理地址就是我们图片的代理地址，比如原来的 Cloudflare 链接 https://Cloudflare自定义域名/图片地址 经过代理变为 https://WebP代理地址/图片地址 。

这里的代理地址同样支持使用自定义域名，在你的域名提供商处手动添加一下 DNS 记录即可。

3.4 配置 PicGo#

不需要改别的，只需要将 S3 配置中的自定义域名改为上图的代理地址即可！

3.5 图片压缩配置#

默认图片压缩比率为 80% 。可自行设置

Warning

在配置完成后，你可能会发现访问图片链接后返回的类型仍然是 PNG ，如果确保上述操作无误，一种可能的原因是图片本身太小，转换为 WebP 后的体积大于等于原图，所以直接返回了 PNG 。

3.6 安全性配置#

3.6.1 防止外部网页嵌入#

为防止图片直接或通过 <img> 标签被嵌入外部网站，WebP Cloud 提供了自定义 CORS 头部和 Referer 头限制的选项，具体原理可以参考官方文档。简单来说，你可以把代理 CORS 标头和代理允许的 referer 来源设置为你的博客域名，比如我的 blog.yokumi.cn ，这样外部网页嵌入你的图片将返回 403 或 CORS 错误。

3.6.2 防止 CDN 渗透#

你可以将 User-Agent 设置为自定义的值，这样，User-Agent 可以作为一个预共享密钥，确保源地址只能被 WebP Cloud 访问，从而消除由于猜测源地址而导致的 CDN 渗透问题。

写在后面#

至此，Cloudflare R2 + WebP Cloud + PicGo 就大功告成啦！

参考资料#

《药屋少女的呢喃》第二季完结个人杂谈

Sun, 27 Jul 2025 02:22:00 GMT

Warning

虽然 7 月 4 号已经完结了，不过我是后来才补完的。这一季依然很吸引我，遂水一篇博客。以下内容存在剧透（不过已经完结挺久了）。

相比于第一季，每集之间较为独立，基本都是一个个推理小故事，前后之间有点关联但不算多，主要作为序章来交代后宫的整体情况，对人物的整体刻画也不是很细，有点后宫柯南的味道。第二季在剧情安排上明显更好，虽然前半部分基本沿用了之前的小故事，看似每集之间关系不大，但当到中期进入主线后，你会发现前面几集的伏笔都被一一回收了，ep19还是ep20一集里甚至交代了过多的内容，导致观感上有些云里雾里，不过仔细一想还是能联系的上的。

主要人物（子翠等）身份的揭露也属于意料之外但联系前面几集的内容又在情理之中的感觉。并且通过这种方式更好地塑造了人物形象，你可能发现第二季中，无论是主角猫猫、壬氏，以及子翠等配角人物，形象都是多面且丰满的，猫猫不再只是一味地探案，也开始能洞察人的情感，而子翠前后身份的转变带来的反差，“笼中鸟何时飞”，在城墙上的最后一舞向观者展现了最真实的自己。

最后猫猫送给子翠的发簪也是意外地救下了子翠（没死是对的，子翠你带我走吧😭），也算是大团圆结局了（毕竟恶意已经全部推给神美了）。不过最后子翠变玉藻，小兰也出宫找到了工作，而猫猫则回到她忠诚的花街，当时只道是寻常，不知三小只还会有重逢的机会吗？

如果要说观感不太好的地方，猫猫被带到城寨后，主线的进度事实上就靠“造反到起兵镇压”这种偏宏大的叙事推动了，和探案相比，确实略显平淡，造反但缺少权谋，显得被很轻易就镇压了，子昌最后给人的感觉有点“可怜之人必有可恨之处”，而神美则是所有恶意的承受者了（不过确实抽象，罪有应得）。有关前朝的交代感觉也有点语焉不详，关系理不太清楚。从网上的评价来看，偏日式风格的神话故事、宫廷传说，以及日式特有的霸凌和恶役角色等和风元素夹在中华风的宫廷剧中，确实是不少观众诟病的点。不过说到这个，就不得不提动画制作组一开始以中华风作为宣传结果在🇰🇷网友的压力下又被迫改成“东洋风”的事了😆。

虽然设定上的文化差异等确实对观感产生了影响，但第二季无论是剧情节奏、人物塑造、伏笔的回收上都是非常戳我的。至于感情线，我倒是觉得没亲上是最好的（最好永远别亲上，毕竟感觉亲完不知道之后要如何围绕猫猫展开了），我也不磕CP，你最好也别喂我糖精，猫猫的回避性人格给人感觉淡淡的，看透一切知道世间的悲哀却仍是平静也是很戳我的点。

“想要娶猫猫的人，似乎无意让她成为嫔妃。”

期待第三季捏，有空也会补一下小说，最后放一张最好的三人组！

Workflow 还是 Agentic？

Mon, 21 Jul 2025 02:42:00 GMT

Workflow#

Workflow（工作流），简单来说，一系列对 LLM 的调用，旨在通过预定的一系列步骤来解决特定问题。可以理解为用 DAG（有向无环图）把 LLM 节点连起来。市面上一些可视化拖拽式 Agent 开发平台，例如 Coze、Dify 等，基本上都是基于 Workflow 的设计思路来实现的。

整个控制流还是由人为定义，人需要先对解决该问题的流程有一个清晰的认识，才能设计出合理的 Workflow。
适合于流程相对固定的问题，此外如果 LLM 自身的能力不够强大，无法通过单次调用规划并解决多步复杂问题，那么 Workflow 也是一个不错的选择。

Parallelization workflows#

Workflow 的一个重要优势是它可以很方便地实现并行化（parallelization）。例如，在一个 Workflow 中，如果有多个步骤之间没有依赖关系，那么这些步骤就可以同时执行，一般做法是将可并行节点拆分为多个 SubAgent 来并行处理，最终将结果汇总再进行下一步。

Chaining workflows#

链式调用（chaining），即将多步串联成完整的 Workflow，适合于流程相对固定的问题，让 LLM 能专注于每一步的具体实现。

Routing workflows#

路由（routing），即根据不同的输入或条件，动态选择不同的 Workflow 路径来处理问题。这种方式适合于流程较为复杂且具有分支逻辑的问题，可以让 LLM 根据实际情况灵活地选择最合适的处理路径。

Agentic#

给 LLM 提供目标和工具，自行探索并实现目标。

人对实现目标的具体流程没有预设，完全交由 LLM 来规划和执行；
Agent 自行设计流程来实现目标，更加灵活；
Agent 并不能盲目地持续干活，需要能够有观察环境的工具，据此进行决策并调整行为；

一个相当经典的 Agent Loop (ReAct) 的流程如下：

Reasoning→Action→Observation→Reasoning again→...\text{Reasoning} \rightarrow \text{Action} \rightarrow \text{Observation} \rightarrow \text{Reasoning again} \rightarrow ...Reasoning→Action→Observation→Reasoning again→...

简单来说，边想边做，单步迭代。

有时也会加上 Reflection（反思）来让 Agent 进行自我评估和改进，对动作执行结果进行检查。

还有一种稍微复杂一点的 Agent Loop 是 Plan-and-Execute，顾名思义就是先规划（Plan）再执行（Execute），在规划阶段，Agent 会根据当前的环境状态和目标来制定一个详细的计划，明确每一步需要执行的动作和使用的工具；在执行阶段，Agent 会按照规划好的步骤来完成任务，同时在执行过程中不断监控环境的变化，并根据需要进行调整。

相比于 ReAct，Plan-and-Execute 将规划和执行完全分开。

Workflow vs. Agentic#

同：
- 都需要工具来执行更小的子任务；
异：
- Workflow 的控制流由人预设，Agentic 的控制流由 LLM 自行规划；
- Workflow 适合于流程相对固定的问题，对单个子任务更专注，一般完成效果更好，而 Agentic 能够提供更灵活的体验；

Thinking:

个人认为随着模型能力的提升，Agentic 的优势会越来越明显，毕竟它能够更好地适应复杂多变的环境和任务需求，而 Workflow 则可能会因为流程设计不合理而导致效率低下或者无法完成任务，并且用户期望的场景就是大白话的自然语言描述需求，Agent 自主规划完成目标，而不是用户需要先把实现目标的流程设计好再让模型去执行，大道至简这一块。
不过在一些特定场景下，例如流程相对固定且对效率或可靠性要求较高的任务，Workflow 仍然是一个不错的选择。

WSL2 折腾记录

Sat, 12 Jul 2025 02:50:00 GMT

写在前面#

WSL2（Windows Subsystem for Linux version 2）是微软推出的一项功能，它允许你在 Windows 10 和 Windows 11 上运行一个真正的 Linux 内核，并使用几乎完整的 Linux 用户空间工具和程序，而无需安装虚拟机或双系统。相较于一代，WSL 2 在文件系统、IO 性能比 WSL1 有很大提升。如果你不想装虚拟机，或者不想花时间折腾双系统，那么 WSL2 将会是你的不二之选。

安装 WSL2 以及 Linux 发行版本#

下面的操作默认你的系统是 Windows 10 or Windows 11 。如低于此版本请参考微软官方文档或查阅其他网络资料。

用管理员权限打开命令行工具，输入：

Terminal window

1
wsl --install

注意此命令会安装 WSL2 及其默认的 Linux 发行版（Ubuntu），如需更改，可以使用：

Terminal window

1
wsl --install -d <Distribution Name>

发行版名称可以输入以下命令查看：

Terminal window

1
wsl --list --online

输入形如：

设置 Linux 用户名和密码#

在上一步的安装结束后，WSL2 会自动启动 Linux 并提示你输入用户名和密码。

注意：

创建用户名和密码后，该帐户将是分发版的默认用户，并将在启动时自动登录；
此帐户将被视为 Linux 管理员，能够运行 sudo 管理命令；
如需更改密码，请启动 Linux 并输入 passwd ；
如忘记密码，请打开 PowerShell 并输入 wsl -d <Distribution Name> -u root 进入目标发行版的根目录，再使用 passwd <username> 更新对应用户的密码；更新完毕后，输入 exit 关闭；

迁移安装位置（可选）#

WSL2 默认安装在 C 盘（系统盘），如果你容量不足，可以考虑迁移到非系统盘，步骤如下：

确保 Linux 发行版本处于关闭状态；

Terminal window

1
wsl -l -v

输出形如：

导出系统镜像；

Terminal window

1
# 以压缩包的形式导出系统镜像
2
wsl --export Ubuntu-20.04 E:\WSLinux\Ubuntu-20.04.tar

其中，E:\WSLinux 请替换你自己的目标位置；

注销原有的 Linux 发行版本；

Terminal window

1
wsl --unregister Ubuntu-20.04

可以通过 wsl -l -v 检查是否成功注销；

重新导入系统；

Terminal window

1
wsl --import Ubuntu-20.04 E:\WSLinux\ E:\WSLinux\Ubuntu-20.04.tar --version 2

请将上述命令中的内容替换为你的名称和路径；其中 --version 2 表示使用 WSL2 。

修改默认用户；

在重启 Linux 后，系统默认使用 root 账户登录，如需切换为你刚刚创建的用户，请在 Linux 中输入：

Terminal window

1
ubuntu2004.exe config --default-user yokumi

注意：

ubuntu-2004.exe 请替换为对应发行版名称，比如如果你的发行版名称是 Ubuntu-22.04，对应的可执行文件名称为 ubuntu-2204.exe ；
--default-user 请替换为你自己的用户名。
输入后不会输出反馈信息，重新启动 Linux 后可以验证；

更新和升级软件包#

WSL2 自带的 Linux 发行版的大部分包的版本都较旧，用包管理器升级即可：

Terminal window

1
sudo apt update && sudo apt upgrade

Docker 远程容器配置#

1. 安装和配置#

安装 Docker Desktop ；
调整 Docker Settings ：

找到 Settings -> General ，启用 Use the WSL 2 based engine ，如下图：

找到 Resource -> WSL integration ，勾选对应的 Linux 发行版本：

勾选并应用；

验证 Docker 生效；

重启 Linux 后，输入 docker -v ，以及运行简单的内置 Docker 映像：docker run hello-world ，观察到类似以下输出，说明安装成功，并正常工作：

注意，如遇网络问题，请自行寻找魔法或者 Docker 镜像！

2. 迁移 Docker Desktop 和 Docker Desktop Data#

和迁移 Linux 发行版是一致的，此处不再演示。

Warning

较新版本（应该是 2023+）的 Docker 中，提供了快速迁移的设置 Resource -> Advanced ，如下图：

实测直接选择自定义路径即可，并且重启 Linux 后无其他问题。同时，高版本的 Docker 将数据和服务整合进一个子系统中，运行 wsl -v 只会看到 docker-desktop 。

3. 回收 Docker 环境空间#

Docker 用久了会产生很多镜像文件。直接删除 Image 可能对回收存储空间并无大用，因为 ext4.vhdx 的磁盘空间会根据加载的数据自动增长，但是无法自动回收。需要进行手动回收。

停止 Linux ：

Terminal window

1
wsl --shutdown

运行 diskpart 释放空间：

Terminal window

1
diskpart
2

3
# 选择你对应虚拟机文件地址执行释放空间程序
4
select vdisk file="E:\WSLinux\docker-desktop-data\ext4.vhdx"
5
attach vdisk readonly
6
compact vdisk
7
detach vdisk
8
exit

实现远程连接#

考虑以下场景：

1
Host A   ----->   Host B   ----->   WSL(at Host B)

1. 配置 WSL 上的 SSH 端口#

WSL2 不需要折腾 WSL 自带的虚拟网卡了。WSL 中 openssh-server 默认的 22 端口会和 Windows 的 OpenSSH 服务冲突，导致 WSL 中的 SSH 服务无法启动。

这里采用更改 WSL 的 SSH 端口的方案。（当然，你更改 Windows 的 SSH 端口并配置防火墙规则也是可以的）

编辑 WSL 的 SSH 配置文件；

Terminal window

1
sudo vim /etc/ssh/sshd_config

找到以下几项，去掉前面的注释 # 并修改即可：

1
Port 2222
2
PermitRootLogin yes
3
PubkeyAuthentication yes
4
PasswordAuthentication yes

作为本地桥接的主机，并不需要很多安全需求，很多 SSH 的安全功能反而会带来麻烦。这里直接允许 ROOT 用户登录。

开启并设置 SSH 服务开机自启动；

Terminal window

1
sudo systemctl enable ssh
2

3
sudo systemctl start ssh

本机（Host B）测试连接；

首先通过以下命令获取你的 WSL 的 IP 地址：

Terminal window

1
ip addr

然后在 Windows 命令行输入：

Terminal window

1
ssh -p 2222 root@<wsl ipaddr>

如果成功连接，则说明现在本机已经能连接 WSL 的 SSH 服务。

但是这并不意味着远程主机（Host A）也能直接通过该 IP 地址建立连接，仔细观察该 IP 地址即可发现其是私有地址（一般是 172 开头的），显然无法出网。

2. 配置端口转发#

为了能够从远程主机连接到你的 WSL Linux 子系统，你需要确保 WSL 具有公共 IP 地址，需要设置镜像网络或者设置端口转发以将流量路由到 WSL 子系统的局域网 IP 地址。

假设 WSL 的 SSH 服务在 172.28.240.1:2222 ，你可以让 Windows 把端口（默认为 22 ）转发过去：

在 Windows Powershell（管理员）中运行：

Terminal window

1
netsh interface portproxy add v4tov4 listenport=22 listenaddress=0.0.0.0 connectport=2222 connectaddress=172.28.240.1

可以通过以下命令查看当前设置的所有转发规则：

Terminal window

1
netsh interface portproxy show all

如需删除，可通过以下命令：

Terminal window

1
netsh interface portproxy delete v4tov4 listenport=22 listenaddress=0.0.0.0

在远程主机（Host A）上测试连接：

Terminal window

1
ssh -p 22 root@<Host B 的公网 IP 地址>

当然，使用局域网 IP 地址也可以（适用于没有公网 IP 地址，比如校园网环境的情况，两台主机在同一局域网下即可）。

注意，如果你没有使用 Windows 的默认端口 22 ，请自行添加防火墙规则！

3. 配置镜像网络（可选）#

WSL2 在 2.0.0 版本引入了以下网络新特性，可以通过配置让 WSL 网络与 Windows 网卡桥接，而不是 NAT ，这样，WSL 的 IP 会与 Windows 在同一网段，外部设备（如 Host A）可以直接访问 WSL 的服务，非常方便！

更新 WSL 2 ；

由于新特性还是 pre-release 上的内容，需要通过以下参数获取更新：

Terminal window

1
wsl --update --pre-release

注意，如仍无法使用，可能是 Windows 的版本问题，可参考启动 WSL 后输出的信息。

创建配置文件；

Terminal window

1
notepad C:\Users\<你的用户名>\.wslconfig

添加以下内容：

1
[wsl2]
2
networkingMode=mirrored

重启 WSL ：

Terminal window

1
wsl --shutdown

验证功能生效：

1
ip addr

输出的 IP 地址和你的本机地址一致。

4. 配置 Windows 端口#

如果你在上述操作中，Windows 中设置的转发端口（端口转发方式）或 WSL 中设置的 SSH 服务端口（镜像网络方式，这种方式下，Windows 和 WSL 都使用同一个你设置的端口）不是默认端口 22 ，那么你需要额外进行以下操作：

使用命令行添加防火墙规则：

在 Windows Powershell（管理员）中执行：

Terminal window

1
netsh advfirewall firewall add rule name="WSL SSH" dir=in action=allow protocol=TCP localport=<你设置的对应端口>

或者通过图形化界面设置：

图形界面配置：
1. 打开“控制面板” → 系统与安全 → Windows Defender 防火墙 → 高级设置；
2. 进入“入站规则”，点击右侧新建规则：
- 类型：端口
- 端口号：2222（TCP）
- 允许连接
- 应用于所有网络类型（私有、公共、域）
- 命名：WSL SSH（或自定义的）
在远程主机上进行测试；

在远程主机（Host A）的终端输入：

Terminal window

1
telnet <Host B IP> <Your Port>

如果连接成功，就说明防火墙放行了。

接下来，你可以通过：

Terminal window

1
ssh -p <Your Port> root@<Host B IP>

输入密码后，成功实现远程连接！

设置 WSL 的开机启动和后台运行#

WSL2 的启动时间其实是较慢的。同时，WSL2 还会默认关闭不使用的实例，当你关闭了 WSL 的 Console 后，实例会自动关闭，虽然它的初衷是为了减少计算机资源占用，但是对于会频繁唤醒 WSL 的用户来说，确实会出现启动时间过长的情况。解决方法如下：

WIN + R 输入并运行 shell:startup 打开启动目录；
新建一个文件名为 wsl-startup.vbs ；
使用记事本编辑文件，填入以下内容：

Terminal window

1
set ws = wscript.CreateObject("wscript.shell")
2
ws.run "wsl -d <你的 Linux 发行版名称>", 0

这样当你系统启动，登录系统后，Windows 会开启 WSL 实例，它会永久等待输入，不会关闭。所以当你下次再使用WSL命令时，就不会遇到需要重新唤醒 WSL 的耗时。

关于 WSL 在后台运行占用资源的问题，事实上你可以通过任务管理器查看，其并不会占用多少内存，不过如果你还担心，你可以继续在配置文件中添加：

Terminal window

1
notepad C:\Users\<你的用户名>\.wslconfig

1
[wsl2]
2
memory=4GB
3
processors=2

博客美化记录

Thu, 03 Jul 2025 05:06:00 GMT

写在前面#

众所周知，一个好的前端/排版是继续做下去的动力（bushi）。

难得有空，继续来建设一下博客，简单美化一下前端。

自定义 JS/CSS/HTML#

引入自定义的 JS/CSS/HTML 是继续下列美化操作的条件，可以通过以下主题配置（楼主使用的是 Fluid 主题，不同主题之间可能存在一些差异）。你可以在配置文件中找到：

1
# 指定自定义 .js 文件路径，支持列表；路径是相对 source 目录，如 /js/custom.js 对应存放目录 source/js/custom.js
2
# Specify the path of your custom js file, support list. The path is relative to the source directory, such as `/js/custom.js` corresponding to the directory `source/js/custom.js`
3
custom_js:
4
- /js/custom.js
5

6
# 指定自定义 .css 文件路径，用法和 custom_js 相同
7
# The usage is the same as custom_js
8
custom_css:
9
- /css/custom.css

自行添加自定义的 JS/CSS/HTML 文件即可。

全局字体#

首先在 custom.css 中引入字体 CDN ；

1
/* 字体 */
2
@import url('https://chinese-fonts-cdn.deno.dev/packages/maple-mono-cn/dist/MapleMono-CN-Bold/result.css');

然后修改主题配置文件的字体部分，例如：

1
# 主题字体配置
2
# Font
3
font:
4
font_size: 16px
5
font_family: 'Maple Mono CN'
6
font_weight: 400
7
letter_spacing: 0.02em
8
code_font_size: 85%

文章界面背景毛玻璃效果#

在 source/css 目录下新建样式文件 frostedglassbackground.css ，内容如下：

1
#board {
2
  -webkit-backdrop-filter: blur(15px);
3
  backdrop-filter: blur(15px);
4
}
5

6
#toc {
7
  padding: 10px;
8
  top: 4rem;
9
  background-color: var(--board-bg-color);
10
  border-radius: 10px;
11
  -webkit-backdrop-filter: blur(15px);
12
  backdrop-filter: blur(15px);
13
}

引入自定义的 CSS 文件，操作略；
修改主题配置文件 _config.fluid.yml 的以下字段：

1
# 主面板背景色
2
# Color of main board
3
board_color: "#ffffff80"
4
board_color_dark: "#15172280"

统一图片宽度#

markdown 本身的图片渲染大小就是一大玄学，这里直接采用插入自定义样式文件匹配图片元素，将其固定为页面大小的 70% ，CSS 文件内容如下：

1
.markdown-body p > img,
2
.markdown-body p > a > img,
3
.markdown-body figure > img,
4
.markdown-body figure > a > img {
5
  width: 70%; /* 强制宽度为页面的70% */
6
  height: auto; /* 保持图片比例 */
7
  display: block;
8
  margin-left: auto;
9
  margin-right: auto; /* 图片居中 */
10
}
11
.page-content img, .post-content img {
12
  width: 70%; /* 强制宽度为页面的70% */
13
  height: auto; /* 保持图片比例 */
14
  display: block;
15
  margin-left: auto;
16
  margin-right: auto; /* 图片居中 */
17
}

Mac 样式代码块#

在 source/css 目录下新建样式文件 mac.styl ，内容如下：

1
.highlight
2
    background: #011627
3
    border-radius: 5px
4
    box-shadow: 0 10px 30px 0 rgba(0, 0, 0, .4)
5
    padding-top: 30px
6

7
    &::before
8
      background: #fc625d
9
      border-radius: 50%
10
      box-shadow: 20px 0 #fdbc40, 40px 0 #35cd4b
11
      content: ' '
12
      height: 12px
13
      left: 12px
14
      margin-top: -20px
15
      position: absolute
16
      width: 12px

然后在配置文件 _config.fluid.yml 中引入该自定义样式文件：

1
custom_css:
2
- /css/custom.css
3
- /css/mac.css

Warning

注意，不要写成 /css/mac.styl ，否则会被错误识别为 /css/mac.styl.css 。

折叠框中的方式有一定 BUG，并且会和我的伪代码渲染冲突，如需参考还是尽量先参考上文的方法吧，楼主会在之后有空尽可能提供支持#

安装 Hexo Shiki Plugin 插件：

Terminal window

1
# 在博客根目录下执行
2
npm install hexo-shiki-plugin --save

添加/修改该插件有关配置：

1
# 在 Hexo 配置文件 config.yml 中
2
# 以下部分一般是初始配置文件中就有的内容
3
syntax_highlighter: # 留空，原本为 highlight.js
4
highlight:
5
  enable: false
6
prismjs:
7
  enable: false
8

9
# 添加该插件的配置
10
shiki:
11
  theme: one-dark-pro # highlight-theme：one-dark-pro / github-light / github-dark / material-theme-palenight
12
  line_number: true # whether to show the line_number
13
  beautify: true # whether to add highlight tool true or false
14
  highlight_copy: true # copy button
15
  highlight_lang: true # show the code language
16
  highlight_height_limit: 360 # code-block max height,unit: px
17
  is_highlight_shrink: false # true: shrink the code blocks / false: expand the code blocks | none: expand code blocks and hide the button
18
  copy: # copy message
19
    success: 'Copy Success'
20
    error: 'Copy Error'
21
    no_support: 'Browser Not Support'

修改主题配置文件 _config_fluid.yml ：

1
code:
2
  copy_btn: false
3
  language:
4
  enable: false
5
  highlight:
6
  enable: false

上述操作主要都是为了禁用 Hexo 和主题原有的 Highlight 相关内容，避免造成冲突。

引入图标文件：

添加 Font Awesome 图标库，这里用的是 360 的 CDN，也可以选择其他的，在 custom.css 中添加即可：

1
@import url('https://lib.baomitu.com/font-awesome/6.1.2/css/all.min.css');

仿知乎链接卡片#

在 source/css 目录下新建样式文件 linkcard.css ，内容如下：

1
:root {
2
  --linkcard-bg-color: #eeefef;
3
}
4
[data-user-color-scheme="dark"] {
5
  --linkcard-bg-color: #242a38;
6
}
7

8
.LinkCard, .LinkCard:hover {
9
    text-decoration: none;
10
    border: none !important;
11
    color: inherit !important;
12
}
13
.LinkCard {
14
    position: relative;
15
    display: block;
16
    margin: 1em auto;
17
    width: 60%;
18
    box-sizing: border-box;
19
    border-radius: 12px;
20
    max-width: 100%;
21
    overflow: hidden;
22
    color: inherit;
23
    text-decoration: none;
24
    background: var(--linkcard-bg-color);
25
    transition: transform 0.4s ease-in;
26
}
27
.ztext { word-break: break-word; line-height: 1.6; }
28
.LinkCard-content {
29
    position: relative;
30
    display: flex;
31
    align-items: center;
32
    justify-content: space-between;
33
    padding: 12px;
34
    border-radius: inherit;
35
    background-color: var(--linkcard-bg-color);
36
}
37
.LinkCard-text { overflow: hidden; }
38
.LinkCard-title {
39
    display: -webkit-box;
40
    -webkit-line-clamp: 2;
41
    line-clamp: 2;
42
    overflow: hidden;
43
    text-overflow: ellipsis;
44
    max-height: calc(16px * 1.25 * 2);
45
    font-size: 16px;
46
    font-weight: 500;
47
    line-height: 1.25;
48
    color: inherit;
49
}
50
.LinkCard-meta {
51
    display: flex;
52
    margin-top: 4px;
53
    font-size: 14px;
54
    line-height: 20px;
55
    color: #999;
56
    white-space: nowrap;
57
}
58
.LinkCard-imageCell {
59
    margin-left: 8px;
60
    border-radius: 6px;
61
}
62
.LinkCard-image {
63
    display: block;
64
    width: 60px !important;
65
    height: auto !important;
66
    border-radius: inherit;
67
    margin-bottom: 0 !important;
68
}
69
.LinkCard:hover {
70
    transform: translate3d(0, -2px, 0);
71
    box-shadow: 0 0 16px 0 rgba(34, 135, 250, 0.8);
72
}

展开收起

在 source/js 目录下新建自定义 js 文件：

1
window.onload = function () {
2
    var LinkCards = document.getElementsByClassName('LinkCard');
3
    for (var i = 0; i < LinkCards.length; i++) {
4
        // 截断链接
5
        var truncateLink = function(url, maxLength) {
6
            if (url.length <= maxLength) return url;
7
            return url.slice(0, maxLength) + '...';
8
        };
9

10
        var LinkCard = LinkCards[i];
11
        var link = LinkCard.href;
12
        var title = LinkCard.innerText;
13
        // 如果没有指定logo地址，则使用默认的loading图片
14
        var logourl = LinkCard.name ? LinkCard.name : '/img/loading/loading1.gif';
15
        var displayLink = truncateLink(link, 32);
16

17
        LinkCard.innerHTML =
18
            `<span class="LinkCard-content">
19
                <span class="LinkCard-text">
20
                    <span class="LinkCard-title">${title}</span>
21
                    <span class="LinkCard-meta">
22
                        <span style="display:inline-flex;align-items:center">
23
                            <svg class="Zi Zi--InsertLink" fill="currentColor" viewBox="0 0 24 24" width="17" height="17">
24
                                <path d="M6.77 17.23c-.905-.904-.94-2.333-.08-3.193l3.059-3.06-1.192-1.19-3.059 3.058c-1.489 1.489-1.427 3.954.138 5.519s4.03 1.627 5.519.138l3.059-3.059-1.192-1.192-3.059 3.06c-.86.86-2.289.824-3.193-.08zm3.016-8.673l1.192 1.192 3.059-3.06c.86-.86 2.289-.824 3.193.08.905.905.94 2.334.08 3.194l-3.059 3.06 1.192 1.19 3.059-3.058c1.489-1.489 1.427-3.954-.138-5.519s-4.03-1.627-5.519-.138L9.786 8.557zm-1.023 6.68c.33.33.863.343 1.177.029l5.34-5.34c.314-.314.3-.846-.03-1.176-.33-.33-.862-.344-1.176-.03l-5.34 5.34c-.314.314-.3.846.03 1.177z" fill-rule="evenodd"></path>
25
                            </svg>
26
                        </span>
27
                        <a href="${link}" title="${link}" style="color:inherit;text-decoration:none;">${displayLink}</a>
28
                    </span>
29
                </span>
30
                <span class="LinkCard-imageCell">
31
                    <img class="LinkCard-image" alt="logo" src="${logourl}" onerror="this.src='/img/loading/loading1.gif'">
32
                </span>
33
            </span>`; // 如果获取指定logo地址失败，则使用默认的loading图片
34
    }
35
}

展开收起

在主题配置文件中引入，此处演示略。
使用方法：

在文章中直接插入：

1
<a href="你的链接" name="链接的ico地址" class="LinkCard">你的卡片标题</a>

使用效果：

Fluid主题美化

这也是这文的部分内容参考的博客，感谢博主提供的思路，如有侵权，请联系我删除！使用致歉！

樱花特效#

这里直接用来该网站的 API 接口。并在自定义 js 文件中添加如下内容：

1
$(document).ready(function() {
2
  // 判断是否为首页
3
  if (location.pathname === '/' || location.pathname === '/index.html' || location.pathname === '/index') {
4
    // 加载樱花特效
5
    $.getScript("https://api.vvhan.com/api/script/yinghua");
6
  }
7
});

我只在首页展示了该特效，所以在前面加了条件判断。

高斯模糊#

1. 设置方法#

首先，引入自定义 CSS 文件：

1
/* 高斯模糊样式 */
2
.blur-text {
3
  filter: blur(5px);
4
  transition: filter 0.3s ease;
5
}
6

7
.blur-text:hover {
8
  filter: none;
9
}

你可以直接在文章中通过 HTML 标签插入，比如：

1
<span class="blur-text">这是被模糊的内容</span>

也可以创建 Hexo 标签插件：
1. 在博客根目录创建 scripts 文件夹（如果不存在）；
2. 创建一个新文件 scripts/blur.js，内容如下：

1
/**
2
 * 模糊文字标签插件
3
 * 使用方法: {% blur 这是被模糊的内容 %}
4
 */
5
hexo.extend.tag.register('blur', function(args, content) {
6
  var text = args.join(' ');
7
  return '<span class="blur-text">' + text + '</span>';
8
}, {ends: false});
9

10
/**
11
 * 支持多行内容的模糊文字标签插件
12
 * 使用方法:
13
 * {% blur_block %}
14
 * 这是被模糊的内容
15
 * 可以包含多行
16
 * {% end_blur_block %}
17
 */
18
hexo.extend.tag.register('blur_block', function(args, content) {
19
  return '<div class="blur-text">' + hexo.render.renderSync({text: content, engine: 'markdown'}) + '</div>';
20
}, {ends: true});

2. 配置示例（新站不再动态渲染）#

这段内容是正常显示的。

这段内容被模糊了，鼠标悬停或点击可以查看。

或者使用标签插件：

文本黑幕#

与高斯模糊的原理是类似的。

1. 使用方法#

引入自定义 CSS 文件：

1
/* 文本黑幕样式 */
2
.shady {
3
    position: relative;
4
    display: inline-block;
5
    padding: 0 2px;
6
    border-radius: 2px;
7
    cursor: pointer;
8
}
9

10
.shady::before {
11
    content: "";
12
    position: absolute;
13
    top: 0;
14
    left: 0;
15
    width: 100%;
16
    height: 100%;
17
    background-color: #000;
18
    border-radius: 2px;
19
    transition: opacity 0.3s ease;
20
    z-index: 1;
21
}
22

23
.shady:hover::before {
24
    opacity: 0;
25
}
26

27
.shady > * {
28
    position: relative;
29
    z-index: 0;
30
}

展开收起

你可以直接在文章中通过 HTML 标签插入，比如：

1
<span class="shady">这是被黑幕遮挡的内容</span>

也可以创建 Hexo 标签插件：
1. 在博客根目录创建 scripts 文件夹（如果不存在）；
2. 创建一个新文件 scripts/shady.js，内容如下：

1
/**
2
 * 文本黑幕标签插件
3
 * 使用方法: {% shady 这是被黑幕遮挡的内容 %}
4
 */
5
hexo.extend.tag.register('shady', function(args, content) {
6
  var text = args.join(' ');
7
  return '<span class="shady"><span>' + text + '</span></span>';
8
}, {ends: false});
9

10
/**
11
 * 支持多行内容的文本黑幕标签插件
12
 * 使用方法:
13
 * {% shady_block %}
14
 * 这是被黑幕遮挡的内容
15
 * 可以包含多行
16
 * {% end_shady_block %}
17
 */
18
hexo.extend.tag.register('shady_block', function(args, content) {
19
  return '<div class="shady"><div>' + hexo.render.renderSync({text: content, engine: 'markdown'}) + '</div></div>';
20
}, {ends: true});

2. 配置示例（新站不再动态渲染）#

这是正常显示的文本。

这是一段被黑幕遮挡的内容，鼠标悬停可以查看。

或者使用标签插件：

插入图表#

使用 EChart 工具，该工具比较成熟且能绘制的图表多样。

1. 使用方法#

安装 hexo-tag-echarts 插件：

Terminal window

1
npm install hexo-tag-echarts --save

在需要插入图表的文章开头添加以下 js 内容：

1
// 通过jsDelivr的CDN引入echarts
2
<script src="https://cdn.jsdelivr.net/npm/echarts@4.8.0/dist/echarts.min.js"></script>
3
// 使用GL里的各种组件时需要添加，否则可不需要
4
<script src="https://cdn.jsdelivr.net/npm/echarts-gl@1.1.1/dist/echarts-gl.min.js"></script>

注：这里不通过 js 文件直接引入是因为用到的地方比较少，没必要作为必要加载。（博客里塞的自定义小垃圾已经够多了，加上没做优化，尽可能还是少加载一些）

插入图表内容：

1
{% echarts 400 '85%' %}
2
...
3
{% endecharts %}

具体格式说明参考 Echart官网；

2. 配置示例（新站不再动态渲染）#

这里以折线图为例：

1
option = {
2
  title: {
3
    text: 'Stacked Area Chart'
4
  },
5
  tooltip: {
6
    trigger: 'axis',
7
    axisPointer: {
8
      type: 'cross',
9
      label: {
10
        backgroundColor: '#6a7985'
11
      }
12
    }
13
  },
14
  legend: {
15
    data: ['Email', 'Union Ads', 'Video Ads', 'Direct', 'Search Engine']
16
  },
17
  toolbox: {
18
    feature: {
19
      saveAsImage: {}
20
    }
21
  },
22
  grid: {
23
    left: '3%',
24
    right: '4%',
25
    bottom: '3%',
26
    containLabel: true
27
  },
28
  xAxis: [
29
    {
30
      type: 'category',
31
      boundaryGap: false,
32
      data: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
33
    }
34
  ],
35
  yAxis: [
36
    {
37
      type: 'value'
38
    }
39
  ],
40
  series: [
41
    {
42
      name: 'Email',
43
      type: 'line',
44
      stack: 'Total',
45
      areaStyle: {},
46
      emphasis: {
47
        focus: 'series'
48
      },
49
      data: [120, 132, 101, 134, 90, 230, 210]
50
    },
51
    {
52
      name: 'Union Ads',
53
      type: 'line',
54
      stack: 'Total',
55
      areaStyle: {},
56
      emphasis: {
57
        focus: 'series'
58
      },
59
      data: [220, 182, 191, 234, 290, 330, 310]
60
    },
61
    {
62
      name: 'Video Ads',
63
      type: 'line',
64
      stack: 'Total',
65
      areaStyle: {},
66
      emphasis: {
67
        focus: 'series'
68
      },
69
      data: [150, 232, 201, 154, 190, 330, 410]
70
    },
71
    {
72
      name: 'Direct',
73
      type: 'line',
74
      stack: 'Total',
75
      areaStyle: {},
76
      emphasis: {
77
        focus: 'series'
78
      },
79
      data: [320, 332, 301, 334, 390, 330, 320]
80
    },
81
    {
82
      name: 'Search Engine',
83
      type: 'line',
84
      stack: 'Total',
85
      label: {
86
        show: true,
87
        position: 'top'
88
      },
89
      areaStyle: {},
90
      emphasis: {
91
        focus: 'series'
92
      },
93
      data: [820, 932, 901, 934, 1290, 1330, 1320]
94
    }
95
  ]
96
};

展开收起

首页文章滑入动画#

在 source/js 目录下新建自定义 JS 文件 scrollanimation.js ，内容如下：

1
const cards = document.querySelectorAll('.index-card')
2
if (cards.length) {
3
    document.querySelector('.row').setAttribute('style', 'overflow: hidden;')
4
    const coefficient = document.documentElement.clientWidth > 768 ? .5 : .3
5
    const origin = document.documentElement.clientHeight - cards[0].getBoundingClientRect().height * coefficient
6

7
    function throttle(fn, wait) {
8
        let timer = null;
9
        return function () {
10
            const context = this;
11
            const args = arguments;
12
            if (!timer) {
13
                timer = setTimeout(function () {
14
                    fn.apply(context, args);
15
                    timer = null;
16
                }, wait)
17
            }
18
        }
19
    }
20

21
    function handle() {
22
        cards.forEach(card => {
23
            card.setAttribute('style', `--state: ${(card.getBoundingClientRect().top - origin) < 0 ? 1 : 0};`)
24
        })
25
    }
26

27
    document.addEventListener("scroll", throttle(handle, 100));
28
}

在 source/css 目录下新建自定义样式文件 scrollanimation.css ，内容如下：

1
.index-card {
2
  transition: all 0.5s;
3
  transform: scale(calc(1.25 - 0.25 * var(--state)));
4
  opacity: var(--state);
5
  margin-bottom: 2rem;
6
}
7

8
.index-img img {
9
  margin: 20px 0;
10
}

在配置文件中引入自定义 css 和 js 文件，操作略；

网页元素悬停放大特效#

在 source/css 目录下新建自定义样式文件 hover.css ，内容如下：

1
/* 首页文章封面 */
2
.index-img {
3
  /* 动画时间 */
4
  transition: .4s;
5
}
6
.index-card:hover .index-img {
7
  /* 放大倍数 */
8
  transform: scale(1.05);
9
}
10

11
/* 头像 */
12
.about-avatar img {
13
  transition: .4s;
14
}
15
.about-avatar:hover img {
16
  transform: scale(1.05);
17
}
18

19
/* 标签云 */
20
.tagcloud a {
21
  transition: .4s;
22
}
23
.tagcloud a:hover {
24
  transform: scale(1.05);
25
}

你可以自由补充你希望悬停放大的网页元素。

引入自定义样式文件，操作略；

标签页文字跟随焦点切换#

原理是添加一个对页面可见性事件 visibilitychange 的监听。

在 source/js 目录下新建自定义 JS 文件 visibilitychange.js ，内容如下：

1
jQuery(document).ready(function() {
2
    var b, c, a = document.title;
3
    var welcomeTimer = null;
4
    function d() {
5
        if (document[b]) {
6
            document.title = " 你切到别的标签页了 ";
7
            if (welcomeTimer) {
8
                clearTimeout(welcomeTimer);
9
                welcomeTimer = null;
10
            }
11
        } else {
12
            document.title = " 你在当前标签页 ";
13
            welcomeTimer = setTimeout(function() {
14
                document.title = a;
15
            }, 2000);
16
        }
17
    }
18

19
    if (typeof document.hidden !== "undefined") {
20
        b = "hidden";
21
        c = "visibilitychange";
22
    } else if (typeof document.mozHidden !== "undefined") {
23
        b = "mozHidden";
24
        c = "mozvisibilitychange";
25
    } else if (typeof document.webkitHidden !== "undefined") {
26
        b = "webkitHidden";
27
        c = "webkitvisibilitychange";
28
    }
29

30
    if ((typeof document.addEventListener !== "undefined" || typeof document[b] !== "undefined") && c) {
31
        document.addEventListener(c, d, false);
32
    }
33
});

展开收起

引入自定义 JS 文件，操作略；

后记#

持续更新中。没什么技术含量，主要是一些小构思。

从零开始的MacBook配置指南

Thu, 19 Jun 2025 01:39:00 GMT

从这台正式加入我的三件套，完成了苹果全家桶的最后一块拼图，取代联想拯救者 Y7000P 2020H成为我的工作主力已经有近一年了（拯救者已经基本吃灰了）。故特此记录一下一些使用心得与软件推荐。不过使用的偏好与习惯因人而异，适合自己的才是最好，当然从 Win 转 Mac 操作系统，一般都得适应一段时间。

Warning

本文中所涉及的软件等，本人不会提供任何破解版的安装方法或地址，并请不要在评论区留言涉及有关内容。如有能力，请尽量支持正版！

一、基本设置#

以下是个人的一些习惯性设置，选择性参考即可。

1.1 键盘设置#

关于输入法，哥们就是传统拼音 + 英文输入法，如果你习惯打五笔或者双拼，可以在系统偏好设置 →\rightarrow→ 键盘 →\rightarrow→ 输入法 →\rightarrow→ 编辑 →\rightarrow→ 点击左下角的加号，添加所需输入法。

另外，推荐你在系统偏好设置 →\rightarrow→ 键盘 →\rightarrow→ 输入法 →\rightarrow→ 编辑 →\rightarrow→ 关闭“连按两下空格键插入句号”。

其余设置如下，基本没改：

1.2 触控板设置#

MacBook 的优势之一其实就是它牛波一的触控板，用惯了之后你就不习惯用鼠标了（笑）。

启用轻点来点按：系统偏好设置 →\rightarrow→ 触控板 →\rightarrow→ 光标与点按 →\rightarrow→ 启用轻点来点按；
更多手势设置如下：

用惯双指和三指了你就会明白触控板的好了。

二、日常软件#

2.1 安装网络工具#

在国内，安装软件的第一步，肯定是先安装上网工具。以下是一些推荐工具，有些安装地址就不放了，自己发挥主观能动性吧。

ClashX or Clash Pro（推荐！）：适用于 MacOS 的 Clash 系列；
V2rayN：适合新手，上手容易吧；

关于配置等问题，可以参考胖橙佬的文章 Clash 新手完美使用指南；

2.2 浏览器#

Safari —— 苹果自带的其实就挺好用的，只不过我更喜欢谷歌；
Google ，可以直接通过 3.2 中的 HomeBrew Cask 直接安装：

Terminal window

1
brew install --cask google-chrome

顺便推荐一些浏览器插件：

Tampermonkey —— 大名鼎鼎的油🐒插件；
沉浸式翻译 —— 网页翻译，好用！
AdGuard —— 广告拦截器，还可以屏蔽一些暗链；
GitZip —— 一个支持下载仓库内的指定文件的插件；
iCloud密码 —— 你都用苹果了不用 iCloud ？

2.3 截图工具#

Paste：支持截图、滚动截图、标注和 OCR ，唯一缺点就是付费；

2.4 菜单栏管理#

三、开发配置#

3.1 HomeBrew#

Homebrew 是 MacOS 上的包管理工具（类似 Windows 上的 Scoop），可以用来安装各种软件，甚至字体，并且无需像 Win 一样配置环境变量。伟大，无需多言。

官网提供的安装方式如下：

Terminal window

1
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

安装完成后，推荐配置以下镜像源，有时候 HomeBrew 还是挺慢的，将以下内容添加进 ~/.zprofile 即可：

Terminal window

1
export HOMEBREW_BREW_GIT_REMOTE="https://mirrors.ustc.edu.cn/brew.git"
2
export HOMEBREW_CORE_GIT_REMOTE="https://mirrors.ustc.edu.cn/homebrew-core.git"
3
export HOMEBREW_BOTTLE_DOMAIN="https://mirrors.ustc.edu.cn/homebrew-bottles"
4
export HOMEBREW_API_DOMAIN="https://mirrors.ustc.edu.cn/homebrew-bottles/api"

正确配置后，HOMEBREW_API_DOMAIN 会把包安装信息的地址设置成镜像地址，如下图：

3.2 HomeBrew Cask#

Homebrew Cask 允许你使用命令行安装 macOS 应用。比如你可以这样安装 Chrome：brew install --cask google-chrome。不过它是社区驱动的，提供的应用不一定是最新版本，目前 Homebrew Cask 已经和 Homebrew 深度集成，不需要单独安装了。

3.3 终端配置 —— iTerm2#

很多人觉得苹果的原生终端不好用且不好看（毕竟默认白色和个记事本一样），我也尝试了很多别的第三方终端工具，总体体验下来最终选择了 iTerm2 ，相比于原生终端提供了更多快捷的功能和特性。我使用的是 powerlevel10k 主题，效果如下：

漫游计算机网络之情景篇

Tue, 10 Jun 2025 09:00:00 GMT

QoS 的一个例子：保证转发#

所有的业务被划分为4个优先级；
通过 Traffic Policer 的令牌桶机制进行流量整形；
在经过 Traffic Policer 时，每个优先级下又被分类为3种优先级，或者说丢弃优先级，即丢包的可能性大小；
所以最终实际上有12种服务等级；
在每个 Packet 的 IP Header 的 ToS 字段(Type of Service 服务类型) 会携带 DSCP(6bits) + ECN(2bits)，其中：
- DSCP(Differentiated Services Code Point 服务等级)；
- ECN(Explicit Congestion Notification 拥塞控制)；
路由器接收到被划分后的包，根据以下2种机制进行分组调度：
- WFQ(Weighted Fair Queuing 加权公平队列)：按照优先级进行公平调度；
- RED(Random Early Detection 随机早期检测)：采用主动丢弃机制，这里被丢弃的概率就是前面划分的丢弃优先级；

PSTN 公用交换电话网#

PSTN ，即 Public Switched Telephone Network ，公用交换电话网。

1. 本地环路 Local Loop#

进行模拟信号传输；
使用双绞线，从家到端局；
设备包括 CodeC, Modem or ADSL Modem ；
早期只包括电话线（300 Hz ～ 3400 Hz），即模拟信号的传输；后期由于加入用户电脑等设备，需要传送数字信号，所以先通过 Modem ，再通过 CodeC ，如下图所示；

比较点	Modem（拨号）	ADSL Modem
功能	拨号上网，将数字信号调制成适合带宽传输的模拟信号	拨号上网，将数字信号调制成适合带宽传输的模拟信号
传输介质	UTP 3 ，即普通电话线	UTP 3 ，即普通电话线
信道带宽	整个电话线频段 3100 Hz（需要引入滤波器，将带宽限制在语音范围）	1.1 MHz（无需滤波器）
工作层次	物理层	物理层
通信方式	全双工，以字符为单位	全双工，以字符为单位，PPP 协议
调制速率	2400 Baud	4000 Baud
调制技术	QAM	DMT-离散多音调制技术（QAM 的升级版）
信号	模拟信号	模拟信号
复用技术	无复用	频分复用 FDM

2. 中继 Trunk#

交换局和交换局之间，使用光纤连接。

中继线上传输的是数字信号，其中用到了时分复用技术，包括：

项目	T1	E1
标准组织	Bell Labs（美国）	ITU-T（国际电信联盟）
使用地区	美国、日本、加拿大	欧洲、中国等大部分其他地区
传输速率	1.544 Mbps	2.048 Mbps
时隙数量	24 个时隙（channels）	32 个时隙
每个时隙速率	64 Kbps（语音标准）	64 Kbps（语音标准）
可传语音通道数	24 路	30/32 路（其中 2 个为控制与同步）
帧结构	每帧 193 bit（8×24 + 1）	每帧 256 bit（8×32）

3. 综述#

用户家里的电话和电脑都通过电话线，其中，电脑的数字信号先经过 ADSL Modem 转换为模拟信号，然后和语音信号一起经过 Splitter ，将频段分离，经过用户线后，到达端局，和其他 DSL 用户的信号一起经过 DSLAM 集中汇集，再转发到互联网。

数据包分片过程#

数据链路层（以太网）、网络层（IP 协议）、传输层（TCP 协议）事实上都涉及分片的操作。

应用层的数据交给传输层后，这部分数据即 TCP 的有效载荷；
TCP 是面向字节流的，故有效载荷不能超过 MSS Bytes ；TCP 首先对数据进行了一次分片，分成不同的 TCP 报文；
TCP 并对其进行封装，加上至少 20 Bytes 的 TCP Header ；
交给网络层后，网络层同样对其进行封装，加上 20 Bytes ～ 60 Bytes 的IP Header ；
这样，IP Header + TCP Header + Payload 已经完成封装，交给数据链路层，作为 Frame 的 Data 部分；
数据链路层为其加上 18 Bytes 的控制字段，封装成帧，最终在物理层中实际传输；

我们知道，对于以太网，MTU = 1500 Bytes ，即最大传输单元（不包含控制字段），所以反推出 MSS 不能超过 1500 - 20 - 20 = 1460 Bytes ；

问题：MSS 似乎并没有必要，只需 MTU 即可？#

并非如此，网络层是不可靠的，服务尽力而为，并没有像 TCP 一样高效的重传机制。不考虑 MTU ，让 IP 层直接负责对 TCP 报文的分片，会发生什么呢？

一个 TCP 报文，直接被 IP 层划分为多个 IP 包，传输过程中，如果其中 1 个 IP 包分片丢失，根据 IP 协议，就需要重传所有的 IP 包分片；

看起来好像没什么问题，但是 IP 协议哪里有重传这一说，重传是通过上层，即 TCP 协议来控制的，由于某个分片丢子，IP 包无法进行重组，自然不会交给上层，接收方的传输层根本不知道，所以发送方的传输层需要在超时后才能进行重传。那么效率是可想而知的低的。

引入 MSS 后，事实上确保了一个 TCP 报文不会被 IP 协议分片，即 1 个 IP 包对应 1 个 TCP 报文。往往在 TCP 建立连接的过程中，双方会协商好 MSS 的大小；

漫游计算机网络之设备篇

Mon, 09 Jun 2025 13:01:00 GMT

网络层及以上#

1. 网关 Gateway#

简单来说，网关是一种能连接两个不同网络的设备，它在网络层或更高层起作用，负责协议转换、地址转换、路由转发等功能。

你可以简单的理解为，所有网关都是路由器，不过路由器并不一定是网关。

几种简单的类型包括：

默认网关（Default Gateway）：连接子网与外部网络的设备（通常是路由器）；
- 比如你在家里笔记本电脑需要通过家里的局域网访问互联网，你家的路由器的 IP 地址就是你的默认网关；
应用层网关（Application Gateway）：邮件网关，HTTP 代理服务器等；

2. 路由器 Router#

不讲了。

3. NAT#

3.1 NAT 是什么？#

NAT ，即 Network Address Translation ，网络地址转换。是在路由器或防火墙上进行的技术，一般需要专门支持 NAT 的路由器，称之为 NAT Router 。

3.2 NAT 有什么用？#

把私有 IP 地址转换为公有 IP 地址（或反之） 的技术，使得多个私有网络设备可以通过一个或少量公网地址访问互联网。

注：也可能将 TCP/UDP 的端口号一起进行转换。

私有地址包括：

10.0.0.0 ～ 10.255.255.255/8；
172.16.0.0 ~ 172.31.255.255/12；
192.168.0.0 ~ 192.168.255.255/16；

3.3 工作过程#

3.4 常见 NAT 类型#

动态 NAT 表项：
- 当内部主机需要访问公网时才建立 NAT 表项；
- 动态创建和回收（连接关闭或长久未使用时回收）；
- 私有 IP 从公网 IP 池中动态选取一个进行映射，动态创建表项；
静态 NAT 表项：
- 手动创建并配置表项，一个私有 IP 对应一个固定公网 IP ；
- 映射关系固定；

3.5 评价#

优点：
- 节省了 IPv4 地址；
- 增加了内网安全性；
- 更灵活；
缺点：
- 作为网络层，更改了传输层的端口，打破了端到端的通信；
- 只是 IPv6 协议的过渡方案；

数据链路层#

1. NIC 网卡#

网络接口卡，Network Interface Card ，简称网卡，是计算机或其他网络设备与网络进行通信的硬件接口。

1.1 功能#

网卡负责实现物理层和数据链路层的协议功能，包括：

发送与接收帧
实现 MAC 地址识别与封装
执行数据链路层和物理层的一些功能
提供驱动程序供操作系统使用

1.2 常见类型#

以太网网卡：最常见，用于连接局域网，通过网线（RJ45）；
无线网卡：实现 Wi-Fi，无需网线，常见于笔记本；

1.3 网卡号#

网卡号，即网络接口卡（NIC）的硬件地址 —— 也就是 MAC 地址。

全球唯一，由网卡厂商在出厂时烧录。作用范围是同一局域网。

2. Switch 交换机#

2.1 功能#

交换机（Switch）是一种工作在 数据链路层 的网络设备，它根据每台主机的 MAC 地址 来决定将数据帧转发到哪个端口，从而高效地连接多个局域网设备。

功能	说明
帧转发	根据 MAC 地址决定数据应发往哪个端口
MAC 学习功能	自动学习每台设备的 MAC 所在的端口，并建立 MAC 地址表
广播隔离	只将帧发往目的主机对应端口，而不是所有端口（不像 Hub）
全双工通信	支持同时收发，提高带宽效率
冲突域隔离	每个端口是独立冲突域，避免传统 Hub 的冲突问题

相较于 Hub ，其优点主要就是支持全双工通信，并且隔离了冲突域。

2.2 类型#

直通式（Cut-Through）：边接收数据帧边根据帧头的目的地址直接转发；
- 无法检查错误；
- 输入输出速率相同；
- 延迟低；
存储转发式（Store-and-Forward）：缓存整个数据帧，检查数据包是否正确，过滤掉碰撞的残帧和 CRC 错误帧，再根据目的 MAC 地址转发；
- 支持差错检测；
- 支持不同输入/输出端口的交换；
- 延迟高；

2.3 交换机的转发表#

字段	说明
MAC 地址	设备的硬件地址，用于唯一标识局域网中的主机
端口号（接口）	MAC 地址所在的交换机端口号
时间戳 / 老化计时器	用于判断该项是否长期未被使用，控制老化删除

有些高级交换机还会记录 VLAN ID，用于支持 VLAN 分布式转发。

当交换机的某个端口接收到一个以太网帧时，执行 MAC 学习过程：

查看该帧的源 MAC 地址；
如果该 MAC 地址不在表中，或端口发生变化；
则在转发表中添加 / 更新该 MAC 对应的端口号与时间戳；

这其实和网桥的学习过程是很像的。

为了防止转发表无限增大或信息过期，交换机会在：

某个 MAC 地址在一段时间（比如 300 秒）没有出现；
该项对应的端口断开或设备下线；

此时会触发：老化机制（Aging Mechanism），删除这项。

3. Bridge 网桥#

网桥，用于连接多个局域网，并进行帧的存储和转发，延迟增加。即插即用。

注：网桥隔离了冲突域，但并未隔离广播域，无法防止广播风暴！

广播域 Broadcast Domain：站点发送广播帧时，收到该帧的站点与其处在同一个广播域。连接在一个交换机、网桥或集线器的所有站点同处一个广播域。

3.1 学习网桥#

3.1.1 后向学习 Backward Learning#

用于构造转发表，主要涉及泛洪 Flooding 、丢弃 Discard 、转发 Forwarding 三种操作。将帧中的源 MAC 地址和输入端口的映射关系加入到转发表。

3.1.2 生成树网桥#

断环，构造无环树。

3.2 网桥 vs. 交换机#

对比项	网桥（Bridge）	交换机（Switch）
端口数量	少（2~4 个）	多（通常为 24、48 个）
学习实现方式	主要基于软件实现，效率较低	使用 ASIC（专用集成电路）硬件转发，高效快速
MAC 表容量	小（适用于小型网络）	大（适用于大型复杂网络）
处理	一次只能处理一帧	可以并行处理多路
转发机制	软件查表+转发（存储转发）	硬件查表+线速转发（可以使用直通式）
延迟和吞吐量	较高延迟，低吞吐	低延迟，高吞吐（适合现代多业务网络）
管理和功能	简单，通常不支持 VLAN、QoS 等高级功能	丰富，支持 VLAN、QoS、端口镜像、生成树等
协议支持	支持生成树协议（STP）	支持生成树 + 多种扩展（RSTP、MSTP 等）

物理层#

1. Hub 集线器#

物理上星型，逻辑上总线型，即冲突域仍包括和 Hub 连接的所有设备；
参数 100 Base -T X 含义：
- 100 ：100 Mbps，传输速率；
- Base ：使用基带传输，不调制；
- T ：双绞线，传输媒介；
- X ：编码方式，一般采用 Manchester 编码；

2. Repeater 中继器#

一句话，就是接收、放大、再生信号，并将其转发到更远的物理距离，从而扩展网络的传输范围。

功能	描述
放大信号	补偿信号在传输过程中的衰减（如电缆越长越弱）
再生信号	还原数字信号的波形，使其更“干净”，减少误码率
扩展物理距离	使网络电缆可超出单段长度限制，例如 Ethernet 的 100 米限制

半双工；
用于将两个总线型的以太网连接；
中继器只是“看到信号波形”，并进行电气层面的复制和放大，不识别具体内容；

冲突域 Collision Domain：两个站点不能同时发送数据，则这两个站点属于一个冲突域。连接在一个集线器（或者用中继器 repeater 连接的多个网段）的所有站点属于一个冲突域。

3. Transponder 转发器#

卫星通信中使用，监听地面的上行电波，经过放大后再以另一种频率的下行电波广播给地面天线。

4. 数字通信系统的有关设备#

4.1 模拟信号数字化 —— CodeC#

信源编/解码器 CodeC：模拟信号 →\rightarrow→ 数字信号；

采样、量化、编码，e.g. PCM（Pulse Code Modulation 脉码调制），采样率为 8000/s8000/s8000/s ，每秒采样 888 bits ，数据率/带宽为 64 kbps；

4.2 数字基带信号传输 —— 信道编码器#

和加密器一起，主要是给数字序列加一些冗余位等。

4.3 带通信号传输 —— Modem 调制器#

Modem ，调制器，用于将基带信号转换为带通信号。

4.4 多路信号复用到同一信道 —— Multiplexer 多路复用器#

多路复用器，使用多路复用技术，来提高信道利用率，包括：

TDM 时分复用：
- STDM 同步时分复用，e.g. PCM ；
- ATDM 统计/异步时分复用，e.g. 介质访问控制；
FDM 频分复用：e.g. ADSL 非对称数字用户线；
WDM 波分复用；
CDM 码分复用；

4.4 ADSL Modem#

详见《漫游计算机网络之情景篇》。

4.5 DSLAM#

DSLAM ，全称 Digital Subscriber Line Access Multiplexer ，即数字用户线接入复用器，属于局端设备。是电信运营商用来将多个 DSL 用户的信号集中接入、并转发到互联网的设备。

漫游计算机网络之技术篇

Mon, 09 Jun 2025 05:50:00 GMT

其实完全可以放在《协议篇》里，确信。不过为方便对比分析，所以单开一篇来水了。

Retransmission 重传机制#

1. 概述#

哪些层需要进行重传？

即答：数据链路层 and 传输层；

2. 数据链路层的重传#

ARQ 技术，即 Automatic Repeat Request ，自动重传请求。当物理层出现传输误码时，数据链路层需要对错误进行恢复。由于一般采用检错码，所以需要发送方对出错的数据进行重传，并且重传是发送方自主完成的。

3. 传输层的重传#

本质上也用到了 ARQ ，但使用了一些机制用于优化重传。

3.1 超时重传#

就是普通的重传，重传计时器 RTO 超时，重传对应的数据包。

3.2 快速重传#

优化前者，当发送方连续收到 3 个重复的 ACK ，它就知道该包可能丢了，于是无需等待该包的 RTO 超时就直接进行重传。

3.3 SACK 选择确认#

接收方在 TCP Header 的选项字段添加 SACK ，告诉发送方自己已经接收到哪些数据，这样发送方就只需重传特定的数据。

3.4 Duplicate SACK#

简单来说，就是让发送方知道自己是否发送了重复的数据包。

Timer 定时器管理#

1. 概述#

哪些层有定时器

事实上，除了物理层之外，其上每一层都有定时器，只不过有些并不明确把它当作一个定时器，但是事实上也发挥了定时器的功能。

2. 数据链路层的定时器#

Frame Timer 帧计时器：每一个帧在发送时启动一个对应的重传计时器，若超时还没收到 ACK 则重传该帧；
ACK Timer ACK 计时器：在收到帧后不直接回送 ACK ，如果在 ACK_Timer 超时前有数据需要发送，则捎带 ACK ，若超时，则单独发送一个 ACK 帧；用于延时确认，减少了单独的 ACK 帧数量，提高了网络效率

无线通信中，虚拟载波监听技术还有 NAV 网络分配向量 ，站点维护一个 NAV ，表示需要退避的时间。

3. 网络层的计时器#

比如 IPV4 包的 TTL 字段， ICMP 报文的超时反馈也涉及 TTL ，部分路由协议中的周期性广播等。

4. 传输层（TCP 协议）的计时器#

传输层的计时器以 TCP 协议为主，TCP 协议也是计时器最复杂的协议之一。

Retransmission Timer 重传计时器：即 RTO ，超时重传计时；
Persistence Timer 持续计时器：用于周期性地进行窗口探测，防止窗口为 0 的死锁；
Keepalive Timer 保活计时器：当另一方始终静默时，发送一个包试探其是否还处于通信状态，防止半开连接；
Time-Waited Timer 等待时间计时器：
- Time-waited State：当主动关闭连接的一方（即先发 FIN 的那一方）在完成 TCP 四次挥手后，会进入一个叫做 TIME_WAIT 的状态；
- 该状态通常会持续一段时间，其值一般为 TIME_WAIT = 2 × MSL（Maximum Segment Lifetime），即最大报文生存时间的 2 倍；
- 作用一是确保对方正确收到了 ACK ，双方都正确关闭连接（为自己第一次发送的 ACK 丢失，对方重发 FIN ，自己重新回 ACK 预留时间）；
- 作用二是防止混入新的连接，确保连接已经完全关闭；

4.1 RTO 计时器的设置#

由于网络情况顺序万变，RTO 本来略大于 RTT 即可，但是 RTT 动态变化，所以 RTO 也需要进行相应调整。

SRTT 平滑 RTT 计算#

SRTT = α\alphaα ×\times× SRTT +++ (1−α)(1 - \alpha)(1−α) ×\times× New_Sample ，一般取 α=78\alpha = \frac{7}{8}α=87 ；

RTTVAR RTT 偏差计算#

RTTVAR = β\betaβ ×\times× RTTVAR + (1−β)(1-\beta)(1−β) ×\times× |SRTT - Sample| ，一般取 β=34\beta = \frac{3}{4}β=43 ；

RTO 计算#

RTO = SRTT + 4 ×\times× RTTVAR ；

信道共享算法#

我们仅看时分复用的部分：

静态信道分配算法（同步时分复用）：将信道划分为多个子信道使用，e.g. PCM；
动态信道分配算法（异步时分复用）：
- 受控多路访问控制：
  - 轮询 Polling（中心式控制）；
  - 令牌 Token（分布式控制）；
- 随机多路访问控制：
  - ALOHA ；
  - CSMA ；
  - CSMA/CD ；
  - CSMA/CA ；

1. 评价信道共享算法的指标#

低负载情况下的时延和高负载下的吞吐量（或信道利用率）；

注：低负载下适合用竞争的方法（即 1-persistent CSMA）；而 p 越小，负载高时，发送帧的随机化越好，冲突越小，吞吐量越高；

2. ALOHA#

2.1 Pure ALOHA#

任何时刻想发就发；
没收到 ACK ，则随机等待一段时间，再进行重传；
脆弱期 = 2ttrans2t_{trans}2ttrans ；

2.2 Slotted ALOHA 时隙 ALOHA#

只能在每个时隙的开始时刻发送数据；
需要统一的时钟管理；
脆弱期 = ttranst_{trans}ttrans ；

3. CSMA 载波监听多路访问#

发前先听：
- 若信道空闲则以一定概率发送；
- 发信道正忙则等待直至空闲；
- 发出一段时间后没收到 ACK ，则重传；
脆弱期 = tpropt_{prop}tprop ；

3.1 常见类型#

Nonpersistant CSMA 如果监听到信道正忙，那它会等待一个随机时间后在进行监听；
- 高负载时，有较高的吞吐量；
Persistant CSMA 如果监听到信道正忙，会持续监听到信道上没有信号，然后以一定的概率 ppp 发送；
- 1 - Persistant CSMA：p=1p = 1p=1，即监听到信道上没有信号就发送；
  - 低负载时，能有较低的时延和较高的吞吐量；
  - 高负载时，吞吐量较低；
- p - Persistant CSMA：以一定的概率 ppp 发送；

简单来说，当 ppp 较小时，高负载情况下，有较好的随机化，冲突概率小，表现更好。

4. CSMA/CD 带冲突检测的 CSMA#

4.1 特点#

半双工 Half Duplex ：即同一个站点同一时刻只能作为发送方或接收方；
经典以太网使用；

4.2 基本步骤#

载波监听；
发送方检测冲突；
冲突检测：当发送方检测到冲突时，停止传输，并发送一个 Jam Signal(强化信号)；
backoff 退避：当发送方接收到 Jam 强化信号后，等待一个随机时间在恢复发送；（目的是避免两个发送方同时检测到冲突并进行退避后，监听到信道空闲又发送导致再一次冲突）

4.3 一些注意点#

发送方来检测冲突；
如何检测？
- 通过一条收线，从总线上读取数据，比较是否与自己发送出去的数据相同；
- 不适用于无线通信，原因：
  - 无线通信收到的信号可能比原信号弱很多；
  - 无线通信的信号分为不同的频段，站点并不一定能收到全部的频段；
  - 隐藏终端和暴露终端问题；
发现冲突的时间 = 2tprop2t_{prop}2tprop ；
采用随机指数退避；
- 一般最多尝试 16 次，超过则认为失败；
- 指数达到 10 后不再增加；
- 基础退避时间 = 51.2 us ；

5. CSMA/CA#

5.1 无线通信中的问题#

5.1.1 Hidden Terminal 隐藏终端#

隐藏终端问题是与正在通信的工作站距离较远时无法判断其正在通信，此时发数据会在接收站产生干扰，如下图：

5.1.2 Exposed Terminal 暴露终端#

暴露终端问题是与正在通信的工作站距离较近但与接收站点距离较远，此时发数据不会产生干扰，但是暴露终端会错误的认为存在干扰。

5.1.3 解决方法 —— MACA#

MACA ，即 Multiple Access Collision Avoidance ，冲突避免多路访问。通过 RTS 和 CTS 帧来预约信道，也可以理解为是一个握手的过程。

简单来说，暴露终端只会收到 RTS ，隐藏终端只会收到 CTS ，都会保持沉默。一种特殊情况是两个站点同时向同一个站点发送 RTS ，此时目的站点先回复先收到的 RTS ，另一个发送站点发现一定时间未收到 CTS ，则采用指数退避。

注：MACA 只是早期提出的一种理论，基于 RTS / CTS 来避免碰撞，并非标准。

5.2 CSMA/CA 的工作流程#

对于发送方：

通过载波监听等待直到信道空闲，并在等待 DIFS 的时间（即在 DIFS 时间内信道空闲，才认为信道空闲，能发送数据）；
随机退避（0 ～ 15 个时间槽），如果在退避时间内信道变为忙碌，设备会停止退避并持续监听，等到信道再次空闲并经过 DIFS 时间后，重新启动退避计时器，直到退避时间结束且信道空闲才发送数据；
如果没有收到 ACK ，那么采用指数退避，加倍退避时间；

对于接收方：

如果正确接收到帧，则等待 SIFS 的时间后回复ACK；

注：tSIFS<tDIFSt_{SIFS} < t_{DIFS}tSIFS<tDIFS，这能保证 ACK 的优先级更高；事实上，可以通过为不同类型的帧设置不同长度的 IFS 帧间隔，来实现优先级服务；

Error Control 差错控制#

1. 哪些层需要差错控制？#

数据链路层 and 传输层；

注：网络层中，IPv4 Header 虽然也有 Checksum 字段，但它只对头部做校验，确保路由器转发正确，并不校验数据部分，也不进行重传，只是尽力而为，所以没有差错控制。到 IPv6 直接把该字段舍去了。

2. 数据链路层的差错控制#

2.1 Error Detection 检错码#

仅加上有限的冗余位，用于接收方判断是否出错，但没有纠错能力。

奇偶校验码（Parity check）；
校验和（Checksum）；
循环冗余校验码（CRC）；

会计算 CRC ：

看给出的多项式G(x)G(x)G(x)的最高位rrr，则在数据位后添加rrr个000后再进行除法；
这里的除法不同于常规的多项式除法，是模2除法，即按位异或；

2.2 Error Correction 纠错码#

纠错码是指在发送端在发送的信息中采用相关算法加上足够多的冗余信息，使接收端不仅可以判断接收的信息有误码，还可纠正出现的错误。

2.2.1 纠正单比特错误的汉明编码#

首先计算需要的校验位位数：

mmm：原始信息长度；
rrr：check bits，即需要增加的校验位长度；
nnn：码字长度，即n=m+rn = m + rn=m+r；

根据原始信息长度，可推出存在 2m2^m2m 合法信息，每一个合法性信息按照码字传输，会产生单比特错误的信息 nnn 个，所以共存在 (n+1)2m(n + 1)2^m(n+1)2m 个码字。

为确保能纠正单比特错误，需要保证 (n+1)2m≤2n⇒m+r+1≤2r(n+1)2^m\le2^n \Rightarrow m + r + 1\le 2^r(n+1)2m≤2n⇒m+r+1≤2r ，即合法的码字和不合法的码字不重叠；

计算校验位（偶检验 or 奇检验）并在 2 的幂次位置插入校验位；

2.3 检错和纠错能力#

检错和纠错能力与汉明距离有关。

汉明距离 = d+1d + 1d+1 ⇒\Rightarrow⇒ 可以检查出 ddd 比特错误；
汉明距离 = 2d+12d + 12d+1 ⇒\Rightarrow⇒ 可以纠正 ddd 比特错误；

3. 传输层的差错控制#

主要就是 TCP 和 UDP 报头中的 Checksum 字段。

Flow Control 流量控制#

1. 概述#

哪些层需要流量控制？

即答：数据链路层 and 传输层；

流量控制的作用？

即答：对于数据链路层，防止链路发送方淹没接收方；对于传输层，防止发送主机淹没接收主机；

传输层和数据链路层的流量控制有什么区别？

比较项	数据链路层流量控制	传输层流量控制
作用范围	相邻两个节点（点到点）	端到端（主机到主机）
主要对象	控制链路发送方别淹没接收方	控制发送主机别淹没接收主机
典型协议/机制	HDLC 和 PPP 协议的滑动窗口机制、Gbit 以太网Pause帧	TCP 滑动窗口
依赖的上下文	链路速度、网卡缓存	应用层速率、操作系统缓存
是否感知整体路径	只感知本地链路	感知整条路径的接收端
是否跨路由器	不跨路由器	会跨多跳路由器
可靠性机制	有时包含确认和重传	包含确认、重传、窗口管理

2. 数据链路层的流量控制#

2.1 滑动窗口机制#

主要包括基本的停等协议，GBN 协议和 SR 协议。考点的话一般包括滑动窗口大小的计算、序列号所需比特数的计算以及对应协议效率的计算。

机制	停等协议	1-bit 滑动窗口	GBN 协议	SR 协议
通信模式	Simplex	Duplex	Duplex	Duplex
Seq Bit	1	1	n	n
WTW_TWT	1	1	>1	一般默认 = 2n−12^{n-1}2n−1
WRW_RWR	1	1	=2n−12^n-12n−1	= 2n−12^{n-1}2n−1

注：需要满足 WT+WR≤2nW_T + W_R \le 2^nWT+WR≤2n ；

2.2 协议效率计算#

发送时间，或称传输实验，即数据装载到信道上的时间为 ttranst_{trans}ttrans ；
传播时延为 tpropt_{prop}tprop ；
令 α=tpropttrans\alpha = \frac{t_{prop}}{t_{trans}}α=ttranstprop ；
单个帧的有效传输时间即为 ttranst_{trans}ttrans ，采用 ACK 确认需要花费的总时延为 ttrans+2tpropt_{trans} + 2t_{prop}ttrans+2tprop ，即单独的 ACK 帧较小，传输时间可以忽略；
当采用 Piggybacking 机制时，由于 ACK 帧和数据一起发送，传输时间并不能忽略；

仅采用 ACK 确认：U=min{100%,WT1+2α}U = min\{100\%, \frac{W_T}{1 + 2\alpha}\}U=min{100%,1+2αWT} ；
采用捎带确认时，U=min{100%,WT2+2α}U = min\{100\%, \frac{W_T}{2 + 2\alpha}\}U=min{100%,2+2αWT} ；
以上均未考虑有错信道；

2.3 G 比特以太网中的流量控制#

进化到 G 比特以太网（全双工通信时）后，由于传输速率过快，接收方极短的 CPU 忙碌就会造成大量帧的堆积，占满缓冲区，接收方此时会向发送方发送一个 Pause 帧，发送方收到后，暂停数据发送。

3. TCP 的流量控制#

TCP 的滑动窗口大小并不是帧的数量，而是面向字节的，以字节数为单位，题目中一般认为窗口大小 = n ×\times× MSS Bytes ；同时 TCP 的窗口大小是动态变化的，适用于多样和复杂的网络环境。

问题：流量控制和拥塞控制有何区别？#

首先，流量控制仅发生在发送方和接收方之间，流量控制是确保让发送方发送的数据不至于淹没接收方，能根据接收方的实际接收能力发送数据。

拥塞控制考虑整个网络的拥塞情况，网络拥堵，TCP 包无法到达，进行重传，进一步加重拥堵，所以在网络拥塞时，同样需要发送方调整发送速率，避免发送方的发送的数据填满整个网络，加重网络负担。

3.1 工作机制#

窗口滑动的操作与数据链路层是类似的。关于动态调整窗口大小的过程，简单来说，当接收方收到 TCP 报文后，存入操作系统缓冲区，不过受限于上层的处理能力，并不一定一次性读取所有数据并前移接受窗口，如果当前接受窗口减小了，会在回复的 ACK 包中的 Window Size 字段指明接收方的处理能力，发送方在收到 ACK 包后，根据接受窗口的大小调整发送速率。

3.2 隐患一、窗口关闭的死锁#

3.2.1 病症#

试想如果接收方的应用层处理能力太逊了，窗口大小减着减着减到 0 了，此时接收方通知发送方窗口为 0 关闭，此时发送方不能再发送数据。

当然，当接收方窗口恢复时，它会发送 Window Update 包通知发送方可以继续发送数据，但是这个包并不需要发送方确认，如果丢了，发送方认为接收方窗口仍关闭，接收方认为发送方确实没数据要发，两边就死锁了。

3.2.2 解决方案：窗口探测包#

一句话：Window Probe 包 + Persistence Timer 持续计时器！

在接收方窗口关闭之后，发送方会周期性（即 Persistence Timer 的时限）地向接收方发送一个 Window Probe 包，试探接收方是否在线，直到收到接收方的回复。

3.3 隐患二、糊涂窗口综合症#

3.3.1 病症#

和上述情形类似，接收方应用层的处理能力有限，导致接收窗口不断减小，并不断通知发送方，使得发送方不断发送小包，浪费带宽。
也有可能发送方的应用层需要发送的数据就是小包。

3.3.2 解决方案：Nagle && Clark 算法#

发送方：Nagle 算法，即延迟发送小包
- 当满足以下条件才发送窗口数据：
  - 收到之前发出的包的 ACK 帧；
  - 缓存的小包大小达到发送窗口大小的一半；
  - 缓存的小包大小超过 MSS ；
- 需要接收方配合，不回复小包的 ACK ；
接收方：Clark 算法，即延迟通知窗口更新
- 当满足以下条件才通知窗口更新：
  - 接受窗口的大小超过 MSS 长度；
  - 接受窗口的大小超过一半，即一半空闲了；

Congestion Control 拥塞控制#

1. 概述#

哪些层需要拥塞控制？

即答：网络层 and 传输层；

拥塞控制的作用？

即答：都是为了减轻网络的拥塞状态；

网络层和传输层的拥塞控制有何区别？

比较项	网络层	传输层
控制位置	路由器	通信两端
控制对象	链路拥塞、队列	数据发送速率
控制手段	丢包、标记、负载均衡	慢启动、窗口调整等
控制范围	局部链路	整体连接
是否需要路由器支持	是	否（也不能否定吧，路由器标记 ECN 也是间接来通知两端的传输层）

虽说控制范围不同，但本质上都作用于整个网络，防止整个网络过于拥塞而“雪崩”。

2. 网络层的拥塞控制#

2.1 概述#

网络层事实上的主要作用是 “感知和通知” 拥塞，不过也有控制手段，主要防止网络层中的链路或节点（主要是路由器）被数据淹没，手段要么及其简单粗暴（粗粒度的），要么就是间接调控。主要分为以下 5 种；

网络供给 Networking Provision；
业务感知路由 Traffic aware-routing；
准入控制 Admission control；
流量限制 Traffic throttling；
负载掉落 Load shedding；

前 2 种属于增加资源的操作，后 3 种属于减少负载的操作；
前 3 种属于预防性措施，后 2 种属于反应性措施；

2.2 流量限制/业务量调节 Traffic throttling#

检测拥塞：通过链路利用率、队列长度、丢包数量或估计队列延时；
通知拥塞：
1. 路由器直接向发送方发送 Choke Packet 抑制分组；
2. 显示拥塞通知：IP 协议来操作！将 IP 包中的 ECN 字段置位，会间接通知传输层；
3. 隐式拥塞通知：详见 TCP 协议，通过超时 Timeout 来判断；
响应拥塞：发送方通过调整发送窗口调整发送速率；

2.3 负载掉落 Load shedding#

2.3.1 RED 随机早期检测#

RED ，即 Random Early Detection ，顾名思义，就是路由器在完全失效前，就开始随机丢弃队列中的一部分分组。

3. 传输层的拥塞控制#

3.1 概述#

相较于前者，传输层的拥塞控制就比较细致了，并且它事实上也使用到了 IP 协议的部分功能，以下是几种典型机制。

3.2 一些泛用的机制#

3.2.1 最大最小公平性#

有什么用？

用于拥塞控制中的资源分配问题。在数据流共享链路的情况下，不让“独占”或“饿死”的情况发生，最大可能的实现公平。

基本思想？

如果不能再增加某个流的带宽，除非减少另一个带宽小于或等于它的流的带宽，那就是最大最小公平。

3.2.2 AIMD 加法增乘法减#

基本思想？

网络进入拥塞是很容易的，但是从中恢复却很难，所以递增过程应该平缓，递减过程应该激进。

怎么做？

评价是理解下图即可：

3.3 TCP 和 IP 层的联动#

我在前面提到了路由器检测到拥塞后会将 IP 包中的 ECN 字段置位，接受端收到该 IP 包后，发现 ECN = 11 ，会将回送给发送端的 TCP 报文头的 ECE(ECN Echo 回声) 设置为有效，发送端收到后，会将发送给接收端的 TCP 报文头的 CWR(Congestion Window Reduce 拥塞窗口减小标志) 设置为有效，告诉接收方我已经响应拥塞了，并减小窗口。

一句话，接收方设置 ECE ，发送方设置 CWR 。

3.4 TCP 的拥塞控制算法#

TCP 通信中，在发送窗口 swnd 和接收窗口 rwnd 的基础上，又新增了一个拥塞窗口 cwnd ，由发送方维护。

swnd=min{rwnd,cwnd}swnd = min\{rwnd,cwnd\}swnd=min{rwnd,cwnd}

注：看清题目问的是发送窗口还是拥塞窗口怎么变。

需要注意以下提到的各种算法一般是结合使用的，即 TCP Reno 。

3.4.1 慢启动 Slow Start#

初始化 cwnd=1cwnd = 1cwnd=1 ；
指数增加，第 iii 个 RTT 时，cwnd=2icwnd = 2^icwnd=2i ；
当 cwnd≥ssthreshcwnd \ge ssthreshcwnd≥ssthresh ，即超过慢启动门限时，转 3.3.2 拥塞避免算法，或者直接称其为 AI(Additive Increase 线性增长)；

3.4.2 拥塞避免算法 —— AI#

cwnd 达到慢启动门限时，每个 RTT 时间，线性增长，即 cwnd+=1cwnd+=1cwnd+=1 ；
也可以这么理解，达到阈值后，每收到 1 个 ACK ，cwnd+=1cwndcwnd += \frac{1}{cwnd}cwnd+=cwnd1 ；

无论有无达到门限，在发生严重拥塞，即重传计时器超时时，都转入 3.3.2 ；

3.4.3 拥塞发生 —— MD#

MD ，即 Multiplicative Decrease ，乘法减少，在拥塞发生时，需要迅速减小发送速率。

重传计时器超时，cwnd=1,ssthresh=12cwndcwnd = 1,ssthresh = \frac{1}{2}cwndcwnd=1,ssthresh=21cwnd ；
重新进入慢启动状态；

3.4.4 快速恢复#

快速恢复事实上是与快速重传配合使用的，首先回顾一下快速重传的概念：

快速重传：当发送方连续收到 3 个重复的 ACK ，它就知道该包可能丢了，于是无需等待该包的 RTO 超时就直接进行重传。

TCP 认为连续收到 3 个重复的 ACK 时，可能只是中间的某个数据包丢了，所以并不太严重，于是执行以下操作：

cwnd=12cwnd,ssthresh=cwndcwnd = \frac{1}{2}cwnd,ssthresh = cwndcwnd=21cwnd,ssthresh=cwnd ；
执行恢复过程，似乎并不要求；

下图还是相当直观的，展示了上述 4 个算法是如何配合工作的：

路由技术#

网络层的功能。由路由器进行，路由表的构建需要路由算法 + 路由协议，这里将一些基本的路由算法，或者也可以说路由技术。

1. 最优化原则#

一句话，最优路径上的任意两点间的路径也是最优的。

2. 泛洪 Flooding 路由算法#

每一个入境分组将被路由器转发到除了它进来的那条路线之外的每一条输出线路上，但是由于扩散算法会产生大量的重复分组，需要改进扩散算法，避免重复的分组。

优点是简单，无需路由表，并且所有路径都会尝试，具有鲁棒性；
缺点是产生大量重复的包；

解决无限制扩散的方法有增设跳计数器和序列号；

3. 距离矢量选路 DVR#

路由器周期性地向邻接路由器广播自己的路由表（包括与其他路由器的最短距离和下一跳使用的接口信息）。

存在无穷计数问题，即好消息迅速传遍整个网络，但对坏消息反应慢，只知道距离，不知道路径！

采用 DVR 的协议？ —— RIP 协议

4. 链路状态选路 LSR#

路由器在网络拓扑结构变化时，向网络内的所有路由器广播自己的链路状态信息，或称自己学习到的网络拓扑结构。

4.1 与 DVR 的区别？#

DVR 周期性广播，LSR 在网络拓扑结构改变时广播；
DVR 只向邻居广播，LSR 向整个网络内其他的路由器广播；

4.2 基本步骤#

发现邻居节点：
1. 路由器向邻居路由器广播一个 Hello 包；
2. 邻居收到 Hello 包后，回复 1 个包含自己网络地址（Route ID ，全网唯一）的包给路由器；
测量线路开销：通过 Echo Packet 包测量 RTT ；
创建链路状态分组 LSP(Link-State Packet)：分组中包含所有它刚刚知道的链路状态信息，具体可见下图；
泛洪链路状态分组：采用刚刚提到的 Flooding 算法发送 LSP ；
计算最短路径：路由器根据网络拓扑采用 Dijkstra 算法计算出到每一个其他路由器的最短路径树；

注：其中 Seq 和 Age 字段就是用来解决 Flooding 算法无限泛滥的问题的。

4.3 应用#

IS-IS 协议；
OSPF 协议；

5. 层次路由 Hierarchical Routing#

大型网络中使用，将网络划分为不同层次的区域，从域内选路到路由器，再从域间选路到域，有效减小了路由表的规模。不过存在次优路由问题。

层次等级：regions 区域 →\rightarrow→ clusters 簇 →\rightarrow→ zones 区 →\rightarrow→ groups 群；

QoS(Quality of Service 网络服务质量)#

1. QoS 参数#

Reliability：可靠性，包括错误率和丢包率；
Delay；
Jitter；
Bandwidth；

一些例子：

电子邮件系统：要求高可靠性，别的无所谓；
电话：抖动和时延，这种语音或者视频流错一点东西看不出来；
视频会议：抖动 + 时延 + 带宽，需要音视频流的实时传输；

2. 哪些层有 QoS ？#

课内讲到的主要涉及数据链路层 and 网络层。

3. 网络层的 QoS#

3.1 流量整形 Traffic Shaping#

目的：减少网络中的突发流量。

3.1.1 漏桶 Leaky Bucket#

桶中保存的是数据，恒定输出速率，当桶满时会丢弃一些数据分组。

3.1.2 令牌桶 Token Bucket#

路由器匀速产生令牌，如果令牌桶满则丢弃多余的令牌；
数据包到达路由器的队列后，需要消耗令牌进行发送，一个 Token 对应一个 Packet；
令牌桶并没有数据队列的缓存限制，不会丢弃数据帧；
令牌桶能接受一定的突发流量，比如突发流量到达，可以一次性消耗所有令牌（跟令牌桶的大小有关）；

突发流量持续时间计算#

令：

突发数据的持续时间为 SSS sec；
令牌桶的容量为 BBB Bytes；
令牌的产生速率为 RRR Bytes/s；
最大的输出速率为 MMM Bytes/s；

则有：

M×S=B+R×SM\times S = B + R\times SM×S=B+R×S

即：

S=BM−RS = \frac{B}{M-R}S=M−RB

3.2 分组调度 Packet Scheduling#

3.2.1 公平队列#

3.2.2 公平加权队列#

4. IEEE 802.11 的 QoS#

4.1 帧间隔#

简单来说，就是设置不同的帧间隔，来实现优先级服务！

4.2 TXOP 机会传输#

默认情况下，站点竞争到信道 1 次，发送 1 个帧。但是这对发送速率快的站点并不公平。假设站点的带宽分别为 c1,c2c_1,c_2c1,c2，则平均数据率为：

1cave=1c1+1c2⇒cave=11c1+1c2\frac{1}{c_{ave}} = \frac{1}{c_1} + \frac{1}{c_2} \Rightarrow c_{ave} = \frac{1}{\frac{1}{c_1} + \frac{1}{c_2}}cave1=c11+c21⇒cave=c11+c211

而 TXOP 给予两个站点相同的发送机会，即竞争一次，获得一段传输时间，即

c=ci/nc = c_i / nc=ci/n

比如对于 6Mbps 和 54Mbps 的两个站点，采用TXOP后，按照 3Mbps 和 27Mbps 发送帧；

Internetworking 网络互联#

互联网络的分组转发；
隧道（Tunneling）计数：当源和目标主机位于相同类型的网络中，中间的网络属于不同类型时使用隧道方案，用中间网络的协议封装源主机发送的数据报；
互联网络路由；
分段与重组：不同网络有不同的 MTU ；
1. 发送主机或路由器进行分片；
2. 目的主机进行重组；

互联的网络中，路由的架构如下：

首先，整个网络被分为无数个自治系统（AS, Autonomous System），可以理解为单一技术下管理的多个路由器，一个 AS 内部需要一种路由协议，不同 AS 之间也需要一种路由协议；
AS 内部路由协议 —— 内部网关协议 IGP（Interior Gateway Protocol）；
- IS-IS 协议；
- RIP 协议；
- OSPF 协议；
AS 间的路由协议 —— 外部网关协议 EGP（External Gateway Protocol）；
- BGP 协议；

漫游计算机网络之协议篇

Mon, 09 Jun 2025 00:20:00 GMT

其实也是期末复习罢了，只不过取了一个花里胡哨的标题。

本文将自顶向下的梳理计算机网络中每层的协议。

应用层#

应用层专注为用户提供特定的功能，一般一类服务就对应了一个协议，所以协议繁多。同时，应用层驱动下层工作，但不关心数据是如何传输的，工作在操作系统的用户态。

1. 有什么协议？#

DNS 、FTP 、HTTP 、SMTP 、DHCP 、Telnet 、BGP 、RIP 等。

提醒自己用：DHCP 、 BGP 、 RIP 协议我在网络层中已经讲了，但是它们都是工作在应用层的协议！

补充：协议工作在哪一层其实并不太重要，有关说法也众说纷纭，把 BGP 和 RIP 划分到应用层的依据是他们分别使用了 TCP 和 UDP 协议，既然协议是为上一层提供服务的，那么他俩就应该是应用层协议。我这边也只是梳理一下方便记忆，还需要自行建立理解。

2. 注意点#

DNS：域名解析协议；
- 作用是提供域名和 IP 之间的映射关系；
- 传输层使用 UDP ；
- 采用 C/S 方式；
SMTP：简单邮件传输协议；
- 作用是将邮件从发送方客户端发送到邮件服务器，或由一个邮件服务器发送到另一个邮件服务器；是异步传输，收发并不同步；
- 传输层使用 TCP ；
POP3：邮局协议；
- 用于从邮件服务器上接收（拉取）邮件到客户端。只负责接收邮件；与 SMTP 协议一起工作，实现异步的邮件传输；
- 传输层同样使用 TCP ；
IMAP：互联网邮件访问协议；
- 比 POP 3 更强，支持多设备的同步管理；
- 传输层同样使用 TCP ；
HTTP：超文本传输协议；
- 传输层使用 TCP ；
- 采用 C/S 方式；
DHCP：动态主机配置协议；
- 用于在主机没有被分配 IP 地址时，向 DHCP Server 请求 IP 地址等网络配置信息；
- 传输层使用 UDP ；
- 采用 C/S 方式；
RIP：路由信息选路协议；
- 采用距离矢量选路 DVR 构建路由表；
- 传输层使用 UDP ；
BGP：边界网关协议；
- 采用路径矢量选路 PVR 构建路由表；
- 传输层使用 TCP ，可靠传输；

3. 应用场景#

电子邮件系统：

邮件服务器和邮件服务器之间一定使用 SMTP ；
客户端发送邮件至邮件服务器，使用 SMTP / HTTP ；
客户端从邮件服务器接收（拉取）邮件，使用 POP3 / IMAP / HTTP ；

访问网站的一个典型过程：

浏览器分析 URL ；
浏览器通过 DNS 获得 IP 地址；
浏览器根据 IP 地址，和服务器建立 TCP 连接；
浏览器发送 HTTP Request 请求；
服务器发送一个响应的 Web Page 给浏览器；
释放 TCP 连接；
浏览器呈现前端页面；

用到了 TCP + DNS + UDP（DNS 协议的传输层用到了 UDP 协议） + HTTP 协议；

传输层#

传输层提供的是端到端的可靠、高效、节省开销的服务，事实上提供的是进程(Process)到进程的通信。

1. 有什么协议？#

TCP、UDP 协议；

其中：

TCP 协议为上层的 STMP 、IMAP 、POP3 、HTTP 、BGP 协议服务；
UDP 协议为上层的 DNS 、 DHCP 、RIP 协议服务；

2. TCP 协议#

TCP 协议提供端到端的、面向连接的、面向字节流的可靠传输服务；

什么是面向连接？

TCP 是面向连接的，这就意味着它只能“一对一”连接，两个主机之间通过 Socket ，即四元组（源地址，源端口，目的地址，目的端口）唯一确定连接。

什么是面向字节流？

应用层的消息可能会被 TCP 分成多个 TCP 报文，即 TCP 不保留消息的边界！

2.1 TCP 报文格式#

TCP Header：20 Bytes + Option 字段！！！
MSS：Maximum Segment Size，最大报文段长度，只包含 TCP Payload ，即数据部分，不包括 TCP Header ；
伪头部：共 12 Bytes ，包括源 IP 地址、目的 IP 地址等；并不参与实际的传输，仅用于 TCP Checksum 的计算；

2.2 TCP 的连接建立#

连接建立即 3 次握手：

客户端向服务器发送 SYN 包，其中 Seq = x ；
服务器向客户端发送 SYN + ACK 包，其中 Seq = y ，ACK = x + 1 ；
客户端向服务器发送 ACK 包，其中 Seq = x + 1 , ACK = y + 1 ；

需要注意的是，单独的 ACK 包并不占用 Seq 的字节，即对于下一个要发送的 TCP 报文，其 Seq 还是等于 x + 1 ；而 SYN 和 FIN 包虽然不携带数据，但需要占用 1 个字节；

2.3 TCP 的连接释放#

连接释放即 4 次挥手 or 3 次挥手：

客户端向服务器发送的 FIN 包，其中 Seq = x ；
服务器向客户端发送 ACK 包，其中 Seq = y ，ACK = x + 1 ；
服务器向客户端发送 FIN 包，其中 Seq = y ，ACK = x + 1 ；
客户端向服务端发送 ACK 包，其中 Seq = x + 1 ，ACK = y + 1 ；

第 2 次和第 3 次事实上可以合并为 1 次握手，具体取决于服务器上层是否还有数据需要发送。

2.4 TCP 协议的功能#

重传；
滑动窗口；
流量控制；
拥塞控制；

详见《漫游计算机网络之技术篇》。

3. UDP 协议#

UDP 无 ACK 、无差错控制（这个是可选的）、无流量控制、无拥塞控制，无连接、不可靠。为 IP 协议提供了一个接口，并加上端口号，实现复用。

3.1 和 TCP 有什么区别？#

比较项	TCP	UDP
是否面向连接	✅ 是（需三次握手建立连接）	❌ 否（无连接，直接发送）
可靠性	✅ 可靠（有确认 ACK、重传、顺序控制）	❌ 不可靠（不确认、不重传、不保证顺序）
是否保留消息边界	不保留	保留
是否支持一对多	不支持，一对一，面向连接	支持广播和组播，可以实现一对多
传输顺序	✅ 保证顺序	❌ 不保证顺序
拥塞控制	✅ 有（慢启动、拥塞避免等）	❌ 没有
流量控制	✅ 有（滑动窗口）	❌ 没有
首部开销	📦 大（20 字节起）	📦 小（8 字节）
速度	🐢 较慢（因为各种控制）	⚡ 较快（无握手/控制）
适用场景	文件传输、网页浏览、邮件（需要可靠性）	音视频、语音通话、DNS 查询（需要实时性）

3.2 报文格式#

UDP Header：8 Bytes ！！！
- Src Port Number ：16 bits ；
- Dest Port Number ： 16 bits ；
- Total Length ： 16 bits ；
- Checksum ： 16 bits ；
UDP Data：应用层有多少传多少，不会对数据进行分片，如果超出最大可发送的长度就不会发送；
伪报头：和 TCP 类似，UDP 同样会在差错检测计算校验和时添加一个伪报头，包括源 IP 地址、目的 IP 地址等，共 12 Bytes ；

网络层#

网络层是处理端到端通信的最底层。

1. 有什么协议？#

IP 协议（真王朝了），以及 IPv4 和 IPv6 ，可以说统治了整个网络层。
在 IP 协议之下，有 ARP 和 RARP 协议；
在 IP 协议之上，有 OSPF 、ICMP 和 IS-IS 协议；

关于 RIP 和 BGP 协议的问题已经在前文中阐述，并且按照前文的理解，IP 协议既然也为 OSPF 协议提供服务，那么 OSPF 协议应该属于传输层协议。不过说白了，由于 TCP/IP 的统治力，界限未必一定要搞得很分明。

简单来说：

RIP 、BGP 、OSPF 协议是 Routing Protocol ，即路由协议，用来计算最优路径并更新路由表；
而 IP 协议严格来说是 Routed Protocol ，即可被路由协议，或者称其为路由的载体，将上层上层打包为 IP 包，根据路由表进行转发；

2. 有什么功能？#

Internetworking 网络互联；
Addressing 编址；
Routing 路由；
Packeting 组包；
Fragmenting 分片；

3. 提供的服务？#

3.1 无连接的服务 —— 数据报 Datagram#

无连接；
每个包需要携带完整的目的地 IP 地址；
包可能乱序到达；

3.2 面向连接的服务 —— 虚电路 Virtual Circuit#

面向连接的；
在正式传输数据前，先建立一条从源路由器到目的路由器之间的路径；

3. IPv4 协议#

3.1 IPv4 报文格式#

考试会提供报文格式，这里再复习一遍几个比较重要的字段：

IHL(IP Header Length)：报文头长度，实际的头长度是 IHL ×\times× 4 ，即这 4 bits 表示的范围是 5 ～ 15 ，实际头长度范围是 20 Bytes ～ 60 Bytes ；
Type of Service：知道这里的后 2 bits 是显式拥塞控制位即可；
Total Length：注意包括头长度 + 数据长度；
DF：不分片标志，DF = 1 则表示不分片，一般为 0 ；
MF：更多段标志，同一个 IP 包，除最后一个分片外，MF = 1 ；
Fragment Offset：分片后的数据在原始数据中的位置，即偏移量，注意实际偏移量必须是 8 的整数倍，这 13 bits 的内容 ×\times× 8 = 实际偏移量；
Checksum：只对 IP Header 进行校验；

3.2 IPv4 地址#

IPv4 地址共 32 bits ；

3.2.1 分类 IP 地址#

网络号 + 主机号。

3.2.2 特殊的 IP 地址#

主要在计算 IP 地址块数时，减去网络号和网络等广播地址；

3.2.3 私有 IP 地址#

用于 NAT 中。

3.2.4 子网与子网掩码#

简单来说，就是向主机号借若干位，作为子网号，将 1 个较大的网分为若干个子网。对外界是不可见的。

子网掩码：一般为 255.255.224.0 这种形式，不过写成前缀长度的形式 /19 似乎也没问题。

路由时，如何得到子网地址？

将目的 IP 与子网掩码进行按位与的操作即可。

3.2.5 无类别地址 CIDR#

形如 a.b.c.d/x ；

3.2.6 路由聚合#

使用 CIDR 除了可以用来表示一个子网，也可以将多个子网聚合为一个超网；不过，将多个地址数较少的网合并为一个大网，会使地址空间被放大。

对于路由时，一个目的 IP 地址与多个不同前缀长度网络匹配时，选择前缀最长的那个网络进行转发，这就是最长匹配原则。

4. IPv6 协议#

大概了解即可：

IPv6 的地址长度为 128 bits ；
IPv6 Header 头长度固定为 40 Bytes ；
IPv6 的扩展头位于 Payload ，即数据部分；

5. ARP 地址解析协议#

用于解决从网络层的 IP 地址到数据链路层的 MAC 地址的映射关系问题。即已知 IP 地址，需要获得 MAC 地址。

6. RARP 协议#

上述的逆向，即已知 MAC 地址，需要获得 IP 地址，已经被淘汰了。

7. ICMP 因特网控制报文协议#

包括差错报告报文、控制报文和查询报文。

8. IS-IS 协议#

IS-IS 协议，全称 Intermediate System-Intermediate System ，为 IGP（内部网关协议）之一，属于链路状态协议，使用 LSP 链路状态选路工作。

8.1 IS-IS 协议 vs. OSPF 协议#

比较项	IS-IS	OSPF
起源	OSI 协议（CLNP），更早	IP 协议（IETF）
网络层协议	原生支持 CLNP，后支持 IPv4/IPv6 等多种协议	只支持 IP 协议
封装方式	使用 OSI 网络层直接封装，不依赖 IP	运行在 IP 层，使用协议号 89
灵活性	更易扩展，适合大规模网络	设计固定，结构清晰
应用领域	常用于运营商、ISP、MPLS 网络	企业网、数据中心常见

介质访问控制子层#

1. 有什么协议？#

IEEE 802.3（经典以太网，CSMA/CD）；
IEEE 802.11（Wifi，CSMA/CA）；
IEEE 802.1g（VLAN）；

2. 有什么功能？#

解决广播式链路（即共享通信介质）的通信环境下介质访问控制问题，共享介质的通信环境包括有线通信环境和无线通信环境。

3. Ethernet 以太网#

3.1 10M 经典以太网#

传输介质：Coaxial Cable 或 Twisted Pair（一般使用的是 UTP5），常见的有 10Base5-Thick 和 10Base-T ；
拓扑结构与设备：
- 同轴电缆采用 Bus 总线型；
- 到双绞线后引入集线器 Hub ；
- 由于电缆长度有限，所以引入中继器 Repeater；
编码方式：Manchester 编码；
共享信道协议：使用 1 - 坚持的 CSMA/CD 技术；
- 注意，经典以太网中，认定信道空闲的方式有说区别：需要监听到信道在 IFG(Inter Frame Gap, 帧间隙)时间内均空闲，才认为空闲；
最大最小帧长：
- 数据部分长度范围为 46 Bytes ～ 1500 Bytes ；
- 加上 18 Bytes 的控制字段，所以总长度为 64 Bytes ~ 1518 Bytes ；
- 如果不满足最小长度，则需要用 Pad 字段补齐；

3.2 百兆以太网/快速以太网#

传输介质：双绞线或光纤，常见的有 100Base-T4 和 100Base-TX ；
工作方式：
- 100Base-T4 ：使用 4 对 UTP3 双绞线，半双工；
- 100Base-TX ：使用 2 对 UTP 5 双绞线，全双工；
编码方式：不再使用 Manchester 编码，而是使用 8B/6T（三电平）或 4B/5B + MLT-3 ；
共享信道协议：如果采用 Hub 连接，则为半双工模式，且仍需要 CSMA/CD 技术；

3.3 G 比特以太网#

传输介质：双绞线或光纤；
工作方式和设备：Hub 或 Switch ，对应半双工或全双工的工作方式；
共享信道协议：如果采用 Hub 连接，仍需 CSMA/CD 技术，但存在问题，由于速度更快，电缆的最大长度相应减少；
流量控制：发送 Pause 帧；

3.3.1 解决电缆长度限制的方法#

Carrier Extension 载波扩展：在原来帧的尾部再添加一个 Extension 字段，将帧长度扩展至 512 Bytes ；
Frame Burst 帧突发：如果对于有大量需要连续发送的帧的情况，帧的发送往往用队列存储，发送方可以将需要连续发送的帧拼成一个帧进行发送；

3.4 10G 比特以太网#

传输介质：电缆较短的一般用的是双绞线（6a UDP），长距离一般使用光纤；
应用环境：高速的本地骨干网、高性能企业网络、数据中心等；
工作方式和设备：彻底抛弃了 Hub ，只有全双工工作模式，不再需要 CSMA/CD 技术；

3.5 以太网一图流#

4. Wireless 无线通信 IEEE 802.11#

4.1 共享信道协议#

CD ，即冲突检测已经不再适用！

Point coordination function（PCF, 点协调）：
- 基站控制，进行轮询 Polling ；
Distributed coordination function（DCF, 分布式协调）：
- 没有中心控制，实行 CSMA/CA ；

4.2 CSMA/CA#

详见《漫游计算机网络之技术篇》。

4.3 监听方式#

物理监听；
虚拟监听：
- 每个站点都记录一个 NAV(Network Allocation Vector, 网络分配向量)；
- 每个帧都携带一个 NAV；
- NAV 表示这个数据帧将预计占用信道多长时间，通过 NAV 来确定退避时间，减少冲突；

4.4 可靠性 —— 段突发#

短帧出错概率小，所以采用 Fragment burst 段突发 的方式，将较长的帧分为小的 Fragment进行发送，来提高可靠性；

4.5 节省电量#

一直监听信道会造成电量浪费。

4.5.1 省电模式#

客户端进入省电模式：
- 终端设备（如笔记本、手机）告诉 AP（无线接入点）自己要进入省电状态。
- 然后设备会关闭无线网卡部分模块，不再一直监听信道。
AP 缓存数据（buffer traffic）：
- 当有数据要发给该客户端时，AP 会暂时缓存这些数据。
Beacon 帧广播：
- AP 会周期性发送 Beacon 帧（例如每 100ms），
- 其中包含一个 Traffic Indication Map（TIM），指示哪些客户端有待接收的数据。
客户端唤醒并检查 Beacon：
- 客户端周期性唤醒接收 Beacon 帧，看看 TIM 中是否有自己的标识。
发送 PS-Poll 帧：
- 如果 TIM 表示有数据，客户端就发送一个 PS-Poll（Power Save Poll）帧 请求接收数据。
AP 发送缓存数据：
- AP 收到 PS-Poll 后立即发送缓存数据给客户端。

4.5.2 APSD 增强型省电机制#

客户端进入 APSD 模式（也处于省电状态）；
客户端主动发送数据帧（比如语音包）；
AP 在接收到数据帧后，立即发送之前缓存的数据（无需 PS-Poll）；
客户端周期性发送语音包（如每 20ms），正好触发 AP 同步传送下行数据；

4.6 QoS —— 帧间隔 and TXOP#

详见《漫游计算机网络之技术篇》。

5. VLAN 虚拟局域网#

5.1 为什么需要 VLAN ？#

目的	好处
隔离广播	将单一的大广播域拆分成多个小广播域，减少网络风暴与 CPU 占用
提高安全性	不同部门/业务放在不同 VLAN，相互默认不可直接访问
灵活部署	逻辑分段代替物理布线；用户搬工位只要改端口 VLAN 设置即可
简化管理	基于功能或安全策略（而非地理位置）来组织网络

5.2 IEEE 802.1Q 协议#

在以太网帧头插入 4 字节字段，携带 12 位 VLAN ID ；

第一个遇到的支持 VLAN 的网桥/交换机给帧加上 VLAN 字段，最后一个去掉 VLAN 字段。

注：

终端设备对 VLAN Tag 无感知，即只需要网桥/交换机支持 VLAN ；
集线器 Hub 由于工作在物理层，因此无法识别 VLAN 的标记。

数据链路层#

1. 有什么协议？#

面向局域网 LAN 的：
- IEEE 802.3(Ethernet)；
- IEEE 802.11(Wifi)；
面向广域网 WAN 的：
- PPP 协议；
- HDLC 协议；

2. 有什么功能？#

差错控制；
流量控制；
编址（MAC 地址）和介质访问控制（应用于共享信道）；
成帧 Framing ；

2.1 Framing 成帧#

字符计数法；
字节填充法；
比特填充法；
物理层编码违例；

字节填充法如下图所示：

比特填充法如下图所示：

只需要知道：

PPP 协议使用字节填充法；
HDLC 协议使用比特填充法，HDLC等协议差错校验和成帧的顺序是：
- 发送方处理步骤：
  - 计算并添加校验码 -> 0比特填充 -> 添加收尾标记01111110
- 接受方处理步骤：
  - 收到物理层的01比特串 -> 首先根据首尾标记位提出帧 -> 删除发送方添加的零比特，就是进行比特删除 -> 最后，进行差错校验
如果物理层采用 Manchester 编码，则可以使用物理层编码违例方式；

2.2 差错控制#

详见《漫游计算机网络之技术篇》。

2.3 流量控制#

详见《漫游计算机网络之技术篇》。

3. 提供的服务？#

Connectionless services 无连接的服务；
- Unacknowledged connectionless services：大多数局域网LAN使用无确认；
- Acknowledged connectionless services：无线通信；
Acknowledged connection-oriented services 面向连接的服务；

4. HDLC 协议#

HDLC 协议，即 High-level Datalink Control ，高级数据链路控制协议；

4.1 特点#

可靠，面向连接；
包含流量控制（GBN ARQ or SR ARQ）和差错控制功能（CRC）；
同步串行链路传输；
不支持链路和网络参数协商；
不支持认证；

4.2 帧格式#

从上图也可见，HDLC 采用零比特填充；

注：监督帧就是单独的 ACK 或 NAK ；

5. PPP 协议#

PPP 协议，即 Point-to-Point Protocol ，点对点协议；

5.1 特点#

只支持点到点；
无连接，无确认；
采用字节填充法；
适配多种网络层协议；
支持身份认证；
物理层可以采用异步和同步传输；

5.2 帧格式#

注：

其中用红线❌掉的都是可以省略的部分；
Checksum 使用 CRC 校验来检错；

6. HDLC vs. PPP 协议#

物理层#

物理层涉及的主要是一些标准，包括对速率、传输介质、编码方式和调制方式的规定。

1. 基本概念#

1.1 带宽 Bandwidth#

带宽最早用来指模拟信号具有的频段宽度，即信道能够有效传输信号的频率范围，对应的单位就是 HzHzHz ，e.g. 语音电话线 300 ～ 3400 Hz ，对应带宽 3.1 KHz ；

现在这个概念被扩展到数字信号上，带宽指的事实上就是最大数据率。

1.2 数据率/比特率/传输速率#

指的就是数据的传送速率，单位 bpsbpsbps ，e.g. 百兆以太网数据率为 100 Mbps ；

1.3 吞吐量 Throughput#

在单位时间内通过某个网络的数据量，或者说网络可以传送的数据位数。单位：b/sb/sb/s（其实就是 bpsbpsbps）；

其与数据率是不同的，数据率是可用带宽，而吞吐量是一个实际链路工作过程中的测试指标，往往数据率。

1.4 负载 Load#

单位时间内注入网络的数据位数，单位：bpsbpsbps 。

1.5 码元速率/调制速率/波特率 and 采样速率#

每秒钟传输的码元数，单位 BaudBaudBaud ，和比特率有以下转换关系：

Bit Rate=Baud Rate×log2V,V为信号级数Bit\space Rate = Baud\space Rate\times log_2{V},V \text{为信号级数}Bit Rate=Baud Rate×log2V,V为信号级数

一个例外是 Manchester 编码，其用 2 个码元代表 1 个 bit ，所以 Bit Rate = 12\frac{1}{2}21 Baud Rate 。

关于采样速率是否与前者相同的问题，理论上来说，采样速率应该指的是对模拟信号的采样过程，而波特率已经是数字信号了。不过似乎题目中有时也会把两者混为一谈，比如：

1.6 带宽时延积 bandwidth-delay product#

表示充满整个网络的比特数。带宽时延积 = tprop×Bandwidtht_{prop} \times Bandwidthtprop×Bandwidth ；

1.7 单工/半双工/全双工#

单工 Simplex：信息只进行单向的传输，e.g. 收音机；
半双工 Half-Duplex：同一节点，在同一时刻只能作为发送方或接收方，e.g. 对讲机；
全双工 Full-duplex：同一节点在同一时刻可以既发又收，e.g. 打电话；

1.8 同步/异步传输#

2. 信道最大传输速率计算#

CNyquist=2Blog2V,CShannon=Blog2(1+SN),SNdb=10log10SNC_{Nyquist} = 2Blog_2{V},C_{Shannon}=Blog_2(1 + \frac{S}{N}),\frac{S}{N}_{db} = 10log_{10}{\frac{S}{N}}CNyquist=2Blog2V,CShannon=Blog2(1+NS),NSdb=10log10NS ；

3. 计算采样率#

Nyquist 指出，对于一个带宽为 BBB 的基带信号，需要 2B2B2B sample/s 的采样率才能够完全重构。

4. 传输介质#

有线传输介质：
- 双绞线 Twisted Pair：既能传模拟信号（电话线），又能传数字信号（以太网）；
- 同轴电缆 Coaxial Cable：和双绞线相比，屏蔽性能和带宽更好；
- 光纤 Fiber Optics：带宽大，抗干扰能力好；
无线传输介质：
- 无线电：一句话，频率越高，波长越短，传播距离越短，超高频需要在视线范围内传播；
- 微波：直线传输，适合长距离，需要地面中继站 Repeater 进行整形和放大；
- 红外线和可见光通信：略；
- 卫星通信：通信卫星相当于微波通信中中继站 Repeater 的作用，只不过在大气层以外；

5. 数字调制技术#

ASK ，FSK ，PSK ，QAM ，QPSK 等。

6. 物理层协议#

参数包括：

Mechanical Features 机械特性：接口形状和尺寸、引线数目和排列、固定和锁定装置等；
Electrical Features 电气特性：电缆线上的电压范围；
Functional Features 功能特性：某条线上出现的某一电平的电压保持何种意义；
Procedure Features 过程特性：对于不同功能的各种可能事件的出现顺序；

e.g. RS-232 协议。

如何在 Hexo 博客中插入伪代码

Mon, 19 May 2025 04:11:00 GMT

在技术博客中，优雅地展示算法伪代码是常见需求。但是 Hexo 本身并不支持 LaTeX\LaTeXLATEX 的，Hexo 默认只支持常规代码高亮，无法直接渲染算法伪代码。当然，Hexo 提供丰富的插件，但是我搜索后并没有找到相关的（如果是我遗漏了，可以在评论区指出）。

所以，自行摸索后，找到以下的替代方法：

pseudocode.js 是一个 JavaScript 库，可将伪代码精美地排版为 HTML，轻量且兼容多种浏览器。以下是具体的配置步骤，由于我使用的是 Fluid 主题模板，支持直接在主题配置文件中引入自定义的 css 和 js 文件，不同主题可能存在区别，但原理类似。

1. 具体步骤#

步骤一：引入依赖#

1. 引入 CSS#

在 source/css/custom.css 末尾添加：

1
@import url('https://cdn.jsdelivr.net/npm/pseudocode@2.4.1/build/pseudocode.min.css');

2. 动态引入 JS#

编辑 source/js/custom.js，添加如下内容：

1
// 动态加载 JS 文件
2
function loadScript(url) {
3
    return new Promise((resolve, reject) => {
4
        const script = document.createElement('script');
5
        script.src = url;
6
        script.onload = resolve;
7
        script.onerror = reject;
8
        document.head.appendChild(script);
9
    });
10
}
11

12
// 加载 KaTeX 和 Pseudocode.js
13
Promise.all([
14
    loadScript('https://cdn.jsdelivr.net/npm/katex@0.16.2/dist/katex.min.js'),
15
    loadScript('https://cdn.jsdelivr.net/npm/pseudocode@2.4.1/build/pseudocode.min.js')
16
]).then(() => {
17
    if (typeof pseudocode === 'undefined') {
18
        console.error('Pseudocode.js not loaded');
19
        return;
20
    }
21
    // 匹配 Hexo 渲染后的伪代码块
22
    const pseudocodes = document.querySelectorAll('figure.highlight table tr td.code pre code.hljs.pseudocode');
23
    // 渲染每个伪代码块
24
    const options = {
25
        lineNumber: true,
26
        lineNumberPunc: ':',
27
        noEnd: false,
28
        titlePrefix: 'Algorithm'
29
    };
30
    pseudocodes.forEach((codeBlock) => {
31
        try {
32
            const code = codeBlock.textContent;
33
            const container = codeBlock.closest('figure.highlight');
34
            const newContainer = document.createElement('div');
35
            newContainer.className = 'pseudocode-container';
36
            pseudocode.render(code, newContainer, options);
37
            container.parentNode.replaceChild(newContainer, container);
38
        } catch (error) {
39
            console.error('Error rendering pseudocode:', error);
40
        }
41
    });
42
}).catch(error => {
43
    console.error('Error loading required scripts:', error);
44
});

展开收起

这里主要是查找原页面 HTML 中的伪代码并渲染。具体可以参考 pseudocode官方文档；

步骤二：美化伪代码样式#

我在使用默认配置渲染时，会出现行号和标点换行的问题，如果出现这一问题，则在 source/css/custom.css 末尾添加如下样式，保证行号悬挂、缩进美观：

1
.pseudocode-container .ps-line {
2
    position: relative;
3
    padding-left: 2.5em !important;
4
    text-indent: 0 !important;
5
}
6
.pseudocode-container .ps-linenum {
7
    position: absolute !important;
8
    /* 不强制 left: 0，保留 JS 计算的 left，兼容多层嵌套 */
9
    min-width: 2em;
10
    text-align: right;
11
    white-space: nowrap;
12
    color: #607080;
13
    font-variant-numeric: tabular-nums;
14
    line-height: inherit;
15
}

步骤三：在 Markdown 中书写伪代码#

直接在 Markdown 文件中使用如下格式：

1
\begin{algorithm}
2
\caption{Quicksort}
3
\begin{algorithmic}
4
\PROCEDURE{Quicksort}{$A, p, r$}
5
    \IF{$p < r$}
6
        \STATE $q = $ \CALL{Partition}{$A, p, r$}
7
        \STATE \CALL{Quicksort}{$A, p, q - 1$}
8
        \STATE \CALL{Quicksort}{$A, q + 1, r$}
9
    \ENDIF
10
\ENDPROCEDURE
11
\PROCEDURE{Partition}{$A, p, r$}
12
    \STATE $x = A[r]$
13
    \STATE $i = p - 1$
14
    \FOR{$j = p$ \TO $r - 1$}
15
        \IF{$A[j] < x$}
16
            \STATE $i = i + 1$
17
            \STATE exchange $A[i]$ with $A[j]$
18
        \ENDIF
19
    \ENDFOR
20
    \STATE exchange $A[i+1]$ with $A[r]$
21
\ENDPROCEDURE
22
\end{algorithmic}
23
\end{algorithm}

2. 常见问题与解决#

行号换行/错位：请务必添加上文的 CSS，保证 .ps-linenum 不换行且悬挂。
嵌套算法块行号对齐：推荐保留 Pseudocode.js 的 left 机制，CSS 不要强制 left: 0，以兼容多层嵌套。

如有疑问，欢迎留言交流！

使用jsDelivr加速Github图床

Sun, 18 May 2025 02:18:00 GMT

前言#

对于个人博客，图片如果保存在本地，迁移时总是不太方便。一种比较好的方式就是使用图床，无需再担心迁移时的麻烦。像腾讯云、阿里云和七牛云等厂商都提供稳定但收费的 OSS 对象存储服务，国内免费的图床也有，不过多数有上传限制，或存在不稳定的因素（毕竟公益运营，存在跑路可能性），并且有些会对图片内容的合规性进行检测（比如二维码等内容是不被允许的），国外的图床多数国内访问容易被墙。

Github，作为知名代码托管平台，早就被发掘出图床的功能，但是一样存在国内联通性不佳的问题。因此，需要使用 CDN 来加速和优化图片的加载速度。

CDN，即内容分发网络（Content Delivery Network）是一种通过分布在全球各地的服务器节点，将内容快速、可靠地传递给用户的网络架构。它的核心目标是在尽可能靠近用户的位置提供服务，从而提高访问速度、稳定性并降低传输成本。

简单来说，CDN 会在多个地理位置部署缓存服务器，这些节点将原始服务器上的内容缓存下来。当用户访问某个内容时，CDN 会自动将请求引导至距离用户最近、最优的节点，从而实现快速响应和数据传输。

jsDelivr，作为一款开源且免费的公共 CDN，并且与 GitHub 和 NPM 紧密集成，不存在带宽限制和付费功能。Github 存储和 jsDelivr 加速，稳定快速免费高效的选择，你值得拥有。

有关 jsDelivr 的加速效果，可以看下图，至于有没有别的平替，反正我觉得是没什么同类竞品的，当然有钱且有备案（其实我觉得整一个备案比下面的方法还折腾），也可以考虑国内 CDN。

一、方法#

1.1 Github 存储部分#

1.1.1 新建仓库#

首先，需要新建一个仓库，仓库要求公开，别的无所谓。

1.1.2 创建 Token#

进入 Settings →\rightarrow→ Developer Settings →\rightarrow→ Personal access tokens，然后，新建一个 classic token，然后勾选相应的权限，点击 Generate token，注意这里的 Token 只会生成一次，请妥善保存！

1.2 PicGo配置#

1.2.1 PicGo 下载#

PicGo 是一个用于快速上传图片并获取图片 URL 链接的工具，支持多种图床，并且支持自行开发适配其他图床。下载见 PicGo。

1.2.2 图床配置#

下载完毕后，打开主窗口（默认可能在任务栏中，不显示），找到图床设置，选择 Github，填入相应配置，参考下图：

有几个注意点：

仓库名：即 Github用户名/仓库名；
分支名：一般默认为 master，但是如果你选择了其他分支，你需要在自定义域名部分作相应修改；
存储路径：这个无所谓；
自定义域名：
1. 如果是默认分支，那么自定义域名为 https://cdn.jsdelivr.net/gh/Github用户名/仓库名；
2. 如果是其他分支，那么自定义域名为 https://cdn.jsdelivr.net/gh/Github用户名/仓库名@分支名；

有关 jsDelivr 的具体细节，可以参考 jsDelivr 官网；

1.2.3 PicGo 设置#

你可以参考我对 PicGo 进行如下设置，这样，PicGo 就可以自动读取你剪切板中的图片，上传并生成 MarkDown 链接了。

Git 微操自救指南

Fri, 16 May 2025 16:17:00 GMT

使用 Git 进行版本管理时，在通过 commit 提交并 push 了大量垃圾（bushi）后，然后看到提交历史，往往对自己的 push 垃圾的行为后悔不已。那么有对 git 不太熟悉的就要问了，主包主包，有什么悔棋的方法吗？

有的兄弟，有的。像这样的方法，这篇博客一共整理了 9 个。

目前仅整理了部分内容，学习 Git 不亚于新学一门编程语言，学不完，根本学不完。

Warning

！！！禁止修改多人共用的远端分支！！！ 你在使用任何 Git 操作时都应该明确这一点，如果一条远端分支有多人共用，那么不要在上面执行 reset 、rebase 等会修改这条分支已经存在的 commit object 的命令。具体原因可以参考 understanding-git-rebase-and-the-golden-rule ；

一、修改最近一个提交#

开发过程中，提交完发现有一些临时的 log 等文件忘记去掉，或者有一些文件忘了提交，甚至 commit 信息打了错别字或者单纯写的不满意，这些情形是常有的。回滚回前一次提交再重新提交当然没啥问题，以下提供一种更清晰快捷的方法。

1.1 操作步骤#

假如此时你已经提交了部分内容（无论有没有推送到远程仓库）。比如：

Terminal window

1
# 修改了几个文件
2
git add a.py b.py
3
git commit -m "feat: 实现初始功能"
4

5
# 又改了 a.py，或者想把别的文件一起补进去上一次提交
6
git add a.py
7
git commit --amend # 然后输入新的提交信息

不过需要注意的是 --amend 会覆盖上一次提交，你可以观察到提交的哈希值变了，所以如果你已经推送到远程仓库，需要使用 git push --force 强推新的提交。

二、提交一个文件中的部分修改#

你可以使用 git add -p（patch 模式）或 git add -i（interactive 模式）来选择性地将文件的部分修改加入暂存区，而不是整个文件。这对于精细控制提交、按功能分组提交代码非常有用。

执行 git add -p <文件名> ；

你可以先执行 git add -i ，进入交互菜单，按数字键选择 patch 模式。（interactive 模式还提供多种操作，这里暂不展开）

Git 会逐个展示该文件的修改块（hunk），你可以选择是否添加这个修改；

比如，某一次的修改提示为：

1
diff --git a/index.js b/index.js
2
@@ -1,6 +1,7 @@
3
 function add(a, b) {
4
+  console.log('计算中...');
5
   return a + b;
6
 }
7

8
Stage this hunk [y,n,q,a,d,s,e,?]?

它会提供给你如下选项：

输入	含义
y	暂存这个 hunk（即这部分更改）
n	不暂存这个 hunk
q	退出
a	暂存所有剩余的 hunk
d	不暂存任何剩余的 hunk
s	拆分这个 hunk 为更小的块（如果可能）
e	手动编辑这个 hunk（精确选择添加哪些行）
?	显示帮助信息

一般，如果你想要提交部分内容，推荐使用 s 进行拆分。

三、普通版：合并多个提交为一个提交#

大部分人合并可能都会用 git reset 命令实现：

Terminal window

1
git reset --soft HEAD~X && git commit -m 'xxx'

但是 git reset 只能合并最近的 X 个提交。如果你要整理整个提交历史呢？

git rebase 是 Git 中非常强大的命令，用于整理提交历史、合并分支时避免产生多余的 merge commit，甚至于还能对其中的一些提交进行排序，提高提交历史的清晰度。

3.1 操作步骤#

现在，假如你的提交历史如下：

1
A - B - C - D - E - F - G - H - I - J (HEAD)

如果你现在想要合并 C、D、E 这三个提交成一个提交。

首先，找到你所希望合并的提交中的最早一个提交的上一个提交（本情形中是 B）；

可以使用该命令查看节点与其对应的哈希值：

Terminal window

1
git log --oneline

然后可以看到类似以下内容：

1
j9k8l7  J
2
i8h7g6  I
3
...
4
e5d4c3  E
5
d4c3b2  D
6
c3b2a1  C
7
b2a1z0  B   ← ← 这个是你需要的基准点
8
a1z0y9  A

执行 rebase 命令：git rebase -i b2a1z0 ；

在执行完以上命令后，终端会自动跳转到 Git 的 Vim 编辑器；

编辑提交列表；

Vim 编辑器会打开如下列表（从旧到新）：

1
pick c3b2a1 C
2
pick d4c3b2 D
3
pick e5d4c3 E
4
pick ...    （后面的如果不希望合并就不用管）

改为：

1
pick c3b2a1 C
2
squash d4c3b2 D
3
squash e5d4c3 E

然后保存；

编辑提交信息，输入你希望保留的新提交说明，保存退出即可完成；
推送到远程仓库：git push --force-with-lease ；

3.2 注意点#

如果你在上述操作过程中有任何失误，可以运行 git rebase --abort 及时恢复到变基以前的状态；
⚠️ rebase 会导致新的 commit 节点产生，所以切记不要对多人共用的远端分支进行 rebase 。

四、进阶版：合并多个提交为大于一个提交#

其实与上面的操作是类似的，只不过你不需要重复上述步骤整理单独一个提交，这就是 git rebase -i 的强大之处 —— 你可以精确控制哪些 commit 合并，哪些保留。

现在假设你的提交历史为：

1
A - B - C - D - E - F - G (HEAD)

你想把：

B+C+D 合并为一个提交
E+F 合并为另一个提交
保留 G 不动

仍然找所有你希望变更的提交里最早的前一个提交并变基：

本情形中就是 git rebase -i <A的commit哈希> ；

然后会进入编辑提交列表，形如：

1
pick bbbbbbb B
2
pick ccccccc C
3
pick ddddddd D
4
pick eeeeeee E
5
pick fffffff F
6
pick ggggggg G

编辑提交历史；

1
pick bbbbbbb B
2
squash ccccccc C
3
squash ddddddd D
4
pick eeeeeee E
5
squash fffffff F
6
pick ggggggg G

说明：

第一组：B（pick）+ C（squash）+ D（squash） → 合并成 1 个提交
第二组：E（pick）+ F（squash） → 合并成另一个提交
第三组：G 保持不动

编辑 commit message

Git 会依次提示你编辑每一组的合并 commit message ；

五、找回丢失的 commit 节点或分支#

5.1 原理#

首先，你需要知道，在你通过 Git 合并或删除一些提交或分支后，远程仓库和本地仓库的提交历史看似没有内容，确实删除了，但并非不可恢复。

分支和提交均有唯一的哈希值，虽然远程仓库不保存删除或覆盖的内容，但是 Git 的强大之处就在于，它提供了 Reflog 命令，它可以查看你本地 Git 仓库中所有分支引用的变动历史，即使是你已经被“删除”的 commit 或 reset 过的状态，它也能找到。（只要还没被垃圾回收，Git 默认在本地保留 reflog 数据 90 天）

5.2 具体步骤#

执行命令：git reflog ；

会输出以下信息：

1
8a2c28d (HEAD -> main) HEAD@{0}: reset: moving to origin/main
2
fbf9a61 HEAD@{1}: commit: 修复BUG
3
77d0d44 HEAD@{2}: commit: 添加功能A
4
e4d0c1b HEAD@{3}: rebase -i (finish): returning to refs/heads/main

其中，HEAD@{0} 是当前 HEAD 的变更位置（0 表示最新）。

找到你需要恢复的节点的哈希值，恢复该版本；

比如：

Terminal window

1
git reset --hard <commit哈希>

或者：

Terminal window

1
git checkout <commit哈希>
2
# 或者创建个分支保住它
3
git checkout -b rescued-branch <commit哈希>

六、获得干净的工作空间#

假如你在本地修改了一些文件，但又没必要上传，或者只是临时用的，在实际工作中仍需与远程仓库一致，这时候，你当然可以通过 git reset --hard HEAD 等直接丢弃本地修改，但万一等你重置完又想用了呢，这些文件并没有提交到 Git 历史，自然无法通过第三部分中的操作恢复。

6.1 原理#

git stash 是 Git 中的一个命令，用来临时保存当前工作目录的修改，让你可以切换分支或执行其他操作，而不会丢失当前更改。它非常适用于“你正在开发功能 A，突然需要切换到主分支修个 Bug，但你又不想提交当前没完成的代码。”的这种情形。

一句话概括，git stash 让你可以随时“藏”起当前代码进度，切分支不怕打断，再“拿”回来继续写。

6.2 具体步骤#

执行 git stash ，暂存当前修改（包括已暂存和未暂存的）；

或者你也可以像 commit 一样，增加信息，方便区分：

Terminal window

1
git stash push -m "临时代码：XX模块"

还有一些参数可以选择：

Terminal window

1
git stash -k       # 只保存未暂存的文件
2
git stash -u       # 包含 untracked
3
git stash -a       # 包含 untracked + ignored

恢复最近一次 stash （同时会将其从 stash list 中删除）；

Terminal window

1
git stash pop

你也可以通过 git stash apply stash@{1} 恢复特定一次的 stash ；

可以通过 git stash list 查看 stash 列表；
如果希望删除某次 stash ，可以通过 git stash drop stash@{0} ；
如果希望清空所有 stash ，可以通过 git stash clear ；

七、占位#

八、占位#

九、占位#

写好提示词

Tue, 15 Apr 2025 12:32:00 GMT

Prompt Engineering = improving prompts to get more reliable, higher-quality outputs from language models.

1. Being Clear and Direct#

Key components = Action verb at start + direct task statement + expected output details.

避免提问，直接告诉模型要做什么。
例如：Instead of “Can you summarize this article?”, say “Summarize the following article in 3 sentences: [article text]”.

Examples:

“Write three paragraphs about how solar panels work”
“Identify three countries that use geothermal energy and for each include generation stats”
“Generate a one day meal plan for an athlete that meets their dietary restrictions”

2. Being Specific#

Type A (Attributes) = list qualities/attributes desired in output (length, structure, format)
- 适用于一般情况下的大多数任务，帮助模型理解输出的具体要求。
Type B (Steps) = provide specific steps for model to follow in reasoning process
- 通常用于复杂任务，帮助模型分解问题并逐步解决。
- 需要模型有更广阔的视角，能够考虑更多因素并进行更深入的分析。

3. Structure with XML Tags#

一种已经在现代模型中能够以几乎确定性的方式被正确解析的结构化提示方法，通过结构化的标签区分内容边界，而非依靠模型对自然语言提示的理解推理边界。

对于传统的自然语言提示，边界是隐式的，以理解”First analyze the data then provide recommendations.”这句话的语义来推断出”analyze”和”recommendations”为例，逐词解析时对每一步的隶属关系都保持着“不确定性”，假设模型在解析时对每个词的概率分布如下：

词	P(analysis)	P(recommendations)
First	0.95	0.05
analyze	0.9	0.1
the	0.85	0.15
data	0.8	0.2
then	0.4	0.6
provide	0.2	0.8
recommendations	0.1	0.9

其中，“then”是一个边界词（boundary token），这就是边界不确定性出现的时刻，这种不确定性会向前传播，导致模型可能错误地将”provide”归到”analysis”的部分，从而导致后续对”recommendations”的理解也受到影响。

而 XML 标签直接在算法层面，让模型能直接通过语法解析来区分不同部分的内容，消除了边界不确定性，例如：

1
<analysis>
2
analyze the data
3
</analysis>
4

5
<recommendations>
6
provide recommendations
7
</recommendations>

它的可能解析结果如下：

token	P(analysis)	P(recommendations)
`<analysis>`	1	0
analyze	1	0
the	1	0
data	1	0
`</analysis>`	1	0
`<recommendations>`	0	1
provide	0	1
recommendations	0	1
`</recommendations>`	0	1

概率经过标签直接跳变，直接阻断了边界不确定性的传播。

几点建议：

Tag naming = Use descriptive, specific tag names (e.g., “sales_records” better than “data”) to provide context about content nature.
Example use case = Debugging prompt with mixed code and documentation becomes clearer when separated into <my_code> and tags.

4. Providing Examples#

即 One-shot/Multi-shot，通过提供示例来引导模型理解任务要求和预期输出格式。

为边界情况提供示例，帮助模型理解如何处理特殊或复杂的输入。
提供的示例包括对为什么该输出理想的解释。
将示例放在主要提示和指导原则之后。

一些有关Game Theory(博弈论)的学习记录

Sat, 05 Apr 2025 08:22:00 GMT

前言：

以下是笔者学习【耶鲁大学】博弈论课程中整理的内容，因为笔者实在是懒的自己找书啃。有些内容可能结合自己的研究方向（Multiple-Agent-System）简单拓展。

一、Prisoner’s Dilemma 囚徒困境#

1.1 四个重要结论#

Important

定义 1.1：Strictly Dominant Strategy 严格优势策略

假如策略α\alphaα在无论对手选择何种应对的情况下的收益都高于策略β\betaβ，则称策略α\alphaα为相对β\betaβ的严格优势策略；

Note

结论 1.1：不要使用严格劣势策略

我们假设参与博弈的行为人都是理性的（和经济学中定义的理性经济人类似），都希望追求更高的收益（当前，每个人衡量收益大小的标准有不同，对收益的看法显然也会影响决策）；

Note

结论 1.2：理性的选择可能导致更糟的结果

显然，如果双方均追求对于个人收益的最大化，可能导致双输；

Important

如何破解囚徒困境？

沟通并不能解决这个困境，在缺乏强制力介入的情况下，沟通缺乏意义，可能有效的方式是有强制力的合同（比如书面合同）、重复博弈、教育。

Note

结论 1.3：如欲得之，必先知之 If you want to get it, you must know it first

如果我们不知道一个人或一场博弈中的收益情况，那么我们就不可能获得收益；

Note

结论 1.4：换位思考 Put yourself in others’ shoes and try to figure out what they’ll do

假如我们知道另一方的收益情况，那么如果我们确认对方会根据 结论 1.1 选择某种策略，那么我们可以根据对方的选择选择对于自己收益更高的那种，即使站在自己的角度，并没有严格优势策略；

1.2 Grade Game 积分游戏#

关于耶鲁大学《博弈论》课程上的积分游戏的具体推导见下，懒地打了。。。

积分游戏推导#

1.3 Ingredients of a game 博弈的要素#

Players 参与者；
Strategies 策略；
- sis_isi: PlayeriPlayer_iPlayeri的某个特定策略；
- SiS_iSi: PlayeriPlayer_iPlayeri的策略集合；
- SSS: 一次博弈，即所有参与者的策略组合；
Payoff 收益；
Assumption 假设：每个参与者都知道其他人的可能策略和收益，即博弈者之间信息透明；
S−iS_{-i}S−i: 一次博弈中除了PlayeriPlayer_iPlayeri之外的其他所有参与者的策略；

定义符号后，我们给出更严格的严格优势策略的定义：

Important

定义 1.1 Plus：Strictly Dominant Strategy 严格优势策略

PlayeriPlayer_iPlayeri‘s strategy Si′S^\prime_iSi′ is strictly dominated by PlayeriPlayer_iPlayeri‘s strategy SiS_iSi if Ui(Si,S−i)>Ui(Si′,S−i)U_i(S_i, S_{-i}) > U_i(S^\prime_i, S_{-i})Ui(Si,S−i)>Ui(Si′,S−i) for all S−iS_{-i}S−i；

1.4 Hannibal 汉尼拔#

Ben教授通过汉尼拔进军罗马的例子，引入了弱优势策略，弱优势策略允许了一部分策略组下收益相等而不是严格大于；

Important

定义 1.1 Extension：Weakly Dominant Strategy 弱优势策略

PlayeriPlayer_iPlayeri‘s strategy Si′S^\prime_iSi′ is weakly dominated by PlayeriPlayer_iPlayeri‘s strategy SiS_iSi if Ui(Si,S−i)≥Ui(Si′,S−i)U_i(S_i, S_{-i}) \ge U_i(S^\prime_i, S_{-i})Ui(Si,S−i)≥Ui(Si′,S−i) for all S−iS_{-i}S−i, and Ui(Si,S−i)>Ui(Si′,S−i)U_i(S_i, S_{-i}) > U_i(S^\prime_i, S_{-i})Ui(Si,S−i)>Ui(Si′,S−i) for some S−iS_{-i}S−i;

关于汉尼拔的具体推导见下：

汉尼拔#

1.5 Iterative Deletion 迭代剔除劣势策略#

该策略要求参与者首先找到所有劣势策略，剔除它们，然后再重新审视整个博弈，如此往复。一个具体的例子如下：

每人选择一个1到100之间的数字，谁选的数字最接近平均数的三分之二，则获得胜利。

第一层：假设大家选取的数字是在 0 ～ 100 间随机分布的，那么 average 约等于50，50的2/3应该是33左右；但是问题也很明显，大家不会都进行随机选择；
第二层：我认为别人都按照第一层的思路进行思考，即大部分人都会选择33，那么我应该选择 33 * 2/3 = 22；
第三层：从这一层开始，使用了博弈论的框架，即假设参与者都是理性的。那么，选择大于67的数字属于弱劣势策略（除非大家均选择100）；那么大于67的数字就被剔除了；按照这个思路，我选择45；
第四层：如果大家都考虑到了上面一层，那么基于第三层，现在选择大于45的也变成了弱劣势策略；按照这个思路，我应该选择30；

按照这个逻辑一直持续下去，30 ～ 20、20 ～ 13，不断持续剔除下去，那么最终所有人都会选择1；

但1就是正确答案吗？

得到1需要反复迭代、剔除，即需要我不断知道别人都想到了上一层，即我知道你知道我知道你知道（无限套娃）我是理性的，即 Common Knowledge 共同知识 。

Important

定义 1.5：共同知识

共同知识是指某个信息或事件不仅被所有参与者知晓，而且所有参与者都知道其他参与者也知道该信息，并且知道其他参与者也知道其他人知道该信息，如此无限递归。

即：所有人都是理性的；所有人都知道所有人是理性的；所有人都知道所有人都知道所有人是理性的……

1.6 The Median-Voter Theorem 中位选民定理#

该定理事实上只是迭代剔除劣势策略在政治学上的一个应用。并且该模型还是简化了现实问题，存在不少问题；

首先，对于2个候选人A和B，他们的立场用 1 ～ 10 数字表示，假定每个数字对应10%的选民，选民仅按立场的接近程度进行投票；如果立场的接近程度相同，则一半一半；候选人的目标就是最大化选票，即收益；

容易发现，1和10为劣势策略，具体推导如下：如果A选择2，那么

当B选1时，UA(2,1)=90%>UA(1,1)=50%U_A(2,1) = 90\% > U_A(1,1) = 50\%UA(2,1)=90%>UA(1,1)=50%；
当B选2时，UA(2,2)=50%>UA(1,2)=10%U_A(2,2) = 50\% > U_A(1,2) = 10\%UA(2,2)=50%>UA(1,2)=10%；
当B选3时，UA(2,3)=20%>UA(1,3)=15%U_A(2,3) = 20\% > U_A(1,3) = 15\%UA(2,3)=20%>UA(1,3)=15%；
当B选4时，UA(2,4)=25%>UA(1,4)=20%U_A(2,4) = 25\% > U_A(1,4) = 20\%UA(2,4)=25%>UA(1,4)=20%；

以此类推，后面都是2优于1并且均相差5%5\%5%；

选2严格优于选1，根据对称性，选9也严格优于选10。

越接近中间就优于两侧吗？并不，可以算一个例子：如果A选择3，那么

当B选择1时，UA(3,1)=85%<UA(2,1)=90%U_A(3,1) = 85\% < U_A(2, 1) = 90\%UA(3,1)=85%<UA(2,1)=90%，即A选3并不严格优于选2；

但是如果按照迭代剔除的思想，剔除劣势策略1和10之后，那么接下来策略2和9就变成了劣势策略，以此类推，最优的策略是选5和选6；这就是中位选民定理；

这个模型存在以下问题：

选民并非平均分布；
选民并非完全根据立场来投票，即考量因素往往是多维度的；
选民往往会根据候选人过去的行为判断立场而并非按候选人所声称的；
选民存在弃票；
候选人往往大于2个；
大选之前还有初选；
…

1.7 Best Response 最优对策#

如果站在双方的角度，都不存在严格最优对策，那么站在我的角度，假设另一方采取某策略的概率是ppp，据此计算我选择每个策略的期望收益；

二、Nash Equilibrium 纳什均衡#

2.1 Penalty Kick Game 足球比赛#

考虑以上情形。数字表示进球的可能性，比如 4 代表点球者有 40% 点进，对于守门员就是 40% 失球，用 -4 表示。按照 1.7 节中的最优对策，可以画出点球者使用 3 种不同策略时，期望收益和守门员扑向右侧的概率的关系。

从图中可见，点球者向中间射门，在守门员采取任何扑救的情况下，都不是最优策略；

Note

结论 2.1：

不要选择在任何情况下都不是最优对策的策略。

当然，这个模型还是相当简化的。

Important

Def PlayeriPlayer_iPlayeri‘s strategy Si′′S^{\prime\prime}_iSi′′ is a BR (Best Response) to the strategy S−iS_{-i}S−i of other players if Ui(Si′′,S−i)≥Ui(Si′,S−i)U_i(S^{\prime\prime}_i, S_{-i}) \ge U_i(S^{\prime}_i, S_{-i})Ui(Si′′,S−i)≥Ui(Si′,S−i) for all Si′∈SiS^{\prime}_i \in S_iSi′∈Si.

定义可能并不是很好理解，简单来说，就是对于所有玩家 iii 的可能策略 Si′S^{\prime}_iSi′，如果策略 Si′′S^{\prime\prime}_iSi′′ 的效用不低于其他策略的效用，那它就是一个最优应对；换句话说，S′′iS^{\prime\prime}iS′′i 是使得 Ui(Si,S−i)U_i(S_i, S{-i})Ui(Si,S−i) 最大的策略。

还有一个更广义的定义：

Important

Def PlayeriPlayer_iPlayeri‘s strategy Si′′S^{\prime\prime}_iSi′′ is a BR to the belief PPP about the others’ choices if EUi(Si′′,P)≥EUi(Si′,P)EU_i(S^{\prime\prime}_i, P) \ge EU_i(S^{\prime}_i, P)EUi(Si′′,P)≥EUi(Si′,P) for all Si′∈SiS^{\prime}_i \in S_iSi′∈Si.

这和上述情形类似，事实上就是引入了不确定性；当其他玩家的选择不再是确定的，而是存在一种概率信念 PPP（即“我认为对手可能这么选的概率是多少”），我们就不能只考虑一个确定的对手策略组合，而是要对可能结果取期望。(马上就要引入纳什均衡的主题了)

2.2 Partnership Game 商业合作#

这种博弈常用于商业合作，甚至于任何合作项目中，用来分析个人的努力如何影响总收益、合作是否可持续、是否存在“搭便车”现象等。

妈的，我寻思这不是小组作业吗？

一个典型的模型结构如下：

设有两个玩家 i=1,2i = 1,2i=1,2，每人选择一个努力水平 ei∈[0,4]e_i \in [0,4]ei∈[0,4]，努力有成本，但共同创造总收益；

总产出函数（合作创造的收益）：Π(e1,e2)=α(e1+e2+γe1e2)\Pi(e_1, e_2) = \alpha (e_1 + e_2 + \gamma e_1 e_2)Π(e1,e2)=α(e1+e2+γe1e2)，其中 α>0,γ≥0\alpha > 0,\gamma \geq 0α>0,γ≥0，体现了协同效应；
努力成本函数：C(ei)=12cei2,c>0C(e_i) = \frac{1}{2} c e_i^2, \quad c > 0C(ei)=21cei2,c>0；
收益分配：两个玩家平分产出，也就是每人拿到 12Π(e1,e2)\frac{1}{2} \Pi(e_1, e_2)21Π(e1,e2) ；

关于协同和边际效应，将在之后叙述。

自然，可以计算出对于每个玩家的收益，或者说效用函数为：

Ui(e1,e2)=12Π(e1,e2)−C(ei)=12α(e1+e2+γe1e2)−12cei2U_i(e_1, e_2) = \frac{1}{2} \Pi(e_1, e_2) - C(e_i) = \frac{1}{2} \alpha (e_1 + e_2 + \gamma e_1 e_2) - \frac{1}{2} c e_i^2Ui(e1,e2)=21Π(e1,e2)−C(ei)=21α(e1+e2+γe1e2)−21cei2

此时，另一个玩家的策略集合并不是一个离散的（努力或者完全不努力），而是一个连续的取值，自然难以画出图像进行求解。那么如果要计算玩家效用的最大化，就需要对 e1e_1e1 求导了。

先求一阶导数：

∂Ui∂ei=12α(1+γej)−cei\frac{\partial U_i}{\partial e_i} = \frac{1}{2}\alpha \left(1 + \gamma e_j\right) - c e_i∂ei∂Ui=21α(1+γej)−cei

求一阶导数是不够的，因为无法判断是极大值还是极小值，所以继续求二阶导数：

∂2Ui∂ei2=−c<0\frac{\partial^2 U_i}{\partial e_i^2} = -c < 0∂ei2∂2Ui=−c<0

恒小于 000 表示效用函数关于 eie_iei 是严格凹的，这意味着效用在 eie_iei 上存在唯一最大值。即在给定对方努力 eje_jej 的情况下，玩家 iii 的最优努力是：

ei∗=α(1+γej)2ce_i^* = \frac{\alpha(1 + \gamma e_j)}{2c}ei∗=2cα(1+γej)

这是玩家 i 的最优反应函数。同样，对于另一名玩家，显然这是对称的。

按照课上的情形，取 α=4,c=2,γ=14\alpha=4,c=2,\gamma=\frac{1}{4}α=4,c=2,γ=41 ，可以画出两者的最优反应函数如下图：

无限套娃，最终逼近交点，即 e1∗=e2∗=43e_1^* = e_2^* = \frac{4}{3}e1∗=e2∗=34 ，该交点意味着博弈双方均达到了平衡，即这是双方在没有外部协调机制、各自最大化自己效用时，最终均衡下的努力水平。

但这对企业整体的收益并非最优解，原因也很简单，和努力程度和协同效应越大都没啥关系，即使协同效应，即 γ\gammaγ 进一步增加，合伙人还是只获得产出的 50%，边际成本却全自己承担，所以 Nash 均衡下的努力水平仍是次优的（即低于社会最优）；

在经济学上，这种就称之为外部性；

Important

正外部性：一个人的行为对他人带来额外好处，但他自己无法完全内化这个收益；

简单来说，你的努力对别人有“正外部性”，但在博弈中，你只能拿到产出的一部分（比如一半），所以你没有激励为别人多努力；结果就是：所有人都努力得比社会最优要少，也就是激励不足。

也可以通过图像进一步验证，如果协同效应 γ\gammaγ 减少，两条直线的交点会向原点方向持续下移，即双方投入的努力均变少。

这种博弈也被称为策略互补博弈（Strategic Complements Game）。

在这里给出 NE 的标准定义：

Note

Def a strategy profile S∗=(S1,S2,…,Sn∗)∈S1×⋯×Sn\mathbf{S}^* = (S_1^, S_2^, \dots, S_n^*) \in S_1 \times \dots \times S_nS∗=(S1,S2,…,Sn∗)∈S1×⋯×Sn is a NE(Nash Equilibrium) if and only if ∀i∈N,∀Si′∈Si,Ui(S∗,S−i)≥Ui(Si′,S−i∗)\forall i \in N,\quad \forall S^{\prime}_i \in S_i,\quad U_i(\mathbf{S}^*, S_{-i}) \ge U_i(S^{\prime}_i, S_{-i}^*)∀i∈N,∀Si′∈Si,Ui(S∗,S−i)≥Ui(Si′,S−i∗).

简单来说，就是“你做了最优选择，假设别人不变；别人也做了最优选择，假设你不变。没有人想自己单独改变。”纳什均衡是一个自我实现的信念，既博弈双方都认为事情会如此发展，最后事情也确实如此发展了，双方都不后悔。

课上还举了几个非连续决策空间的例子，找到双方对策 BR 的重合点就是 NE ，比较基础，这里就偷懒跳过了。

纳什均衡可以和第一章中的优劣势策略建立起一定的联系：

所有严格优势策略均衡都是纳什均衡；
纳什均衡不一定由严格优势策略构成；
严格劣势策略不可能出现在纳什均衡中；（被迭代剔除了）
弱劣势策略可能出现在纳什均衡中；

2.3 Investment Game 投资游戏#

博弈对象包括全体同学，策略是投资 10 元，收益是净赚 5 元，但是要满足 90% 的人都选择了投资，或者不投资并无收益。很显然，这里的 NE 有 2 种情况，要么都投资，要么都不投资。

初始情况非常重要，如果第一次博弈中，更多的人站在了不投资的这一方，那么在下一轮投资中，更多的人也会不投资，最终在不断重复博弈过程中达到 (0,0) 的 NE ；但如果一开始就有超过 90% 的人选择投资，那么结果会达到 (1,1) 的 NE 。

现实中的案例包括：如腾讯的 QQ 和微信，在面世后就会面对协调博弈，安装的这些沟通软件的人必须要大于一个阈值，彼此才会有收益；股票交易所，如果上市的公司数量、交易量等大于阈值，则会形成良性循环；银行挤兑的问题，储户要么都不跑，要么一起跑，很多历史案例中银行本身并没有问题，但是由于预期变化，储户们选择了一起跑，那么就寄了。

注意它和囚徒困境的区别，囚徒困境中，沟通并不能有效解决问题，但是本情形属于协调博弈（Coordination Game），通过沟通，可以引导参与者从一个 NE 向另一个 NE 移动，这种移动是符合自身利益的，并非舍弃优势策略，所以并不需要强制力的介入，领导力在其中发挥了重要作用。

2.4 Battle Of Sex 性别大战#

考虑情侣约会决定看什么电影的情形：

很显然，选择看白雪公主对双方都是严格劣势策略，所以先剔除。然后会发现存在两个 NE ，但与之前情形的区别是，这次双方对于选择哪种 NE 有利益上的冲突。

2.5 Cournot Duopoly 古诺双寡头模型#

古诺双寡头模型（Cournot Duopoly Model） 是博弈论和产业组织理论中的一个经典模型，用来描述两个厂商（寡头）在同时决定产量的条件下如何竞争，并分析均衡市场价格与产量。

博弈者：生产同质化商品的两家厂商（Firm 1 和 Firm 2）；
策略：选择生产某种同质化产品的产量 q1q_1q1 及 q2q_2q2 ；
然后市场上形成一个统一价格：P(Q)=a−bQP(Q) = a - bQP(Q)=a−bQ，其中 Q=q1+q2,a,b>0Q = q_1 + q_2, a, b > 0Q=q1+q2,a,b>0 ；
厂商成本函数：Ci(qi)=cqiC_i(q_i) = c q_iCi(qi)=cqi（单位成本，或者说边际成本为常数 ccc）；
每个厂商的利润函数：πi(qi,qj)=[a−b(qi+qj)]qi−cqi\pi_i(q_i, q_j) = \left[ a - b(q_i + q_j) \right] q_i - c q_iπi(qi,qj)=[a−b(qi+qj)]qi−cqi ，其中 j≠ij \ne ij=i，即厂商 iii 把对方产量当作已知，最大化自己的利润，与之前的商业合作类似；

同样，对 qiq_iqi 求一阶导数，设导数为 000 ，得到最优反应函数（Best Response Function）：

dπidqi=a−b(qi+qj)−bqi−c=0⇒qi=a−c−bqj2b\frac{d\pi_i}{dq_i} = a - b(q_i + q_j) - bq_i - c = 0 \Rightarrow q_i = \frac{a - c - b q_j}{2b}dqidπi=a−b(qi+qj)−bqi−c=0⇒qi=2ba−c−bqj

进一步求二阶导数：d2πidqi2=−2b<0\frac{d^2 \pi_i}{d q_i^2} = -2b < 0dqi2d2πi=−2b<0 ，所以该点为极大值点。

BR(q2)=q1^=a−c−bq22bBR(q_2) = \hat{q_1} = \frac{a - c - b q_2}{2b}BR(q2)=q1^=2ba−c−bq2BR(q1)=q2^=a−c−bq12bBR(q_1)=\hat{q_2} = \frac{a - c - b q_1}{2b}BR(q1)=q2^=2ba−c−bq1

显然，NE 为两条曲线的交点，即 q1∗=q2∗=a−c3bq_1^* = q_2^* = \frac{a - c}{3b}q1∗=q2∗=3ba−c 。不同于投资或者合作，付出的努力越多收益也越多，这里，企业继续增加产量对自己并没有好处，属于策略替代博弈（Strategic Substitute）；这里的替代并不是指生产产品上的替代，而是策略替代，即我的策略实施的越多，你的策略实施的就越少，反之亦然。

现在，我们考虑以下情形，如果两家企业协议，各自生产垄断产量的一半，即 q1=q2=QM2=a−c4bq_1 = q_2 = \frac{Q^M}{2} = \frac{a - c}{4b}q1=q2=2QM=4ba−c ，如果两家均遵守协议，这种产量安排就等价于一个双头垄断，实现利润最大化。

但现实情况并非如此：

如果另一方按协议不动，你偷偷多产一点，你能多赚；
另一方料到了你会偷偷多产，那么他就会根据你的产量调整到 BR ，即也进行多产；
如此博弈，那么最终又回到了 NE ，即古诺产量；

就算两方能严格遵守协议，在寡头联合操控市场、价格抬高之后：高价格和高利润就会吸引新企业进入市场，使得产量扩大，原来的两人“垄断协议”会被打破。

2.6 Bertrand competition 伯特兰模型#

它与古诺模型是有部分相似之处的，首先，他们研究的都是不完全竞争市场（Imperfect Competition），即是市场上企业数量有限，或存在某种市场势力（market power），企业可以影响价格或产量，不再是完全竞争中那种“价格接受者”。模型的基本设定如下：

博弈者：仍是两家生产同质产品的企业；
策略：选择某种同质化产品的价格，分别记为 p1p_1p1 和 p2p_2p2 ，为方便分析，假定 0≤pi≤10\le p_i\le 10≤pi≤1 ；
生产成本：假定边际成本仍为常数 ccc ；
市场总需求量：Q=1−plowerQ = 1 - p_{lower}Q=1−plower ，plowerp_{lower}plower 为 p1,p2p_1,p_2p1,p2 中的较小者；
两家的销量：q1={1−q1if q1<q20if q1>q21−q12if q1=q2q_1 =\begin{cases}1 - q_1 & \text{if } q_1 < q_2 \\0 & \text{if } q_1 > q_2 \\\dfrac{1 - q_1}{2} & \text{if } q_1 = q_2\end{cases}q1=⎩⎨⎧1−q1021−q1if q1<q2if q1>q2if q1=q2 ；（q2q_2q2 同理）
企业的收益：payoff1=⌈q1⌉(p1−c)payoff_1 = \left \lceil q_1 \right \rceil (p_1 - c)payoff1=⌈q1⌉(p1−c) ；（payoff2payoff_2payoff2 同理）

不难发现，与古诺模型的区别就是，古诺模型中，企业决定产量，而伯特兰模型中，企业决定价格。那么，伯特兰模型中，BR 是什么？

BR1(p2)={p1>p2if p2<cp1=p2−εif p2>c1−p12,if p1=p2p1≥cif p2=cBR_1(p_2) = \begin{cases} p_1 > p_2 & \text{if } p_2 < c \\ p_1 = p_2 - \varepsilon & \text{if } p_2 > c \\ \dfrac{1 - p_1}{2}, & \text{if } p_1 = p_2 \\ p_1 \ge c & \text{if } p_2 = c \end{cases}BR1(p2)=⎩⎨⎧p1>p2p1=p2−ε21−p1,p1≥cif p2<cif p2>cif p1=p2if p2=c

简单解释一下：

当 p2p_2p2 定价小于成本时，我从事生产将会亏本，所以应该选择退出市场，p1>p2p_1 > p_2p1>p2 就相当于把市场份额全部让给另一家企业了；
当 p2>cp_2 > cp2>c 时，我需要做的就是比另一家企业定价稍微低一点点，这样我就能最大化利润，并且占有全部市场份额；
当 p1=p2p_1 = p_2p1=p2 时，那么我们五五开；
当 p2=cp_2 = cp2=c 时，我需要做的就是大于等于成本，即一起生产但不都赚，或者直接退出市场；

容易发现 NE=(p1=c,p2=c)NE = (p_1=c,p_2=c)NE=(p1=c,p2=c) 是一个纳什均衡点，还有别的吗？比如(p1=c,p2=c+3ε)(p_1 = c,p_2 = c + 3\varepsilon)(p1=c,p2=c+3ε) ？

当 p1=c+3εp_1 = c + 3\varepsilonp1=c+3ε 时，企业 1 的 BR 应该是 c+3ε−ε=c+2εc + 3\varepsilon - \varepsilon = c + 2\varepsilonc+3ε−ε=c+2ε ；然后站在另一家企业的角度考虑，当 p1=c+2εp_1 = c + 2\varepsilonp1=c+2ε 时，BR 应该是 c+εc + \varepsilonc+ε ，你会发现也是不断向 NE=(p1=c,p2=c)NE = (p_1=c,p_2=c)NE=(p1=c,p2=c) 移动。

结果就产生了一个悖论：两个厂商居然会像“完全竞争市场”一样，把价格压到边际成本。这与我们观察到的现实不符（现实中寡头通常有市场势力）！伯特兰悖论（Bertrand Paradox） 说明，该模型本身预测的太极端了，或者说，需要对它的假设进行修正。

2.6* 应对伯特兰悖论的扩展模型 —— 线性城市模型 Linear City Model#

该模型假设：

一条长度为 1 的线段，代表“线性城市”；
消费者均匀分布在这条线上；
两家企业分别设在线上的不同位置（通常是 0 和 1）；
消费者购买时，不仅考虑价格，还考虑与厂商的距离成本。

虽然两个企业仍生产同质化产品，但由于地理位置，变相引入了差异化。这里并不一定需要一定是地理位置，可能是消费者对同一品类的不同品牌的偏好性（比如可口可乐 and 百事可乐）。

Firm 1 在 x=0x = 0x=0，Firm 2 在 x=1x = 1x=1 ；
消费者在 x∈[0,1]x \in [0,1]x∈[0,1] ；
厂商价格为 p1p_1p1、p2p_2p2 ；
消费者有交通成本（或者就是产品“差异化”不适配的心理成本）：t⋅dt\cdot dt⋅d ；（注意这里与课程的差异，课程使用了 d2d^2d2 ，而标准的线性城市模型似乎使用的是 ddd ，我在这里先使用后者进行求解）；

一个消费者在位置 x∈[0,1]x \in [0,1]x∈[0,1]，面临两种选择：

从 Firm 1 购买，支付 p1+t⋅xp_1 + t \cdot xp1+t⋅x ；
从 Firm 2 购买，支付 p2+t⋅(1−x)p_2 + t \cdot (1 - x)p2+t⋅(1−x) ；

显然，消费者会选择成本更小的，我们首先找出这条直线上的分界点：

p1+tx=p2+t(1−x)⇒tx+tx=p2−p1+t⇒x∗=p2−p1+t2t\begin{matrix} & p_1 + t x = p_2 + t (1 - x) \\ \Rightarrow & t x + t x = p_2 - p_1 + t \\ \Rightarrow & x^* = \frac{p_2 - p_1 + t}{2t} \end{matrix}⇒⇒p1+tx=p2+t(1−x)tx+tx=p2−p1+tx∗=2tp2−p1+t

x∗x^*x∗ 即为无差异点：

位于左侧（x<x∗x < x^*x<x∗）的消费者选择 Firm 1；
位于右侧（x>x∗x > x^*x>x∗）的消费者选择 Firm 2。

由于消费者在直线上均匀分布，自然可以计算出 Firm 1 和 Firm 2 的市场份额以及对应利润函数：

π1=(p1−c)⋅p2−p1+t2t\pi_1 = (p_1 - c) \cdot \frac{p_2 - p_1 + t}{2t}π1=(p1−c)⋅2tp2−p1+tπ2=(p2−c)⋅p1−p2+t2t\pi_2 = (p_2 - c) \cdot \frac{p_1 - p_2 + t}{2t}π2=(p2−c)⋅2tp1−p2+t

然后是经典微积分环节：

dπ1dp1=(p2−2p1+t+c)2t=0⇒p1∗=p2+t+c2\frac{d\pi_1}{dp_1} = \frac{(p_2 - 2p_1 + t + c)}{2t} = 0 \Rightarrow p_1^* = \frac{p_2 + t + c}{2}dp1dπ1=2t(p2−2p1+t+c)=0⇒p1∗=2p2+t+cdπ2dp2=(p1−2p2+t+c)2t=0⇒p2∗=p1+t+c2\frac{d\pi_2}{dp_2} = \frac{(p_1 - 2p_2 + t + c)}{2t} = 0 \Rightarrow p_2^* = \frac{p_1 + t + c}{2}dp2dπ2=2t(p1−2p2+t+c)=0⇒p2∗=2p1+t+c

则有：

BR1(p2)=p1^=p2+t+c2BR_1(p_2) = \hat{p_1} = \frac{p_2 + t + c}{2}BR1(p2)=p1^=2p2+t+cBR2(p1)=p2^=p1+t+c2BR_2(p_1) = \hat{p_2} = \frac{p_1 + t + c}{2}BR2(p1)=p2^=2p1+t+c

不难求得纳什均衡 NE=(p1=t+c,p2=t+c)NE = (p_1 = t+c,p_2 = t+c)NE=(p1=t+c,p2=t+c) ，双方定价相等，且各占有一半市场，并且定价高于成本，均获利，解决了伯特兰悖论。

如果像课上一样改成凸运输成本？

同样，先求解无差异点：

p1+tx2=p2+t(1−2x+x2)⇒2tx=p2−p1+t⇒x∗=p2−p1+t2t\begin{matrix} & p_1 + t x^{2} = p_2 + t (1 - 2x + x^{2}) \\ \Rightarrow & 2t x = p_2 - p_1 + t \\ \Rightarrow & x^* = \frac{p_2 - p_1 + t}{2t} \end{matrix}⇒⇒p1+tx2=p2+t(1−2x+x2)2tx=p2−p1+tx∗=2tp2−p1+t

可以发现，和线性成本下完全一致，那么之后的运算也是一样的。

2.7 Candidate-Voter Model 选民投票#

该模型与 1.6 的中位选民模型基本类似，选民均匀分布，但有以下区别：

候选人数量不固定；
候选人不能自行选择立场，简单来说，选民是知道这个候选人是什么成分的；

博弈者：选民/候选人（选民也可以参选，参选了就变成候选人了）；
策略：参选或不参选；
收益：设胜选收益为 BBB ，参选成本为 CCC ，并且对于选民 XXX ，如果选民 YYY 成功，则还需要额外付出 ∣X−Y∣|X-Y|∣X−Y∣ 的成本（可以理解为对政治立场与自己不同的人获胜的不爽）；

可能你会觉得与中位选民类似，但事实上情况要复杂很多：

如果候选人人数 = 0 ，并不存在 NE ，因为此时任何一个人参选，都会获得更高的收益；
如果候选人人数 = 1 ，如果总人数为奇数，那么最中间的人参选达到 NE ；
如果候选人人数 = 2 ，如果总人数为偶数，，并且候选人为中间两位时达到 NE ；（考虑如果 1 ～ 10 个选民，选民 4 如果不参选，选民 5 和 6 平局，收益为 −5+62−4=−1.5-\frac{5 + 6}{2}-4=-1.5−25+6−4=−1.5 ，如果参选，那么将会导致选民 6 获胜，收益为 −c−(6−4)=−c−2<1.5-c - (6 - 4) = - c - 2 < 1.5−c−(6−4)=−c−2<1.5 ，所以选民 4 不会参选，该情形属于纳什均衡）

该情形比较复杂，这一就不一一罗列。我们考虑参选人的立场最远能极端到什么程度，现在假设有选民 1 ～ 9 ，假如选民 2 、5 、8 参选，那么它们得票的概率是一致的。可以说，在均匀的直线上，16,12,56\frac{1}{6},\frac{1}{2},\frac{5}{6}61,21,65这三个位置正好是三方打平的临界状态。当两个候选人从临界位置向中间靠拢的时候，即便是正中间的选民也不可能通过参选获胜了，反之，当两个候选人从临界位置向两端偏离的时候，可以通过参选获胜的中间区域扩大。

Note

Lesson 1：该选民投票模型有很多 NE ，并且并非如中位选民模型一般位于中间；

Note

Lesson 2：任意选民参选可能导致一个立场偏离自己更远的候选人获胜；

Note

Lesson 3：如果在两人参选的均衡中两人位置偏离中间太远，即太极端，那么中间位置的选民可以参选并获胜；

Note

Lesson 4：先猜后证。

2.8 Location Model 选址模型#

博弈者：10w 个高个子 and 10w 个矮个子；
策略：选择东城区或西城区居住，每个城区可以住 10w 人；
收益：y={x50000,if 0<x≤5000032−x100000,if 50000<x<100000y =\begin{cases}\dfrac{x}{50000}, & \text{if } 0 < x \le 50000 \\\dfrac{3}{2} - \dfrac{x}{100000}, & \text{if } 50000 < x < 100000\end{cases}y=⎩⎨⎧50000x,23−100000x,if 0<x≤50000if 50000<x<100000 ，其中 xxx 表示与自己同类的人的数量；

画图可以看出这个收益函数是倒 U 型的，在同类人数量 x=50000x = 50000x=50000 时收益达到峰值（y=1y = 1y=1）；如果同类太少，则不合群，收益低；反之，如果同类太多，则拥挤、缺多样性，收益也低；

采用先猜后证的方法，不难看出 2 种纳什均衡，10 万个同类人全住在一个城区（比如东区），异类人住在另一城区（西区），这样，大家的收益都是 12\frac{1}{2}21 。证明也并不难，考虑：东城区住着 10 万个高个子，西城区住着 10 万个矮个子；（反过来一样）

对于单个高个子，是否想搬到西城区？搬过去之后，收益变为 000 ！不搬；反过来，单个矮子也不搬，所以没人想改变选择，确实是 NE ！这就是一种种族隔离的均衡。

还有一种纳什均衡，就是每个城区都高个子和矮个子都五五开混居。因为任意个人搬家，都会导致他自己的收益略微降低。

但是，可不要小看个体的影响，一旦如果一个个体搬家了，原来城区中所有同类的收益均会受损，并且此时搬家成了他们的 BR 。事实上，混居的均衡是不稳定的，或者说是弱均衡。而种族隔离的均衡是严格均衡且稳定。

在本次博弈中，50% 就是临界点 Tipping Point，一旦越过了 50% 的临界点，那么原有的均衡将“失衡”，向着另一个均衡的方向快速发展，尽管人们更偏好原有的均衡。

不过，如果博弈中，所有人都选择了一个地方呢？那么根据规则，将由政府进行随机分配（中央调控）。

Note

Lesson 1：建模时的琐碎细节可以导致巨大的区别；

Note

Lesson 2：社会随机分配的结果好于自主选择（根据大数定律）；

简单解释一下，如果让个体自主选择，会因策略性行为、聚集心理、博弈效应而偏离整体最优；而随机分配则避免这些效应，在大样本下平均结果更好（靠近期望）。

Note

Lesson 3：在一个区域看到了种族隔离现象，不能等价于人们偏好隔离状态。

Note

Lesson 4：随机分配政策的合理性；

Note

Lesson 5：可以由个人的随机化选择替代系统随机（中央调控）；

最后一点就引入了接下来一节的混合策略。注意，我在前两章讲的都是纯策略，即博弈者确定性地选择一个动作，而对于混合策略，玩家选择的是一个概率分布，即以一定概率在多个动作中随机选择一个行动。

三、Mixed Strategies 混合策略#

3.1 Rock, Paper, Scissors 剪刀石头布#

显然，剪刀石头布游戏中，我单纯的采取某种策略，比如每次博弈都出剪刀，那么对方的 BR 就是出石头，那么你的 BR 就是出布，如此循环，并非 NE ，这时候就需要混合策略了。

设 Player 1 使用混合策略 (pR,pS,pP)(p_R, p_S, p_P)(pR,pS,pP)，分别是出石头、剪刀、布的概率。Player 2 使用混合策略 (qR,qS,qP)(q_R, q_S, q_P)(qR,qS,qP) 。则有：

Player 1 出石头时的预期收益为：UR=0⋅qR+1⋅qS+(−1)⋅qP=qS−qPU_R = 0 \cdot q_R + 1 \cdot q_S + (-1) \cdot q_P = q_S - q_PUR=0⋅qR+1⋅qS+(−1)⋅qP=qS−qP ；
Player 1 出剪刀时的预期收益为：US=(−1)⋅qR+0⋅qS+1⋅qP=−qR+qPU_S = (-1) \cdot q_R + 0 \cdot q_S + 1 \cdot q_P = -q_R + q_PUS=(−1)⋅qR+0⋅qS+1⋅qP=−qR+qP ；
Player 1 出布时的预期收益为：UP=1⋅qR+(−1)⋅qS+0⋅qP=qR−qSU_P = 1 \cdot q_R + (-1) \cdot q_S + 0 \cdot q_P = q_R - q_SUP=1⋅qR+(−1)⋅qS+0⋅qP=qR−qS ；

显然，如果出某个动作的预期收益比另外两个高，那就会只出期望高的那个动作，退化为纯策略，所以，需要使得 UR=US=UPU_R = U_S = U_PUR=US=UP ，可解得 qR=qS=qP=13q_R = q_S = q_P = \frac{1}{3}qR=qS=qP=31 。同理也解得 pR=pS=pP=13p_R = p_S = p_P = \frac{1}{3}pR=pS=pP=31 。

此时双方均达到了 BR ，所以 S(13,13,13),(13,13,13)S_{(\frac{1}{3},\frac{1}{3},\frac{1}{3}),(\frac{1}{3},\frac{1}{3},\frac{1}{3})}S(31,31,31),(31,31,31) 是 NE 。

Important

Def a mixed strategy PiP_iPi is a randomization over i’s pure strategies.

Pi(Si)P_i(S_i)Pi(Si) is the probability that PiP_iPi assigns to pure strategy SiS_iSi.

Note

Lesson 1：如果一个混合策略是 BR ，那么这个混合策略中的每一个纯策略必然也都是 BR ，并且每一个策略的预期收益相同。

这点由加权平均数的角度理解就行，混合策略的收益是期望，所以结果必定界于纯策略中最大的收益和最小的收益之间，如果该混合策略是最优反应，那么其中的所有纯策略必然收益最大且相同。

Important

Def a mixed strategy profile p1∗,p2∗,⋯ ,pn∗p^*_1,p^*_2,\cdots,p^*_np1∗,p2∗,⋯,pn∗ is a mixed NE if for each Player iii, pi∗p^*_ipi∗ is a BR to p−1∗p^*_{-1}p−1∗.

Note

Lesson 2：如果混合最优策略中某一纯策略的采用概率大于 0 ，那么这个纯策略必然是最优反应。

3.2 Tennis Match 网球比赛#

假设有 2 个选手正在进行网球比赛，选手 1 要选择打左边还是打右边，选手 2 需要预判向左还是向右防守。博弈矩阵如下，数字表示得分概率：

显然，不存在纯策略的 NE 。那么混合策略呢？

不妨设选手 1 在达到 NE 时的混合策略为 (p,1−p)(p,1-p)(p,1−p) ，选手 2 在达到 NE 时的混合策略为 (q,1−q)(q,1-q)(q,1−q) 。

EU1(L,q&1−q)=50q+80(1−q)=80−30qEU_1(L,q \& 1-q) = 50q + 80(1-q) = 80-30qEU1(L,q&1−q)=50q+80(1−q)=80−30qEU1(R,q&1−q)=90q+20(1−q)=20+70qEU_1(R,q \& 1-q) = 90q + 20(1-q) = 20+70qEU1(R,q&1−q)=90q+20(1−q)=20+70q

那么，选手 2 的混合策略如果希望达到 NE ，应该使得选手 1 选左或选右都没有区别，即每一个纯策略预期收益都相同，则 EU1(L,q&1−q)=EU1(R,q&1−q)EU_1(L,q \& 1-q)=EU_1(R,q \& 1-q)EU1(L,q&1−q)=EU1(R,q&1−q) ，由此可解得 q=0.6q = 0.6q=0.6 。

那么对于选手 1 的混合策略是同理的：

EU2(p&1−p,L)=50p+10(1−p)=EU2(p&1−p,R)=20p+80(1−p)⇒p=0.7EU_2(p \& 1-p,L) = 50p+10(1-p)=EU_2(p \& 1-p,R) = 20p+80(1-p)\Rightarrow p = 0.7EU2(p&1−p,L)=50p+10(1−p)=EU2(p&1−p,R)=20p+80(1−p)⇒p=0.7

所以，双方分别采用混合策略 [(0.7,0.3),(0.6,0.4)][(0.7,0.3),(0.6,0.4)][(0.7,0.3),(0.6,0.4)] 是 NE 。简单解释一下，如果选手 1 选择左边的概率大于 0.7 ，那么选手 2 就应该选择始终防守左边（退化为纯策略）；如果选手 2 选择左边的概率大于 0.6 ，那么选手 1 就应该始终进攻右边。

现在，假如选手 2 的反手击球（往左）能力提升了呢？比如，博弈矩阵的 (L,L)(L,L)(L,L) 处变为 (30,70)(30,70)(30,70) ，并且该信息对双方都是透明的，即对手也知道选手 2 的能力进步了。

我们先从直觉的角度看这个问题，如果选手 2 的反手能力提升：

直接影响：选手 2 更倾向于打反手球，qqq 增大；
间接/战略影响：由于信息透明，选手 1 会减少打反手球，那么选手 2 也会相应减少打反手球，qqq 减小；

该问题的关键是，谁起了主导地位？即最后的 qqq 是增大还是减小？

求解 NE 如下：

EU1(L,q&1−q)=30q+80(1−q)=EU1(R,q&1−q)=90q+20(1−q)⇒q=0.5EU_1(L,q \& 1-q) = 30q + 80(1-q)=EU_1(R,q \& 1-q) = 90q + 20(1-q)\Rightarrow q = 0.5EU1(L,q&1−q)=30q+80(1−q)=EU1(R,q&1−q)=90q+20(1−q)⇒q=0.5

即，qqq 减小，战略/间接影响发挥了主导作用。同样，对于选手 1 呢？既然选手 2 减小了反手球的概率，那么从直觉来看，选手 1 进攻左边的概率也会减小，即 ppp 减小，你也可以通过计算验证，此处省略。

以下是对于上述得出的混合策略是最优策略的证明：

对于选手 1 ，其选择左边的收益为 50×0.6+80×0.4=6250\times 0.6 + 80\times 0.4=6250×0.6+80×0.4=62 ，选择右边的收益为 90×0.6+20×0.4=6290\times 0.6 + 20\times 0.4 = 6290×0.6+20×0.4=62 ，采用混合策略的收益为 0.7×62+0.3×62=620.7\times 62 + 0.3\times 62 = 620.7×62+0.3×62=62 。显然，采用纯策略也并非严格有利，对于其他的混合策略，其收益也肯定界于较高的纯策略收益和较低的纯策略收益之间。

由此也可以得出一个新结论：

Note

Lesson 3：混合策略是否是最优策略，只需证明改选纯策略是否严格有利即可。

3.3 Battle Of Sex Ⅱ 性别大战 Ⅱ#

与之前提到的类似，博弈矩阵如下：

显然，（选择1，选择1）和（选择2，选择2）都是 NE 。只要通过沟通便能达到均衡。但如果现实中，并没有事先沟通，协调失败的情况也是常有的。那么就需要考虑混合策略。计算混合策略下的 NE 的方法已经在上面一节给出了，这里直接计算。

设男方采用混合策略 (p,1−p)(p,1-p)(p,1−p) ，女方采用混合策略 (q,1−q)(q,1-q)(q,1−q) 。

EUM(1,q&1−q)=2×q+(1−q)×0=EUM(2,q&1−q)=0×q+1×(1−q)⇒q=13EU_{M}(1,q\&1-q)=2\times q + (1-q)\times 0=EU_M(2,q\&1-q)=0\times q + 1\times (1-q)\Rightarrow q = \frac{1}{3}EUM(1,q&1−q)=2×q+(1−q)×0=EUM(2,q&1−q)=0×q+1×(1−q)⇒q=31EUW(p&1−p,1)=1×p+(1−p)×0=EUW(p&1−p,2)=0×p+2×(1−p)⇒p=23EU_{W}(p\& 1-p,1)=1\times p + (1-p)\times 0=EU_W(p\& 1-p,2)=0\times p + 2\times (1-p)\Rightarrow p = \frac{2}{3}EUW(p&1−p,1)=1×p+(1−p)×0=EUW(p&1−p,2)=0×p+2×(1−p)⇒p=32

来简单验证一下 [(23,13),(13,23)][(\frac{2}{3},\frac{1}{3}),(\frac{1}{3},\frac{2}{3})][(32,31),(31,32)] 是 NE ，对于男方，选择 1 的收益为 2×13+0×23=232\times\frac{1}{3}+0\times\frac{2}{3}=\frac{2}{3}2×31+0×32=32 ，选择 2 的收益为 0×13+1×23=230\times\frac{1}{3}+1\times\frac{2}{3}=\frac{2}{3}0×31+1×32=32 ，混合策略的收益也为 23\frac{2}{3}32 ，改选纯策略并非严格有利的策略。对于女方也类似。

这里混合策略中的概率，并不一定是字面意义上的随机化。可以理解为实际约会中，对手对你会怎么做的一种猜测。

至于为什么混合策略的期望收益只有 23\frac{2}{3}32 ，这是因为纯策略下，双方见面成功，但是混合策略下，双方只有 23×13+13×23=49\frac{2}{3}\times\frac{1}{3}+\frac{1}{3}\times\frac{2}{3}=\frac{4}{9}32×31+31×32=94 的概率见面成功。

3.4 Tax Payer 纳税人#

考虑以下情形：

如图，纯策略下并不存在 NE 。同上，计算混合策略：

设税务人员采用的混合策略为 (p,1−p)(p,1-p)(p,1−p) ，纳税者采用的策略为 (q,1−q)(q,1-q)(q,1−q) 。

EUA(审查,q&1−q)=2×q+(1−q)×4=EUA(不审查,q&1−q)=4×q+0×(1−q)⇒q=23EU_A(\text{审查},q\&1-q)=2\times q + (1-q)\times 4=EU_A(\text{不审查},q\&1-q)=4\times q + 0\times (1-q)\Rightarrow q = \frac{2}{3}EUA(审查,q&1−q)=2×q+(1−q)×4=EUA(不审查,q&1−q)=4×q+0×(1−q)⇒q=32EUT(p&1−p,如实申报)=0×p+(1−p)×0=EUT(p&1−p,瞒报)=−10×p+4×(1−p)⇒p=27EU_T(p\& 1-p,\text{如实申报})=0\times p + (1-p)\times 0=EU_T(p\& 1-p,\text{瞒报})=-10\times p + 4\times (1-p)\Rightarrow p = \frac{2}{7}EUT(p&1−p,如实申报)=0×p+(1−p)×0=EUT(p&1−p,瞒报)=−10×p+4×(1−p)⇒p=72

混合策略下，NE=[(27,57),(23,13)]NE=[(\frac{2}{7},\frac{5}{7}),(\frac{2}{3},\frac{1}{3})]NE=[(72,75),(32,31)] 。容易验证。即对于税务人员以 27\frac{2}{7}72 的概率进行审查（或者说审查 27\frac{2}{7}72 的纳税人），而对于纳税者，以 23\frac{2}{3}32 的概率选择如实纳税。当然，这都是从个体采取的策略来理解的。

还有一种理解是，这里的概率不一定要理解为策略的随机化，也可以视为采取不同策略的人的比例，比如该案例的总体中，有 23\frac{2}{3}32 选择如实纳税，即可以用来预测比例。

接下来，从政策制定者的角度考虑，如果你发现逃税者的比例很高，并希望通过提升偷税漏税的惩罚力度来减少逃税者，会发生什么呢？假如博弈矩阵变化如下：

我们希望计算 qqq ，即逃税者的比例，需要计算税务人员的期望收益，即：

和之前一样，纳税意愿并没有改变。不改变税务人员的收益，自然不会改变纳税人的纳税意愿。新均衡只改变了 ppp ，容易计算出 ppp 会减小，即税务人员审查的力度下降了。

四、Evolution 进化论#

4.1 Simplified Model 简化模型#

简化的模型有以下假设：

种群内部竞争；
博弈者之间的各类情况互为镜像；
博弈者们身处一个大数量的种群中，随机配对博弈；
相对成功的策略会增长；
不存在基因重组，即只考虑无性繁殖；

现在，假如一个大种群中的所有个体都采用了相同策略 SSS ，但是某一时刻有一部分个体发生了“变异”，改为采用策略 S′S^\primeS′ ，如果发生变异的个体采用的策略只可能导致灭绝，那么则称原策略 SSS 是进化稳定（Evolutionarily Stable） 的。

继续以囚徒困境为例：

C 和 D 分别代表合作/不合作。现在，假设所有鼠鼠都是天生理性的，都会选择合作。显然，如果都是合作型鼠鼠，无论如何随机配对，互相都有收益，能无限繁衍下去。

现在，假如突然产生了变异，出现了一只不合作鼠鼠，它随机配对到一个合作型鼠鼠进行博弈，于是这个合作型鼠鼠会死，不合作鼠鼠活下去并无性生殖，不合作鼠鼠越来越多，不会灭绝。

显然，合作策略下，发生突变的个体并不会灭绝，所以合作策略并不是一个进化稳定的策略。或者你也可以通过计算期望收益，假设合作的个体占种群的 ε\varepsilonε ：

E(C)=2ε+0(1−ε)=2εE(D)=3ε+1(1−ε)=2ε+1\begin{aligned} & E(C)=2\varepsilon + 0(1-\varepsilon)=2\varepsilon\\ & E(D)=3\varepsilon + 1(1-\varepsilon)=2\varepsilon + 1 \end{aligned}E(C)=2ε+0(1−ε)=2εE(D)=3ε+1(1−ε)=2ε+1

显然，不合作个体的收益更大，它们不会灭绝，并且不合作才是进化稳定（ES）的策略。由此案例我们可以得出 2 个结论：

Note

Lesson 1：自然选择的结果可能是糟糕的。

Note

Lesson 2：严格劣势策略一定不是 ES ，会在进化中被淘汰。

为什么该模型会推出与现实似乎有些相悖的结论呢？简单来说，就是因为该模型假设的是无性繁殖，没有考虑基因的融合。

再考虑以下博弈：

假如种群中的所有个体天生都会选择 c ，c 是 ES 吗？考虑 b 入侵 c 的情况，设 b 占比为 ε\varepsilonε ，则：

EUc=0(1−ε)+1(ε)=εEUb=1(1−ε)+0(ε)=1−ε\begin{aligned} &EU_c=0(1-\varepsilon)+1(\varepsilon)=\varepsilon\\ &EU_b=1(1-\varepsilon)+0(\varepsilon)=1-\varepsilon \end{aligned}EUc=0(1−ε)+1(ε)=εEUb=1(1−ε)+0(ε)=1−ε

由于 ε\varepsilonε 是一个无穷小量，所以 EUb>EUcEU_b > EU_cEUb>EUc ，所以 c 不是 ES 。但 b 和 c 是对称的，同样可以推出 b 也不是 ES 。

该博弈中的 NE 不难推出是 (a, a)、(b, c) 和 (c, b) 。如果一个策略不是 NE ，那么肯定是不能形成进化稳定的，因为必然会出现有利变动入侵该策略。所以进化稳定策略一定是 NE 。

反过来成立吗，即 NE 一定是进化稳定策略吗？并非如此，可以看以下例子：

NE = (a, a) and (b, b) ，而 (b, b) 并不是进化稳定的，因为：

EUb=0(1−ε)+0ε=0EUa=0(1−ε)+1ε=ε\begin{aligned} & EU_b = 0(1-\varepsilon)+0\varepsilon=0\\ & EU_a = 0(1-\varepsilon)+1\varepsilon=\varepsilon\\ \end{aligned}EUb=0(1−ε)+0ε=0EUa=0(1−ε)+1ε=ε

事实上，NE 与最优策略的交集才是进化稳定策略，即：

Note

Lesson 3：严格纳什均衡和进化稳定策略互为充要条件。

最后，我们再从生物学和经济学的视角分别给出进化稳定的标准定义：

Important

定义 4.1：在 2 个玩家的对称博弈（symmetric game）中，一个纯策略满足进化稳定策略（Evolutionarily Stable）当满足以下条件：

∃ε∗>0\exists \varepsilon^* > 0∃ε∗>0 满足 (1−ε)U(S,S)+εU(S,S∗)>(1−ε)U(S∗,S)+εU(S∗,S∗)(1-\varepsilon)U(S,S)+\varepsilon U(S,S^*)>(1-\varepsilon)U(S^*,S)+\varepsilon U(S^*,S^*)(1−ε)U(S,S)+εU(S,S∗)>(1−ε)U(S∗,S)+εU(S∗,S∗) 对于其余所有策略 S∗S^*S∗ 和对足够小的正数 ε∗<ε\varepsilon^*<\varepsilonε∗<ε 。

简单来说，就是少量使用其他策略 S∗S^*S∗ 的突变者不能获得更高收益，即突变体不能成功“入侵”，则称策略 SSS 是进化稳定策略。

Important

定义 4.2：在 2 个玩家的对称博弈（symmetric game）中，一个纯策略满足进化稳定策略（Evolutionarily Stable）当满足以下条件：

如果 (S,S)(S,S)(S,S) 是一个对称纳什均衡，那么 U(S,S)≥U(S,S∗),∀S∗U(S,S)\ge U(S,S^*),\forall S^*U(S,S)≥U(S,S∗),∀S∗ ；如果 U(S,S)=U(S,S∗)U(S,S)=U(S,S^*)U(S,S)=U(S,S∗) ，则 U(S,S∗)>U(S∗,S∗)U(S,S^*)>U(S^*,S^*)U(S,S∗)>U(S∗,S∗) 。

经济学上的定义涵盖了 2 种情况，第一种情况属于严格 NE ，而第二种情况，即弱纳什均衡，则还需要进一步满足边界情况，即使突变个体和原始个体在博弈时收益还不错，但突变个体之间博弈收益极低。

这两个定义是等价的。

持续更新中…

MCP协议，换皮的工具调用？

Fri, 04 Apr 2025 13:25:00 GMT

0. MCP 的前世: Function Calling#

假如有一个函数 get_weather(location) ，传统的客服机器人的做法是：

接收用户输入（e.g. 帮我查一下杭州今天的天气）；
关键词提取/匹配或 NLP 等较为繁琐的转换来匹配程序员写的后端逻辑

e.g.if (keyword === 'weather') return await get_weather("杭州");）

后端调用 get_weather() 返回结果给前端。

LLM 提供了强大的自然语言理解能力，而 Function Calling 的目标就是非结构化的自然语言描述 →\rightarrow→ 函数调用。现在的处理流程变为：

前端接受用户输入；
后端携带用户提示和工具参数给 LLM；
LLM 返回需要被调用的工具列表（意图识别）；
后端执行工具的具体逻辑，并将返回结果和用户输入再传递给 LLM；
LLM 润色后返回最终结果给后端；
用户接收到输出；

1. MCP 时代#

1.1 Why MCP?#

Function Calling 虽然阐述了如何与大模型进行信息交换，但没有明确，还停留在具体情景具体代码实现层面。例如，假如你要开发一个 LLM Chat APP，你需要在你的 Server 上实现工具来调用外部服务，例如天气查询 API，同时你的工具还需要注册到大模型服务商的API 中，来完成工具调用的整个流程，工具注册、工具调用、结果返回等都需要你自己去实现，开发者需要关注的点过多，开发成本较高。

相比之下，MCP 提出了一个 Protocol 来定义，这样开发者只需要关注 MCP 工具包的接口，不需要关注具体数据交换的数据流了。APP 的 Server 充当 MCP Client 的角色，工具注册和调用的流程由 MCP Server 来完成，面向应用开发者，无需关注 MCP Server 内部如何实现。

正如标题所言，MCP 协议被不少人诟病的点是其似乎只是对 Function Calling 的换皮，但不能完全等同两者，两者是互补的，关键区别在于工具由谁来实现。

1.2 What MCP do?#

MCP 的目的主要是方便进行工具调用，我们先通过以下时序图回顾一下 MCP 协议做了什么。

当前 MCP 主要做的是通过标准化 MCP Server 实现，使 LLM 能够与本地和远程资源进行交互。但 MCP 本身还主要围绕在对服务器的规定，包括客户端如何发现和注册工具（上图中的工具注册阶段）和如何调用工具。

作为开发者，亟待解决的一点是标准化 MCP Client 与 MCP Server 的交互方式（例如 Standard I/O, HTTP or WebSocket），当前 MCP 协议并没有对这一部分进行规范，导致开发者需要适配不同 MCP Server 的接口来实现工具调用的功能。

从上图中的数据通路可以看出，MCP Client 和 MCP Server 间主要有以下几种消息功能：

ListToolsRequest/ListToolsResult：工具注册和发现的请求和结果；
CallToolRequest/CallToolResult：工具调用的请求和结果；

下图示例会更加直观：

1.3 MCP 的局限性#

MCP Client 还需要主动去适配这些 MCP Server，无疑增加了复杂度。
实际场景中往往不止需要一次、或者一类工具调用，可能需要循环与用户对话，并调用多个 MCP Server 的工具，但 MCP Client 与 MCP Server 的交互，MCP Client 与 LLM 交互的标准也没有统一，MCP 协议只是关注于标准化单次的工具调用。

Thinking:

统一 MCP Server 暴露的接口，类似 HTTP Stream。
统一大模型与 Client 交互的方式，比如 Prompt 的格式。
大模型并不调用工具，而是由 MCP Server 或软件系统调用工具执行获得结果再传递给大模型。这里事实上涉及两次与 LLM 的交互，第一次是获得需要调用的工具和参数（意图识别），第二次是获得结果再传递给 LLM 生成回答。统一暴露给客户端的接口，即生成完整的回答，同时这种方式还有没有优化空间？

2. How to develop MCP?#

很多主流编程语言都已经开发了针对 MCP 协议的 SDK，这里以 Python SDK 为例：

1
@mcp_tool(
2
  name="get_weather",
3
  description="Get the weather information for a given location"
4
)
5
def get_weather(location: str) -> str:
6
  # 这里是工具的具体实现逻辑，例如调用天气 API 获取天气信息
7
  return f"The weather in {location} is sunny with a high of 25°C."

3. 针对 MCP 的常见误区#

MCP Server 的几个关键要素：

工具由模型控制：模型决定何时调用工具，并使用工具返回的结果；
资源由 APP 控制：APP 负责提供资源；
Prompt 由用户控制：用户决定是否要使用提示词；

RAG（Retrieval-augmented generation）个人学习笔记

Sat, 22 Feb 2025 08:54:00 GMT

为什么需要 RAG？#

传统的 LLM 模型主要存在以下 2 个问题：

幻觉
外部知识/最新知识的缺失。

RAG 可以通过结合基于检索和生成模型的优势来提供更准确和上下文相关的响应，可以添加自己的预料构建知识库。

RAG vs. fine-tuning a LLM model

RAG 更适合知识库需要动态更新的情景，这部分数据不作为用于 LLM 的训练数据，而是通过 LLM 的能力进行检索。
RAG 由于采用检索的形式，数据来源是可知的，而 LLM 是黑箱。
RAG 可以对生成过程提供更多控制。

Before RAG?#

理论上，对于需要外挂知识库，即需要处理大量文本数据的场景，不通过微调，将这些文本数据全部塞进 Prompt 未尝不可，但：

超出 LLM 的上下文窗口 / 输入 Token 限制；
烧钱；
LLM 对于长文本的理解能力有限，可能无法正确理解和利用这些文本数据；
处理和响应的效率较低。

从目标来看，我们需要的是大量文本数据中能够回答用户问题的相关信息，而不是让 LLM 直接处理这些文本数据。RAG 的出现正是为了满足这一需求，其分为两步：

分块：将大量文本数据分成更小的块，便于处理和检索。
检索：根据用户的查询，从这些块中检索出相关块放入 Prompt 中，供 LLM 生成回答。

RAG 的实现#

Text Chunking#

Size-based chunking：根据文本块的大小进行分块；
- 优点：简单易行；
- 缺点：可能会切断句子或段落，导致信息丢失或上下文不完整，因此实现上会在句子间引入一定的重叠。
Structure-based chunking：根据文本的结构进行分块，例如段落、章节等；
- 优点：保持文本的完整性和上下文关系；
- 缺点：可能会导致块的大小不均匀，某些块可能过大或过小。并且实际应用中文本并不一定有明确的结构。
Semantic-based chunking：根据文本的语义内容进行分块，例如使用自然语言处理技术识别主题或概念；
- 优点：可以更好地捕捉文本的语义信息和上下文关系；
- 缺点：实现复杂，可能需要更多的计算资源和时间。

Semantic Search#

语义搜索，通过将文本块和用户查询转换为向量表示（Text Embeddings），并使用向量相似度来检索相关块。

a basis Pipeline for RAG#

Chunk source text.
Generate embeddings.
Store embeddings in a vector database.
Embed user query, find closest chunks.
- 通过余弦相似度计算用户查询与文本块之间的相似度，检索出相关块。
- 范围为 -1 到 1，值越大表示越相似。
Add related chunks to the prompt, generate answer.

Integrating with Lexical Search#

语义搜索虽然能够捕捉文本的语义信息，但在某些情况下可能会遗漏一些重要的细节信息。为了弥补这一不足，可以将语义搜索与词汇搜索（Lexical Search）结合起来，常用方法是 BM25 算法，其基本流程如下：

Tokenize the user query.
For each text chunk, calculate the BM25 score based on the frequency of query tokens in the chunk and the overall token distribution in the corpus.
Rank the chunks based on their BM25 scores and select the top N chunks for further processing.

a hybrid Pipeline for RAG#

Retriever（检索器）：处理用户查询，使用语义搜索 + 词汇搜索来检索相关文本块。

将语义搜索和词汇搜索得到的结果混合需要进行一定的排序，常用方法是 Reciprocal Rank Fusion（倒数排序），其计算方式如下：

RRF(d)=∑i=1n1k+ranki(d)RRF(d) = \sum_{i=1}^{n} \frac{1}{k + rank_i(d)}RRF(d)=i=1∑nk+ranki(d)1

其中，RRF(d)RRF(d)RRF(d) 是文档 ddd 的最终得分，nnn 是搜索方法的数量，ranki(d)rank_i(d)ranki(d) 是文档 ddd 在第 iii 个搜索方法中的排名，kkk 是一个常数（通常设置为 60）以避免排名为 0 的情况。分数越高表示文档越相关。

NSFC 数据爬取

Wed, 22 Jan 2025 12:47:00 GMT

需求#

从国家自然科学基金大数据知识管理服务门户爬取论文数据。

搜索API#

打开浏览器的开发者工具（如 Chrome 的 F12）；
在网络（Network）选项卡中，监控搜索的请求；
找到接口()[https://kd.nsfc.cn/api/baseQuery/completionQueryResultsData]；
其请求体如下：

1
{"code":"A01","fuzzyKeyword":"","complete":true,"isFuzzySearch":false,"conclusionYear":"2020","dependUnit":"","keywords":"","pageNum":0,"pageSize":10,"personInCharge":"","projectName":"","projectType":"218","subPType":"","psPType":"","ratifyNo":"","ratifyYear":"","order":"enddate","ordering":"desc","codeScreening":"","dependUnitScreening":"","keywordsScreening":"","projectTypeNameScreening":""}

需要用到的字段只有：

1
code // 申请代码
2
conclusionYear // 结题年度
3
projectType // 资助类别

观察其返回内容：为一串无规律的长字符串，初步判断是经过了某种加密；

解密#

页面的HTML文件：

1
<body>
2
        <noscript>
3
            <strong>We're sorry but 国家自然科学基金大数据知识管理服务门户 doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
4
        </noscript>
5
        <div id="app"></div>
6
        <script src="/js/chunk-vendors.559d99e0.js"></script>
7
        <script src="/js/app.17b88e26.js"></script>
8
    </body>

在网页的 JavaScript 文件中，尝试寻找相关的解密代码，最终在app.17b88e26.js中找到以下内容（注释为后期补充）：

1
function g(e) {
2
    // 定义密钥
3
    var t = p.a.enc.Utf8.parse("IFROMC86");
4

5
    // 使用 DES 解密方法
6
    var n = p.a.DES.decrypt(
7
        {
8
            ciphertext: p.a.enc.Base64.parse(e) // 解析 Base64 编码的密文
9
        },
10
        t, // 解密密钥
11
        {
12
            mode: p.a.mode.ECB, // 使用 ECB 模式
13
            padding: p.a.pad.Pkcs7 // 使用 PKCS7 填充方式
14
        }
15
    );
16

17
    // 将解密后的内容解析为 UTF-8 字符串并转为 JSON
18
    return JSON.parse(n.toString(p.a.enc.Utf8));
19
}

使用 Python 的 pycryptodome 库来实现解密：

Terminal window

1
pip install pycryptodome

1
from Crypto.Cipher import DES
2
from Crypto.Util.Padding import unpad
3
import base64
4
import json
5

6
def decrypt_des_ecb(ciphertext):
7
    # 密钥
8
    key = b"IFROMC86"
9
    # Base64 解码
10
    encrypted_data = base64.b64decode(ciphertext)
11

12
    # 初始化 DES 解密器
13
    cipher = DES.new(key, DES.MODE_ECB)
14

15
    # 解密数据并移除填充
16
    decrypted_data = unpad(cipher.decrypt(encrypted_data), DES.block_size)
17

18
    # 解密后的字符串转为 JSON 格式
19
    return json.loads(decrypted_data.decode('utf-8'))

对网页发送请求，成功得到解密后的JSON文件：

一文白嫖阿里云服务器+配置基本开发环境+博客等服务部署

Fri, 17 Jan 2025 08:20:00 GMT

零、（白嫖）步骤#

阿里云的学生优惠会送一张无门槛300元代金券（传送门：阿里云高校计划_云工开物_助力高校科研与教育加速-阿里云），刚好够白嫖用券专区中的小服务器一整年（还多出15块可以买个20g的流量包）；个人配置如下：

实例规格：ecs.e-c1m1.large；
CPU&内存：2核2G；
操作系统：Ubuntu 22.04 LTS 64位；
带宽计费方式：按使用流量；
公网带宽：5 Mbps；

注：别选固定带宽，这是另外的价钱；

白嫖完后，进入配置；

一、本地远程连接#

1.1 密钥对认证#

由于本人采用密钥对进行认证，在创建并绑定密钥对后会自动下载一个 .pem 的文件到本地，ssh连接需要采用以下方式：

直接连接：

Terminal window

1
ssh -i ~/.ssh/你的私钥文件 用户名@服务器IP

简化连接方式

每次手动输入私钥文件显然过于不便了，我们可以将私钥文件添加到SSH配置文件中；

Terminal window

1
nano ~/.ssh/config

增加配置如下：

1
Host 服务器别名(随便取)
2
  HostName 服务器IP
3
  User 用户名
4
  IdentityFile ~/.ssh/你的私钥文件
5
  Port 22

按下 ^x 和 y 保存后，可以直接采用服务器别名连接：

Terminal window

1
ssh 服务器别名

1.2 常见问题#

连接时报错：

1
Warning: Permanently added '你的服务器IP' (ED25519) to the list of known hosts. @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ @ WARNING: UNPROTECTED PRIVATE KEY FILE! @ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ Permissions 0644 for '你的私钥文件地址' are too open. It is required that your private key files are NOT accessible by others. This private key will be ignored. Load key "你的私钥文件地址": bad permissions 用户名@服务器IP: Permission denied (publickey).

这是因为SSH出于安全考虑，要求私钥文件的权限必须足够严格，不允许其他用户访问。你需要修改私钥文件的权限，确保只有你自己可以读取和写入：

Terminal window

1
chmod 600 ~/.ssh/你的私钥文件

二、基本环境配置#

2.1 基本工具安装#

系统更新

Terminal window

1
sudo apt update
2
sudo apt upgrade -y

基本工具安装（有些已经自带）

Terminal window

1
sudo apt install -y build-essential curl wget git vim htop net-tools

防火墙配置

Terminal window

1
sudo apt install -y ufw
2
sudo ufw allow ssh
3
sudo ufw allow http
4
sudo ufw allow https
5
sudo ufw enable

2.2 安装Docker#

以下步骤也可以直接参考 Docker 官方文档；

Terminal window

1
# 安装所需依赖
2
sudo apt install -y apt-transport-https ca-certificates gnupg lsb-release
3

4
# 添加 Docker 的官方 GPG 密钥（通过阿里云镜像）
5
sudo mkdir -p /etc/apt/keyrings && \
6
curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg && \
7
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null && \
8
sudo apt-get update
9

10
# 安装最新的 Docker
11
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

常见问题#

由于运营商网络等不稳定因素可能导致镜像加速器无法成功拉取到指定版本的容器镜像，阿里云提供了免费的镜像加速器，配置步骤如下：

登录容器镜像服务控制台。
在左侧导航栏选择镜像工具 > 镜像加速器
在镜像加速器页面获取加速器地址。

接下来，在云服务器上更新 Docker 配置：

Terminal window

1
sudo mkdir -p /etc/docker
2
sudo tee /etc/docker/daemon.json <<-'EOF'
3
{
4
  "registry-mirrors": ["你的镜像加速器地址"]
5
}
6
EOF
7
sudo systemctl daemon-reload
8
sudo systemctl restart docker

最后，验证是否可以成功拉取 Docker Hub镜像：

1
sudo docker run hello-world

如果看到以下输出，说明成功拉取！

1
Hello from Docker!
2
This message shows that your installation appears to be working correctly.

2.3 配置 git#

这里采用使用 SSH 密钥认证，首先在云服务器上生成 SSH 密钥对；

Terminal window

1
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

可以直接一路回车到底，默认情况下，密钥会保存到 ~/.ssh/id_rsa；

将公钥添加到 GitHub 账户

Terminal window

1
# 查看公钥内容
2
cat ~/.ssh/id_rsa.pub

复制后，登录到 GitHub，进入 Settings -> SSH and GPG keys，点击 New SSH key，将公钥复制到 GitHub 的文本框中并保存；

验证连接

Terminal window

1
# 测试连接
2
ssh -T git@github.com

如果配置成功，会观察到输出如下信息：

1
Hi username! You've successfully authenticated, but GitHub does not provide shell access.

2.4 安装 Anaconda#

下载 Anaconda 的安装包

你可以在官网自行查找需要的版本，替换以下链接即可：

Terminal window

1
wget https://repo.anaconda.com/archive/Anaconda3-2024.10-1-Linux-x86_64.sh

安装anaconda

Terminal window

1
# 授予可执行权限
2
chmod +x Anaconda3-2024.10-1-Linux-x86_64.sh
3

4
# 执行
5
./Anaconda3-2024.10-1-Linux-x86_64.sh

然后疯狂回车（中间需要输入一次yes）即可；

验证安装

打开新的终端，输入：

Terminal window

1
conda --version

如果输出正确的 conda 版本，则说明安装成功并且正确配置环境变量；

1
conda 24.9.2

2.5 安装 MySQL#

安装 MySQL APT 存储库

Terminal window

1
sudo wget https://dev.mysql.com/get/mysql-apt-config_0.8.33-1_all.deb

安装 MySQL 服务器

Terminal window

1
#安装 MySQL 服务器
2
sudo apt install -y mysql-server
3
#启动 MySQL 服务
4
sudo systemctl start mysql
5
#检查启动状态
6
sudo systemctl status mysql
7
#在系统启动时自动启动。
8
sudo systemctl enable mysql

安装安全向导（可选）

Terminal window

1
sudo mysql_secure_installation

它会让你自信选择安全策略，包括如下内容：

Would you like to setup VALIDATE PASSWORD component?
- 是否需要启用 VALIDATE PASSWORD 组件？
There are three levels of password validation policy:
- LOW Length >= 8
- MEDIUM Length >= 8, numeric, mixed case, and special characters
- STRONG Length >= 8, numeric, mixed case, special characters and dictionary file
- 这里选择输入 2 ，表示设置密码策略要求密码至少包含一个大写字母、一个小写字母、一个数字和一个特殊字符，并且密码总长度至少为8个字符；
Remove anonymous users?
- 是否移除匿名用户？
- 这里输入 y ，表示移除；
Disallow root login remotely?
- 禁止MySQL的 root 用户从远程登录；
- 这里选择 y；
Remove test database and access to it?
- 是否需要移除MySQL自带的 test 数据库？
- 无所谓，删了吧；
Reload privilege tables now?
- 输入 y ，重新加载权限表，使得更改生效；

配置安全组规则

配置安全组时，MySQL 默认使用3306端口。确保实例安全组的入站规则开放3306端口。如果选择了不同的端口，请根据实际情况调整安全组设置。具体步骤请参考添加安全组规则。

添加用于远程访问的用户

将以下输入的 <username> 和 <password> 部分自行修改；

Terminal window

1
sudo mysql -uroot -p \
2
-e "CREATE USER '<username>'@'%' IDENTIFIED BY '<password>';" \
3
-e "GRANT ALL PRIVILEGES ON *.* TO '<username>'@'%' WITH GRANT OPTION;" \
4
-e "FLUSH PRIVILEGES;"

执行后需要输入 root 账户的密码；

Terminal window

1
sudo mysql -u <username> -p

输入密码后，进入 mysql 环境，成功！

输入以下内容可以退出 mysql 环境：

1
exit;

2.6 配置 Node.js 开发环境#

下载 NVM 源码

Terminal window

1
git clone https://gitee.com/mirrors/nvm.git ~/.nvm && cd ~/.nvm && git checkout `git describe --abbrev=0 --tags`

配置环境变量

Terminal window

1
sudo sh -c 'echo ". ~/.nvm/nvm.sh" >> /etc/profile'
2
source /etc/profile

设置镜像源

Terminal window

1
export NVM_NODEJS_ORG_MIRROR=https://npmmirror.com/mirrors/node

自行下载所需版本，例如：

Terminal window

1
nvm install v23.3.0

若观察到以下输出，说明安装成功：

1
Computing checksum with sha256sum
2
Checksums matched!
3
Now using node v23.3.0 (npm v10.9.0)
4
Creating default alias: default -> v23.3.0

2.7 配置 Java 环境#

安装所需版本的JDK（以Java 1.8 为例）：

Terminal window

1
sudo apt-get install -y openjdk-8-jdk

如果需要下载其他版本，可以运行以下命令查看：

Terminal window

1
sudo apt search openjdk

验证安装

Terminal window

1
java -version

2.8 Screen 工具#

在通过 Scp 等远程传输文件时，特别是大文件时，往往因为 SSH 连接不稳定而导致中断。而 Screen 工具提供了从单个 SSH 会话中使用多个 shell 窗口的能力。当会话被分离或网络中断时 Screen 会话中启动的进程仍将运行，我们可以随时重新连接到 Screen 会话。

安装 Screen

Terminal window

1
sudo apt install screen

创建一个会话

Terminal window

1
screen -S test

挂起一个会话

按下 Ctrl + a + d 即可保持这个 Screen 到后台并回到我们 SSH 的主终端；

恢复一个会话

Terminal window

1
screen -r -d test

即可重新进入该 Screen；

查看已经存在的 Screen 终端

Terminal window

1
screen -ls

2.9 安装 Nginx 环境#

使用 Nginx 官方源安装；

Terminal window

1
#更新系统已安装软件并更新包管理工具
2
sudo apt update -y
3
#Nginx安装前必要环境
4
sudo apt install -y curl gnupg2 ca-certificates lsb-release ubuntu-keyring
5
#导入官方Nginx签名密钥
6
curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
7
#设置apt仓库
8
echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" | sudo tee /etc/apt/sources.list.d/nginx.list
9
#安装nginx
10
sudo apt install -y nginx

接下来根据实际需要修改配置文件；

三、搭建 Cloudreve 云盘#

3.1 快速部署#

下载 Cloudreve 发布版本，你可以自行从 Release 选择适合你的操作系统的；

Terminal window

1
wget https://github.com/cloudreve/Cloudreve/releases/download/3.8.3/cloudreve_3.8.3_linux_amd64.tar.gz
2

3
# 创建程序目录
4
mkdir -p /usr/local/cloudreve
5

6
# 解压获取到的主程序到所在目录
7
tar -zxvf cloudreve_3.8.3_linux_amd64.tar.gz -C /usr/local/cloudreve
8

9
cd /usr/local/cloudreve
10
# 赋予执行权限
11
chmod +x ./cloudreve
12

13
# 启动 Cloudreve
14
./cloudreve

观察到以下输出，说明启动成功：

在首次启动时，会创建初始管理员账号，请注意保管下方的管理员密码，此密码只会在首次启动时出现；

Cloudreve 默认会监听5212端口，你可以在浏览器中访问 http://服务器IP:5212 进入 Cloudreve。注意需要增加阿里云服务器的安全组规则。

3.2 启动进程守护#

编辑配置文件

Terminal window

1
vim /usr/lib/systemd/system/cloudreve.service
2

3
[Unit]
4
Description=Cloudreve
5
Documentation=https://docs.cloudreve.org
6
After=network.target
7
After=mysqld.service
8
Wants=network.target
9

10
[Service]
11
WorkingDirectory=/usr/local/cloudreve
12
ExecStart=/usr/local/cloudreve/cloudreve
13
Restart=on-abnormal
14
RestartSec=5s
15
KillMode=mixed
16

17
StandardOutput=null
18
StandardError=syslog
19

20
[Install]
21
WantedBy=multi-user.target

更新配置并启动

Terminal window

1
# 更新配置
2
systemctl daemon-reload
3

4
# 启动服务
5
systemctl start cloudreve
6

7
# 设置开机启动
8
systemctl enable cloudreve

管理命令

Terminal window

1
# 启动服务
2
systemctl start cloudreve
3

4
# 停止服务
5
systemctl stop cloudreve
6

7
# 重启服务
8
systemctl restart cloudreve
9

10
# 查看状态
11
systemctl status cloudreve

访问前端服务

通过 https://你的服务器IP:5212 即可访问；

四、部署 hexo 博客#

纯纯自用罢了；

4.1 服务端 git 的有关配置#

创建一个单独的用户用于管理仓库；

Terminal window

1
sudo adduser git
2
sudo passwd git

设置 git 用户 sudo 权限；

Terminal window

1
sudo chmod 740 /etc/sudoers
2
sudo vim /etc/sudoers

添加一行：

1
git ALL=(ALL) ALL

按下 :wq 保存更改，然后：

Terminal window

1
sudo chmod 400 /etc/sudoers

上传公钥到服务器并添加到 git 用户

在本机执行：

Terminal window

1
scp ~/.ssh/id_rsa.pub root@<你的服务器IP>:/home/git/tempkey.pub -i ~/.ssh/你的私钥文件.pem

然后登录服务器：

Terminal window

1
ssh 你的服务器别名
2
sudo su - git
3
mkdir -p ~/.ssh
4
cat ~/tempkey.pub >> ~/.ssh/authorized_keys
5
chmod 600 ~/.ssh/authorized_keys
6
chmod 700 ~/.ssh
7
exit

你同样可以在本机化简配置：

1
Host 你的服务器别名_2
2
  HostName 你的服务器公网IP
3
  User git
4
  IdentityFile ~/.ssh/id_rsa
5
  Port 22

4.2 配置 Git 仓库和部署钩子#

初始化一个裸仓库；

Terminal window

1
su git
2
cd ~
3
git init --bare hexo.git

添加 post-receive 自动部署钩子；

Terminal window

1
vi ~/hexo.git/hooks/post-receive

输入以下内容并保存退出（）：

1
#!/bin/bash
2
GIT_WORK_TREE=/data/hexo git checkout -f

赋予执行权限：

Terminal window

1
chmod +x ~/hexo.git/hooks/post-receive

Terminal window

1
sudo mkdir -p /data/hexo
2
sudo chown -R git:git /data/hexo
3
sudo chmod -R 755 /data/hexo

4.3 Hexo 配置#

4.3.x 关于资源文件夹的问题#

当然，使用图床等工具，直接在 markdown 中插入外链是最方便的，并且不用担心在博客迁移时发生问题。不过如果你想要保存图片在本地，那么可以参考如下方法：

保存图片在 source/ 文件夹下；

这是肯定的，区别只是在于后面的引用格式问题；

如果图片的目录为 source/img/example.png ；

那么，默认配置下，你的引用格式应该为

1
![](img/example.png)

如果你希望不同文章的图片保存在不同目录，你可以自行修改保存路径和相应的引用格式（注意是相对于 source 文件夹的路径）；当然，你也可以使用 Hexo 提供的配置方式，将配置文件 _config.yml 修改为：

1
post_asset_folder: true

但你每次通过命令行新建一个文章时，它会自动在 _posts 文件夹下生成一个同名文件夹，你可以将文章图片都放在该文件夹中，此时引用格式为：

1
![](example.png)

但是，这并不是特别方便，特别是对于需要通过别的阅读器，比如 Typora 等进行阅读。如果你希望维持相对路径格式又能对图片进行分类，你可以通过修改 Typora 设置来进行，但我推荐使用插件 hexo-asset-link 插件，这个插件可以保留你原本写的路径结构，即：

1
![](./文章名/example.png)

安装和配置方法如下：

Terminal window

1
npm install hexo-asset-link --save

在 _config.yml 中添加：

1
asset_link:
2
  enable: true
3
  post_asset_folder: true

重新生成并部署即可！

其余部分暂略；

4.4 部署 Hexo 博客#

4.4.x 部署 Hexo 博客到云服务器#

安装 hexo-deployer-git 插件；

Terminal window

1
npm install hexo-deployer-git --save

修改 _config.yml 中的 deploy 部分；

1
deploy:
2
  type: git
3
  repo: git@你的服务器别名_2:/home/git/hexo.git
4
  branch: master

运行以下命令进行部署；

Terminal window

1
hexo clean
2
hexo generate
3
hexo deploy

或直接写成：

Terminal window

1
hexo c && hexo g && hexo d

修改 Nginx 配置文件；

Terminal window

1
sudo vim /etc/nginx/nginx.conf

为：

1
user  nginx;
2
worker_processes  auto;
3

4
error_log  /var/log/nginx/error.log notice;
5
pid        /var/run/nginx.pid;
6

7
events {
8
    worker_connections  1024;
9
}
10

11
http {
12
    include       /etc/nginx/mime.types;
13
    default_type  application/octet-stream;
14

15
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
16
                      '$status $body_bytes_sent "$http_referer" '
17
                      '"$http_user_agent" "$http_x_forwarded_for"';
18

19
    access_log  /var/log/nginx/access.log  main;
20

21
    sendfile        on;
22
    keepalive_timeout  65;
23

24
    include /etc/nginx/conf.d/*.conf;
25
}

修改虚拟主机配置；

Terminal window

1
sudo vim /etc/nginx/conf.d/default.conf

如果没有域名，则修改为：

1
server {
2
    listen        80;
3
    listen   [::]:80;
4
    server_name  你的公网IP;
5

6
    location / {
7
        root   /data/hexo;
8
        index  index.html index.htm;
9
    }
10

11
    error_page   500 502 503 504  /50x.html;
12
    location = /50x.html {
13
        root   /usr/share/nginx/html;
14
    }
15
}

如果仅有域名，则修改为：

1
server {
2
    listen        80;
3
    listen   [::]:80;
4
    server_name  yourdomain.com;
5

6
    location / {
7
        root   /data/hexo;
8
        index  index.html index.htm;
9
    }
10

11
    error_page   500 502 503 504  /50x.html;
12
    location = /50x.html {
13
        root   /usr/share/nginx/html;
14
    }
15
}

如果你有域名并申请过 SSL 安全证书，则修改为：

1
server {
2
    listen        80;
3
    listen   [::]:80;
4
    server_name  yourdomain.com;
5

6
    rewrite ^(.*)$ https://${server_name}$1 permanent;
7
}
8

9
server {
10
    listen 443 ssl;
11
    server_name yourdomain.com;
12

13
    ssl_certificate     /path/to/your/cert.pem;
14
    ssl_certificate_key /path/to/your/key.pem;
15

16
    ssl_session_cache   shared:SSL:1m;
17
    ssl_session_timeout 5m;
18
    ssl_ciphers         HIGH:!aNULL:!MD5;
19
    ssl_prefer_server_ciphers on;
20

21
    location / {
22
        root   /data/hexo;
23
        index  index.html index.htm;
24
        proxy_set_header   X-Real-IP        $remote_addr;
25
        proxy_set_header   Host             $http_host;
26
        proxy_set_header   X-Forwarded-For  $proxy_add_x_forwarded_for;
27
    }
28

29
    error_page   500 502 503 504  /50x.html;
30
    location = /50x.html {
31
        root   /usr/share/nginx/html;
32
    }
33
}

展开收起

注意将上面的域名、SSL 证书的路径字段替换为你实际的。

启动 Nginx 进程；

Terminal window

1
sudo systemctl start nginx
2
sudo systemctl status nginx
3
sudo systemctl reload nginx

阿里云服务器一般默认开放了 80 和 443 端口，如果服务商不同，请自行开放防火墙；

配置域名解析（如果没有域名，则无需进行这一步）；

如果你使用的是阿里云的 DNS，那么你需要登录域名管理后台，添加一条 A 记录：

主机记录	类型	记录值	TTL
blog	A	你的公网IP	600(s)

解析是否生效可以通过以下命令进行验证：

Terminal window

1
ping yourdomain.com

如果你的域名 DNS 指向了非服务商，比如我使用了 Cloudflare 的 DNS，那么你需要在 Cloudflare 的控制面板中设置，添加 A 记录：

类型	主机名	内容（IP 地址）	TTL	代理状态
A	blog	你的服务器公网IP	自动	关闭小云朵（点一下变灰）

说明：如果你只是做博客访问，把“代理状态”的小云朵关闭（变灰），否则 Nginx 会收到 Cloudflare 的 IP 而不是你用户的真实 IP；

特别说明：

如果你使用的是中国大陆的服务器，那么需要提交备案申请，未备案域名将无法通过 HTTP/HTTPS 正常访问，云服务商会限制端口 80 和 443。如果你想通过云服务器部署个人博客，请遵循有关规定。不过我懒。

补充：

备案时应该要求你的域名 DNS 指向阿里云 DNS，否则存在不通过的风险。（我记得备案的时候用途就不能写个人博客来着）

4.4.y 配置服务到 Github Page 或其他托管平台#

把 Hexo 部署到 GitHub Pages 或其他托管平台并绑定你的域名也同样可行且省事，而且完全免费、无需备案。

新建一个 Github 仓库；

命名为：（啥也不用勾选，空的公开仓库即可）

1
XXX.github.io

修改 Hexo 的配置文件；

将 deploy 部分改为：

1
deploy:
2
  type: git
3
  repo: 你的仓库地址
4
  branch: main

如果你默认 GitHub 用 master 分支，那就把 branch 改为 master 即可；

绑定域名；

首先，添加一个名为 CNAME 的文件到 source 目录下：

Terminal window

1
echo "yourdomain.com" > source/CNAME

类型	名称	值
CNAME	blog	XXX.github.io

确保开启了 小云朵（代理）图标，启用 CDN 与 HTTPS；

重新部署博客：

Terminal window

1
hexo clean && hexo g && hexo d

设置 GitHub Pages 部署配置；

在你的仓库中打开「Settings」→「Pages」，设置以下内容：

Source 设为：main 分支（或者 master，看你哪个在用）
Branch folder 选的是 / (root)
Custom domain 应该已填写为：yourdomain.com

在重新部署一次，如果 DNS 已生效，那么就可以正常浏览你的博客了！

五、WebDav 网盘服务部署#

5.1 说明#

Zotero 默认提供 300M 大小的云同步空间，但同步较慢，且文献一多（主要是附件占用，不同步附件基本上用不完）空间就不够用了，好在它还提供了第三方云盘服务支持，本体直接支持 WebDav（坚果云等），或者使用插件来使用第三方网盘服务（比如百度云这种），区别如下：（来源：Zotero中文社区）

对比项	Zotero 官方存储空间 / WebDAV 同步	Attanger + 同步盘方案
配置难度	简单	复杂
多台电脑上同步附件	是	是
更改附件存储位置/自定义存放附件的文件夹名	否	是
支持的网盘种类	很少	较多
是否可以在移动端 Zotero/Papership 打开附件	是	否

5.2 部署步骤#

安装完整的 Nginx 模块：

之前已经介绍并且配置过 Nginx 做端口转发，不过默认的 Nginx 并不提供 WebDav 模块，需要安装完整版：

Terminal window

1
sudo apt update
2
sudo apt install nginx-full apache2-utils

注意需要使用 www-data 用户组，它是 Nginx 的默认运行用户，具有读写权限，权限范围仅有 Web 服务需要访问的目录，确保安全性。

Terminal window

1
sudo mkdir -p /var/www/zotero
2
sudo chown -R www-data:www-data /var/www/zotero

创建 WebDav 用户：

Terminal window

1
# 创建用户
2
sudo htpasswd -c /etc/nginx/webdav.passwd username
3

4
# 之后添加用户
5
sudo htpasswd /etc/nginx/webdav.passwd anotherusername

回车后会让你输出密码。

配置 Nginx：

编辑配置文件：（也可以在默认配置文件 /etc/nginx/sites-available/default 中编辑）

Terminal window

1
sudo nano /etc/nginx/conf.d/webdav.conf

具体内容可参考：

1
server {
2
    listen 80;
3
    server_name yourdomainname.com;
4

5
    location /zotero/ {
6
        alias /var/www/zotero/;
7
        autoindex on;
8
        dav_methods PUT DELETE MKCOL COPY MOVE;
9
        dav_ext_methods PROPFIND OPTIONS;
10
        create_full_put_path on;
11
        dav_access user:rw group:rw all:r;
12

13
        auth_basic "Restricted";
14
        auth_basic_user_file /etc/nginx/webdav.passwd;
15

16
        client_max_body_size 2G;
17

18
        limit_except GET OPTIONS {
19
            allow all;
20
        }
21
    }
22
}

在 Zotero 中修改配置并验证是否生效：

打开 Zotero，在“设置” →\rightarrow→ “同步” →\rightarrow→ “文件同步”，选择 WebDav，填入你的服务器配置以及用户认证信息即可。

启用 HTTPS 以及证书认证；

可选，由于我的服务器没备案，这一步就省略了。

注：不定期随缘更新中…