企业官网建设流程全解析

每年结课季都会有一批同学被“计算机系统原理大作业”折磨到怀疑人生。这门课的大作业，说难也难，说简单也简单：你需要把课本里零零散散的门电路、触发器、指令周期、冯诺依曼结构这些东西，亲手串成一个能跑起来的系统。这篇文章我就拿最常见的“模拟CPU”选题为例，完整复盘一遍从选题、设计、编码、排错到答辩的全过程。无论你现在是在纠结选什么题目、卡在某段代码里出不来，还是不知道报告和演示怎么准备，都可以从里面找到直接能用的思路和方案。

我见过太多人一上来就奔着“搞个大新闻”去，结果写了几千行代码还跑不通第一个程序，然后彻底放弃。这个项目最忌讳的就是贪大。一个能正常执行8条指令、支持循环和输入输出的虚拟机，比一个写了20条指令但Bug多到根本跑不起来的半成品，在老师那里拿的分要高得多。你可以通过完整的、可复现的路线，在两天内写完核心代码，再用一天优化调试和文档，稳稳当当交出一份漂亮的大作业。

1. 项目选题与整体设计思路

1.1 为什么“模拟CPU”是计算机系统原理的黄金课题

计算机系统原理的大作业方向其实不少。常见的有进程调度模拟、页面置换算法模拟、Cache命中率模拟、用硬件描述语言写个小CPU，再就是我们这次要聊的纯软件虚拟机方案。每个方向都有价值，但“模拟CPU”有一个其他题目都难以替代的优势：它把“存储程序”这个计算机最核心的思想，从抽象概念变成了你眼见的现实。

做调度算法模拟，你处理的是一个个队列和优先级，虽然也是在模拟操作系统行为，但始终是站在“软件之上”看软件。做Cache模拟，本质上是写一个统计工具，重点在命中率曲线。而模拟CPU不一样，它逼迫你去实现一条指令的完整生命周期：内存怎么被组织、指令怎么被取出、操作数怎么被寻址、ALU怎么执行运算、结果怎么写回去，所有这些环节都缺一不可。做完之后，“程序在计算机里到底是怎么跑起来的”这个问题，你会有一个极其具体的答案。

再加上硬件描述语言方向对开发工具和调试手段的要求比较高，而且如果实验室环境不完善，卡在工具链上的时间可能会超过写代码的时间。用C或Python写一个虚拟机，门槛低、见效快、排错直观，尤其适合那些想把核心精力花在理解计算机原理本身、而不是和开发环境较劲的同学。

1.2 用什么语言和工具实现

先解决一个最常见的问题：用C还是用Python？

我的建议是，核心模拟器用C/C++，工具链用Python。这样搭配有两个原因。第一，C语言里指针和数组天然贴近硬件内存模型，你在模拟“内存”“寄存器”的时候，思维不会被高级语言的列表和字典带跑偏。比如你定义uint16_t memory[4096]，这就是一块实实在在的“内存”，访问越界、内存覆盖这些问题，在C下面更容易被感知和排查，这对理解计算机系统原理是有加分的。第二，C语言写出来的模拟器执行效率很高，就算一次性跑几十万条指令也只是毫秒级的事，Debug的时候你可以随意打印状态、反复重启，完全不用等。

Python在这里适合做“外围工具”，比如写一个迷你汇编器，把可读的汇编代码翻译成模拟器能加载的机器码。Python脚本开发快、字符串处理方便，用来做这种一次性工具再合适不过。当然，如果你Python很熟、C很生疏，也可以用纯Python写模拟器，实验数据规模小的时候完全够用。千万不要把精力浪费在纠结语言上，选自己顺手的，然后把时间留给原理和实现。

开发环境方面，Linux下用GCC加Makefile，Windows下用MinGW或者Visual Studio都可以。我自己的习惯是在Linux终端里配好gcc、vim、gdb三个工具，写起来很顺手。调试器用gdb，配合print打印寄存器状态，定位问题很快。这套组合覆盖了整个开发流程，不需要额外安装任何重型IDE。

1.3 明确目标与验收标准

动手写代码之前，一定要先想清楚这个东西最终要“长什么样”。别小看这一步，很多同学到后面代码越写越乱，就是因为一开始没有定义好范围和终点。

我给自己定的目标是这样的：实现一个16位虚拟机，内存空间4096个单元，CPU包含一个累加器ACC、一个程序计数器PC，外加一个指令寄存器IR。指令集方面，支持装载、存储、加法、减法、跳转、条件跳转、输入、输出、停机，一共9条指令。程序从内存地址0开始加载，数据段放在高地址区间。虚拟机启动后从PC=0开始取指、译码、执行，直到遇到HALT指令停机。

这个目标听起来不大，但它已经足够验证“存储程序”“指令周期”“分支跳转”“输入输出”这些核心概念了。更重要的是，它有一个非常清晰的验收标准：写一个从1加到N的汇编程序，编译成机器码加载进虚拟机，运行后输入5，能得到15，输入100，能得到5050。只要这个测试能通过，整个模拟器的正确性基本就有了底气。这种“小型但完整”的路线，既保证了深度，又不会把你拖进过度工程化的泥潭。

2. 核心设计拆解与关键技术细节

2.1 指令集设计：定义一台虚拟机的“官方语言”

指令集是整个模拟器的灵魂。它决定了一台虚拟机能做什么、不能做什么。设计指令集的核心原则是“够用且简单”。所谓够用，是指它要支持顺序执行、分支跳转、循环、输入输出、算术运算，这样才能做到图灵完备，任何可计算的问题在理论上都能用它表达。所谓简单，是指指令格式要统一、易解码，不要给自己挖坑。

我用的是16位定长指令格式。高4位放操作码，低12位放操作数。16位字长意味着最大能表达65535这个无符号数，12位地址意味着最多寻址4096个内存单元，这个规模做演示和测试完全足够了。指令表如下：

这个指令集的设计是有讲究的。LOAD/STORE负责内存与寄存器之间的数据搬运，ADD/SUB负责运算，JMP/JZ负责控制流，IN/OUT负责与外部的交互，HALT负责终止。你可以发现，没有任何一条“花哨”的指令，但组合起来就能写出循环和分支。

关于条件跳转，我特意只实现了JZ而不是完整的JLE、JGE等比较跳转指令。原因很简单，完整的跳转体系需要在CPU里增加标志位寄存器（ZF、CF、SF等），复杂度会显著上升。而JZ配合SUB指令，已经可以写出“相等时跳出循环”的逻辑，对课程要求来说完全够用。这种“用组合替代专用指令”的设计思路，本身就是计算机体系结构的核心思想之一。

2.2 寄存器、内存与程序布局

模拟器的存储体系可以分成三层来理解：内存、累加器、程序计数器。

内存就是一块uint16_t memory[4096]数组，它承担两大职责：存放指令，存放数据。这就是冯诺依曼结构的核心特征——指令和数据共用同一块存储空间。虚拟机启动时，把编译好的机器码写入内存的起始位置，然后PC从0开始运行。为了防止指令区把数据区覆盖掉，我的习惯是把指令从地址0开始放，数据段放在地址200以后，两个区域物理隔开，不容易互相踩踏。

ACC累加器是唯一的通用寄存器。为什么要采用“累加器架构”而不是通用寄存器组？因为累加器架构最简单，适合教学演示。所有算术运算都发生在ACC上，没有复杂的寄存器编号字段，指令格式可以做得非常规整。当然，这也意味着代码里大量的LOAD和STORE会频繁进出内存，但对我们模拟器来说性能不是问题，反而更能体现“内存和寄存器之间搬数据”的过程。

PC和IR则分别承载两个关键职责。PC保存下一条要执行的指令地址，每次取完指令后自动加1。IR保存当前正在执行的指令，在译码和执行阶段发挥作用。这两个寄存器是理解“指令周期”这个概念的关键，后面专门用一节来展开。

内存的地址空间设计还有一个细节：4096个单元，地址范围0到4095，刚好用12位二进制数表达。这里就有个隐患，如果操作数给出的地址被错误地按16位解析，就可能导致越界访问。所以取operand的时候一定要做掩码处理，只保留低12位，这点在后面的代码里会体现出来。

2.3 取指-译码-执行循环：计算机真正在做的事

计算机运行程序的本质，就是不断重复“取指、译码、执行”这三个步骤。我可以用一个收银台的类比帮你理解这个过程。

想象你是超市收银员，面前有一张长长的购物清单（程序），上面写着一条条操作指令。你的手里有一个计数器（PC），告诉你现在该看清单上的第几行。第一步，你按照计数器的指示，取出对应行内容（取指），然后把计数器加1，表示这一行已经处理过了。第二步，你读一读这一行写的是什么（译码），可能是“扫描一件商品”或“按下打折键”。第三步，你实际执行这个动作（执行），可能是扫码、计算金额、找零。处理完这一条之后，再看计数器指向的下一行，继续循环，直到清单最后写着“下班”为止。

对应到模拟器里，主循环的伪代码非常简洁：

while (running) { ir = memory[pc]; // 取指 pc = pc + 1; // PC自增 opcode = ir >> 12; // 译码：取出高4位操作码 operand = ir & 0xFFF; // 译码：取出低12位操作数 execute(opcode, operand); // 执行 }

两点需要特别留意。第一，PC的自增放在译码之前还是之后？我习惯放在取指之后、执行之前。这样无论当前指令是普通指令还是跳转指令，进入执行阶段时PC已经指向下一条指令了。如果当前指令是JMP或JZ且条件满足，直接在执行阶段覆盖PC即可；如果不满足条件，PC已经是正确的下一条地址，什么都不用改。第二，操作数一定要用& 0xFFF做掩码，把高4位的操作码屏蔽掉，否则你拿到的会是一个14位甚至16位的混杂数值。

这个循环会让程序一条条执行，直到遇到HALT指令，把running置为0，虚拟机停机。完整地理解这个过程，你就掌握了计算机系统原理课中最重要的一段。

3. 从零实现：实操步骤与核心代码解析

3.1 项目文件划分与数据结构

我建议把工程拆成几个清晰的部分，这样每个模块都能独立测试，出问题也容易定位。我的文件划分如下：

• vm.h：定义虚拟机结构体和函数接口
• vm.c：实现虚拟机核心逻辑
• assembler.py：微型汇编器，把汇编代码转成机器码
• sum.asm：测试用汇编程序
• machine.hex：汇编器生成的机器码文件，模拟器加载它
• Makefile：一键编译

虚拟机结构体的定义非常直观：

// vm.h #ifndef VM_H #define VM_H #include <stdint.h> #define MEM_SIZE 4096 typedef struct { uint16_t memory[MEM_SIZE]; uint16_t acc; // 累加器 uint16_t pc; // 程序计数器 int running; // 运行状态 } VM; void vm_init(VM *vm); void vm_load(VM *vm, const char *filename); void vm_run(VM *vm); void vm_dump(VM *vm); // 打印寄存器和内存状态 #endif

注意acc和pc都用了uint16_t类型，这是有讲究的。16位无符号整数天然模拟了16位机器的字长，加减运算溢出时自动截断到16位，正好对应真实CPU中寄存器溢出后丢弃高位的硬件行为。

vm_init负责清空内存和寄存器，把PC设为0，running设为1。这里有个很多新手会忽略的点：如果不显式清零内存，数组里的初始值是不确定的，加载程序和运行时会埋下难以排查的随机性Bug。

3.2 实现加载器与主循环

加载器的任务是把汇编器生成的机器码文件读入内存。机器码文件采用最简单的文本格式，每行两个十六进制数，第一个是内存地址，第二个是对应地址的数值：

void vm_load(VM *vm, const char *filename) { FILE *fp = fopen(filename, "r"); if (!fp) { perror("open file failed"); exit(1); } unsigned addr, value; while (fscanf(fp, "%x %hx", &addr, &value) == 2) { if (addr >= MEM_SIZE) { fprintf(stderr, "address out of range: %u\n", addr); exit(1); } vm->memory[addr] = (uint16_t)value; } fclose(fp); }

主循环就是前面提到的取指-译码-执行，用switch语句实现：

void vm_run(VM *vm) { while (vm->running) { uint16_t ir = vm->memory[vm->pc & 0xFFF]; // 取指 vm->pc = (vm->pc + 1) & 0xFFF; // PC自增 uint16_t opcode = ir >> 12; // 译码 uint16_t operand = ir & 0x0FFF; // 译码 switch (opcode) { case 0: // HALT vm->running = 0; break; case 1: // LOAD addr vm->acc = vm->memory[operand]; break; case 2: // STORE addr vm->memory[operand] = vm->acc; break; case 3: // ADD addr vm->acc += vm->memory[operand]; break; case 4: // SUB addr vm->acc -= vm->memory[operand]; break; case 5: // JMP addr vm->pc = operand; break; case 6: // JZ addr if (vm->acc == 0) { vm->pc = operand; } break; case 7: // IN scanf("%hu", &vm->acc); break; case 8: // OUT printf("%u\n", vm->acc); break; default: fprintf(stderr, "unknown opcode: %u\n", opcode); vm->running = 0; break; } } }

这里我做了几个关键防护。取指和PC自增时都用& 0xFFF做了地址掩码，保证地址永远落在0到4095之间，即使程序出错跳转到非法地址也不会导致数组越界崩溃，而是会读取到一个垃圾值然后继续执行。这样虽然程序逻辑可能错，但进程不会崩，调试体验好很多。

3.3 用Python写一个微型汇编器

直接用十六进制机器码写程序太反人类了。我写了一个不到40行的Python两遍扫描汇编器，它能把带标签的汇编代码翻译成机器码。

汇编代码长这样：

.org 0 IN 0 ; 读入N STORE 200 ; M[200] = N LOAD 204 ; ACC = 0 STORE 201 ; sum = 0 LOAD 203 ; ACC = 1 STORE 202 ; i = 1 .loop: LOAD 202 ; ACC = i ADD 201 ; ACC = i + sum STORE 201 ; sum = ACC LOAD 202 ; ACC = i SUB 200 ; ACC = i - N JZ .output ; if i == N jump to output LOAD 202 ; ACC = i ADD 203 ; ACC = i + 1 STORE 202 ; i = i + 1 JMP .loop .output: LOAD 201 ; ACC = sum OUT 0 ; print sum HALT .org 200 .word 0 ; M[200] = N，运行时由IN写入 .word 0 ; M[201] = sum .word 0 ; M[202] = i .word 1 ; M[203] = 1 .word 0 ; M[204] = 0

汇编器需要两遍扫描。第一遍先确定所有标签（比如.loop和.output）对应的内存地址，第二遍再根据标签地址生成机器码：

import sys OPS = { "HALT": 0, "LOAD": 1, "STORE": 2, "ADD": 3, "SUB": 4, "JMP": 5, "JZ": 6, "IN": 7, "OUT": 8 } def assemble(text): lines = text.strip().splitlines() labels = {} memory = [] addr = 0 # 第一遍：记录标签位置 for raw in lines: raw = raw.split(';')[0].strip() if not raw: continue if raw.endswith(':'): labels[raw[:-1]] = addr continue parts = raw.replace(',', ' ').split() if parts[0] == '.org': addr = int(parts[1]) elif parts[0] == '.word': addr += len(parts) - 1 else: addr += 1 # 第二遍：生成机器码 addr = 0 for raw in lines: raw = raw.split(';')[0].strip() if not raw: continue if raw.endswith(':'): continue parts = raw.replace(',', ' ').split() if parts[0] == '.org': addr = int(parts[1]) elif parts[0] == '.word': for token in parts[1:]: value = int(token) & 0xFFFF memory.append((addr, value)) addr += 1 else: op = OPS[parts[0]] if op in (1, 2, 3, 4, 5, 6): operand = labels[parts[1]] if parts[1] in labels else int(parts[1]) instruction = (op << 12) | (operand & 0xFFF) else: instruction = op << 12 memory.append((addr, instruction)) addr += 1 return memory if __name__ == '__main__': with open("sum.asm", "r", encoding="utf-8") as f: code = f.read() result = assemble(code) with open("machine.hex", "w") as f: for addr, value in result: f.write(f"{addr:04x} {value:04x}\n")

两遍扫描是汇编器的基础思想，值得好好理解。第一遍的目的只是为了拿到所有标签的地址，第二遍才能真正生成指令。如果你在第二遍里遇到“标签还未定义”之类的问题，多半就是第一遍的地址计算和实际不一致，最常见的坑在.word伪指令的地址推进逻辑上。

机器码文件生成后长这样：

0000 7000 0001 20c8 0002 10cc 0003 20c9 ...

第一列是内存地址，第二列是指令的十六进制编码。注意看STORE 200变成了20c8，其中操作码2占高4位，地址0x0c8占低12位，一目了然。

3.4 测试：让模拟器跑通“1加到N”

有了模拟器和汇编器，就可以做完整的联调了。先在终端里跑汇编器：

python3 assembler.py

然后编译并运行C模拟器：

gcc -o vm vm.c ./vm machine.hex

输入5回车，输出15。再输入100回车，输出5050。第一次看到这个结果的时候，那种成就感是很强烈的，因为这不是一段用高级语言写好的for循环，而是你亲手实现的一台机器，切切实实地按照你的指令完成了计算。

建议在测试时多准备几个用例：

• 输入0，应该输出0，验证边界条件
• 输入1，应该输出1，验证最小非零情况
• 输入100，应该输出5050，验证大规模累加

每个用例都通过，才能有信心这段程序是真的正确，而不是碰巧跑对了一次。

3.5 调试利器：状态转储与单步执行

写模拟器这种项目，最怕的就是程序跑完发现结果不对，但不知道中间哪个环节出了问题。我的办法是给虚拟机加一个vm_dump函数，把所有寄存器和指定内存段的状态都打印出来：

void vm_dump(VM *vm) { printf("PC=%04x ACC=%04x running=%d\n", vm->pc, vm->acc, vm->running); for (int i = 0; i < MEM_SIZE; i += 8) { int nonzero = 0; for (int j = 0; j < 8; j++) { if (vm->memory[i + j] != 0) { nonzero = 1; break; } } if (nonzero) { printf("%04x: ", i); for (int j = 0; j < 8; j++) { printf("%04x ", vm->memory[i + j]); } printf("\n"); } } }

这个函数只打印非零内存区域，避免4096个全是0的地址刷屏。调试时每一步结束都调一次vm_dump，就能清清楚楚看到PC和ACC是怎么变化的。另一个更精细的调试手段是加一个“单步模式”，每次执行一条指令后等待用户按回车再继续，这样就能一条条观察程序轨迹。

千万不要小看这种“土办法”。在我接触过的所有调试手段里，打印状态仍然是最直观、最不容易出错的。gdb虽然强大，但对于这个规模的虚拟机，printf加vm_dump已经能解决90%的问题。

4. 大作业踩坑实录与排查手册

4.1 PC自增位置不对导致“无限循环”和“跳过指令”

这个坑我印象太深了。早期版本我把PC自增放在整个switch执行完之后，结果每条指令执行完后PC已经指向下一条指令的位置，我又在末尾加了一次自增，导致每执行一条指令就跳过一条指令。程序以一种匪夷所思的方式“跳跃式”执行，清理所有寄存器和内存都找不出原因。

后来我把取指和PC自增耦合在一起，放在译码之前，问题立刻消失。经验教训是：PC更新是取指阶段的一部分，不是在执行阶段结束时发生的。它应该紧跟在“从内存取出当前指令”之后，这样到了执行阶段，PC已经天然指向下一条指令，跳转指令想要覆盖PC也可以直接覆盖，所有逻辑都清晰了。

4.2 操作数没有掩码导致访问超预期地址

另一个让我折腾了半小时的Bug，是忘记对操作数做掩码。指令ir = 0x20C8，高4位操作码是2，但如果你直接用int operand = ir & 0xFFFF来取操作数，拿到的依然是0x20C8，而不是想要的0x0C8。这下内存访问就直接越界或者访问到完全错误的指令区了。

解决方案就是在译码阶段用operand = ir & 0x0FFF把高4位彻底屏蔽掉。类似的掩码问题还会出现在PC上，要对4096取模防止越界。这种位运算的小细节，恰恰是计算机系统原理课最看重的“位级理解”能力。

4.3 数据段与指令段重叠导致程序被“篡改”

有一版我偷懒，把数据段直接放在指令段后面，结果测试循环程序的时候，程序在运行时不断往数据区写值，写到最后把后面的指令也覆盖掉了。程序跑着跑着就变成了垃圾指令，乱跳一气。

这个问题的本质是“存储程序”和“数据即代码”的暧昧关系。解决方式很简单：把数据段的起始地址设得离指令区域足够远。我在示例里让数据段从地址200开始，程序指令区最多占用前几十个单元，完全不会冲突。如果你也想用.org自定义内存布局，务必先算清楚指令最多占多少地址。

4.4 汇编器标签计算偏差

两遍扫描汇编器里，标签地址计算错误是非常隐蔽的。特别是.word伪指令，每遇到一个常量就要多占一个内存单元，第一遍扫描时忘记把这个距离加上，就会导致所有标签整体偏移。

解决这个问题的办法是，第一遍和第二遍的地址推进逻辑必须完全一致。我在代码里专门用了同一个addr变量，并且在两遍循环中重复了.word推进逻辑，保证两遍看到的内存布局完全一致。如果你在写自己的汇编器，建议把“这个伪指令占多少内存单元”的逻辑单独抽成一个函数，两遍都调它，从根上消灭不一致的可能。

4.5 快速定位问题的三板斧

我把自己的排错流程总结成了三板斧，遇到问题照着做，效率很高：

1. 看PC和ACC的打印轨迹。先确认PC是不是按预期走了，跳转指令生效没有，再确认ACC里的值变化是否符合算术逻辑。
2. 拆小问题。在循环程序的第1条、第6条、第11条等关键位置加打印，看看数据在哪一步开始不对。
3. 对照机器码。汇编代码和机器码之间可能藏着汇编器的Bug，手工把几条关键指令按“操作码<<12|操作数”算一遍，比对汇编器输出的hex文件，能快速确认是编译环节还是执行环节出错。

5. 扩展方向与答辩加分技巧

5.1 加一条新指令有多简单

这个模拟器最有价值的地方之一是它的可扩展性。加新指令只需要做三件事：在汇编器的OPS字典里加一个助记符，在模拟器的switch里加一个case，再在文档里更新指令表。

比如你想加一条减法立即数指令SUBI，只需要把操作码9定义为“ACC减去立即数”，执行时直接从operand取数值而不是从内存取数。类似的，DEC、INC、NOT、AND、OR、XOR都能很简单地塞进去。这种“改一个枚举、加一个分支”的体验，会让你对指令集架构的扩展性有极深的体会。

5.2 加分项：流水线与Cache模拟

如果做完基础版还有余力，可以加两个非常加分的扩展。

一个是五级流水线模拟。在现有执行循环里，把取指、译码、执行、访存、写回拆成五个阶段，模拟一下流水线处理。你不需要实现真实的时间并行，只需要按阶段推进，并制造几个数据相关冲突，展示一下什么是冒险和停顿。这个扩展能直接呼应当前CPU设计的核心思想，答辩时老师一定喜欢。

另一个是Cache模拟。给虚拟机加一块模拟Cache，每次LOAD和STORE都先查Cache，统计命中率。你可以在汇编程序里构造一些局部性较差和较好的数据访问模式，对比命中率曲线。这个扩展把你从“CPU设计”延伸到了“存储层次”这个重要主题，内容一下子丰厚起来。

5.3 写好报告和演示的要点

报告是决定最后分数的另一半。结构上可以这样安排：背景与选题动机、系统整体架构、指令集设计、核心实现细节、测试结果展示、遇到问题与解决过程、总结与展望。其中“遇到问题与解决过程”往往最受老师重视，因为这体现了真实的思考过程。比如我前面写的PC自增位置Bug、数据覆盖指令区这些问题，都可以原原本本写进去，再附上排查思路，比任何“本项目运行良好”的套话都更有说服力。

演示环节准备一个固定脚本：第一步展示程序加载和运行1到N的累加，第二步展示指令集扩展，比如现场加一条新指令再重新汇编运行，第三步展示内存转储功能，解释程序在运行过程中数据和指令是怎么分布的。通常网上能找到的题目要求，比如“计算机系统原理13015”这类编号的任务，核心验收就是这三样：系统能跑、原理讲清、代码好读。照着这个标准去准备，基本不会失手。

做计算机系统原理大作业的那几天，是我整个学期里对计算机理解加深最快的一段时间。以前看“程序被CPU执行”总觉得是个抽象结论，直到自己亲手写出一台能跑程序的虚拟机，才真正明白什么叫“一条指令一条生命周期”。哪怕这台虚拟机只有9条指令，跑个累加程序都要十几条指令，但当它真的在控制台输出结果时，那种“整台机器都是我造的”的感觉是任何知识都替代不了的。

最后再分享一个小经验：不要害怕从最简单的东西做起。很多同学担心自己写的模拟器太简陋，非要一开始就上复杂指令集、上流水线、上Cache，结果代码量失控，最后连基本功能都交不出来。我见过不少老师的评价标准里，“完整运行的小系统”远比“功能零散的大项目”得分高。把基础功能做扎实、测试做完整、文档写清楚，你已经超过至少一半的同学了。