手写查字在线避坑指南：3天搞定手写实现
看了一堆教程还是不会写项目？别慌，这是大多数人的常态。
痛点在于你只看了语法，没动过脑子去拆解逻辑。
今天咱们不整虚的，直接上手【手写查字在线】的【手写实现】。
1. 项目目标：到底要做什么？
很多学员一上来就问：“老师，用什么框架？”
停！先想清楚需求。这个项目的核心是**“查”和“在线”。
简单来说，就是用户输入一个汉字，系统实时反馈这个字的拼音、部首、笔画数，甚至还能手写识别。
但为了降低入门门槛，我们第一版只做“字库查询+前端交互”。
为什么这么定？
因为【手写查字在线】如果一上来就上OCR（光学字符识别），你会被模型训练劝退。
我们要的是可复现的工程化能力**。
目标是：用户输入汉字，毫秒级返回数据。
界面要有“在线”的感觉，比如Loading状态、错误提示。
代码结构清晰，能直接作为简历里的“个人项目”写进去。这里有个关键点：数据从哪来？
别自己造字库，那是几GB的大坑。
我们要用公开的API。
我推荐用 hanzi.db 或者一些开源的JSON字库文件。
为了演示方便，我们模拟一个本地JSON文件作为后端数据源。
这符合【手写实现】的初衷：控制每一个字节，而不是黑盒调用。
2. 目录结构：像老手一样组织代码
新手写代码喜欢把所有东西扔进 index.js。
老手？老手知道模块化是工程化的第一块砖。
我们要用 Node.js + Express 搭建后端，用原生 JavaScript (Vanilla JS) 做前端。
为什么不用 Vue/React？
因为【手写实现】的核心是理解底层。
当你用原生JS搞懂了DOM操作、Promise、Fetch，再学框架就是降维打击。
以下是项目目录，请照着敲，别偷懒：
handwriting-query/
├── public/ # 前端静态资源
│ ├── css/
│ │ └── style.css
│ ├── js/
│ │ └── app.js
│ └── index.html
├── src/ # 后端源码
│ ├── routes/
│ │ └── api.js # 路由处理
│ ├── services/
│ │ └── dictService.js # 数据服务层
│ └── app.js # 入口文件
├── data/
│ └── hanzi.json # 模拟字库数据
├── package.json
└── README.md划重点：
services 层是灵魂。
它负责从 data/hanzi.json 读取数据，清洗、格式化，然后吐给路由。
如果以后你要把本地JSON换成 MySQL 或 Redis，你只需要改 dictService.js，其他代码一行不用动。
这就是解耦。面试官最爱问这个。
3. 核心代码实现：逐行拆解
3.1 后端：Express 极简API
打开终端，初始化项目：
npm init -y
npm install express
新建 src/app.js：
const express = require('express');
const path = require('path');
const apiRoutes = require('./routes/api');const app = express();// 1. 静态文件服务：让浏览器能访问 public 下的文件
app.use(express.static(path.join(__dirname, '../public')));// 2. 挂载API路由
app.use('/api', apiRoutes);// 3. 启动服务
const PORT = 3000;
app.listen(PORT, () = {console.log(`【手写查字在线】服务已启动: http://localhost:${PORT}`);
});代码不多，但每一行都有讲究。
express.static 是关键。
很多人手写项目时，前端和后端端口搞混，导致跨域报错。
这里我们把前端静态文件直接由 Express 托管，同源访问，彻底干掉 CORS 问题。
这也是【手写实现】中体现工程思维的地方：能简单解决的，绝不复杂化。
3.2 数据服务层：模拟高性能查询
新建 data/hanzi.json，放入几条测试数据：
[{ char: 你, pinyin: nǐ, radical: 亻, stroke: 7 },{ char: 好, pinyin: hǎo, radical: 女, stroke: 6 },{ char: 在, pinyin: zài, radical: 土, stroke: 6 }
]新建 src/services/dictService.js：
const fs = require('fs');
const path = require('path');// 模块加载时，一次性读取文件到内存
// 注意：生产环境大数据量时，这里要换成数据库或缓存
const dataPath = path.join(__dirname, '../../data/hanzi.json');
let hanziMap = new Map();try {const raw = fs.readFileSync(dataPath, 'utf-8');const arr = JSON.parse(raw);// 建立 Map，Key 是汉字，Value 是详细信息// Map 的查找复杂度是 O(1)，比数组的 find() O(n) 快得多arr.forEach(item = {hanziMap.set(item.char, item);});console.log(`加载字库成功，共 ${hanziMap.size} 个字`);
} catch (err) {console.error('字库加载失败:', err);
}/*** 查询单个汉字* @param {string} char - 汉字* @returns {Object|null} - 查询结果或 null*/
exports.getHanziInfo = (char) = {if (!char || char.length !== 1) {return null; // 简单的参数校验}return hanziMap.get(char) || null;
};这里有个大坑：
很多新手会在每次请求时都 fs.readFileSync。
千万别！
文件I/O是阻塞且昂贵的。
我们在模块初始化时（require 时）就把数据读进内存，建立 Map 索引。
后续查询，纯内存操作，速度极快。
这就是性能优化的第一步：减少I/O，利用缓存。
3.3 路由层：规范HTTP响应
新建 src/routes/api.js：
const express = require('express');
const router = express.Router();
const { getHanziInfo } = require('../services/dictService');/*** GET /api/hanzi?char=你*/
router.get('/hanzi', (req, res) = {const { char } = req.query;// 1. 参数校验if (!char) {return res.status(400).json({ code: 400, msg: '缺少参数 char' });}// 2. 查询数据const info = getHanziInfo(char);// 3. 统一响应格式if (info) {res.json({code: 200,msg: 'success',data: info});} else {res.status(404).json({code: 404,msg: '未找到该汉字',data: null});}
});module.exports = router;注意 res.status(400) 和 res.status(404)。
不要所有错误都返回 200！
这是很多初级开发者的通病。
状态码是 HTTP 协议的一部分，用对状态码，前端的 fetch 拦截器才能正确捕获异常。
这也是参考 MDN Web Docs 中关于 HTTP 状态码的标准定义来写的。
3.4 前端：原生 JS 的优雅实现
新建 public/index.html：
!DOCTYPE html
html lang=zh-CN
headmeta charset=UTF-8title手写查字在线 - Demo/titlelink rel=stylesheet href=css/style.css
/head
bodydiv class=containerh1手写查字在线/h1div class=search-boxinput type=text id=charInput placeholder=请输入单个汉字 maxlength=1button id=queryBtn查询/button/divdiv id=result class=result/div/divscript src=js/app.js/script
/body
/html新建 public/js/app.js：
const input = document.getElementById('charInput');
const btn = document.getElementById('queryBtn');
const resultDiv = document.getElementById('result');// 封装 Fetch 请求
async function queryHanzi(char) {// 清空旧结果，显示 LoadingresultDiv.innerHTML = 'p查询中.../p';try {const response = await fetch(`/api/hanzi?char=${encodeURIComponent(char)}`);// 检查 HTTP 状态码if (!response.ok) {throw new Error(`HTTP error! status: ${response.status}`);}const data = await response.json();// 检查业务状态码if (data.code === 200) {renderResult(data.data);} else {resultDiv.innerHTML = `p class=error${data.msg}/p`;}} catch (error) {resultDiv.innerHTML = `p class=error网络错误: ${error.message}/p`;}
}// 渲染结果
function renderResult(info) {if (!info) {resultDiv.innerHTML = 'p无数据/p';return;}const html = `div class=cardh2${info.char}/h2p拼音: strong${info.pinyin}/strong/pp部首: strong${info.radical}/strong/pp笔画: strong${info.stroke}/strong/p/div`;resultDiv.innerHTML = html;
}// 绑定事件
btn.addEventListener('click', () = {const val = input.value.trim();if (!val) {alert('请输入汉字');return;}queryHanzi(val);
});// 支持回车键查询
input.addEventListener('keypress', (e) = {if (e.key === 'Enter') {queryHanzi(input.value.trim());}
});前端避坑指南：encodeURIComponent：虽然汉字通常不需要编码，但养成习惯。如果用户输入了特殊字符，不编码会导致 URL 解析错误。
async/await：比 .then() 链条清晰得多。
try/catch：网络请求一定会失败（断网、超时），必须有捕获。
XSS 防护：这里我们用了模板字符串插入。
警告！ 如果数据来自用户输入，直接插入 innerHTML 是危险的。
在本例中，数据来自后端，相对安全。
但在真实项目中，务必使用 DOM API 创建节点，或对数据进行转义。
参考 MDN Web Docs 中关于 Cross-site scripting (XSS) 的安全指南，了解如何安全地处理动态内容。4. 运行与测试：像工程师一样验证
代码写完了，别急着吹牛。
跑起来，才是真的。在项目根目录运行：node src/app.js
浏览器打开 http://localhost:3000
输入“你”，点击查询。预期结果：
显示拼音 nǐ，部首 亻，笔画 7。
怎么测试边界情况？输入空字符：前端会提示“请输入汉字”。
输入英文 A：后端返回 404，前端显示“未找到该汉字”。
输入两个汉字 你好：前端 maxlength=1 限制了输入，后端也会校验 char.length !== 1。
断网测试：关闭服务器，点击查询。前端应捕获网络错误，而不是白屏或无限 Loading。进阶测试技巧：
打开浏览器开发者工具（F12）- Network 标签。
观察 /api/hanzi 请求。状态码是 200 还是 404？
响应时间（Time）是多少？应该小于 10ms。
Response 里的 JSON 结构是否符合预期？如果你发现响应很慢：
检查是不是每次请求都在读文件？
回到 dictService.js，确认 hanziMap 是否在模块加载时初始化。
如果是，那速度应该很快。
如果慢，可能是 Node.js 事件循环被阻塞了？
在这个简单场景下，同步读取小文件不会阻塞太久，但生产环境建议用 readFile 异步加载，或者启动时预加载。
5. 优化扩展：从Demo到生产
现在的版本能跑，但离“生产级”还有距离。
面试时，你可以主动提出以下优化点，体现你的成长型思维。
5.1 性能优化：防抖（Debounce）
现在用户每点一次按钮，发一次请求。
如果用户想边输入边查呢？
直接绑定 input 事件会疯狂发请求，服务器会被打爆。
解决方案：防抖。
修改 public/js/app.js：
// 简单的防抖函数
function debounce(func, wait) {let timeout;return function (...args) {clearTimeout(timeout);timeout = setTimeout(() = {func.apply(this, args);}, wait);};
}const debouncedQuery = debounce((char) = {if (char) queryHanzi(char);
}, 300); // 300ms 防抖// 替换原来的 input 事件
input.addEventListener('input', (e) = {debouncedQuery(e.target.value.trim());
});效果：
用户停止输入 300ms 后，才发起请求。
体验更流畅，服务器压力更小。
5.2 后端优化：缓存层
如果字库有 10 万条，内存 Map 可能占用几百 MB。
怎么办？
引入 Redis。
改造 dictService.js：
// 伪代码：引入 redis 客户端
const redis = require('redis');
const client = redis.createClient();exports.getHanziInfo = async (char) = {// 1. 先查 Redisconst cached = await client.get(`hanzi:${char}`);if (cached) {return JSON.parse(cached);}// 2. 缓存未命中，查内存 Map 或 数据库const info = hanziMap.get(char);// 3. 如果查到，存入 Redis，设置过期时间（比如 1 小时）if (info) {await client.set(`hanzi:${char}`, JSON.stringify(info), { EX: 3600 });}return info;
};注意：
这会把 getHanziInfo 变成异步函数。
路由层也需要改成 async/await。
这就是技术债务的偿还过程。
先跑通，再优化。
不要一开始就过度设计。
5.3 安全性：限流（Rate Limiting）
防止有人恶意刷接口。
使用 express-rate-limit 中间件。
const rateLimit = require('express-rate-limit');
const limiter = rateLimit({windowMs: 15 * 60 * 1000, // 15 分钟max: 100, // 每个 IP 最多 100 次请求
});// 应用到 /api 路由
app.use('/api', limiter, apiRoutes);简单几行代码，就能挡住 90% 的爬虫和攻击。
这也是工程化的一部分。
6. 小结：你学到了什么？
回头看看，我们从零搭建了一个【手写查字在线】的小项目。
你学会了：模块化思维：前端、后端、数据服务层分离。
性能意识：内存缓存、Map 索引、防抖。
规范意识：HTTP 状态码、统一响应格式、错误处理。
安全意识：XSS 防护、限流。这些，才是面试官想看的。
不是你会用 Vue，而是你懂原理。
当你用原生 JS 手写实现过一遍，再去看 Vue 的响应式原理、React 的虚拟 DOM，你会发现它们不过如此。
最后，抛个问题：
你在项目里踩过这个坑吗？
比如：防抖函数写错了，导致最后一次的输入没发出去？
Map 的 Key 冲突，导致查错了字？
跨域问题，折腾了三天才解决？评论区聊聊，互相避雷。
你的经历，可能是别人的捷径。
手写查字在线避坑指南：3天搞定手写实现
手写查字在线避坑指南：3天搞定手写实现
看了一堆教程还是不会写项目？别慌，这是大多数人的常态。
痛点在于你只看了语法，没动过脑子去拆解逻辑。
今天咱们不整虚的，直接上手【手写查字在线】的【手写实现】。
1. 项目目标：到底要做什么？
很多学员一上来就问：“老师，用什么框架？”
停！先想清楚需求。这个项目的核心是**“查”和“在线”。
简单来说，就是用户输入一个汉字，系统实时反馈这个字的拼音、部首、笔画数，甚至还能手写识别。
但为了降低入门门槛，我们第一版只做“字库查询+前端交互”。
为什么这么定？
因为【手写查字在线】如果一上来就上OCR（光学字符识别），你会被模型训练劝退。
我们要的是可复现的工程化能力**。
目标是：用户输入汉字，毫秒级返回数据。
界面要有“在线”的感觉，比如Loading状态、错误提示。
代码结构清晰，能直接作为简历里的“个人项目”写进去。这里有个关键点：数据从哪来？
别自己造字库，那是几GB的大坑。
我们要用公开的API。
我推荐用 hanzi.db 或者一些开源的JSON字库文件。
为了演示方便，我们模拟一个本地JSON文件作为后端数据源。
这符合【手写实现】的初衷：控制每一个字节，而不是黑盒调用。
2. 目录结构：像老手一样组织代码
新手写代码喜欢把所有东西扔进 index.js。
老手？老手知道模块化是工程化的第一块砖。
我们要用 Node.js + Express 搭建后端，用原生 JavaScript (Vanilla JS) 做前端。
为什么不用 Vue/React？
因为【手写实现】的核心是理解底层。
当你用原生JS搞懂了DOM操作、Promise、Fetch，再学框架就是降维打击。
以下是项目目录，请照着敲，别偷懒：
handwriting-query/
├── public/ # 前端静态资源
│ ├── css/
│ │ └── style.css
│ ├── js/
│ │ └── app.js
│ └── index.html
├── src/ # 后端源码
│ ├── routes/
│ │ └── api.js # 路由处理
│ ├── services/
│ │ └── dictService.js # 数据服务层
│ └── app.js # 入口文件
├── data/
│ └── hanzi.json # 模拟字库数据
├── package.json
└── README.md划重点：
services 层是灵魂。
它负责从 data/hanzi.json 读取数据，清洗、格式化，然后吐给路由。
如果以后你要把本地JSON换成 MySQL 或 Redis，你只需要改 dictService.js，其他代码一行不用动。
这就是解耦。面试官最爱问这个。
3. 核心代码实现：逐行拆解
3.1 后端：Express 极简API
打开终端，初始化项目：
npm init -y
npm install express
新建 src/app.js：
const express = require('express');
const path = require('path');
const apiRoutes = require('./routes/api');const app = express();// 1. 静态文件服务：让浏览器能访问 public 下的文件
app.use(express.static(path.join(__dirname, '../public')));// 2. 挂载API路由
app.use('/api', apiRoutes);// 3. 启动服务
const PORT = 3000;
app.listen(PORT, () = {console.log(`【手写查字在线】服务已启动: http://localhost:${PORT}`);
});代码不多，但每一行都有讲究。
express.static 是关键。
很多人手写项目时，前端和后端端口搞混，导致跨域报错。
这里我们把前端静态文件直接由 Express 托管，同源访问，彻底干掉 CORS 问题。
这也是【手写实现】中体现工程思维的地方：能简单解决的，绝不复杂化。
3.2 数据服务层：模拟高性能查询
新建 data/hanzi.json，放入几条测试数据：
[{ char: 你, pinyin: nǐ, radical: 亻, stroke: 7 },{ char: 好, pinyin: hǎo, radical: 女, stroke: 6 },{ char: 在, pinyin: zài, radical: 土, stroke: 6 }
]新建 src/services/dictService.js：
const fs = require('fs');
const path = require('path');// 模块加载时，一次性读取文件到内存
// 注意：生产环境大数据量时，这里要换成数据库或缓存
const dataPath = path.join(__dirname, '../../data/hanzi.json');
let hanziMap = new Map();try {const raw = fs.readFileSync(dataPath, 'utf-8');const arr = JSON.parse(raw);// 建立 Map，Key 是汉字，Value 是详细信息// Map 的查找复杂度是 O(1)，比数组的 find() O(n) 快得多arr.forEach(item = {hanziMap.set(item.char, item);});console.log(`加载字库成功，共 ${hanziMap.size} 个字`);
} catch (err) {console.error('字库加载失败:', err);
}/*** 查询单个汉字* @param {string} char - 汉字* @returns {Object|null} - 查询结果或 null*/
exports.getHanziInfo = (char) = {if (!char || char.length !== 1) {return null; // 简单的参数校验}return hanziMap.get(char) || null;
};这里有个大坑：
很多新手会在每次请求时都 fs.readFileSync。
千万别！
文件I/O是阻塞且昂贵的。
我们在模块初始化时（require 时）就把数据读进内存，建立 Map 索引。
后续查询，纯内存操作，速度极快。
这就是性能优化的第一步：减少I/O，利用缓存。
3.3 路由层：规范HTTP响应
新建 src/routes/api.js：
const express = require('express');
const router = express.Router();
const { getHanziInfo } = require('../services/dictService');/*** GET /api/hanzi?char=你*/
router.get('/hanzi', (req, res) = {const { char } = req.query;// 1. 参数校验if (!char) {return res.status(400).json({ code: 400, msg: '缺少参数 char' });}// 2. 查询数据const info = getHanziInfo(char);// 3. 统一响应格式if (info) {res.json({code: 200,msg: 'success',data: info});} else {res.status(404).json({code: 404,msg: '未找到该汉字',data: null});}
});module.exports = router;注意 res.status(400) 和 res.status(404)。
不要所有错误都返回 200！
这是很多初级开发者的通病。
状态码是 HTTP 协议的一部分，用对状态码，前端的 fetch 拦截器才能正确捕获异常。
这也是参考 MDN Web Docs 中关于 HTTP 状态码的标准定义来写的。
3.4 前端：原生 JS 的优雅实现
新建 public/index.html：
!DOCTYPE html
html lang=zh-CN
headmeta charset=UTF-8title手写查字在线 - Demo/titlelink rel=stylesheet href=css/style.css
/head
bodydiv class=containerh1手写查字在线/h1div class=search-boxinput type=text id=charInput placeholder=请输入单个汉字 maxlength=1button id=queryBtn查询/button/divdiv id=result class=result/div/divscript src=js/app.js/script
/body
/html新建 public/js/app.js：
const input = document.getElementById('charInput');
const btn = document.getElementById('queryBtn');
const resultDiv = document.getElementById('result');// 封装 Fetch 请求
async function queryHanzi(char) {// 清空旧结果，显示 LoadingresultDiv.innerHTML = 'p查询中.../p';try {const response = await fetch(`/api/hanzi?char=${encodeURIComponent(char)}`);// 检查 HTTP 状态码if (!response.ok) {throw new Error(`HTTP error! status: ${response.status}`);}const data = await response.json();// 检查业务状态码if (data.code === 200) {renderResult(data.data);} else {resultDiv.innerHTML = `p class=error${data.msg}/p`;}} catch (error) {resultDiv.innerHTML = `p class=error网络错误: ${error.message}/p`;}
}// 渲染结果
function renderResult(info) {if (!info) {resultDiv.innerHTML = 'p无数据/p';return;}const html = `div class=cardh2${info.char}/h2p拼音: strong${info.pinyin}/strong/pp部首: strong${info.radical}/strong/pp笔画: strong${info.stroke}/strong/p/div`;resultDiv.innerHTML = html;
}// 绑定事件
btn.addEventListener('click', () = {const val = input.value.trim();if (!val) {alert('请输入汉字');return;}queryHanzi(val);
});// 支持回车键查询
input.addEventListener('keypress', (e) = {if (e.key === 'Enter') {queryHanzi(input.value.trim());}
});前端避坑指南：encodeURIComponent：虽然汉字通常不需要编码，但养成习惯。如果用户输入了特殊字符，不编码会导致 URL 解析错误。
async/await：比 .then() 链条清晰得多。
try/catch：网络请求一定会失败（断网、超时），必须有捕获。
XSS 防护：这里我们用了模板字符串插入。
警告！ 如果数据来自用户输入，直接插入 innerHTML 是危险的。
在本例中，数据来自后端，相对安全。
但在真实项目中，务必使用 DOM API 创建节点，或对数据进行转义。
参考 MDN Web Docs 中关于 Cross-site scripting (XSS) 的安全指南，了解如何安全地处理动态内容。4. 运行与测试：像工程师一样验证
代码写完了，别急着吹牛。
跑起来，才是真的。在项目根目录运行：node src/app.js
浏览器打开 http://localhost:3000
输入“你”，点击查询。预期结果：
显示拼音 nǐ，部首 亻，笔画 7。
怎么测试边界情况？输入空字符：前端会提示“请输入汉字”。
输入英文 A：后端返回 404，前端显示“未找到该汉字”。
输入两个汉字 你好：前端 maxlength=1 限制了输入，后端也会校验 char.length !== 1。
断网测试：关闭服务器，点击查询。前端应捕获网络错误，而不是白屏或无限 Loading。进阶测试技巧：
打开浏览器开发者工具（F12）- Network 标签。
观察 /api/hanzi 请求。状态码是 200 还是 404？
响应时间（Time）是多少？应该小于 10ms。
Response 里的 JSON 结构是否符合预期？如果你发现响应很慢：
检查是不是每次请求都在读文件？
回到 dictService.js，确认 hanziMap 是否在模块加载时初始化。
如果是，那速度应该很快。
如果慢，可能是 Node.js 事件循环被阻塞了？
在这个简单场景下，同步读取小文件不会阻塞太久，但生产环境建议用 readFile 异步加载，或者启动时预加载。
5. 优化扩展：从Demo到生产
现在的版本能跑，但离“生产级”还有距离。
面试时，你可以主动提出以下优化点，体现你的成长型思维。
5.1 性能优化：防抖（Debounce）
现在用户每点一次按钮，发一次请求。
如果用户想边输入边查呢？
直接绑定 input 事件会疯狂发请求，服务器会被打爆。
解决方案：防抖。
修改 public/js/app.js：
// 简单的防抖函数
function debounce(func, wait) {let timeout;return function (...args) {clearTimeout(timeout);timeout = setTimeout(() = {func.apply(this, args);}, wait);};
}const debouncedQuery = debounce((char) = {if (char) queryHanzi(char);
}, 300); // 300ms 防抖// 替换原来的 input 事件
input.addEventListener('input', (e) = {debouncedQuery(e.target.value.trim());
});效果：
用户停止输入 300ms 后，才发起请求。
体验更流畅，服务器压力更小。
5.2 后端优化：缓存层
如果字库有 10 万条，内存 Map 可能占用几百 MB。
怎么办？
引入 Redis。
改造 dictService.js：
// 伪代码：引入 redis 客户端
const redis = require('redis');
const client = redis.createClient();exports.getHanziInfo = async (char) = {// 1. 先查 Redisconst cached = await client.get(`hanzi:${char}`);if (cached) {return JSON.parse(cached);}// 2. 缓存未命中，查内存 Map 或 数据库const info = hanziMap.get(char);// 3. 如果查到，存入 Redis，设置过期时间（比如 1 小时）if (info) {await client.set(`hanzi:${char}`, JSON.stringify(info), { EX: 3600 });}return info;
};注意：
这会把 getHanziInfo 变成异步函数。
路由层也需要改成 async/await。
这就是技术债务的偿还过程。
先跑通，再优化。
不要一开始就过度设计。
5.3 安全性：限流（Rate Limiting）
防止有人恶意刷接口。
使用 express-rate-limit 中间件。
const rateLimit = require('express-rate-limit');
const limiter = rateLimit({windowMs: 15 * 60 * 1000, // 15 分钟max: 100, // 每个 IP 最多 100 次请求
});// 应用到 /api 路由
app.use('/api', limiter, apiRoutes);简单几行代码，就能挡住 90% 的爬虫和攻击。
这也是工程化的一部分。
6. 小结：你学到了什么？
回头看看，我们从零搭建了一个【手写查字在线】的小项目。
你学会了：模块化思维：前端、后端、数据服务层分离。
性能意识：内存缓存、Map 索引、防抖。
规范意识：HTTP 状态码、统一响应格式、错误处理。
安全意识：XSS 防护、限流。这些，才是面试官想看的。
不是你会用 Vue，而是你懂原理。
当你用原生 JS 手写实现过一遍，再去看 Vue 的响应式原理、React 的虚拟 DOM，你会发现它们不过如此。
最后，抛个问题：
你在项目里踩过这个坑吗？
比如：防抖函数写错了，导致最后一次的输入没发出去？
Map 的 Key 冲突，导致查错了字？
跨域问题，折腾了三天才解决？评论区聊聊，互相避雷。
你的经历，可能是别人的捷径。