From e18ec6ae16b0e9234f279a92b6f620ed6367e809 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=A8=E4=BF=8A=E6=9E=97?= <3228239486@qq.com>
Date: Sun, 15 Mar 2026 22:28:03 +0800
Subject: [PATCH 1/5] feat:zuoye
---
...41\345\235\227\346\223\215\344\275\234.md" | 48 +++++++++++
"2026-3-13-\347\273\274\345\220\210.md" | 79 +++++++++++++++++++
...6-3-7 -\345\210\235\350\257\206Node.js.md" | 53 +++++++++++++
...03\351\200\211\346\213\251\351\242\230.md" | 48 +++++++++++
...16\345\214\205\347\256\241\347\220\206.md" | 65 +++++++++++++++
5 files changed, 293 insertions(+)
create mode 100644 "2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md"
create mode 100644 "2026-3-13-\347\273\274\345\220\210.md"
create mode 100644 "2026-3-7 -\345\210\235\350\257\206Node.js.md"
create mode 100644 "2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md"
create mode 100644 "2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md"
diff --git "a/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md" "b/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md"
new file mode 100644
index 0000000..4380650
--- /dev/null
+++ "b/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md"
@@ -0,0 +1,48 @@
+## 练习
+### 选择题
+1.
+
+ 在CommonJS模块系统中，引入模块使用 require
+2.
+
+ 正确的CommonJS导出方式: module.exports = ...
+3.
+
+ ES Modules需要设置 "type": "module"才能在Node.js中使用
+4.
+
+ exports = function() { console.log('hello'); };
+ 应该是 module.exports
+5.
+
+ 模块化的好处
+ 1. 代码复用
+ 2. 便于维护
+ 3. 清晰结构
+
+### 简答题
+1.什么是模块？为什么要使用模块？
+
+ 模块 = 把一段相对独立、可复用的代码，单独放在一个文件里，方便其他地方导入使用。
+ 为了复用、清晰、好维护、少出错、效率高。
+2.请解释module.exports和exports的区别。
+
+ 本质关系：exports 是 module.exports 的引用（别名），初始指向同一个空对象。
+导出规则：Node.js 最终导出的是 module.exports，而非 exports。
+使用区别：给 exports 加属性和 module.exports 等价；直接给 exports 赋值会失效，必须用 module.exports 赋值。
+3.CommonJS和ES Modules有什么区别？
+
+ 语法层面：CJS 用 require/module.exports，ESM 用 import/export；
+核心逻辑：CJS 运行时动态加载（同步），ESM 编译时静态加载（异步），后者支持树摇；
+环境适配：CJS 是 Node.js 老规范，ESM 是官方新标准，前端优先用 ESM。
+4.Node.js加载模块的顺序是怎样的？
+
+
+ 1.缓存优先：任何模块加载先查缓存，避免重复加载；
+ 2.优先级排序：核心模块 > 文件模块（路径开头） > 第三方模块（无路径）；
+ 3.查找规则：文件模块按「文件→文件夹入口」查找，第三方模块递归向上找 node_modules。
+5.什么是模块作用域？它有什么作用？
+
+ 1.模块作用域定义：每个 Node.js 模块有独立作用域，内部变量 / 函数默认私有，仅模块内可访问；
+ 2.核心作用：① 避免全局变量污染和命名冲突；② 封装内部逻辑，提高代码安全性；③ 明确模块边界，提升可维护性；
+ 3.关键规则：只有通过 module.exports/exports 导出的内容，才能被其他模块通过 require 访问。
\ No newline at end of file
diff --git "a/2026-3-13-\347\273\274\345\220\210.md" "b/2026-3-13-\347\273\274\345\220\210.md"
new file mode 100644
index 0000000..9a52676
--- /dev/null
+++ "b/2026-3-13-\347\273\274\345\220\210.md"
@@ -0,0 +1,79 @@
+## 笔记
+
+|知识点 |关键内容|
+|--|--|
+|文件操作| fs模块读写文件|
+|路径处理| path模块处理文件路径|
+|命令解析| switch或commander解析命令|
+|数据存储| JSON文件持久化数据|
+
+## 完整命令
+
+
+ node todo.js add <内容> # 添加待办
+ node todo.js list # 列出待办
+ node todo.js done <编号> # 标记完成
+ node todo.js delete <编号> # 删除待办
+ node todo.js clear # 清空待办
+ node todo.js help # 显示帮助
+
+## 作业
+
+1.
+
+ Node.js中，获取命令行参数的属性是process.argv
+
+2.
+
+ fs.readFile可以读取文件内容
+
+3.
+
+ __dirname当前文件所在目录
+
+4.
+
+ package.json中bin用于配置全局命令
+
+5.
+
+ 图形界面更美观是命令行工具的优点
+
+6.
+
+## 简答题
+1.请解释什么是CLI工具？它和GUI有什么区别
+
+ CLI工具是“指令驱动”的轻量交互工具，侧重高效、自动化和资源节省；GUI是“图形驱动”的直观交互工具，侧重易用性和可视化。二者没有优劣之分，根据使用场景和需求选择即可——普通用户日常使用优先GUI，专业场景（开发、运维）优先CLI。
+2.process.argv返回的数组包含哪些内容？
+
+ 索引值
+
+3.请说明fs.readFileSync和fs.readFile的区别
+
+ fs.readFile：异步读取。调用后不会阻塞后续代码执行，文件读取完成后，通过回调函数（或Promise）返回结果。Node.js 的核心特性就是异步非阻塞，该方法更符合 Node.js 设计理念。
+
+ fs.readFileSync：同步读取。调用后会阻塞后续代码执行，直到文件读取完成、返回结果后，才会继续执行下一行代码。
+
+4.为什么要使用JSON文件存储数据？有什么优缺点？
+
+ 原因：选择JSON存储数据，核心是其简洁性和跨环境兼容性
+
+ 优点：
+ 1.轻量高效
+ 2.易维护
+ 3.通用性强
+ 4.适合存储结构化数据
+ 缺点：
+ 1.不支持注释
+ 2.不适合存储大量二进制数据
+ 3. 解析性能有限
+ 4.无类型约束
+ 5.不支持并发写入：多个程序同时读写同一个JSON文件时，容易出现数据错乱，
+
+5.如何让开发的CLI工具可以全局使用
+
+ 1.编写 CLI 核心代码
+ 2.配置 package.json
+ 3.全局链接（开发阶段）
+ 4.发布到 npm 后，用户可通过 npm install -g my-global-cli 全局安装；
\ No newline at end of file
diff --git "a/2026-3-7 -\345\210\235\350\257\206Node.js.md" "b/2026-3-7 -\345\210\235\350\257\206Node.js.md"
new file mode 100644
index 0000000..1f040fc
--- /dev/null
+++ "b/2026-3-7 -\345\210\235\350\257\206Node.js.md"
@@ -0,0 +1,53 @@
+## 笔记：
+
+|知识点 |关键内容|
+|---|---:|
+|Node.js定义 | 基于Chrome V8引擎的JavaScript运行时|
+|单线程 | 一个线程处理所有请求，节省资源|
+|非阻塞I/O | I/O操作时不等待，继续执行其他任务|
+|事件驱动 | 通过事件和回调处理异步操作|
+|应用场景 | Web服务器、API服务、实时通信、命令行工具|
+
+##### Node.js = V8引擎（执行JavaScript）+ libuv（处理I/O）
+
+---
+
+核心优势：
+- 高性能（V8引擎）
+- 高并发（非阻塞I/O）
+- 前后端同语言（JavaScript）
+- 丰富的npm生态
+
+## 作业：
+### 选择题
+1. Node.js是基于V8JavaScript引擎开发的
+2. 多线程是Node.js的核心特性
+3. Node.js适合开发实时聊天系统
+4. Ryan Dahl是Node.js的创始人
+5. Node.js中的"I/O"主要指Input/Output（输入/输出）
+
+
+## 简答题：
+### 什么是Node.js？
+答：
+Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境，支持事件驱动和非阻塞 I/O 模型，具有高效、轻量的特点。
+
+请解释"非阻塞I/O"是什么意思，它有什么优点？
+答：
+官方回答
+阻塞I/O：在进行I/O操作时，进程会被阻塞，直到数据准备好并复制到进程的缓冲区中才返回。
+
+非阻塞I/O：当I/O操作会导致进程阻塞时，该调用会立即返回一个错误，进程可以继续执行其他任务。
+自己的理解：不会影响你当时要做的事情就比如说我现在在敲代码刚好到饭点我需要吃饭，我只需要点一个外卖就可以继续敲我的代码而不是要我自己停下来去做饭。
+
+### 为什么Node.js适合开发实时聊天应用？
+答：
+Node.js 基于 Google 的 V8 JavaScript 引擎构建，该引擎以其高性能而著称。这使得 Node.js 成为构建需要速度和可扩展性的实时通信应用程序的完美工具。Node.js 还是事件驱动型的，这意味着它可以同时处理多个连接，使其成为构建实时应用程序的完美工具。
+
+### 请列举Node.js的3个应用场景
+答：
+ 微信 qq 淘宝
+
+### Node.js和传统后端语言（如Java、PHP）相比，有什么优势？
+答：
+Node.js、Java和PHP作为当前最流行的后端开发语言，各自拥有独特的优势和局限性。 本文将从性能、适用场景、优缺点等多个维度，深入对比这三门语言，帮助开发者做出更明智的选择。 异步非阻塞I/O模型：Node.js采用事件驱动、非阻塞I/O模型，使其在处理大量并发请求时表现出色。 这种模型能够充分利用系统资源，减少线程切换和同步调用的开销，从而提高服务器的吞吐量和响应速度。 统一的编程语言：Node.js允许开发者使用JavaScript进行前后端全栈开发，降低了开发难度和学习成本，提高了开发效率。
\ No newline at end of file
diff --git "a/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md" "b/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md"
new file mode 100644
index 0000000..e140879
--- /dev/null
+++ "b/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md"
@@ -0,0 +1,48 @@
+### 选择题
+### Node.js的LTS版本是什么意思？目前最新的LTS版本是哪个？
+1.
+
+ LTS 是 Long-Term Support（长期支持） 的缩写，是 Node.js 官方为企业级、生产环境应用提供的版本类型，核心特点如下：
+
+- 稳定性优先：LTS 版本会经过充分的测试和验证，不会包含实验性特性，避免因功能迭代引入新问题，适合对稳定性要求高的生产环境。
+- 长期维护支持：官方会为 LTS 版本提供长达数年的支持（分为「Active LTS（活跃支持）」和「Maintenance LTS（维护支持）」阶段），包括安全补丁、关键 bug 修复，但不会新增功能。
+- 对比非 LTS 版本：Node.js 还有「Current（当前）」版本（也叫稳定版），会包含最新功能，但支持周期短（仅 6 个月），适合开发、测试环境，不建议生产环境使用。
+
+2.
+
+ Node.js 官方最新的 LTS 版本是 Node.js 20.x（代号 Iron）
+### npm是用来做什么的？
+ 答：npm是用来管理Node.js包
+
+### 初始化Node.js项目的命令是？
+ 答:npm init
+### 运行Node.js程序的命令是？
+ 答:node app.js
+### package.json文件主要记录什么信息？
+ 答:package.json 是 Node.js/ 前端项目的标配配置文件，本质是一个 JSON 格式的文本文件，它集中记录了项目的所有核心元信息和依赖配置，包管理器（npm/yarn/pnpm）会根据这个文件识别项目、安装依赖、运行脚本等。
+### 请解释LTS版本和Current版本有什么区别？
+答:
+
+ 1.
+ 核心差异：LTS 版本侧重稳定和长期维护，适合生产环境；Current 版本侧重新功能，仅短期维护，适合开发 / 测试；
+ 2.
+
+ 维护周期：LTS 总计维护 30 个月，Current 仅维护 6 个月；
+ 3.
+
+ 选择原则：生产用 LTS，开发可按需选 Current，新手优先 LTS。
+### npm和Node.js是什么关系？
+ 答:Node.js 是运行环境，npm 是随 Node.js 一起安装的包管理工具。
+### package.json文件中的dependencies和devDependencies有什么区别？
+ 答:dependencies 是项目运行时必须的依赖（生产环境要用），devDependencies 是仅开发 / 测试阶段需要的依赖（生产环境用不上）。
+### VSCode有哪些特点让它适合开发Node.js？
+ 答:VS Code = 写 Node.js 的 “官方标配编辑器”
+ 自带终端 + 智能提示 + 调试 + 插件生态，让 Node.js 开发最简单、最快、最不容易出错
+### 请描述在Windows上安装Node.js的步骤。
+
+ 答:
+ 1.去官网下载安装包
+ 2.运行安装包
+ 3.安装向导步骤（一路点下一步即可）
+ 4.验证是否安装成功
+ 5. 最简单测试：运行一段 Node.js
\ No newline at end of file
diff --git "a/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md" "b/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md"
new file mode 100644
index 0000000..efa6bb6
--- /dev/null
+++ "b/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md"
@@ -0,0 +1,65 @@
+### 选择题
+1.package.json中，哪个字段用于记录项目运行必需的依赖？
+
+ 答：dependencies
+2.版本号"^4.18.0"表示安装什么版本
+
+ 答: 安装4.x.x最新版本
+3.下面哪个命令可以查看npm的镜像源设置？
+
+ 答:npm config get registry
+4.安装全局包的参数是?
+
+ 答:--global
+5.npm install 和 npm ci 有什么区别？
+
+ 答:npm ci更快，适合CI/CD环境
+6.npm install 和 npm ci 有什么区别？
+
+ 答:支持离线安装
+7.pnpm的主要特点是什么？
+
+ 答:节省磁盘空间
+## 简答题
+1.请解释dependencies和devDependencies的区别。
+
+ 答:dependencies 是项目运行必需的生产依赖，随项目发布；devDependencies 仅开发阶段使用，发布时会被忽略。
+2.什么是语义化版本号？请举例说明 "^1.2.3" 的含义
+
+ 答:语义化版本号是一套标准化的版本命名规则，目的是让开发者通过版本号就能清晰判断更新的类型和兼容性，格式为 MAJOR.MINOR.PATCH（主版本号。次版本号。补丁版本号），每个部分都是非负整数，且不包含前导零。
+
+ ^1.2.3:主版本为1.x.x 包含1.2.3以及1.2.4等
+3.为什么国内使用npm需要配置镜像源？
+
+ 答:服务器在国外，国内网络访问：
+ 1.速度慢
+ 2.丢包、超时
+ 3.安装大型依赖（如 node-sass、electron）经常失败
+4.请描述npm install命令的执行过程。
+
+ 答:
+ 1. 读取配置与环境
+ 2. 解析依赖声明
+ 3. 检查缓存与 lock 文件
+ 4. 构建依赖树（最重要的一步）
+ 5. 下载依赖包
+ 6. 解压并安装到 node_modules
+ 7. 执行生命周期脚本（可选）
+ 8. 更新 lock 文件与 package.json
+5.全局安装和本地安装有什么区别？
+
+ 答:
+ 全局安装：装在系统目录，供所有项目使用终端命令，不写入项目依赖，有版本冲突风险；
+
+ 本地安装：装在项目 node_modules，仅当前项目使用，可代码引入 / 通过 npm scripts 调用，版本独立无冲突；
+6.yarn和npm相比有什么优势？
+
+ 答:Yarn 核心优势是安装速度更快、离线模式更友好、锁文件更可靠、Monorepo 支持更好；
+7.pnpm的node_modules结构有什么特点？为什么能节省空间？
+
+ 答:
+ pnpm 的 node_modules 核心是符号链接 + 全局内容可寻址存储，顶层仅存直接依赖，子依赖嵌套且通过链接指向全局 store；
+
+ 节省空间的关键是跨项目 / 同项目共享依赖副本，用链接替代复制，同一个版本的包全局仅存一份；
+
+ 相比 npm/yarn，pnpm 不仅大幅节省磁盘空间，还能避免隐式依赖，安装速度也更快。
--
Gitee
From 9dd0f663c8a17baf929d8e76451b1aaf3ad351bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=A8=E4=BF=8A=E6=9E=97?= <3228239486@qq.com>
Date: Sun, 15 Mar 2026 22:31:09 +0800
Subject: [PATCH 2/5] feat:zuoye
---
...2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md" | 0
.../2026-3-13-\347\273\274\345\220\210.md" | 0
.../2026-3-7 -\345\210\235\350\257\206Node.js.md" | 0
...47\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md" | 0
...26-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md" | 0
5 files changed, 0 insertions(+), 0 deletions(-)
rename "2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md" => "\345\205\250\344\277\212\346\236\227/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md" (100%)
rename "2026-3-13-\347\273\274\345\220\210.md" => "\345\205\250\344\277\212\346\236\227/2026-3-13-\347\273\274\345\220\210.md" (100%)
rename "2026-3-7 -\345\210\235\350\257\206Node.js.md" => "\345\205\250\344\277\212\346\236\227/2026-3-7 -\345\210\235\350\257\206Node.js.md" (100%)
rename "2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md" => "\345\205\250\344\277\212\346\236\227/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md" (100%)
rename "2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md" => "\345\205\250\344\277\212\346\236\227/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md" (100%)
diff --git "a/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md" "b/\345\205\250\344\277\212\346\236\227/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md"
similarity index 100%
rename from "2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md"
rename to "\345\205\250\344\277\212\346\236\227/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md"
diff --git "a/2026-3-13-\347\273\274\345\220\210.md" "b/\345\205\250\344\277\212\346\236\227/2026-3-13-\347\273\274\345\220\210.md"
similarity index 100%
rename from "2026-3-13-\347\273\274\345\220\210.md"
rename to "\345\205\250\344\277\212\346\236\227/2026-3-13-\347\273\274\345\220\210.md"
diff --git "a/2026-3-7 -\345\210\235\350\257\206Node.js.md" "b/\345\205\250\344\277\212\346\236\227/2026-3-7 -\345\210\235\350\257\206Node.js.md"
similarity index 100%
rename from "2026-3-7 -\345\210\235\350\257\206Node.js.md"
rename to "\345\205\250\344\277\212\346\236\227/2026-3-7 -\345\210\235\350\257\206Node.js.md"
diff --git "a/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md" "b/\345\205\250\344\277\212\346\236\227/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md"
similarity index 100%
rename from "2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md"
rename to "\345\205\250\344\277\212\346\236\227/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md"
diff --git "a/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md" "b/\345\205\250\344\277\212\346\236\227/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md"
similarity index 100%
rename from "2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md"
rename to "\345\205\250\344\277\212\346\236\227/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md"
--
Gitee
From 9f17571d16ac0964c11a8ebc3af6990ae03f12c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=A8=E4=BF=8A=E6=9E=97?= <3228239486@qq.com>
Date: Mon, 16 Mar 2026 11:27:38 +0800
Subject: [PATCH 3/5] feat:zuoye
---
.../20260307-\345\210\235\350\257\206Node.js.md" | 0
...47\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md" | 0
...260309-npm\344\270\216\345\214\205\347\256\241\347\220\206.md" | 0
.../20260311-\346\250\241\345\235\227\346\223\215\344\275\234.md" | 0
4 files changed, 0 insertions(+), 0 deletions(-)
rename "\345\205\250\344\277\212\346\236\227/2026-3-7 -\345\210\235\350\257\206Node.js.md" => "\345\205\250\344\277\212\346\236\227/20260307-\345\210\235\350\257\206Node.js.md" (100%)
rename "\345\205\250\344\277\212\346\236\227/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md" => "\345\205\250\344\277\212\346\236\227/20260308-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md" (100%)
rename "\345\205\250\344\277\212\346\236\227/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md" => "\345\205\250\344\277\212\346\236\227/20260309-npm\344\270\216\345\214\205\347\256\241\347\220\206.md" (100%)
rename "\345\205\250\344\277\212\346\236\227/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md" => "\345\205\250\344\277\212\346\236\227/20260311-\346\250\241\345\235\227\346\223\215\344\275\234.md" (100%)
diff --git "a/\345\205\250\344\277\212\346\236\227/2026-3-7 -\345\210\235\350\257\206Node.js.md" "b/\345\205\250\344\277\212\346\236\227/20260307-\345\210\235\350\257\206Node.js.md"
similarity index 100%
rename from "\345\205\250\344\277\212\346\236\227/2026-3-7 -\345\210\235\350\257\206Node.js.md"
rename to "\345\205\250\344\277\212\346\236\227/20260307-\345\210\235\350\257\206Node.js.md"
diff --git "a/\345\205\250\344\277\212\346\236\227/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md" "b/\345\205\250\344\277\212\346\236\227/20260308-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md"
similarity index 100%
rename from "\345\205\250\344\277\212\346\236\227/2026-3-8-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md"
rename to "\345\205\250\344\277\212\346\236\227/20260308-\346\220\255\345\273\272\345\274\200\345\217\221\347\216\257\345\242\203\351\200\211\346\213\251\351\242\230.md"
diff --git "a/\345\205\250\344\277\212\346\236\227/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md" "b/\345\205\250\344\277\212\346\236\227/20260309-npm\344\270\216\345\214\205\347\256\241\347\220\206.md"
similarity index 100%
rename from "\345\205\250\344\277\212\346\236\227/2026-3-9-npm\344\270\216\345\214\205\347\256\241\347\220\206.md"
rename to "\345\205\250\344\277\212\346\236\227/20260309-npm\344\270\216\345\214\205\347\256\241\347\220\206.md"
diff --git "a/\345\205\250\344\277\212\346\236\227/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md" "b/\345\205\250\344\277\212\346\236\227/20260311-\346\250\241\345\235\227\346\223\215\344\275\234.md"
similarity index 100%
rename from "\345\205\250\344\277\212\346\236\227/2026-3-11-\346\250\241\345\235\227\346\223\215\344\275\234.md"
rename to "\345\205\250\344\277\212\346\236\227/20260311-\346\250\241\345\235\227\346\223\215\344\275\234.md"
--
Gitee
From 5fd3ca499bda2675b5e6a9015f3e65c0874763ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=A8=E4=BF=8A=E6=9E=97?= <3228239486@qq.com>
Date: Sun, 22 Mar 2026 22:03:14 +0800
Subject: [PATCH 4/5] feat:zuoye
---
.../20260313-\347\273\274\345\220\210.md" | 0
...05\347\275\256\346\250\241\345\235\227.md" | 208 ++++++++++++++++++
...41\345\235\227\345\211\257\346\234\254.md" | 97 ++++++++
...73\347\273\237\346\250\241\345\235\227.md" | 111 ++++++++++
.../20260320-http\346\250\241\345\235\227.md" | 73 ++++++
5 files changed, 489 insertions(+)
rename "\345\205\250\344\277\212\346\236\227/2026-3-13-\347\273\274\345\220\210.md" => "\345\205\250\344\277\212\346\236\227/20260313-\347\273\274\345\220\210.md" (100%)
create mode 100644 "\345\205\250\344\277\212\346\236\227/20260316-\345\206\205\347\275\256\346\250\241\345\235\227.md"
create mode 100644 "\345\205\250\344\277\212\346\236\227/20260318-\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227\345\211\257\346\234\254.md"
create mode 100644 "\345\205\250\344\277\212\346\236\227/20260319-\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227.md"
create mode 100644 "\345\205\250\344\277\212\346\236\227/20260320-http\346\250\241\345\235\227.md"
diff --git "a/\345\205\250\344\277\212\346\236\227/2026-3-13-\347\273\274\345\220\210.md" "b/\345\205\250\344\277\212\346\236\227/20260313-\347\273\274\345\220\210.md"
similarity index 100%
rename from "\345\205\250\344\277\212\346\236\227/2026-3-13-\347\273\274\345\220\210.md"
rename to "\345\205\250\344\277\212\346\236\227/20260313-\347\273\274\345\220\210.md"
diff --git "a/\345\205\250\344\277\212\346\236\227/20260316-\345\206\205\347\275\256\346\250\241\345\235\227.md" "b/\345\205\250\344\277\212\346\236\227/20260316-\345\206\205\347\275\256\346\250\241\345\235\227.md"
new file mode 100644
index 0000000..a23d356
--- /dev/null
+++ "b/\345\205\250\344\277\212\346\236\227/20260316-\345\206\205\347\275\256\346\250\241\345\235\227.md"
@@ -0,0 +1,208 @@
+## 内置模块
+### 笔记
+### 内置模块的特点
+|特点| 说明|
+|---|---|
+|无需安装 |Node.js自带，直接 require 即可|
+|性能优化 |由C/C++编写，执行效率高|
+|功能强大 |涵盖文件、网络、加密等方方面面|
+|稳定可靠 |经过长期测试，稳定可用|
+
+### 选择题
+1
+
+ process.version可以获取Node.js的版本号
+2
+
+ Buffer.alloc(10)创建的Buffer，长度是10字节
+3.
+
+ "你好"的Buffer长度6字节（通常汉字在utf-8编码中一个汉字占三个字节）
+4.
+
+ _dirname表示当前文件所在目录
+5.
+
+ console.time()和console.timeEnd()的作用是计时
+### 简答题
+1.解释console.log和console.error的区别
+
+ 核心差异：console.log 输出到 stdout（普通信息），console.error 输出到 stderr（错误信息），且后者在终端通常显红色，更醒目。
+ 使用原则：正常流程 / 调试信息用 console.log，异常 / 错误提示用 console.error，便于日志分类、排查问题。
+ 扩展价值：区分两者可实现日志的精细化管理（如单独收集错误日志），提升问题定位效率。
+2.process.argv返回的数组包含哪些内容？请举例说明。
+
+ process.argv 数组核心包含三部分：Node 可执行文件路径（第 0 位）、当前文件路径（第 1 位）、自定义命令行参数（第 2 位及以后）。
+ 自定义参数需从 process.argv.slice(2) 中获取，是处理命令行输入的核心数据来源。
+ 数组元素顺序严格对应命令行输入顺序，含空格的参数需用引号包裹。
+3.Buffer和普通数组有什么区别？
+
+ 核心差异：普通数组存储任意 JS 类型、动态长度、基于 V8 堆内存；Buffer 仅存字节数据、固定长度、基于堆外内存，专为二进制处理设计。
+ 使用原则：业务数据处理用普通数组，文件 / 网络等二进制数据处理用 Buffer。
+ 关键特性：Buffer 支持编码转换、内存更高效，是 Node.js 处理 IO 操作的核心工具。
+4.__dirname和process.cwd()有什么区别？
+
+ 核心区别：__dirname 是文件所在目录的绝对路径（固定不变），process.cwd() 是执行 node 命令的目录（随执行位置变化）。
+ 使用原则：读取文件自身关联的资源用 __dirname，处理用户命令相关的路径用 process.cwd()。
+ 关键记忆：__dirname 跟 “文件走”，process.cwd() 跟 “命令走”。
+5.path.join()和path.resolve()有什么区别？
+
+ 核心区别：path.join() 仅拼接 + 规范化路径片段（可返回相对路径），path.resolve() 解析为绝对路径（模拟 cd 逻辑，遇绝对路径终止向左解析）。
+ 使用原则：需要相对路径 / 拼接文件关联路径用 path.join()，需要绝对路径 / 基于工作目录解析路径用 path.resolve()。
+ 关键记忆：join 是 “拼接”，resolve 是 “解析（为绝对路径）”。
+
+### 操作题
+```
+// 第一题 关键 process.env || process.env 是 Node.js 全局对象 process 的属性，自动获取当前操作系统的所有环境变量
+// import process from 'process'
+
+// function myPath(){
+// const env=process.env;
+// console.log(env);
+// }
+// myPath();
+
+//第二题
+import fs from 'fs'
+import { exit } from 'process';
+// process.argv[2] 是操作类型（add/sub/mul）
+let math = process.argv[2];
+let num1 = Number(process.argv[3])
+let num2 = Number(process.argv[4])
+//判断是否为数字 （[3][4]默认是字符串，需要Number()转换成数字
+if (isNaN(num1) || isNaN(num2)) {
+ console.log('请输入有效的数字！');
+ process.exit();
+}
+let result;
+if (math === 'add') {
+ result = num1 + num2;
+} else if (math === 'sub') {
+ result = num1 - num2;
+} else if (math === 'mul') {
+ result = num1 * num2;
+} else {
+ console.log('不支持该操作！');
+ process.exit();
+
+}
+console.log(result);
+
+//第三题 Buffer操作：创建一个程序，将中文字符串转为Buffer，再转回字符串，验证是否一致。
+
+
+// 1. 定义要测试的中文字符串
+const str = '你好，Node.js！测试中文转Buffer';
+
+// 2. 转Buffer（指定UTF-8编码，中文必须指定）
+const buf = Buffer.from(str, 'utf8');
+
+// 3. Buffer转回字符串
+const newStr = buf.toString('utf8');
+
+// 4. 验证并输出结果
+console.log('原始字符串：', str);
+console.log('转回字符串：', newStr);
+console.log('是否一致：', str === newStr ? '✅ 一致' : '❌ 不一致');
+
+//第四题 创建一个程序，接收文件路径，输出文件名、扩展名、所在目录。
+//引入node.js 内置的path模块（处理路径专用）
+const path = require('path');
+//获取命令行传入的文件路径参数
+const filepath = process.argv[2];
+
+if (!filepath) {
+ console.error('用法：node path-parser.js [文件路径]');
+ console.error('示例：node path-parser.js ./test.txt 或 node path-parser.js /user/doc/test.png');
+ process.exit(1);
+}
+
+//解析路径：提取目录 文件名 扩展名
+const parsedPath = path.parse(filepath);
+// 整理输出信息（兼容无扩展名的文件）
+const dir = parsedPath.dir; // 所在目录
+const fileName = parsedPath.name; // 文件名（不含扩展名）
+const ext = parsedPath.ext || '无扩展名'; // 扩展名（无则显示“无扩展名”）
+
+// 格式化输出结果
+console.log('=== 文件路径解析结果 ===');
+console.log('输入路径：', filePath);
+console.log('所在目录：', dir);
+console.log('文件名（不含扩展名）：', fileName);
+console.log('扩展名：', ext);
+
+//第五题
+
+import fs from 'fs'
+
+let command = process.argv[2];
+let params = process.argv[3];
+
+
+if (command == 'list') {
+ console.log('========待办事项');
+ let list = readFile();
+ console.log(list)
+
+} else if (command == 'add') {
+ console.log('添加成功');
+ let arr = readFile();
+ console.log({ 'acting': params, 'isdone': false })
+ arr.push({ 'acting': params, 'isdone': false })
+ writeFile(arr);
+ let newArr = readFile();
+
+} else if (command == 'mark') {
+ console.log('状态切换并完成');
+ let fix=readFile();
+ fix.forEach((item)=>{
+ if(item.acting === params){
+ if(item.isdone){
+ item.isdone=false;
+ }else{
+ item.isdone=true;
+ }
+ /*法2*/
+ // item.isdone = !item.isdone
+ }
+ })
+ // let fixdata=JSON.stringify(fix);
+ // fs.writeFileSync('./todo.json',fixdata,"utf-8");
+ // console.log(fix);
+ writeFile(fix)
+
+
+} else if (command == 'del') {
+ console.log('删除成功');
+ let dell = parseInt(params);
+ let delArr = readFile();
+ delArr.splice(dell - 1, 1);
+ writeFile(delArr);
+
+} else if (command == 'clear') {
+ console.log('清除成功');
+ writeFile([]);
+} else {
+ console.log('未知命令，请重新输入');
+}
+
+function readFile(filePath) {
+ filePath = filePath || './todo.json';
+ if (fs.existsSync(filePath)) {
+ let data = fs.readFileSync(filePath, 'utf-8');
+ try {
+ JSON.parse(data)/*转换为JS可操作类型*/
+ } catch (error) {
+ fs.writeFileSync(filePath, "[]", "utf-8")
+ }
+ data = fs.readFileSync(filePath, 'utf-8');
+ return JSON.parse(data) || [];
+ }
+ return [];
+}
+function writeFile(fileContent, filePath) {
+ filePath = filePath || './todo.json';
+ let jsonString = JSON.stringify(fileContent);
+ fs.writeFileSync(filePath, jsonString,);
+}
+```
\ No newline at end of file
diff --git "a/\345\205\250\344\277\212\346\236\227/20260318-\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227\345\211\257\346\234\254.md" "b/\345\205\250\344\277\212\346\236\227/20260318-\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227\345\211\257\346\234\254.md"
new file mode 100644
index 0000000..1292647
--- /dev/null
+++ "b/\345\205\250\344\277\212\346\236\227/20260318-\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227\345\211\257\346\234\254.md"
@@ -0,0 +1,97 @@
+# 笔记
+## 一、模块核心认知
+### 1. 学习价值
+Web 应用中文件操作的核心场景：
+用户文件上传（头像 / 附件）、配置文件读取
+日志生成、数据备份
+Node.js 通过fs模块提供完整的文件操作能力
+### 2. 核心特点
+功能全覆盖：读写、复制、删除、移动、监听等
+两种操作模式：同步（方法名带Sync）/ 异步（回调 / Promise）
+支持大文件：流式处理、权限控制
+## 二、核心 API 分类及用法
+### 1. 文件读写（核心）
+操作类型 同步方法 异步回调方法 Promise 方法（推荐）
+读取文件 fs.readFileSync(path, 'utf8') fs.readFile(path, 'utf8', (err, data) => {}) fs.promises.readFile(path, 'utf8')
+写入文件 fs.writeFileSync(path, data) fs.writeFile(path, data, (err) => {}) fs.promises.writeFile(path, data)
+追加写入 fs.appendFileSync(path, data) fs.appendFile(path, data, (err) => {}) fs.promises.appendFile(path, data)
+关键说明：
+读取二进制文件（图片 / 视频）时，无需指定编码，返回Buffer对象
+Promise 方式需结合async/await使用，错误通过try/catch捕获
+### 2. 文件基础操作
+操作 核心方法 说明
+检查存在性 fs.existsSync(path) 返回布尔值
+获取文件信息 fs.statSync(path) 可判断文件 / 目录、获取大小 / 时间
+删除文件 fs.unlinkSync(path) / fs.promises.unlink(path) 同步 / 异步删除文件
+重命名 / 移动 fs.renameSync(oldPath, newPath) 跨目录重命名即文件移动
+复制文件 fs.copyFileSync(src, dest) Node.js 14 + 内置，也可通过流实现
+### 3. 目录操作
+操作 核心方法 关键参数 / 说明
+创建目录 fs.mkdirSync(path, { recursive: true }) recursive: true支持多级创建
+读取目录 fs.readdirSync(path, { withFileTypes: true }) 可区分文件 / 目录
+删除目录 fs.rmSync(path, { recursive: true, force: true }) Node.js 16+，递归删除非空目录
+### 4. 文件监听
+// 监听文件变化（轻量）
+fs.watch('./data.txt', (eventType, filename) => {
+ console.log(`文件${filename}发生${eventType}事件`);
+});
+
+// 监听文件详细变化（精度更高）
+fs.watchFile('./data.txt', (curr, prev) => {
+ console.log('修改时间:', curr.mtime);
+});
+## 三、实战案例（核心代码）
+### 1. 文件复制工具
+const fs = require('fs');
+const path = require('path');
+
+function copyFile(src, dest) {
+ if (!fs.existsSync(src)) return console.error('源文件不存在');
+ // 确保目标目录存在
+ fs.mkdirSync(path.dirname(dest), { recursive: true });
+ fs.copyFileSync(src, dest);
+}
+### 2. 目录备份工具（带时间戳）
+class BackupTool {
+ constructor(sourceDir, backupDir) {
+ this.sourceDir = sourceDir;
+ this.backupDir = backupDir;
+ }
+
+ backup() {
+ // 创建带时间戳的备份目录
+ const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+ const targetDir = path.join(this.backupDir, `backup_${timestamp}`);
+ fs.mkdirSync(targetDir, { recursive: true });
+
+ // 遍历复制文件
+ fs.readdirSync(this.sourceDir, { withFileTypes: true }).forEach(item => {
+ const src = path.join(this.sourceDir, item.name);
+ if (item.isFile()) fs.copyFileSync(src, path.join(targetDir, item.name));
+ });
+ }
+}
+### 3. 递归目录浏览器（带文件大小格式化）
+function browseDir(dirPath, indent = 0) {
+ const items = fs.readdirSync(dirPath, { withFileTypes: true });
+ const prefix = ' '.repeat(indent);
+
+ items.forEach(item => {
+ const fullPath = path.join(dirPath, item.name);
+ if (item.isDirectory()) {
+ console.log(`${prefix}📁 ${item.name}/`);
+ browseDir(fullPath, indent + 1); // 递归子目录
+ } else {
+ const size = fs.statSync(fullPath).size;
+ console.log(`${prefix}📄 ${item.name} (${formatSize(size)})`);
+ }
+ });
+}
+
+// 格式化文件大小（B/KB/MB/GB）
+function formatSize(bytes) {
+ const k = 1024;
+ const sizes = ['B', 'KB', 'MB', 'GB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(k)) || 0;
+ return (bytes / Math.pow(k, i)).toFixed(2) + ' ' + sizes[i];
+}
\ No newline at end of file
diff --git "a/\345\205\250\344\277\212\346\236\227/20260319-\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227.md" "b/\345\205\250\344\277\212\346\236\227/20260319-\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227.md"
new file mode 100644
index 0000000..190bd8d
--- /dev/null
+++ "b/\345\205\250\344\277\212\346\236\227/20260319-\346\226\207\344\273\266\347\263\273\347\273\237\346\250\241\345\235\227.md"
@@ -0,0 +1,111 @@
+## 简单文件浏览器
+## 笔记
+
+ 步骤：
+ 1.先把需要的包导入进去
+ 2.拿到参数
+ 3.调用函数判断路径是否存在
+ 4.获取命令参数
+
+
+
+## 作业
+### 选择题
+
+ 1.fs.existsSync()可以检查文件是否存在
+ 2. 使用fs.writeFileSync()写入文件
+ 3.appendFileSync是追加，writeFileSync是覆盖
+ 4.fs.mkdirSync('./a/b/c', { recursive: true })创建多级目录
+ 5. fs.statSync()可以获取文件的详细信息（大小、时间等）
+
+### 简答题
+
+ 1.同步方法和异步方法的区别
+ 核心区别：同步阻塞线程（等操作完成再执行），异步非阻塞（后台执行、回调通知）；
+ 写法差异：同步代码线性直观，异步需用回调 / Promise/async-await；
+ 场景选择：简单脚本用同步，高并发服务用异步。
+
+ 2.fs.readFile和fs.readFileSync有什么区别？
+ 执行模式：fs.readFile 异步非阻塞（后台执行，回调通知），fs.readFileSync 同步阻塞（等完成再执行）；
+ 错误 / 结果：同步用 try/catch 捕获错误、直接返回结果；异步通过回调参数获取错误 / 结果；
+ 场景选择：简单脚本用同步，高并发服务用异步。
+
+ 3.如何实现文件的追加写入？
+ 首先先确保包的引入
+ 然后使用fs.appendFileSync()
+
+ 4.什么是流式处理？它适合什么场景？
+ 核心定义：流式处理是将数据拆分为小块，分批次、非阻塞地读取 / 写入 / 处理，内存占用极低；
+ 核心优势：处理大文件 / 持续数据时，避免内存溢出，提升程序稳定性和性能；
+ 适用场景：大文件读写、实时数据传输、边读边处理的转换场景、高并发服务端接口；小文件 / 需完整数据处理的场景不适合。
+
+ 5.如何监听文件的变化？
+ 原生首选：fs.watch 性能高，适合大多数场景；fs.watchFile 兼容性好但性能稍差；
+ 生产环境：优先用 chokidar，解决跨平台差异，API 更友好；
+ 关键技巧：监听文件修改时加 try/catch 处理错误，频繁触发时加防抖逻辑。
+
+### 操作
+```
+//同步读取
+// const fs = require('fs')
+
+// const content =fs.readFileSync('./test.txt','utf-8')
+
+// console.log(content);
+
+//异步读取
+// fs.readFile('./work.txt','utf-8',(err,work)=>{
+// if(err){
+// console.error('读取失败:',err);
+// return;
+// }
+// console.log('读取内容',work);
+
+// });
+
+//同步写入（这里的writeFileSync会覆盖文件的内容）
+// const fs = require('fs');
+// fs.writeFileSync('./work.txt', 'hello,帅气的小灰灰')
+//追加写入(不会覆盖原文件的内容)
+// fs.appendFileSync('./work.txt', '为什么小灰灰这么帅/n');
+
+
+//异步写入
+// const fs = require('fs');
+
+// fs.writeFile('./work.txt','我不是小灰灰','utf-8',(err)=>{
+// if(err)throw err;
+// console.log('写入成功');
+
+// });
+//异步追加
+// fs.appendFile('./work.txt','骗你的我是小灰灰\n',(err=>{
+// if(err)throw err;
+// console.log('追加成功');
+
+// }));
+
+//实现一个函数，递归复制整个目录（要点：读取目录 拼路径 文件夹递归调用自己
+// const fs = require('fs');
+// const path = require('path');
+// function scan(dir) {
+// try {
+// fs.readdirSync(dir).forEach(file => {
+// const fullPath = path.join(dir, file);
+// console.log(fullPath);
+
+// if (fs.statSync(fullPath).isDirectory()) {
+// scan(fullPath);
+// }
+
+// });
+// } catch (err) {
+
+// }
+// }
+// scan('./')
+//try catch的作用遇到不能访问的目录自动跳过
+
+//文件搜索
+
+```
\ No newline at end of file
diff --git "a/\345\205\250\344\277\212\346\236\227/20260320-http\346\250\241\345\235\227.md" "b/\345\205\250\344\277\212\346\236\227/20260320-http\346\250\241\345\235\227.md"
new file mode 100644
index 0000000..36155f0
--- /dev/null
+++ "b/\345\205\250\344\277\212\346\236\227/20260320-http\346\250\241\345\235\227.md"
@@ -0,0 +1,73 @@
+## http模块
+### 笔记
+|作用 |说明|
+|---|---|
+|创建服务器 |使用http.createServer()|
+|发送请求 |使用http.request()|
+|处理请求 |获取URL、Method、参数等|
+|返回响应 |发送HTML、JSON、图片等|
+
+### 核心知识点
+|识点 |关键内容|
+|---|---|
+|创建服务器 |http.createServer()|
+|请求对象 |req.method / req.url / req.headers|
+|URL解析 |new URL() / searchParams|
+|客户端 |http.get() / http.request()|
+
+创建一个HTTP服务器需要使用哪个模块？（B）
+A. url
+B. http
+C. fs
+D. path
+
+获取请求的方法（GET、POST）应该访问哪个属性？（B）
+A. req.url
+B. req.method
+C. req.headers
+D. req.body
+
+设置响应状态码使用哪个属性？（B）
+A. res.status
+B. res.statusCode
+C. res.code
+D. res.statusNumber
+
+返回JSON数据需要设置什么响应头？（B）
+A. 'Content-Type': 'text/html'
+B. 'Content-Type': 'application/json'
+C. 'Content-Type': 'text/plain'
+D. 'Content-Type': 'application/xml'
+
+使用哪个方法发送响应？（C）
+A. res.send()
+B. res.write()
+C. res.end()
+D. res.close()
+
+### 简答题
+请解释req和res分别代表什么？
+req：别人发给我的东西（请求）
+res：我要返回给别人的东西（响应）
+
+
+http.createServer的回调函数接收哪些参数？
+http.createServer() 的回调函数固定接收 req（请求对象）和 res（响应对象）两个参数；
+req 用于读取客户端的请求信息，res 用于向客户端返回响应数据；
+回调函数每次接收到新请求时触发，且必须通过 res.end() 结束响应。
+
+
+如何获取URL中的查询参数？
+用 new URL(req.url, '基准地址')
+再用 .searchParams.get('参数名') 获取查询参数
+
+
+res.writeHead和res.setHeader有什么区别？
+etHeader = 攒响应头
+writeHead = 发响应头 + 状态码
+
+
+http.get和http.request有什么区别？
+仅需发送 GET 请求 → 优先用 http.get()，代码更简洁，无需手动调用 end()；
+需发送 POST/PUT/DELETE 等请求，或需要自定义请求头、请求体 → 必须用 http.request()；
+http.get() 是 http.request() 的 GET 专用封装，核心逻辑完全依赖后者。
\ No newline at end of file
--
Gitee
From 26032292a2167e8737d08f0f7025cc8d848d0fd6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=A8=E4=BF=8A=E6=9E=97?= <3228239486@qq.com>
Date: Sun, 29 Mar 2026 18:36:42 +0800
Subject: [PATCH 5/5] feat:zuoye
---
...13\344\273\266\345\276\252\347\216\257.md" | 120 ++++++++++
.../20260325-EVentEmitter.md" | 112 +++++++++
...260326-\345\210\235\350\257\206express.md" | 213 +++++++++++++++++
...67\346\261\202\345\244\204\347\220\206.md" | 226 ++++++++++++++++++
4 files changed, 671 insertions(+)
create mode 100644 "\345\205\250\344\277\212\346\236\227/20260323-\344\272\213\344\273\266\345\276\252\347\216\257.md"
create mode 100644 "\345\205\250\344\277\212\346\236\227/20260325-EVentEmitter.md"
create mode 100644 "\345\205\250\344\277\212\346\236\227/20260326-\345\210\235\350\257\206express.md"
create mode 100644 "\345\205\250\344\277\212\346\236\227/20260327-\350\267\257\347\224\261\344\270\216\350\257\267\346\261\202\345\244\204\347\220\206.md"
diff --git "a/\345\205\250\344\277\212\346\236\227/20260323-\344\272\213\344\273\266\345\276\252\347\216\257.md" "b/\345\205\250\344\277\212\346\236\227/20260323-\344\272\213\344\273\266\345\276\252\347\216\257.md"
new file mode 100644
index 0000000..d07cf01
--- /dev/null
+++ "b/\345\205\250\344\277\212\346\236\227/20260323-\344\272\213\344\273\266\345\276\252\347\216\257.md"
@@ -0,0 +1,120 @@
+## 事件循环
+
+### 笔记
+- 事件循环的核心理念：不等结果，做别的事，结果到了再处理！
+
+什么是宏任务？
+- 宏任务（MacroTask）是Event Loop的基本单位，每次执行一个。
+
+什么是微任务？
+- 宏任务（MacroTask）是Event Loop的基本单位，每次执行一个。
+
+### 核心知识点
+| 知识点 | 关键内容 |
+| -------- | ------------------------------------------ |
+| 事件循环 | Node.js处理异步任务的机制 |
+| 执行阶段 | timers → pending → poll → check → close |
+| 宏任务 | setTimeout、setInterval、setImmediate、I/O |
+| 微任务 | Promise.then、process.nextTick |
+| 执行顺序 | 同步 → 微任务 → 宏任务 |
+
+
+ 事件循环 = 单线程处理并发
+ Promise.then = 微任务
+ 微任务在 每个宏任务后 清空
+ process.nextTick 比 Promise 先执行
+ 大量同步计算 会阻塞事件循环
+### 任务
+
+事件循环的目的是什么？ B
+A. 提高代码执行速度
+B. 让单线程处理大量并发请求
+C. 增加内存使用
+D. 简化代码结构
+
+以下哪个不是宏任务？C
+A. setTimeout
+B. setImmediate
+C. Promise.then
+D. I/O操作
+
+微任务的执行时机是？B
+A. 宏任务之前
+B. 每个宏任务之后
+C. 同步代码之前
+D. 随机执行
+
+process.nextTick和Promise.then哪个先执行？B
+A. Promise.then先执行
+B. process.nextTick先执行
+C. 同时执行
+D. 不确定
+
+以下哪种情况会阻塞事件循环？C
+A. 使用setTimeout
+B. 使用fs.readFile（异步）
+C. 使用for循环进行大量计算
+D. 使用事件监听
+
+### 简答
+
+1.什么是事件循环？它在Node.js中起什么作用？
+ 事件循环（Event Loop）是 Node.js 实现非阻塞异步 I/O的核心机制。
+ Node.js 是单线程的，事件循环让这一个线程可以：
+ 先执行同步代码
+ 处理异步任务（定时器、网络、文件 I/O 等）
+ 按顺序调度宏任务、微任务
+ 不断循环，让单线程也能处理高并发
+
+2.宏任务和微任务有什么区别？请举例说明。
+ 宏任务（Macrotask）
+ 每次事件循环只取一个执行
+ 执行完后会清空所有微任务
+ 优先级低于微任务
+ 例子：
+ setTimeout / setInterval
+ setImmediate
+ I/O 操作（fs、网络请求）
+ script 整体代码
+ 微任务（Microtask）
+ 会在当前宏任务执行完后立即全部清空
+ 优先级高于下一个宏任务
+ 微任务内部又分优先级：process.nextTick > Promise.then
+ 例子：
+ Promise.then / catch / finally
+ process.nextTick
+ queueMicrotask
+ 核心区别一句话
+ 宏任务一个个执行，微任务一批清空；微任务永远在宏任务之前执行。
+
+3.请解释以下代码的执行顺序：
+ console.log('1');
+ setTimeout(() => console.log('2'), 0);
+ Promise.resolve().then(() => console.log('3'));
+ process.nextTick(() => console.log('4'));
+ console.log('5');
+
+任务执行顺序 1->5->4->3->2
+
+4.什么是阻塞事件循环？它会对应用造成什么影响？
+
+ 阻塞事件循环：
+ 事件循环是单线程，一旦遇到长时间同步计算、死循环、复杂计算，线程被占住，事件循环 就卡住，不再处理任何异步任务。
+
+ 造成的影响：
+ 服务器不再响应请求
+ 定时器不执行
+ I/O 回调不触发
+ 接口超时、服务假死
+ CPU 占用 100%
+
+5.如何避免阻塞事件循环？
+ 避免长时间同步计算复杂计算拆分成小块，用 setTimeout/setImmediate 分段执行
+ 使用异步 API文件、网络、数据库都用异步方法，不要用同步版（fs.readFileSync）
+ 把 CPU 密集任务交给子进程 / 线程
+ child_process
+ worker_threads
+ 单独服务处理
+ 使用队列处理任务如 bull、bee-queue 等，避免主线程压力过大
+ 避免死循环、无限递归
+
diff --git "a/\345\205\250\344\277\212\346\236\227/20260325-EVentEmitter.md" "b/\345\205\250\344\277\212\346\236\227/20260325-EVentEmitter.md"
new file mode 100644
index 0000000..d2d81eb
--- /dev/null
+++ "b/\345\205\250\344\277\212\346\236\227/20260325-EVentEmitter.md"
@@ -0,0 +1,112 @@
+### EventEmitter
+#### 笔记
+EventEmitter的作用
+| 场景 | 不使用EventEmitter | 使用EventEmitter |
+| -------- | ------------------ | ---------------- |
+| 用户登录 | 轮询检查是否登录 | 登录成功自动通知 |
+| 文件上传 | 不断检查进度 | 上传进度实时推送 |
+| 收到消息 | 定时刷新 | 消息到达自动提醒 |
+
+ 创建EventEmitter
+```
+const EventEmitter = require('events');
+
+// 方式1：直接使用
+const emitter = new EventEmitter();
+
+// 方式2：继承EventEmitter
+class MyEmitter extends EventEmitter {}
+const emitter = new MyEmitter();
+```
+监听事件 - on()
+```
+const EventEmitter = require('events');
+const emitter = new EventEmitter();
+
+// 监听事件 -on()
+emitter.on('eventName', (data) => {
+ console.log('收到事件:', data);
+});
+
+// 多次监听
+emitter.on('eventName', () => {
+ console.log('第二个监听器');
+});
+```
+
+触发事件 - emit()
+```
+// 触发事件
+emitter.emit('eventName');
+emitter.emit('eventName', { message: 'Hello' });
+emitter.emit('eventName', 'arg1', 'arg2');
+```
+
+一次性事件 -once()
+```
+// 只触发一次 -once()
+emitter.once('eventName', () => {
+ console.log('只会执行一次');
+});
+
+emitter.emit('eventName'); // 执行
+emitter.emit('eventName'); // 不执行
+```
+移除监听器 -off()
+```
+function listener1() {
+ console.log('listener1');
+}
+
+function listener2() {
+ console.log('listener2');
+}
+
+emitter.on('event', listener1);
+emitter.on('event', listener2);
+
+// 移除指定监听器
+emitter.off('event', listener1);
+
+// 只剩listener2
+emitter.emit('event'); // 只输出 listener2
+```
+
+移除所有监听器
+```
+// 移除某个事件的所有监听器
+emitter.removeAllListeners('event');
+
+// 移除所有监听器
+emitter.removeAllListeners();
+```
+
+- 小结
+| 方法 | 说明 |
+| ---------------------- | -------------- |
+| on(event, listener) | 监听事件 |
+| once(event, listener) | 一次性监听 |
+| emit(event, [...args]) | 触发事件 |
+| off(event, listener) | 移除监听器 |
+| removeAllListeners() | 移除所有监听器 |
+| listenerCount() | 获取监听器数量 |
+
+常用模式
+```
+const EventEmitter = require('events');
+
+// 创建
+const emitter = new EventEmitter();
+
+// 监听
+emitter.on('event', callback);
+
+// 触发
+emitter.emit('event', data);
+
+// 一次性
+emitter.once('event', callback);
+
+// 移除
+emitter.off('event', callback);
+```
diff --git "a/\345\205\250\344\277\212\346\236\227/20260326-\345\210\235\350\257\206express.md" "b/\345\205\250\344\277\212\346\236\227/20260326-\345\210\235\350\257\206express.md"
new file mode 100644
index 0000000..622be8c
--- /dev/null
+++ "b/\345\205\250\344\277\212\346\236\227/20260326-\345\210\235\350\257\206express.md"
@@ -0,0 +1,213 @@
+## 初识express
+
+## 笔记
+# express项目初解
+
+## 项目初始化
+
+- 创建项目文件夹
+- 进入项目文件夹
+- 使用vscode打开项目文件夹
+- 创建package.json
+ - npm init -y
+ - npm init
+ - 手动创建
+ - 安装任意依赖包即可自动创建
+- 安装express包
+- 安装nodemon开发时依赖包
+- 配置package.json
+ - "type":"module"
+ - "scripts":{"dev":"nodemon app.js"}
+
+
+## 代码架构
+- 使用express创建服务器实例：`let app=express()`
+- 启动服务器实例:app.listen(端口号)
+
+## express的请求和响应对象（req和res只和顺序有关，和名称无关）
+- 请求对象
+ - req.method 请求的方法
+ - req.url 请求的路径
+ - req.query 查询字符串
+ - req.params 路由参数
+ - req.body 请求体
+- 响应对象
+ - res.send() 可以响应字符串和html片段
+ - res.json() 响应json数据
+ - res.redirect() 重定向
+ - res.download() 下载
+ - res.status().send() 返回指定状态码以及数据
+
+## 作业
+### 选择
+Express是哪个语言的Web框架？ C
+A. Python
+B. Java
+C. JavaScript
+D. PHP
+
+启动Express服务器需要调用哪个方法？ C
+A. app.run()
+B. app.start()
+C. app.listen()
+D. app.create()
+
+以下哪个方法用于返回JSON数据？ B
+A. res.send()
+B. res.json()
+C. res.text()
+D. res.html()
+
+Express相比原生Node.js的优势不包括？C
+A. 代码更少
+B. 路由自动匹配
+C. 内置数据库
+D. 中间件支持
+
+GET请求通常用于？ C
+A. 创建资源
+B. 更新资源
+C. 获取资源
+D. 删除资源
+
+### 简答题
+什么是RESTful API？它的设计原则是什么？
+
+ 1、RESTful API 就是一套规范、统一、易懂的接口设计风格，用来让前端和后端（或者服务和服务之间）进行数据交互。
+
+ 2、
+ 使用标准 HTTP 方法
+ URL 使用名词，不用动词
+ 用路径参数表示唯一资源
+ 用查询参数做过滤、分页、排序
+ 使用标准 HTTP 状态码
+ 返回统一格式的数据
+
+req对象和res对象分别代表什么？它们有哪些常用属性和方法？
+
+ req（请求）= 拿数据
+ req.query → 拿？参数
+ req.params → 拿路径参数 /users/:id
+ req.body → 拿 POST 数据
+ req.method → 拿请求方式
+
+ res（响应）= 返数据
+ res.send() → 返回文本 / HTML
+ res.json() → 返回 JSON（接口必用）
+ res.status() → 设置状态码
+
+ req 用来收，res 用来发；
+ query 拿参数，json 返数据！
+
+Express中使用哪个方法启动服务器？它接收哪些参数？
+
+ Express 中使用 app.listen() 方法启动服务器。
+
+ 1. 端口号 port（必填）
+ 2. 主机 host（可选，默认：0.0.0.0）
+ 3. 回调函数 callback（可选）
+
+前后端分离的开发模式有什么优点？
+
+ 前后端分离 = 现代开发的标准模式
+ 优点就是：快、稳、省、好维护、用户体验棒
+
+为什么学习Express而不是直接使用原生Node.js？
+
+ 原生 Node：底层、繁琐、不适合业务开发
+ Express：封装好、简单快、企业标准、必学
+ 学习 Express = 用最少的时间，写出最实用的后端服务
+
+
+### 操作题
+
+- 关键代码
+```
+import express from 'express';
+import { log } from 'console';
+import { port } from './config.js'
+
+let app = express();
+
+//首页
+app.get('/', (req, res) => {
+
+ res.send(`
+ Express学习demo
+
+ `);
+});
+
+//关于页面
+
+app.get('/about', (req, res) => {
+
+ res.send(`
+ Express我
+
+ 关于我
+ 这是一个expres学习项目
+ 作者小灰灰
+ - 首页
+
+ `)
+})
+
+//联系页面
+
+app.get('/contact', (req, res) => {
+
+ res.send(`
+ 如何联系我
+ Email: test@example.com
+ Phone: 13800138000
+ 首页
+ `)
+})
+
+
+app.get('/api/users', (req, res) => {
+ res.json([
+ { id: 1, name: '张三' },
+ { id: 2, name: '李四' },
+ { id: 3, name: '王五' }
+ ]);
+});
+
+//创建计算器api
+app.get('/api/calc', (req, res) => {
+ //拿到参数
+ let a = Number(req.query.a);
+ let b = Number(req.query.b);
+ let op = req.query.op;
+ log(a)
+ log(b)
+ log(op)
+
+
+ //计算
+ if (op === 'add') res.send(a + b + '');
+ if (op === 'sub') res.send(a - b + '');
+ if (op === 'mul') res.send(a * b + '');
+ if (op === 'div') res.send(a / b + '');
+})
+
+//静态页面服务
+
+app.get('/api/blogs', (req, res) => {
+ res.send('返回页面')
+})
+
+
+app.listen(port, () => {
+ console.log(`服务器运行在 http://localhost:${port}`);
+
+})
+
+
+
+```
diff --git "a/\345\205\250\344\277\212\346\236\227/20260327-\350\267\257\347\224\261\344\270\216\350\257\267\346\261\202\345\244\204\347\220\206.md" "b/\345\205\250\344\277\212\346\236\227/20260327-\350\267\257\347\224\261\344\270\216\350\257\267\346\261\202\345\244\204\347\220\206.md"
new file mode 100644
index 0000000..e68ea55
--- /dev/null
+++ "b/\345\205\250\344\277\212\346\236\227/20260327-\350\267\257\347\224\261\344\270\216\350\257\267\346\261\202\345\244\204\347\220\206.md"
@@ -0,0 +1,226 @@
+## 路由与请求处理
+### 笔记
+ 什么是路由？
+路由就是确定当客户端请求某个URL时，应该由哪个代码来处理。就像打电话时，交换机会根据电话号码把你的请求转到对应的人。
+
+#### 求情类型
+HTTP协议定义了多种请求方法：
+
+| 方法 | 说明 | 幂等 |
+| ------ | -------- |
+| GET | 获取资源 | 是 |
+| PUT | 完全更新 | 是 |
+| PATCH | 部分更新 | 否 |
+| DELETE | 删除资源 | 是 |
+
+#### 定义路由
+```
+const express = require('express');
+const app = express();
+
+// GET请求 - 获取数据
+app.get('/users', (req, res) => {
+ res.send('用户列表');
+});
+
+// POST请求 - 创建数据
+app.post('/users', (req, res) => {
+ res.send('创建用户');
+});
+
+// PUT请求 - 完全更新
+app.put('/users/:id', (req, res) => {
+ res.send('更新用户');
+});
+
+// PATCH请求 - 部分更新
+app.patch('/users/:id', (req, res) => {
+ res.send('部分更新用户');
+});
+
+// DELETE请求 - 删除数据
+app.delete('/users/:id', (req, res) => {
+ res.send('删除用户');
+});
+
+// 所有方法
+app.all('/users', (req, res) => {
+ res.send('任何方法都可以');
+});
+```
+- 什么是RESTful？
+
+ REST（Representational State Transfer）是一种API设计规范，遵循以下原则：
+ 使用HTTP方法表达动作
+ 使用URL表示资源
+ 无状态通信
+ 返回JSON格式
+
+#### 常用代码
+```
+// 定义路由
+app.get('/path', handler);
+app.post('/path', handler);
+
+// 获取参数
+req.query.keyword; // 查询参数
+req.params.id; // 路由参数
+req.body.name; // 请求体
+
+// 响应
+res.json({ data: ... });
+res.status(201).json({ ... });
+```
+#### RESTful规范
+| 方法 | 路径 | 说明 |
+| ------ | ---------- | ------------ |
+| GET | /users | 获取用户列表 |
+| GET | /users/:id | 获取单个用户 |
+| POST | /users | 创建用户 |
+| PUT | /users/:id | 更新用户 |
+| DELETE | /users/:id | 删除用户 |
+
+#### 选择题
+获取URL查询参数应该使用哪个对象？ B
+A. req.params
+B. req.query
+C. req.body
+D. req.url
+
+以下哪个HTTP方法用于创建资源？C
+A. GET
+B. PUT
+C. POST
+D. DELETE
+
+要获取路由参数 /users/:id 中的id，应该使用？B
+A. req.query.id
+B. req.params.id
+C. req.body.id
+D. req.url.id
+
+POST请求的参数在哪个对象中？C
+A. req.query
+B. req.params
+C. req.body
+D. req.headers
+
+Express中解析JSON请求体需要使用哪个中间件？B
+A. express.urlencoded
+B. express.json
+C. express.static
+D. express.Router
+
+#### 简答
+1.请解释GET、POST、PUT、DELETE四种方法的区别。
+以上四种方法对应增删改查
+ GET
+ 用途：查询、获取资源
+ 特点：参数在 URL，可缓存，幂等，无副作用
+ 例子：获取文章列表、获取用户信息
+ POST
+ 用途：新增、创建资源
+ 特点：参数在请求体，不缓存，不幂等
+ 例子：注册用户、发布评论
+ PUT
+ 用途：完整更新资源（覆盖式）
+ 特点：参数在请求体，幂等
+ 例子：修改用户全部信息、覆盖文章内容
+ DELETE
+ 用途：删除资源
+ 特点：幂等
+ 例子：删除文章、取消订单
+
+2.query参数和params参数有什么区别？分别在什么时候使用？
+ params（路由参数）
+ 形式：/users/:id
+ 获取：req.params.id
+ 作用：定位资源，标识唯一资源
+ 使用场景：获取、修改、删除某个具体资源
+ query（查询字符串）
+ 形式：/search?keyword=xxx&page=1
+ 获取：req.query.keyword
+ 作用：对资源筛选、分页、排序
+ 使用场景：列表过滤、分页、条件查询
+
+3.什么是RESTful API？它的设计原则是什么？
+ REST（Representational State Transfer）是一种API设计规范，遵循以下原则：
+ 使用HTTP方法表达动作
+ 使用URL表示资源
+ 无状态通信
+ 返回JSON格式
+4.为什么要在路由中使用RESTful规范？有什么好处？
+ 接口语义清晰，一看 URL + 方法就知道干什么
+ 统一规范，多人协作、前后端对接更简单
+ 易于维护和扩展，结构稳定
+ 符合 HTTP 标准，能利用缓存、状态码等特性
+ 通用性强，移动端、前端、第三方都能轻松接入
+5.express.json()中间件的作用是什么？
+ 作用：解析客户端传来的 JSON 格式请求体
+ 把 JSON 字符串转成 JS 对象，挂载到 req.body
+ 不加它，req.body 就是 undefined
+
+#### 操作题
+关键代码
+```
+import express from 'express'
+
+let app = express();
+app.use(express.json());
+
+const db = [
+ {
+ id: 1,
+ username: 'admin01',
+ avatar: ''
+ },
+ {
+ id: 2,
+ username: 'admin02',
+ avatar: ''
+ },
+ {
+ id: 3,
+ username: 'admin03',
+ avatar: ''
+ },
+ {
+ id: 4,
+ username: 'admin04',
+ avatar: ''
+ },
+
+]
+
+//获取所有用户
+app.get('/api/users', (req, res) => {
+ res.json({
+ code: 1000,
+ data: db,
+ msg: '获取所有用户成功^_^'
+ })
+})
+//获取指定用户
+app.get('/api/users/:id', (req, res) => {
+
+})
+
+//新增用户
+app.post('/api/users', (req, res) => {
+
+})
+
+//修改指定用户
+app.put('/api/users/:id', (req, res) => {
+
+})
+
+//删除指定用户
+app.delete('/api/users/:id', (req, res) => {
+
+})
+let port = 3000;
+app.listen(port, () => {
+ console.log(`服务器运行的地址：http://localhost:${port}`);
+});
+```
\ No newline at end of file
--
Gitee