hecloud.top

茶叶品类大全

Mon, 14 Sep 2026 00:00:00 GMT

笔者对茶叶品鉴能力不强，目前感受最强的是信阳毛尖，有一种绿茶夹杂的豆香味，更多的茶叶待我评鉴之后更新于此

Linux文件系统目录扫盲

Sun, 13 Sep 2026 00:00:00 GMT

公告与固定页面文案维护

Mon, 07 Sep 2026 00:00:00 GMT

📖 本文管什么#

站点上除了「文章 / 碎碎念」这两种会持续新增的内容，还有一批固定的站点文案——侧边栏公告、关于页、留言板、隐私政策等。它们不常改，但真要改的时候得知道去哪。

一、侧边栏公告#

改公告文字 → `src/config/announcementConfig.ts`#

1
export const announcementConfig = {
2
    title: "",          // 公告栏标题，留空显示默认「公告」
3
    content: "……公告正文……",  // ← 要改的就是这
4
    closable: false,    // true = 访客可点 × 关闭
5
    link: {
6
        enable: true,   // 底部是否放链接
7
        text: "了解更多",
8
        url: "/about/",
9
        external: false, // true = 新窗口外链
10
    },
11
};

可用可选字段：type: "info" | "warning" | "success" | "error"（左侧装饰色），icon（图标名）。

⚠️ 公告是纯文本#

content 里写 Markdown 不会渲染，**加粗**、[链接]() 会原样显示符号。想要链接就走下面那个 link 字段。

显示 / 隐藏公告 → 不在公告配置里！#

公告是「侧边栏组件」，开关注册在 src/config/sidebarConfig.ts。桌面端在 leftComponents、移动端在 mobileBottomComponents 里都有一组 type: "announcement"：

1
{
2
    type: "announcement",
3
    enable: true,      // ← 改成 false 就隐藏
4
    position: "top",
5
    showOnPostPage: true,
6
},

想调公告在侧栏的上/下顺序，也在这里挪位置。

二、固定页面（spec）文案#

「关于我 / 留言板 / 隐私政策 / 用户协议 / 友链信息」这类页面的正文，存在 src/content/spec/ 里，像改普通 Markdown 一样改它们：

页面	文件
关于	`src/content/spec/about.md`
留言板	`src/content/spec/guestbook.md`
隐私政策	`src/content/spec/privacy-policy.md`
用户协议	`src/content/spec/user-agreement.md`
友链页的「本站信息」	`src/content/spec/friends.mdx`

改完的发布#

这几篇是页面正文，改完同样走 git 三连即上线，没有独立的「后台」。

⚠️ 内容同步提醒#

隐私政策 / 用户协议要和站点实际能力保持一致（接入了哪些分析、评论数据存哪）。每次给站点新增会收集数据的服务（统计、弹幕、评论等）后，回来核对一遍这两篇是否还成立。
关于页里通常写着「本站架构说明」，改了架构（换图床、增减部署）要同步更新。

三、站内入口文案（顶部菜单 / 页脚）#

这类不是「正文」，但也属于站点文案，出问题要知道去哪个配置：

想改什么	文件
顶部导航菜单项	`src/config/navBarConfig.ts`
页脚自定义内容（如备案号）	`src/config/footerConfig.ts`
侧栏简介 / 头像 / 社交链接	`src/config/profileConfig.ts`

细讲见系列里「友链与站点入口维护」一篇。

✅ 速记#

公告文字 → announcementConfig.ts；公告显隐/位置 → sidebarConfig.ts
固定页面正文 → src/content/spec/ 对应文件，改完 git 三连
公告是纯文本；隐私/协议文案要跟着站点新功能走
页面文案和正文一样：改文件 → git add/commit/push → 上线

碎碎念（动态）维护指南

Mon, 07 Sep 2026 00:00:00 GMT

📖 什么是碎碎念#

和文章相对的轻量内容：几句话、随手拍、临时想法。它和文章共用一套发布流程（写文件 → git push），只是文件放不同目录、frontmatter 更简单。

	文章（posts）	碎碎念（dynamic）
目录	`src/content/posts/`	`src/content/dynamic/`
形态	长篇、可分类打标签	短句、随手记
frontmatter	十几个字段	就 3 个字段
是否进系列	可	不进系列

一、文件放在哪、怎么命名#

1
src/content/dynamic/2026-09-07-123000.md

目录固定：src/content/dynamic/
文件名 = 发布时间 YYYY-MM-DD-HHMMSS.md（命名规则即排序规则，别乱起名）
每一条碎碎念 = 一个文件

仓库里留了一条参考文件，忘了怎么写就打开看：src/content/dynamic/ 下最早那条。

二、frontmatter（只有 3 个字段）#

1
---
2
published: 2026-09-07 12:30:00    # 必填，发布时间
3
pinned: true                        # 可选，true 则置顶
4
location: 中国                      # 可选，显示地点
5
---
6

7
正文内容随便写……支持普通 Markdown。

字段	必填	作用
`published`	✅	时间。格式 `YYYY-MM-DD HH:MM:SS`
`pinned`	❌	置顶到列表顶部
`location`	❌	在卡片上显示的地点文字

三、发布：脚手架一行命令（最快）#

Terminal window

1
pnpm new-dynamic 今天的第一条碎碎念！

它自动做三件事：

用当前时间生成合法文件名
写进 src/content/dynamic/
自动填好 published 字段

一句话就一条，不需要手动想文件名和日期。

想加地点/置顶时#

脚手架只填 published，要 location/pinned 就手动补两行，或用下面的方式 B：

Terminal window

1
pnpm new-dynamic 带地点的碎碎念
2
# 然后打开生成的文件，在 --- 之间补上
3
# location: 中国

四、图片怎么放#

用标准 Markdown，多张图片会自动拼成图集：

1
正文……
2

3
![第一张](https://cdn.xxx.top/dynamic/2026-09-07-a.webp)
4
![第二张](https://cdn.xxx.top/dynamic/2026-09-07-b.webp)

图片本体先传图床（见 R2 图床运营规范），再贴链接
图片放正文任意位置即可，位置决定显示顺序

五、修改与删除#

改：直接编辑那个 .md 文件（改正文、补 location…）→ git 三步 → 覆盖更新
置顶/取消置顶：加/删 pinned: true
删除：删文件 → git 三步 → 线上消失。删除不可恢复，删前确认

发布/修改/删除都是那三连：

Terminal window

1
git add .
2
git commit -m "新增一条碎碎念"   # 或 修改 / 删除
3
git push

✅ 碎碎念速记#

随手短记录 → src/content/dynamic/
最快发布：pnpm new-dynamic 内容
frontmatter 就 published（+ 可选 pinned/location）
图片：传图床 → ![](链接)，多张自动成图集
上线方式与文章完全一样：git 三连

相册与照片墙维护指南

Mon, 07 Sep 2026 00:00:00 GMT

📖 相册的组成（记牢这个模型）#

每个相册 = 两处配置 + 一处照片来源，任何相册的增删改都逃不出这个框架：

1
① galleryConfig.ts 里加一个「相册对象」  ← 定义名字/密码/封面
2
        ↕ 靠 id 对应
3
② public/gallery/<相册id>/ 目录          ← 照片来源所在
4
        │
5
        ├─ 直接放目录里的图片文件
6
        └─ urls.txt（每行一个远程图片链接）★ 本站主力

本站照片都放对象存储，所以 public/gallery/<id>/ 目录里通常只有一个 urls.txt，图片本体不在仓库里。

一、相册对象的字段（配置在 `src/config/galleryConfig.ts`）#

1
{
2
    id: "trip-2026",            // 唯一标识 = 目录名 = 网址路径，三者必须一致
3
    name: "2026 旅行",          // 相册显示名（必填）
4
    description: "走过的地方",   // 描述
5
    date: "2026-09-07",        // 日期 YYYY-MM-DD
6
    location: "云南",           // 拍摄地
7
    tags: ["旅行", "风景"],      // 标签数组
8
    cover: "https://…",        // 手动指定封面（可选，规则见下）
9
    password: "你的密码",        // 填了就加密（存的是明文字符串，见下方安全提醒）
10
    passwordHint: "给访客的提示",// 密码提示（可选）
11
}

封面三选一规则#

你怎么写	封面是谁
不填 `cover`，目录里有 `cover.*` 图片文件	自动用 `cover.*`
不填 `cover`，也没 `cover.*`	自动用目录里第一张照片
填了 `cover: "https://…"`	用你指定的这张

⚠️ 加密相册的安全提醒#

password 字段的密码会明文写在 galleryConfig.ts 里，而 src/ 源码会打进线上包。加密相册适合「防路人、防误点」级别，别拿来存真正机密。文档示例一律写占位符，别在文章里贴真实相册密码。

二、新增一个相册（两步）#

① 建目录 + 放照片清单

1
public/gallery/trip-2026/urls.txt

urls.txt 每行一个图片链接，# 开头是注释：

1
# 2026 云南旅行
2
https://cdn.xxx.top/gallery/yunnan-1.webp
3
https://cdn.xxx.top/gallery/yunnan-2.webp

（也可以直接把图片文件丢进目录，系统会全部自动扫描收录，jpg/png/webp/avif/gif 都认。）

② 在 galleryConfig.ts 的 albums 数组里加相册对象（见上），保存 → git 三连 → 上线。

三、照片墙 / 相册页怎么显示（两个机制）#

站点有两处用到相册：

主页照片墙 —— 只显示 homeAlbumId 指定的那个相册的前 6 张：

1
homeAlbumId: "photo-wall",   // 想换主页照片墙的内容，就改这里指向别的相册 id

相册页 /gallery/ —— 列出 albums 数组里的全部相册（加密的点击要输密码），点进 /gallery/<相册id>/ 看全部照片。

想让一个相册既出现在相册页、又出现在主页照片墙：把它 id 填给 homeAlbumId 即可。主页照片墙是「绑定某个相册的前 6 张」，不是自动挑最新的——这是刻意的设计，避免加密相册被无密码展示。

四、日常维护操作速查#

想干什么	操作
往现有相册加照片	图片传图床 → `urls.txt` 加一行 → 想放最前面就插到首行
换相册封面	填 `cover: "https://…"`，或目录里放 `cover.*`
改相册名/描述	改 `galleryConfig.ts` 里对应对象
加密/解除加密	加/删 `password` 字段
主页换一批照片	改 `homeAlbumId` 指向别的相册
删除相册	两处一起删：`albums` 数组去掉对象 + 删掉 `public/gallery/<id>/` 目录

⚠️ 三个坑#

id 与目录名必须一字不差，否则照片扫出来是空的
主页照片墙只认 homeAlbumId，其它相册的照片不会出现在主页
删相册要同时删目录，否则删了配置、图片还被构建进站点

✅ 速记#

一个相册 = galleryConfig.ts 对象 + public/gallery/<id>/ 目录
加照片 → 传图床 → 往 urls.txt 加一行链接
封面不填则取 cover.* 或第一张；主页照片墙是绑 homeAlbumId 前 6 张
照片本体永远走对象存储，别往仓库塞大图

友链·导航书签·站点入口维护

Mon, 07 Sep 2026 00:00:00 GMT

📖 本文管什么#

把站点里所有「链接集合」和「身份入口」收在一起讲——友链、导航书签、顶部菜单、简介与社交链接。它们都是配置文件里的一组数组，维护方式高度相似：改数组 → git 三连。

一、友链（`src/config/friendsConfig.ts`）#

友链是一个对象数组，每项大概长这样：

1
{
2
    name: "示例站点",                    // 站点名
3
    url: "https://example.com",
4
    avatar: "https://cdn.xxx.top/page/01-example.webp",  // 头像
5
    description: "一句话介绍",
6
}

加 / 改 / 删友链#

操作	做法
加	数组末尾加一个对象
改	改对应对象字段
删	去掉对应对象
排序	一般按数组顺序，想置顶就挪到前面

⚠️ 头像一定要本地化（重要）#

不要把外链头像直接填进去。别人的头像热链到你的页面，一是依赖对方服务器、随时裂图，二是每次访问都打对方站、不礼貌也慢。

正确姿势：

把对方头像下载 → 转成 webp
传图床上传到 page/ 目录
把 avatar 填成你图床的本地链接（命名规范见 R2 图床运营规范）

已上传的本地头像也叫不回来了——所以对没配头像的友链、或头像失效的，都用「下载 → 转 webp → 传 page/」流程修。

本站自己在别人站里的信息#

友链是双向的：别人挂你，你也得在自己页面放「本站信息」给别人抄——在 src/content/spec/friends.mdx 里维护 site 对象（站点名、网址、头像、邮箱、一句话介绍）。

二、导航书签页（`src/config/booknavConfig.ts`）#

/booknav/ 页面是个收藏夹，两级结构：分组 → 组内书签。

1
export const booknavConfig = [
2
    {
3
        id: "dev",            // 分组锚点 id
4
        name: "开发",          // 分组名
5
        items: [              // 组内的书签
6
            { title: "GitHub", url: "https://github.com" },
7
            { title: "某文档", url: "https://example.com",
8
              icon: "fa7-brands:github",   // 可选，留空自动取目标 favicon
9
              desc: "说明", weight: 1, enabled: true },
10
        ],
11
    },
12
];

书签 icon 留空会自动抓目标站 favicon
weight 越大排越前（默认 0）；enabled: false 可暂时隐藏一条
增删书签 = 增删 items 里的对象

三、顶部导航菜单（`src/config/navBarConfig.ts`）#

页面顶部菜单项也在这里：

1
export const navBarConfig = {
2
    links: [
3
        { name: "全览", url: "/posts/", icon: "…" },
4
        { name: "外部链接", url: "https://example.com", external: true },  // 外部
5
        { name: "带子菜单", url: "#", children: [ /* 子菜单项 */ ] },
6
    ],
7
};

菜单项 = links 数组里的对象；children 支持二级子菜单
external: true 的项会在新窗口打开
首页那几个「板块入口」若有独立配置在页面文件里，改动入口时会单独说明，不在这个文件

四、简介与社交链接（`src/config/profileConfig.ts`）#

侧栏的「个人资料卡」内容在这：

1
export const profileConfig = {
2
    avatar: "/assets/xxx.webp",   // 头像（本地放 public/assets/ 或图床链接）
3
    name: "站点主人",
4
    bio: "主页一句话简介",
5
    sidebarBio: "侧栏简介，留空则复用 bio",   // 想主页和侧栏文案不同就填它
6
    links: [
7
        { name: "GitHub", url: "https://github.com/…", icon: "fa7-brands:github" },
8
        { name: "Email",  url: "mailto:…",            icon: "…" },
9
    ],
10
};

sidebarBio：主页 bio 和侧栏简介想显示不同文字时用（留空回退到 bio）
links：侧栏资料卡的图标链接。注意主页首屏的社交图标可能是另一处（主页背景配置里的 homeText 链接）——两处入口位置不同，都认 name/url 结构

改邮箱 / 社交号等个人资料后，记得 profileConfig.links、主页 hero 社交图标、以及 friends.mdx 里的本站信息是三处独立的，别只改一处。

五、页脚与音乐歌单#

想改什么	文件	说明
页脚底部自定义（备案号等）	`src/config/footerConfig.ts`	`customHtml` 直接写 HTML
换网易云歌单	`src/config/musicConfig.ts`	改歌单 id 即可（播放走第三方接口，主题负责拉取渲染）

换歌单：在网易云把歌单设成公开 → 复制歌单 id → 填进 musicConfig 对应字段 → 本地预览确认能加载 → git 三连。

✅ 速记#

友链、导航书签、顶部菜单、社交链接 = 四个配置文件里的数组，增删都是「加/减一个对象」
友链头像必须本地化：下载 → 转 webp → 传图床 page/
个人资料有多处副本（侧栏 profile / 主页 hero / friends.mdx），改一处记得核对其它
全部改完统一 git 三连上线

内容发布全流程（写文章 + 推送上线）

Mon, 07 Sep 2026 00:00:00 GMT

📖 一句话理解本站内容#

本站是静态站：文字（Markdown）存在 Git 仓库里，图片存在对象存储里，两者分开。你只要做一件事——改好文字 → git push，剩下的构建、上线全部自动完成。

1
你在 Obsidian / 编辑器里写 .md
2
        │
3
   图片先传图床 → 得到 https://cdn.xxx.top/xxx.webp
4
        │
5
   正文里用 ![](图片链接) 引用
6
        │
7
   git add → commit → push（GitHub）
8
        │
9
   云端自动构建 → 站点更新

仓库的位置、图床的上传工具、每次构建后去哪个平台确认，见本系列「R2 图床运营规范」。本文只讲「内容怎么发布」。

一、内容文件都放在哪#

1
src/content/
2
├── posts/      ← 博客文章（长篇，本文的主角）
3
│   ├── xxx.md
4
│   └── 子目录/  ← 也可以建子目录归类，不影响发布
5
├── dynamic/    ← 碎碎念（短记录，单独一篇讲）
6
└── spec/       ← 固定页面（关于/留言板/协议）

判断标准：想认真写的长篇 → posts；随手一句话/一张图 → dynamic；站点固定文案 → spec。

二、新建一篇文章#

方式 A：脚手架命令（推荐）#

Terminal window

1
pnpm new-post my-first-post

会在 src/content/posts/my-first-post.md 生成带完整 frontmatter 模板的文件，你只需填内容。

方式 B：手动新建#

在 src/content/posts/ 里新建 .md 文件，最少只需 3 个字段：

1
---
2
title: 我的第一篇文章      # 网页显示的大标题
3
published: 2026-09-07      # 发布日期，决定出现在哪一天
4
category: 闲谈杂录           # 分类（留空也可以）
5
---
6
正文……支持完整 Markdown。

常用可选字段#

字段	作用	什么时候用
`description`	摘要，显示在列表卡片上	想让首页简介好看点就填
`tags`	标签数组 `[A, B]`	按主题聚合同类文章
`image`	封面图	网络链接或相对路径
`pinned`	`true` = 置顶到列表顶部	公告类、长期有效文章
`draft`	`true` = 草稿，不上线	没写完不想发布
`updated`	修订日期	大改后补一笔
`password` / `passwordHint`	加密整篇正文	私密文章（见系列「文章加密」篇）
`series` / `seriesOrder`	归入系列	见下文

⚠️ cover 图片规范：封面、正文图片一律传图床后填 https://… 完整链接，不要往仓库里塞图片文件（会让仓库变大、构建变慢）。传图细节见 R2 图床运营规范。

三、系列字段（series / seriesOrder）#

「系列」就是把几篇文章串成一个合集，在 /series/ 页面统一展示、自动生成上一篇/下一篇导航。

1
---
2
title: 某一篇
3
series: "Firefly 教程"     # 填同一个系列名 → 自动归到一起
4
seriesOrder: 5             # 该系列内的排序，数字小的在前
5
---

归到哪个系列，取决于 series 填的名字，跟文件在哪个目录无关
不填 series = 独立文章，不进任何系列
seriesOrder 只影响系列内顺序，不影响主页按日期的排序

本站约定：以后所有本站维护教程都放进 Firefly 教程 系列，新文章记得 seriesOrder 接续现有最大号。

四、发布：git 三步#

写完、本地预览没问题后，在仓库根目录执行：

Terminal window

1
git add .
2
git commit -m "新增：xxx 文章"
3
git push

三步各管一件事：

命令	作用
`git add .`	把改动「登记」进暂存区
`git commit`	打一个本地存档点
`git push`	把存档传到 GitHub —— 只有这一步才会触发线上构建

commit 消息建议用 新增：… / 修改：… / 删除：… 开头，方便以后翻历史。

push 成功后，GitHub 会自动触发构建，多个部署平台陆续更新。构建需要一两分钟，别急着刷新。

本地预览（发布前检查）#

Terminal window

1
pnpm dev        # 打开 http://localhost:4321 预览
2
pnpm build      # 生产构建，发布前跑一遍确保没报错

pnpm 全部指令、构建流水线原理、常见坑，见本系列「pnpm 常用指令速查」。

五、修改与删除文章#

改文字：直接改 .md → git 三步 → 覆盖更新
改网址：文章网址 = 文件相对路径去掉扩展名（my-first-post.md → /posts/my-first-post/）。改名 = 改网址，会让旧链接 404、影响已分享出去的地址——发布过的文章尽量别改名
下线文章：最稳妥是 draft: true（保留草稿可再启用）；真要删就删文件，但注意删了无法找回

六、Obsidian 写作小贴士（个人习惯）#

Markdown 语法与系列里的《Markdown 教程》一致，Obsidian 所见即所得
传图用图床工具，自动返回 ![](链接) 格式直接粘贴
写「本站维护教程」时，正文开头能配一张封面/示意图观感更好

✅ 发布清单（自检）#

图片已传图床、正文里是 https://… 链接（不是本地路径）
frontmatter 完整，published 是 YYYY-MM-DD
pnpm dev 本地能正常渲染
git add → commit → push 三连，push 输出无报错
一分钟后线上刷新能看到

pnpm 常用指令速查（本地开发与构建）

Mon, 07 Sep 2026 00:00:00 GMT

📖 前置须知#

本站强制使用 pnpm（项目里配了 preinstall: only-allow pnpm，用 npm/yarn 会被拦下）
环境要求：Node ≥ 22.23，pnpm 11 系（package.json 里锁了 packageManager）
换机器/新克隆仓库后，先 pnpm install 装依赖，再跑下面命令

一、指令速查表#

指令	作用	什么时候用
`pnpm install`	安装依赖	新克隆仓库 / 首次使用 / 报缺依赖
`pnpm dev`	起本地开发服务器（localhost<4321>，改代码热更新）	日常写文章/改配置预览
`pnpm build`	生产构建，产物输出到 `dist/`	发布前必跑，确保能构建成功
`pnpm preview`	本地预览 `dist/` 构建产物	想模拟线上效果时
`pnpm new-post 文件名`	脚手架：建一篇新文章	写新文章（见下）
`pnpm new-dynamic 内容`	脚手架：建一条碎碎念	发碎碎念
`pnpm check`	`astro check` 类型与内容集合检查	改代码后查错误
`pnpm type-check`	TypeScript 类型检查（tsc）	同上，更严格
`pnpm lint` / `pnpm format`	代码规范检查/自动格式化	改过 `.ts/.astro` 源码后
`pnpm astro <子命令>`	直接调 Astro CLI	一些高级操作

需要联网才能完成的#

pnpm install（装依赖）、pnpm new-post 里的中文转拼音（内置依赖）、build 时可能的封面数据拉取（按配置，网络不好会慢/跳过）。

二、内容脚手架#

建文章 `pnpm new-post <文件名>`#

Terminal window

1
pnpm new-post my-first-post        # 或中文名也行
2
pnpm new-post guide/xxx            # 支持子目录，自动建目录

它会在 src/content/posts/ 建好文件，自动补 .md 扩展名、填好今天的日期和一套 frontmatter 模板：

1
---
2
title: my-first-post      # 记得改成真正标题
3
published: 2026-09-07     # 自动填今天
4
description: ''
5
tags: []
6
category: ''
7
draft: false
8
---

生成的 slug/title 只是模板，真正控制显示的是 frontmatter 里的 title；网址由文件名决定（见内容发布全流程）。

发碎碎念 `pnpm new-dynamic 内容`#

Terminal window

1
pnpm new-dynamic 今天的第一条碎碎念！
2
pnpm new-d            # new-dynamic 的别名

自动按当前时间命名文件、写进 src/content/dynamic/、填好 published。细节见碎碎念维护指南。

三、构建流水线（build 到底做了什么）#

pnpm build 不是单纯打包，是一整串流水线（按顺序执行）：

1
① 生成 GitHub 仓库卡片数据   → generate-github-card-data
2
② 生成图片占位 LQIP          → generate-lqips
3
③ 拉取封面数据（按配置）      → generate-vndb-covers
4
④ Astro 主构建               → astro build（产出 dist/）
5
⑤ 清理无用看板娘资源         → prune-pio-assets
6
⑥ 字体子集化                 → subset-fonts
7
⑦ 压缩内联脚本               → minify-inline-scripts
8
⑧ 生成站内搜索索引           → run-pagefind（Pagefind）

所以要理解两件事：

build 比较慢是正常的（要跑 8 步），别以为卡住了
有几步（LQIP、字体、搜索索引）的产物是要提交进仓库的——本地跑过 build 后若提示这些文件有改动，记得一并 git add，否则线上构建用的数据可能旧

四、本地发布自检流程（每次发布前）#

Terminal window

1
pnpm dev        # ① 起本地，浏览器看效果（新文章在 posts 列表/系列里）
2
# —— 满意了 ——
3
pnpm build      # ② 生产构建，确保零报错通过（可选，改动纯内容时可用 dev 代替）
4
git add . && git commit -m "新增：xxx" && git push   # ③ 上线

只加/改 Markdown 内容时，dev 预览够了；动了配置/源码（.ts、.astro、组件）建议 pnpm check + pnpm build 都过一遍再推。

⚠️ 常见坑#

现象	原因	解决
`Only pnpm is allowed`	用了 npm/yarn	换 `pnpm`
build 报 Node 版本错	Node 太老	升到 ≥ 22.23
页面图不显示，本地是好的	图片没走图床	见 R2 图床运营规范
build 后一堆文件「变了」	流水线重新生成了数据	正常，一起 commit

✅ 速记#

日常两条：pnpm dev 看效果，git 三连上线
写文章 pnpm new-post、发碎碎念 pnpm new-dynamic，让脚手架帮你填日期和模板
发布前：纯内容用 dev 预览；动了源码就 check + build 都过
build 是 8 步流水线，慢是正常的；生成的数据要记得 commit

R2 图床运营规范

Mon, 07 Sep 2026 00:00:00 GMT

📖 为什么图片要放图床#

本站文字和图片分离：

文字（Markdown）进 git 仓库 —— 仓库永远很小，克隆、构建都很快
图片进对象存储图床 —— 独立于站点，走 CDN 加速，图片挂了也不拖垮页面

所以规则是：凡是 >几十 KB 的图片，一律传图床，用 https://… 链接引用，绝不把图片文件塞进仓库。

一、上传工具（PicList）#

日常传图用 PicList（桌面图床管理工具），配好一次就不用再动。关键配置点（不含凭证）：

协议：S3 兼容
区域：auto
Endpoint：R2 专属地址（不带桶名前缀）
Path Style：开启
关闭桶名自动前缀：避免路径被重复拼成 桶/桶/文件
自定义域名：填好图床 CDN 域名，上传后它直接返回可用的 https://… Markdown 链接
拖图自动转 webp + 自动生成 ![](链接)，复制即用

凭证（Access Key / Secret）只在工具里配一次，别写进任何文档、别进 git。

二、目录与命名规范#

图床里按用途分目录，别乱堆：

目录	放什么	命名
`gallery/`	相册/照片墙、碎碎念配图	`YYYY-MM-DD-含义.webp`
`page/`	友链头像（本地化用）	`序号-域名.webp`
`firefly-tutorial/`	教程系列封面/示意图	语义化英文

命名规则：日期-含义，扩展名统一 .webp。好处是看图名就知道什么时候传的、什么内容，而且日期天然避免重名冲突。

⚠️ 别用中文文件名（链接里会带 URL 编码，复制粘贴易错），文件名里也别带空格。

三、缓存规则（配一次，但要知道）#

图床域名已配 CDN 缓存规则：Edge/Browser TTL 设为约 1 年。这样访客的图片请求打到 CDN 缓存，不会每次都回源对象存储，省流量也快。

怎么确认缓存生效：浏览器开发者工具看图片请求的响应头，cf-cache-status: HIT（缓存命中）说明走缓存；如果显示 DYNAMIC，说明还没配缓存规则、每次都在回源。

四、⚠️ 最容易踩的坑：换图必须换文件名#

因为缓存 TTL 长达 1 年，同名文件被覆盖后，访客可能几个月都看到旧图（CDN 缓存没失效）。

所以铁律：

改图 = 重新上传一个新文件名，改引用链接。永远不要覆盖同名文件。

正例：

1
原来：2026-09-07-girl.webp  → 引用了它
2
改图：上传 2026-09-07-girl-v2.webp → 把正文链接改成 v2

错误示范：直接覆盖 2026-09-07-girl.webp —— 你本地看是新图，线上访客大概率还是旧图。

五、传完图后回正文#

图床工具会返回 ![](https://cdn.xxx.top/gallery/2026-09-07-xxx.webp)，直接粘进 Markdown 即可。别手动改链接里的域名拼写，复制出来的最稳。

文章 / 碎碎念 / 相册 urls.txt 引用图片的完整流程串起来见对应各篇：

文章怎么引用 → 内容发布全流程
碎碎念配图 → 碎碎念维护指南
相册照片清单 → 相册与照片墙维护指南

✅ 速记#

大图一律图床，仓库只存文字
上传工具配好别乱动，凭证不进文档
目录 gallery/、page/… 分类放；命名 日期-含义.webp
已配 1 年缓存；看到 DYNAMIC 说明缓存没生效
改图 = 新文件名，绝不同名覆盖

00概述

Fri, 28 Aug 2026 00:00:00 GMT

本分类是Java SE的学习笔记，是我个人的根据《Java核心技术卷》的一些知识总结，如有纰漏，欢迎指出。本分类会被作为知识节点串连进入后端路线或者其它用到Java SE的技术路线中。本教程的运行环境是MacOS，不过鼓励读者在任意平台探索，体会Unix家族和Windows的差异。本系列创作过程使用AI辅助创作尽可能避免错误。

上一学年遗憾博客停更，C语言程序设计入门和数据结构部分没有被整理发布，未来如果有时间一定会把C语言部分按照严长生的《C语言小白变怪兽》教程补上，当然我也并非闲的蛋疼，C语言是学习Java SE的前置知识，本笔记也仅面向已掌握C语言的群体。

算法竞赛实际上是高级数据结构+算法，可以说包含了通俗的数据结构课程知识，我会按照罗勇军的《算法竞赛》分类将数据结构部分作为知识节点发布，内容扩充了传统的数据结构课程知识。

我的博客体系就是如此，因为需要用到Java SE的方向一定不仅有后端开发，所以每一个具体知识点我都节点化，在多个路线中共享。

卷一#

章	内容	去向	系数
Ch1	Java 概述	✅ ①	1
Ch2	编程环境	✅ ①	1
Ch3	基本结构（类型/字符串/数组/控制台IO/大数值/日期）	✅ ①	2
Ch4	对象与类（封装/构造/包/文档注释/Object方法）	✅ ②	3
Ch5	继承（多态/抽象/枚举/反射）	✅ ③	3
Ch6	接口/lambda/内部类（服务加载/clone/序列化）	✅ ④	3
Ch7	异常/断言/日志	✅ ⑤	2
Ch8	泛型（通配符/擦除）	✅ ⑥	2
Ch9	集合（含遗留集合/Properties）	✅ ⑦	2
Ch10	GUI 程序设计	❌ 跳	—
Ch11	Swing 组件	❌ 跳	—
Ch12	并发（线程/锁/原子/线程池/CompletableFuture/进程）	✅ ⑧	4

卷二#

章	内容	去向	系数
Ch1	流（Stream API：filter/map/collect/Optional/并行流）	✅ ⑨	2
Ch2	输入输出（IO 流/文件/序列化/正则/NIO）	✅ ⑩	3
Ch3	XML（DOM/SAX/StAX/XPath）	🔀 按需（JSON 为主）	1
Ch4	网络编程（Socket/HttpClient/HTTP Server）	✅ ⑪	2
Ch5	数据库编程（JDBC/事务/连接管理）	✅ ⑬	3
Ch6	日期时间（java.time 进阶，卷I Ch3 已有基础）	✅ 并入①，进阶按需	1
Ch7	国际化	❌ 跳	—
Ch8	编译与脚本（编译 API / 脚本引擎）	❌ 跳	—
Ch9	安全（类加载器/认证/签名/加密）	🔀 按需（平台安全 API，≠后端 Web 安全）	1
Ch10	GUI 程序设计	❌ 跳	—
Ch11	Swing 组件	❌ 跳	—
Ch12	高级 Swing 与图形	❌ 跳	—
Ch13	外部函数与本地方法（FFM/JNI）	❌ 跳	—

01Java背景和基本结构

Fri, 28 Aug 2026 00:00:00 GMT

1.1 Java 程序设计平台#

Java是一个完整的平台，有庞大的库，有大量可以直接抄的代码，有可以保证安全性、跨操作系统、内存垃圾回收的环境，集多种优势于一身。

1.2 Java 白皮书的关键术语#

简单性：几乎所有编程语言的推出的目的都是优化上一代编程语言的不足，Java就是在C++的特性上剔除了许多难以理解的功能。而且刚刚推出时完整占用仅在Kb级别面向对象：（一种程序设计技术）将重点放在数据上而非工具上。分布式：网络功能强大，可以打开和访问云端对象。健壮性：其指针模型可以消除重写内存和损坏数据的可能，编译器可以在运行前检测出问题。安全性：具备沙箱功能，不可信代码隔离运行。体系结构中立：编译后生成的字节码可以在任何有JRE的环境运行，和计算机体系无关。可移植性：基本数据类型和运算行为是明确的，比如int类型的大小在任何机器上都是固定的。解释性：不是纯编译型语言，先编译出字节码之后解释器翻译成机器码高性能：靠JIT即时编译，把运行次数最多的代码片段直接编译成机器码。现代的优化直逼C/C++ 多线程：第一个在语言层面内置多线程，无需附加库。动态性：按需动态加载新代码。

以上特性需要在后续学习中体会，纯看理解不了

1.3 Java applet 与 Internet#

运行在网页上的java代码是applet，开发者在网页上设计java程序发布字节码，用户端直接用本地解释器运行，当时很牛，但马上被flash碾压。

1.4 Java 发展简史#

Java 诞生于 1991 年 Sun 公司的 “Green 项目”。James Gosling 等人最初的设想是给嵌入式消费电子产品（电视机顶盒、遥控器之类）写一门语言，当时取名 Oak（橡树）。可惜产品没有找到市场，项目一度濒临放弃。

转机出现在 1995 年。互联网爆发式增长，Sun 发现网络上的设备五花八门、平台极不统一，而 Oak 的跨平台特性（编译成字节码、由各平台 JVM 解释执行）正好命中了 Web 时代的需求。于是 Oak 改名 Java 正式发布，并借助浏览器运行小程序（applet）一战成名。“一次编写，到处运行”（Write Once, Run Anywhere）成为 Java 最深入人心的口号。

此后 Java 一路快速迭代，几个关键节点：

1996 JDK 1.0 正式版
1997 JDK 1.1：内部类、反射、JDBC、RMI
1998 Java 2（1.2）：Swing、集合框架、JIT 编译器
2004 Java 5：泛型、注解、枚举、自动装箱、并发包 —— 现代 Java 的基石
2006 Java 6：脚本引擎、JDBC 4.0
2009 Oracle 收购 Sun 公司
2011 Java 7：try-with-resources、switch 支持字符串、NIO.2
2014 Java 8：lambda、Stream、java.time、接口默认方法 —— 另一个里程碑
2017 Java 9：模块系统、JShell；此后改为每半年发一版
2018/2021/2023 Java 11 / 17 / 21：长期支持版本（LTS）

只要抓住两个关键版本就够了：Java 5 定下了泛型、注解、并发这些基础语法；Java 8 是写法的分水岭，lambda 与 Stream 让 Java 从”啰嗦的 C++ 改良版”进化成了现代化的语言。之后的版本大多是在这个地基上做增量。本书正是基于这一生态展开的。

1.5 关于 Java 的常见误解#

“Java 很容易学” 语法确实比 C++ 温和，但”学语法”和”会写程序”是两码事。Java 真正的难度在生态：JVM、集合、并发、框架。入门容易，精通极难——就像 C 语法也不难，指针和内存才是坎。

“Java 能取代所有语言” 没有万能语言。C/C++ 统治系统编程与游戏引擎，Python 主导 AI，JavaScript 垄断浏览器，Go/Rust 在云原生崛起。Java 的天下是企业级后端，它再强也取代不了所有场景。

“Java 不过是换了个写法的 C/C++” 这是最值得掰扯的一条。两者的差异不在语法在运行模型：C++ 编译成机器码直接跑，Java 编译成字节码交给 JVM；C++ 手动管内存，Java 自动回收；C++ 指针能算数，Java 引用不行。同样的逻辑任何语言都能表达，但各自解决不同层面的问题——这正是本系列要慢慢体会的。

“Java 是闭源的” 反了。OpenJDK 是开源实现（GPL 许可），语言演进走公开的 JSR 流程。Oracle JDK 也只是基于 OpenJDK 的发行版。把「有大厂主导」说成「闭源」是个误会。

“JavaScript 是 Java 的简易版” 俩名字都带 “Java” 而已。Java 是 Sun 的静态类型面向对象语言，跑在 JVM；JavaScript 是 Netscape 为浏览器发明的脚本语言，跑在浏览器引擎。语法、类型系统、运行环境全都不一样，纯属当年蹭热度起的名字。

“Java 性能低下” 20 年前的刻板印象。早期纯解释执行确实慢，但 JIT 会把热点代码编成机器码，现代 JVM 峰值性能逼近 C++（大厂的高并发服务很多就是 Java）。真正的代价是启动慢、吃内存——它是「用启动速度和内存换运行性能」。

“Java 写程序容易有安全风险” 恰恰相反，Java 的安全设计是核心卖点：没有指针算术杜绝内存破坏、字节码校验、数组越界检查、沙箱机制。C/C++ 里缓冲区溢出、野指针这类经典漏洞，在 Java 里从机制上就没了。Java 的安全问题更多在应用层（框架配置、依赖漏洞），那是所有语言都躲不掉的。

第 2 章 Java 编程环境#

Hello.java（源代码） │ ① javac Hello.java ▼ Hello.class（字节码 bytecode，磁盘文件） │ ② java Hello（启动 JVM） ▼ JVM：类加载 → 字节码校验 → 执行引擎 │ ③ 解释执行 + JIT 即时编译（热点代码） ▼ 机器码（二进制，内存中，CPU 真正执行）

2.1 安装 Java 开发工具包#

https://www.java.com/zh-CN/

Java 的开源本体只有 OpenJDK 一份，Azul Zulu、Amazon Corretto、Eclipse Temurin、Oracle JDK 等全部是基于这同一份源码编译出的发行版——内核相同，差异只在打包方式、支持周期和性能优化。类比 Linux 内核 vs Ubuntu/Fedora。

运行安装程序一路下一步即可完成安装，除非你非要编译安装。记得勾选添加系统环境变量、Add to PATH一类的标识。

运行以下命令，即可查看java版本。（一般装cli软件这一步是必须做的）

Terminal window

1
javac --version

如果报错未找到command not find，多半是你忘了勾选添加环境变量，win用户去设置内找编辑系统环境变量的对话框，手动把你安装java的根目录添加于此。unix-like用户（Linux、MacOS）去~/.zshrc或~/.bashrc文件加一行export PATH=jdk/bin:$PATH(jdk/bin是linux默认安装位置，如果你装在别处请改写)

2.2 使用命令行工具#

学习Java需要具备一定的命令行基础，Java SE相关笔记中会体现一些基本用法。命令行主流教学基本都是 Unix‑like，相关深入用法在 Linux 基础与命令行 节点深入详解。

新建hw.java文件，输入

1
public class Hello {
2
    public static void main() {
3
        System.out.println("Hello World!");
4
    }
5
}

在同级目录下，使用命令

Terminal window

1
javac Hello.java
2
#先用编译器生成class字节码
3
java Hello
4
#再用JVM翻译成机器码，输出第一个hello world

以上过程初学者可能会发现一些必须要遵守的写java程序必须要遵守的原则，简称语法。遵守这些规则怪谈才能不出bug。

2.3 使用集成开发环境#

集成开发环境（IDE，Integrated Development Environment）把编辑、编译、运行、调试、代码补全等工具整合到一个图形界面里，省去手动敲命令的麻烦。

本系列使用 IntelliJ IDEA（JetBrains 出品），业界主流的 Java IDE。它分两个版本：

Community（社区版）：免费开源，本阶段够用
Ultimate（旗舰版）：付费，内置 Spring、数据库等企业开发支持——后面走后端路线时用得上

用 IDEA 跑 Hello World，本质就是把 2.2 的命令行两步（javac 编译、java 运行）搬进图形界面：新建项目 → 指定 JDK → 写代码 → 点运行。

2.4 JShell#

JShell 是 Java 9 起自带的交互式命令行工具（REPL，Read-Eval-Print Loop），类似 Python 的交互式 shell：敲一行、立刻看到结果，不用建文件、编译、运行。

终端敲 jshell 进入，试几条：

1
jshell> System.out.println("Hello World!")
2
Hello World!
3

4
jshell> 1 + 1
5
$1 ==> 2
6

7
jshell> "abc".repeat(3)
8
$2 ==> "abcabcabc"

与 Python shell 的手感差异源于语言本身：Java 声明变量要写类型（int x = 5;），语句结尾要分号。而且 JShell 只是「试用台」——验证语法、算表达式、试 API 很方便，而且还能使用tab键补全查函数名，但正经程序还是走 2.2 的编译运行或 2.3 的 IDEA。对比 C：C 没有官方 REPL，想试个语法得写文件编译，Java 这一点更顺手。

第 3 章 Java 的基本程序设计结构#

3.1 一个简单的 Java 程序#

从 Hello World 起手，对照 C 最容易看清 Java 的程序骨架，很多新概念、新名词在这里先露个脸、留个印象，具体的深入剖析需要到之后的章节。

1
public class Hello {
2
    public static void main(String[] args) {
3
        System.out.println("Hello World!");
4
    }
5
}

类名与文件名：public class Hello 声明一个公共类，类名 Hello。类名习惯以大写字母开头；源文件名必须与公共类同名（Hello.java）。Java 里所有内容都必须放进类的容器中——C 可以在文件顶层写自由函数，Java 不行，这就是「万物皆类」的起点。

访问修饰符：public 表示「公开」，谁都能访问。Java 的类、方法、字段前面几乎都有修饰符（public / private 等）控制可见性，C 没有对应概念，只能靠文件作用域和头文件的约定来模拟。

main 方法——程序入口：public static void main(String[] args)，逐词拆解：

public：JVM 要从外部调用它，必须公开
static：静态方法，不需要创建对象就能调用
void：不返回值
String[] args：命令行参数数组，对应 C 的 int argc, char *argv[]（Java 只保留了参数那半，argc 用 args.length 代替）

执行 java Hello 时，JVM 从 Hello 类的 main 方法开始运行。Java 里函数叫方法（method），等价于 C++ 的成员函数。

调用方法：通用语法是 对象.方法(参数)。System.out.println("Hello World!") 中，System 是一个类，out 是它内部代表标准输出的对象，println 是对象的方法——对应 C 的 printf。区别在于 C 调用的是库函数，Java 调用的是对象的方法，这是面向对象和面向过程的第一处体感差异。

大小写敏感：Java 严格区分大小写，Hello 和 hello 是两回事，main 必须小写。C 同样区分大小写，但 Java 的驼峰命名惯例（类名大写开头、方法变量小写开头）从一开始就要适应。

3.2 注释#

几乎所有编程语言的注释都不会出现在可执行程序中——它们只是写给编译器和人看的说明，编译时被直接丢弃。

三种注释方式，一段代码全演示：

1
public class CommentDemo {
2
    /**
3
     * 文档注释：/** */ 之间的内容，
4
     * 可用 javadoc 工具生成 HTML 文档
5
     */
6
    public static void main(String[] args) {
7
        // 单行注释：// 到行尾都被忽略
8
        System.out.println("Hello");  // 也可以跟在代码后面
9

10
        /*
11
         * 多行注释：/* */ 之间的内容
12
         * 跨越多行全部忽略
13
         */
14
        System.out.println("World!");
15
    }
16
}

展开收起

不能嵌套：三种注释都不能互相嵌套，尤其多行注释——/* 外层 /* 内层 */ 外层 */ 是错的：编译器遇到第一个 */ 就认为注释结束，后面剩的 外层 */ 会被当成代码，直接编译报错。

对比 C：// 和 /* */ 与 C 一致；/** */ 是 Java 新增的文档注释（C 没有），配合 javadoc 工具生成 API 文档。

小提示：示例中多行注释和文档注释每行开头的 * 并非语法要求，只是排版风格——Java 只认开头的 /* 或 /** 和结尾的 */，中间怎么写都行，IDEA 会自动帮你补 *。

3.3 数据类型#

Java 有 8 种基本数据类型，每种的大小在所有平台上都固定不变——这是和 C 最根本的差异之一：C 的 int 在 16/32/64 位机器上是 2/4/4 字节，Java 的 int 永远是 4 字节，跨平台行为完全一致。

类型	存储	取值范围	字面量后缀
`byte`	1 字节	-128 ~ 127	无
`short`	2 字节	-32,768 ~ 32,767	无
`int`	4 字节	-21.4 亿 ~ 21.4 亿	无（整数默认）
`long`	8 字节	-922 亿亿 ~ 922 亿亿	`L` / `l`
`float`	4 字节	约 ±3.4E38（6~7 位有效数字）	`F` / `f`（必须写）
`double`	8 字节	约 ±1.8E308（15 位有效数字）	`D` / `d`（可省，浮点默认）
`char`	2 字节	0 ~ 65,535（无符号）	单引号 `'A'`
`boolean`	不规定	`true` / `false`	无

（E 是科学计数法，3.4E38 = 3.4 × 10³⁸）

整型：整数默认是 int，超过范围加 L（后缀建议大写，小写 l 和数字 1 长得太像）。支持多种进制前缀：

1
int dec = 10;      // 十进制（默认）
2
int oct = 010;     // 八进制：0 开头，值 = 8
3
int hex = 0x10;    // 十六进制：0x 开头，值 = 16
4
int bin = 0b10;    // 二进制：0b 开头（Java 7+），值 = 2

长数字可以用 _ 分组（Java 7+，编译时忽略）：1_000_000 就是 100 万。_ 不能放在开头/结尾、小数点两侧、以及 L/F 后缀前，比如 _100、100_.0 都非法。

vs C：Java 没有无符号数。C 有 unsigned int，Java 所有整数类型都是带符号的，唯一的”无符号”是 char——但它是字符类型，不做算术。

浮点型：带小数默认是 double，存 float 必须写 F 后缀。遵循 IEEE 754 标准，浮点运算有 3 种特殊结果：

Double.POSITIVE_INFINITY 正无穷，如 1.0 / 0
Double.NEGATIVE_INFINITY 负无穷，如 -1.0 / 0
Double.NaN 非数字，如 0.0 / 0

判断 NaN 必须用 Double.isNaN(x)——因为 NaN 不等于任何值，包括它自己，x == Double.NaN 永远为 false。

字符型：char 是 2 字节无符号(C/C++是1字节)，直接表示 Unicode 字符。有个著名大坑：Java 在解析代码之前就先处理 Unicode 转义（\uXXXX），所以写 Windows 路径 "c:\users" 会编译报错——\u 被当成 Unicode 转义开头，而 \users 不是合法的十六进制序列。改成 "c:\\users" 或 "c:/users" 就好。

顺带解释码点（code point）：Unicode 给每个字符分配的唯一编号就是码点，范围 0 ~ 0x10FFFF（约 110 万）。char 只有 16 位，只能直接装 0~65535 的码点（基本多语言平面）；更大的码点（如 emoji）要两个 char 拼成「代理对」表示。意思就是码点可能是一个char也可能是两个char拼起来的代理对。这就是 3.6 字符串「码点与代码单元」要展开的话题。

布尔型：boolean 只有 true / false，和 C/C++ 最大的区别是不能用数字代替——if (1) 在 Java 里是编译错误，必须写布尔表达式。这也顺带杜绝了 C 里”赋值写进条件”那类经典 bug。

3.4 变量与常量#

声明变量：先声明后使用，命名规则：

以字母开头，后面可接字母、数字、_、$，大小写敏感，注意不能用关键字当变量名（class、int、if…）
Java 的”字母”包含 Unicode 字符，支持中文变量名
惯例：驼峰命名、下划线命名，如 int totalCount; int total_count;

1
double salary;       // 声明
2
int i, j;            // 一行声明多个

不区分声明和定义：C/C++ 里声明（告诉编译器类型）和定义（分配存储）是两回事，于是有 extern、头文件、前置声明。Java 没有这套——每个声明天然就是定义，变量一旦声明就真实存在、占存储，因此也不需要头文件。
初始化：Java 编译期强制要求局部变量使用前必须赋值，否则直接编译报错：

1
int x;
2
System.out.println(x);   // 编译错误：变量 x 可能尚未初始化

C/C++ 里这属于未定义行为（可能读到垃圾值），Java 把这种错误直接拦在编译期。

作用域（块作用域）：变量在声明它的块 { } 内有效，块结束即失效，这点和 C 一致。但有个关键差异——Java 禁止遮蔽（shadowing）：

1
int x = 0;
2
{
3
    int x = 1;   // C/C++ 合法（内层遮蔽外层），Java 编译错误！
4
}

C/C++ 允许内层块重新声明同名变量（内层隐藏外层），Java 直接拒绝同名局部变量同时存在于同一作用域链。另外，Java 没有全局变量：C 有文件作用域的全局变量，Java 一切都在类内，最接近的等价物是类里的 static 字段（详见后文对象与类）。

常量：用 final 声明，只能赋值一次：

1
final double CM_PER_INCH = 2.54;

对比 C：C 用 #define（预处理器文本替换，无类型检查）或 const（编译器只读）。Java 的 final 语义更强——基本类型 final 变量的值不可变。类级常量用 static final 声明。

枚举类型：Java 5+ 引入，定义一组有限的值：

1
enum Size { SMALL, MEDIUM, LARGE }

C 也有 enum，但 Java 的枚举是完整的类，能力远超 C（能带字段和方法），细节放到继承那篇展开。

3.5 运算符#

算术运算符：+ - * / % 与 C 一致：

1
int a = 10, b = 3;
2
a / b   // 3：整数除法直接截断（向 0 取整）
3
a % b   // 1：取余

一个 vs C 的差异：Java 里整数除零直接抛异常（ArithmeticException），浮点除零则是无穷或 NaN；C 的整数除零是未定义行为，程序可能悄悄崩掉。

Math 类：Java 的数学函数都收在 Math 类里，静态调用即可，不需要 #include <math.h> 也不用链接 -lm：

1
Math.sin(x)      // 正弦
2
Math.cos(x)      // 余弦
3
Math.tan(x)      // 正切
4
Math.atan(x)     // 反正切（弧度）
5
Math.atan2(y, x) // 直角坐标 → 极坐标的角度
6
Math.exp(x)      // e^x
7
Math.log(x)      // 自然对数 ln(x)
8
Math.log10(x)    // 以 10 为底的对数
9
Math.pow(a, b)   // a 的 b 次方
10
Math.PI          // 圆周率 π
11
Math.E           // 自然常数 e

注意：三角函数参数是弧度，不是角度。

隐式类型转换：小范围类型自动转大范围类型（隐式「拓宽」转换），合法转换如图：

1
byte → short → int → long → float → double
2
               ↑
3
               char

实线箭头无损、可隐式转换。另有几条虚线转换（int→float、long→float、long→double）虽合法但可能损失精度，因为 float/double 的尾数位有限。

隐式转换：

赋值：double d = 3;（右侧自动拓宽成左侧类型）

算术运算：3 + 3.14（窄操作数自动提升成宽操作数）

二元运算时数值会自动提升：操作数里有 double 结果就是 double，其次 float、long，否则一律提升到 int——所以 byte + byte 的结果也是 int。原因是 JVM 的字节码指令没有 byte/short 级别的算术运算，一律按 int（或更大）宽度计算，这和 C 的整型提升（integer promotion）如出一辙。后果就是：

1
byte a = 10, b = 20;
2
byte c = a + b;          // 编译错误：a + b 是 int，不能直接赋给 byte
3
byte d = (byte) (a + b); // 正确：强转回来

强制类型转换：大范围转小范围（「缩小」转换）必须显式强转，语法 (目标类型) 表达式：

1
double x = 9.997;
2
int n = (int) x;   // 9：直接截断小数，不是四舍五入

想要四舍五入用 Math.round(x)，不是强转
大转小可能溢出或截掉高位（如 int → byte），结果可能出乎意料
boolean 不能转数值，数值也不能转 boolean

赋值运算符：= 之外还有复合赋值 += -= *= /= %= &= |= ^= <<= >>= >>>=：

1
x += 4;   // 等价于 x = x + 4;

一个小坑：复合赋值自带一次隐式强转——byte b = 1; b += 1; 合法（等价于 b = (byte)(b + 1)），而 b = b + 1; 编译报错。

自增自减：++ -- 与 C 完全一致，注意前后缀的区别：

1
int x = 5;
2
int y = x++;   // y = 5，先用后加
3
int z = ++x;   // z = 7，先加后用

关系与逻辑运算符（返回 boolean）：全部列出来，按优先级从高到低：

优先级	运算符	说明
1	!	逻辑非
2	< > <= >=	关系比较
3	== !=	相等判断
4	&	与（不短路）
5	^	异或
6	\|	或（不短路）
7	&&	与（短路）
8	\|\|	或（短路）

vs C 的核心差异：&& 和 || 只能操作 boolean，没有 C 里「非 0 即真」那一套，if (1) 直接编译错误。短路：&& || 左边能决定结果时右边不会执行；& | 不短路，两边都会算。

三目运算符：条件 ? 值1 : 值2，与 C 一致：

1
int max = (a > b) ? a : b;

switch：传统写法和 C/C++ 差不多（会 fall-through，记得 break），Java 支持 4 种用法，逐一来看：

1
// ① 整数 / 字符：传统写法，会贯穿，记得 break
2
int day = 2;
3
switch (day) {
4
    case 1:
5
    case 2: System.out.println("工作日"); break;
6
    case 6:
7
    case 7: System.out.println("周末"); break;
8
    default: System.out.println("非法");
9
}
10

11
// ② 字符串（Java 7+）
12
String fruit = "apple";
13
switch (fruit) {
14
    case "apple":  System.out.println("苹果"); break;
15
    case "banana": System.out.println("香蕉"); break;
16
    default:       System.out.println("未知");
17
}
18

19
// ③ 枚举
20
enum Color { RED, GREEN, BLUE }
21
Color c = Color.GREEN;
22
switch (c) {
23
    case RED:   System.out.println("红"); break;
24
    case GREEN: System.out.println("绿"); break;
25
    case BLUE:  System.out.println("蓝"); break;
26
}
27

28
// ④ switch 表达式（Java 14+）：箭头写法，不贯穿，整体可作为表达式
29
int month = 4;
30
int days = switch (month) {
31
    case 2 -> 28;
32
    case 4, 6, 9, 11 -> 30;
33
    default -> 31;
34
};

展开收起

要点：①②③是语句（执行完就完事），④是表达式（能整体返回一个值赋给变量）；前三者会贯穿，④的箭头写法天然不贯穿。箭头分支只有一句表达式时，直接写在 -> 后面就是返回值；要写多句话就用 { } 块，块内必须用 yield 给出值：

1
int days = switch (month) {
2
    case 2 -> 28;
3
    default -> {
4
        System.out.println("走默认分支");
5
        yield 31;   // 块内用 yield 返回值
6
    }
7
};

位运算：& | ^ ~ << >> >>>。操作数是整数时是位运算；操作数是 boolean 时，& | ^ 退化为逻辑运算（不短路）。

右移有 C/C++ 没有的明确行为：

>> 算术右移，高位补符号位
>>> 无符号右移，高位补 0

C/C++ 对有符号数的右移是实现定义（不同编译器可能补符号位或补 0），Java 用 >> / >>> 明确区分，消除了这种不确定性。

括号与优先级：Java 的运算符优先级和 C 基本一致（() 最优先，* / % 高于 + -，然后是移位、关系、逻辑、赋值）。拿不准就加括号，可读性永远第一，记优先级可维护性差。

3.6 字符串#

子串：substring(a, b) 提取子串（左闭右开）；C 没有直接等价物（只能指针 + 长度模拟）
拼接：+ 直接拼字符串，任何类型和字符串 + 都会自动转成字符串：

1
String s = "Hello " + 123;   // "Hello 123"

按分隔符拼一组字符串用 String.join：

1
String csv = String.join(", ", "a", "b", "c");   // "a, b, c"

"str".repeat(n)（Java 11+）重复字符串 n 次，方便方法，知道即可。

字符串不可变：String 一旦创建就不可改变，所有”修改”（拼接、replace、substring）都是创建新字符串对象，旧对象留给垃圾回收。好处是安全、可共享、天然线程安全；代价是每次修改都有开销——这就是第 9 条要用 StringBuilder 的原因。

手感：C++ 的 std::string 可变，且有操作符重载（== 比内容、[ ] 访问），Java 没有操作符重载，一律走方法（.equals()、.charAt()），所以初看不如 C++ 直观。这是设计取舍：Java 用统一的方法调用换来了简单一致的模型。

检测字符串是否相等：内容相等用 equals，忽略大小写用 equalsIgnoreCase。不能用 ==——== 对引用比较的是”是不是同一个对象”，不是内容：

1
String a = "hello";
2
String b = new String("hello");
3
a.equals(b)      // true，内容相等
4
a == b           // false，两个不同的对象
5

6
String c = "hello";
7
a == c           // true：字面量被"驻留"到常量池，指向同一对象

最后这个例子是个陷阱：字符串 字面量（常量） 会被驻留（intern）到常量池，所以两个字面量 == 碰巧相等。但驻留只对字面量和编译期常量生效，运行时生成的新字符串不会自动共享：

1
String d = "he" + "llo";   // 编译期常量折叠 → 仍是字面量，和 a 同一个对象
2
String x = "he";
3
String y = x + "llo";      // 运行时拼接 → 新对象，和 a 不同
4
a == d                     // true
5
a == y                     // false

所以任何依赖 == 判断内容的做法都是侥幸，内容判断一律用 equals，养成习惯。对比 C：C 用 strcmp 才比内容，Java 把”比内容”（equals）和”比身份”（==）拆成两个操作，反而更明确。

空串与 null 串：""（空串，有对象、长度 0）和 null（没有对象）是两回事：

1
String empty = "";
2
String nothing = null;
3

4
empty.length() == 0    // true
5
nothing.length()       // 抛 NullPointerException！

判空用 str.isEmpty() 或 str.length() == 0；判 null 用 str == null。两个都要防时，先判 null 再判空（&& 短路保证安全）：

1
if (str != null && !str.isEmpty()) {
2
    // 既不是 null 也不是空串
3
}

null 可以类比 C++ 的 nullptr：表示引用没指向任何对象；它不是对象，所以对 null 调方法会抛 NullPointerException。 6. 码点与代码单元：length() 数的是 UTF-16 代码单元（char）个数，charAt(i) 取第 i 个 char；codePointCount(a, b) 数的是码点（真实字符）个数，codePointAt(i) 取第 i 个位置的码点：

1
String s = "A😀B";
2
s.length()                       // 4：A + 代理对(占 2 个 char) + B
3
s.codePointCount(0, s.length())  // 3：A、😀、B 三个真实字符

普通文本遍历用 for + charAt 遍历就够；要正确处理 emoji 这类增补字符才需要码点方法。codePoints() 会返回码点流，在 Stream API 的范畴再展开讲。

String API：不用背。Java 标准库方法成千上万，没人全记得住。要做的是：

记住高频的几个：length charAt substring indexOf equals equalsIgnoreCase isEmpty toUpperCase replace
其余靠 IDEA 补全（敲 str. 自动弹）+ 查文档，用多了自然熟

阅读联机 API 文档：Java 标准库的官方文档就是 Oracle 维护的 javadoc，后端开发也查它（docs.oracle.com 搜 java 17 api）。IDEA 里把鼠标悬停在类/方法上，或按 Ctrl+Q（Mac 是 Ctrl+J）直接看说明，不用每次开浏览器。
构建字符串：大量拼接别用 +（每次都会 new 一个新 String），改用 StringBuilder：

1
StringBuilder builder = new StringBuilder();
2
builder.append("Hello");
3
builder.append(" ");
4
builder.append("World");
5
String result = builder.toString();   // "Hello World"

顺带回答一个基础问题——类到底是什么？ 类不是”容器”，是图纸（模板）：它规定了对象长什么样（字段）和能干什么（方法）。StringBuilder 是一个类，new StringBuilder() 是按图纸造出一个对象，builder.append(...) 是调用这个对象的方法。一张图纸可以造出无数个对象，每个对象是独立的一份”实物”。这会在对象与类下一章细说。

文本块（Java 15+）：用 """ 包起来的多行字符串，写 HTML / JSON / SQL 不用再拼一堆 \n：

1
String html = """
2
    <html>
3
        <body>你好</body>
4
    </html>
5
    """;

两个注意点：

内容里的单个 " 不用转义，只有会影响到结束定界符 """ 时才需要 \"
行尾放一个 \ 表示忽略这个换行（\ 不进入字符串）

3.7 输入与输出#

读取输入：从标准输入读数据，用 java.util.Scanner。注意 System.in 不是包，它是 System 类里的一个静态字段，代表标准输入流（对应 C 的 stdin）；Scanner 负责把流里的字节解析成你要的类型：

1
import java.util.Scanner;
2
//`java` 顶级包 → `util` 子包 → `Scanner` 类
3
Scanner in = new Scanner(System.in);
4
String name = in.nextLine();    // 读一整行
5
int age = in.nextInt();         // 读一个整数
6
double score = in.nextDouble(); // 读一个双精度浮点数

对比 C：scanf 靠格式串 + 取地址符，类型不匹配很容易出问题；Scanner 的方法是类型化的（nextInt() 保证返回 int），更安全但略啰嗦。还有 next()（读一个单词）、hasNextInt()（先判断下一个是不是整数）等。

另外还有 java.io.Console（System.console() 获取），适合交互式控制台场景（如读密码不回显）；但它在 IDE/重定向环境下可能拿不到，普通场景用 Scanner 就够。

格式化输出：和 C 的 printf 几乎一模一样——Java 直接把格式串机制搬了过来：

1
System.out.printf("%d %f %s%n", age, score, name);

对应 C 的 printf("%d %f %s\n", age, score, name);，占位符 %d %f %s 完全一致。完整格式串语法是：

1
%[参数索引$][标志][宽度][.精度]转换符

部分	含义
`%`	格式串起始符
`参数索引$`	指定用第几个参数（如 `%1$d` 用第 1 个参数）
`标志`	对齐、符号、补零等控制
`宽度`	最小输出宽度，不足补空格或 0
`.精度`	浮点 = 小数位数；字符串 = 最大长度
`转换符`	决定输出格式与接受类型

全部标志：

标志	作用	示例	输出
`-`	左对齐（默认右对齐）	`printf("%-5d", 12)`	`12`
`+`	正数带 `+` 号	`printf("%+d", 12)`	`+12`
`0`	数字前补 0	`printf("%05d", 12)`	`00012`
`空格`	正数前留一个空格	`printf("% d", 12)`	`12`
`(`	负数用括号包起来	`printf("%(d", -12)`	`(12)`
`,`	千位分隔符	`printf("%,d", 1234567)`	`1,234,567`
`#`	备选形式（如 `0x` 前缀）	`printf("%#x", 255)`	`0xff`
`$`	参数索引结束符：`%2$d` 用第 2 个参数，可重排/复用	`printf("%2$s %1$s", "a", "b")`	`b a`
`<`	复用上一个格式符的参数	`printf("%d %<x", 255)`	`255 ff`

全部转换符：

转换符	含义	适用类型	示例（对 42）
`%d`	十进制整数	byte / short / int / long / BigInteger	`42`
`%o`	八进制整数	同上	`52`
`%x` `%X`	十六进制整数	同上	`2a`
`%f` `%F`	十进制浮点	float / double / BigDecimal	`3.140000`
`%e` `%E`	科学计数法	同上	`3.140000e+00`
`%g` `%G`	通用浮点（自动选 f 或 e）	同上	`3.14000`
`%a` `%A`	十六进制浮点数	float / double / BigDecimal	`0x1.0p-1`（对 0.5）
`%s` `%S`	字符串	String / 任意对象	`hello`
`%c` `%C`	字符	char / byte / short / int	`A`
`%b` `%B`	布尔（`%B` 输出大写）	boolean	`true` / `TRUE`
`%h` `%H`	散列码	任意对象	`5e9a2c`
`%n`	平台换行	—	换行
`%%`	字面量百分号	—	`%`
`%tx` `%Tx`	日期时间（必须跟后缀，如 `%tY` 年份）	long / Long / Date / Calendar	`2026`

%t 单独写不合法，它是日期时间的”前缀”，后面必须跟一个字母指定取哪部分：%tY 年、%tm 月、%td 日、%tH 时（24 小时制）、%tM 分、%tS 秒、%tF 完整日期 yyyy-MM-dd、%tT 完整时间 HH:mm:ss。

几个注意点：

%n 输出平台原生行分隔符。C 的 printf("\n") 在 Windows 文本模式下会自动转成 \r\n，但 Java 的 \n 永远是 LF、不做转换，想要平台分隔符就用 %n
String.format(...) 是 Java 版的 sprintf：格式化后返回字符串而不打印
类型必须匹配：%d 配 String 直接抛异常——C 是未定义行为，Java 把错误拦在运行时
System.out.printf 与 System.out.format 完全等价

文件输入与输出：套路和标准输入输出一模一样，只是把 System.in 换成文件路径。

读文件用 Scanner，传一个 Path：

1
Scanner in = new Scanner(Path.of("data.txt"), StandardCharsets.UTF_8);
2
while (in.hasNextLine()) {
3
    System.out.println(in.nextLine());
4
}

写文件用 PrintWriter：

1
PrintWriter out = new PrintWriter("output.txt", StandardCharsets.UTF_8);
2
out.println("Hello 文件");
3
out.close();   // 写完必须关，否则可能没落盘

对比 C 的 FILE*：C 是 fopen("file.txt", "r") + fscanf / fprintf，Java 是把文件包进 Scanner / PrintWriter 对象再读写——同样是面向对象的”构造对象、调方法”套路。

相对路径：相对的是 JVM 的工作目录（启动 java 命令时所在的目录），不是 .java / .class 文件所在的目录。在 IDEA 里默认是项目模块目录，容易和直觉不符——报 FileNotFoundException 时，先想想”当前工作目录到底在哪”。

两个注意点：

编码：建议显式传 StandardCharsets.UTF_8，否则用平台默认编码，跨机器容易乱码
关闭：用完要 close()，否则数据可能没写入磁盘、句柄泄漏（后面 ⑩ 文件 IO 会讲 try-with-resources 自动关闭）

3.8 控制流程#

块作用域：和 C 一样，变量在声明它的 { } 块内有效。唯一区别在 3.4 提过：Java 不允许内层块遮蔽外层同名变量。

条件语句：if / else if / else 与 C 完全一致，唯一区别是条件必须是 boolean（if (1) 编译错误）。

循环：while、do-while、for 和 C 一模一样：

1
while (条件) { ... }
2
do { ... } while (条件);
3
for (int i = 0; i < n; i++) { ... }

for 里声明的 int i 只在循环内有效，这点和 C99 之后一致。switch 已在 3.5 讲过，不重复。

中断控制流程：break 跳出当前循环/switch；continue 跳过本次循环剩余部分、进入下一轮。Java 还有 C 没有的带标签的 break/continue，专治多层嵌套循环：

1
outer:
2
for (int i = 0; i < 3; i++) {
3
    for (int j = 0; j < 3; j++) {
4
        if (j == 1) break outer;   // 跳出整个外层循环，执行它后面的语句
5
    }
6
}

带标签的 continue 则跳到外层循环的下一次迭代：

1
outer:
2
for (int i = 0; i < 3; i++) {
3
    for (int j = 0; j < 3; j++) {
4
        if (j == 1) continue outer;   // 直接开始外层下一轮 i
5
        System.out.println(i + "," + j);
6
    }
7
}
8
// 输出：0,0 / 1,0 / 2,0

	`break outer`	`continue outer`
行为	退出整个外层循环（不再执行）	跳到外层循环下一次迭代
类比	循环直接结束	外层跳过这一轮，继续

对比 C：C 想跳出多层循环只能靠 flag 标志位或 goto。Java 把 goto 留作保留字但禁用（怕 goto 把结构搅成”意大利面条式代码”），用带标签的 break/continue 作为结构化替代——能跳出/跳过多层循环，但跳转方向被限制在循环的进出，不会乱跳。

带标签的 break 还能用在普通块上（不限于循环）——这是很实用的”提前退出嵌套逻辑”手法：

1
outer:
2
{
3
    if (条件A) {
4
        if (条件B) {
5
            break outer;   // 满足条件，块里剩余代码全部跳过
6
        }
7
        //这里是代码
8
    }
9
    System.out.println("条件不满足时才执行到这里");
10
}

等价于 C 里用 goto 提前跳出，但只允许”从块内退出”，方向被限定，不会乱跳。

最后一条硬性规则：break / continue 只能跳到”包着它”的标签——标签标记的语句必须在词法上包含当前语句。站在块里面才能”跳出去”，站在外面就不能”跳出”这个块，编译器直接报错：

1
outer:
2
{
3
    break outer;   // ✅ 合法：break 在块内部
4
}
5
break outer;       // ❌ 编译错误：已经在块外面了

这一节最容易踩的坑（都是相对 C 的新东西）：

continue 会跳过循环体里的更新语句——for 安全（i++ 在循环头部，continue 跳回时自动执行）；while 危险（更新写在循环体里，continue 直接跳回条件判断，把更新跳过了 → 可能死循环）
带标签的 continue 不保存状态——跳到外层循环的下一轮，内层循环整体作废、从零开始，不会”接着上次”
标签类型有限制——continue 的标签必须标在循环上；break 的标签可以是循环/块/switch。标错当场编译报错
break outer 跳到标签块之后，不是跳到标签那一行

3.9 大数#

C 没有原生大数：long 上限也就 ±9.2×10¹⁸。Java 提供两个类处理超出范围的数：

BigInteger：任意精度整数
BigDecimal：任意精度小数（适合金额，避免浮点误差）

不能直接用 + - * / 运算符，要调方法：

1
BigInteger a = BigInteger.valueOf(1234567890);
2
BigInteger b = BigInteger.valueOf(9876543210L);
3
BigInteger sum = a.add(b);          // 加
4
BigInteger diff = a.subtract(b);    // 减
5
BigInteger prod = a.multiply(b);    // 乘
6
BigInteger quo = a.divide(b);       // 除

构造要点：

小数值用 BigInteger.valueOf(long) 转换
超大数用字符串构造：new BigInteger("123456789012345678901234567890")——直接写数字字面量会因超出 long 范围编译报错

BigDecimal 常见于金额计算。0.1 + 0.2 用 double 算出来是 0.30000000000000004，用 BigDecimal 精确：

1
BigDecimal d = BigDecimal.valueOf(0.1).add(BigDecimal.valueOf(0.2));
2
// 结果是精确的 0.3

坑：用 BigDecimal.valueOf(0.1) 才是精确的 0.1；new BigDecimal(0.1) 会把 double 的二进制近似值原样带进去，反而”不精确”。

3.10 数组#

声明与初始化：数组是对象，声明只是引用，必须 new 才有实体：

1
int[] a = new int[10];           // 10 个元素，默认 0
2
int[] b = { 1, 2, 3, 4, 5 };     // 花括号直接初始化，不用 new
3
int[] c = { 1, 2, 3, 4, 5, };    // 允许最后位置有逗号

vs C：int a[10] 声明即分配，Java 必须 new。

匿名数组与空数组：new int[] { 1, 2, 3 } 是匿名数组，不赋给变量，直接传给方法用：

1
int sum = sum(new int[] { 1, 2, 3 });   // 匿名数组做参数

new int[0]（或 new int[] {}）是长度为 0 的数组——合法且有用：方法没结果时返回空数组而不是 null，调用方就不用判空了。

数组长度固定，但引用可以换：数组对象一旦创建长度就定死，但变量只是个引用，可以随时指向新数组——这就是”声明和构造分离”的灵活性：

1
int[] a;          // 声明：只是引用，没分配内存
2
a = new int[10];  // 构造
3
a = new int[20];  // 换个更大的（旧数组交给垃圾回收）

要”换大小还保留内容”用 Arrays.copyOf(a, 新长度)（自动拷贝并补零/截断）。对比 C：C 里 int a[10] 声明即定死，想换只能手动 malloc + memcpy + free，还得自己管内存——Java 的”引用可换 + GC 回收”灵活得多。

访问与长度：下标从 0 开始；a.length 是属性（不是函数，C 得 sizeof(a)/sizeof(a[0]) 自己算）。越界抛 ArrayIndexOutOfBoundsException——C 越界是未定义行为，Java 直接拦下来。

for each 循环：遍历数组的简写：

1
for (int x : b) {
2
    System.out.println(x);
3
}

等价于 C 的下标遍历。注意拿到的是元素副本，改 x 不影响原数组；想改元素就用传统 for 加下标。

数组拷贝：= 赋值只是复制引用（两个变量指向同一个数组，改一个另一个也变）；要独立副本用 Arrays.copyOf：

1
int[] same = b;                           // 只是多一个引用，同一数组
2
int[] copy = Arrays.copyOf(b, b.length);  // 深拷贝，新数组
3
int[] first3 = Arrays.copyOf(b, 3);       // 只拷前 3 个

数组排序：Arrays.sort(a) 一行升序排序——C 要么手写排序要么 qsort。

命令行参数：main(String[] args) 对应 C 的 argc/argv。Java 不传 argc（用 args.length），且 args[0] 是第一个用户参数（C 的 argv[0] 是程序名）：

1
public static void main(String[] args) {
2
    System.out.println(args.length);  // 参数个数
3
    System.out.println(args[0]);      // 第一个参数
4
}

多维数组：本质是”数组的数组”。声明 int[][] grid = new int[3][4];，访问 grid[i][j]。

不规则数组（Java 的优势）：每一行长度可以不同，C 的多维数组必须是矩形，Java 可以”锯齿”：

1
int[][] triangle = new int[5][];
2
for (int i = 0; i < 5; i++) {
3
    triangle[i] = new int[i + 1];   // 第 i 行 i+1 个元素
4
}

C 想实现不规则数组得用”指针数组 + 手动管理”，Java 天然支持。

附录#

日期#

java.time 的 LocalDate（不可变日期类）：

1
import java.time.LocalDate;
2

3
LocalDate today = LocalDate.now();          // 今天
4
LocalDate bday = LocalDate.of(2000, 1, 1);  // 指定日期
5

6
bday.plusDays(100);       // 100 天后（返回新对象，原对象不变）
7
bday.getDayOfWeek();      // 星期几
8
bday.until(today);        // 距离今天多少天

和 String 一样，LocalDate 是不可变的：plusDays 返回新对象，不会改原来的。

对比 C：C 标准库没有好用的日期类型（time_t 是秒数，得自己转格式），Java 的 java.time 开箱即用。

小结：Java vs C 对照表#

维度	C	Java
程序结构	自由函数 + main	万物皆类，main 在类内
编译运行	`gcc` → 可执行文件 → CPU 直接跑	`javac` → 字节码 → JVM（解释 + JIT）
内存	手动管理（malloc/free）	自动垃圾回收
整型大小	随平台（int 可能是 2/4 字节）	固定（int 永远 4 字节）
无符号数	有 unsigned	没有（唯一”无符号”的 char 不做算术）
字符串	`char*` / `char[]`	`String` 对象，不可变，`equals` 比内容
数组	下标遍历，`sizeof` 求长	对象，`length` 属性，for-each，越界抛异常
输入输出	`scanf` / `printf` / `FILE*`	`Scanner` / `System.out.printf` / `PrintWriter`
大数	无原生支持	`BigInteger` / `BigDecimal`
布尔	0 / 非 0 当真假	只有 `true`/`false`，`if (1)` 报错
内存安全	野指针、越界家常便饭	引用不能算数，越界即异常
等等

本章收获：C 给你完全控制权（和一堆踩坑机会），Java 帮你管好内存与边界，换来跨平台与安全。 学完这一章，可以用 Java 写出任何 C 能写的基础程序了。

蜂窝版 MacBook：80 块钱让 Mac 直插 4G 卡上网 + 保号接码

Tue, 25 Aug 2026 00:00:00 GMT

一颗大疆无人机拆机的 4G 模块，一条 AT 指令，让你的 MacBook 变成「蜂窝版」——既能独立 4G 上网，还能跑 VoHive 平台控制sim卡接码等功能。全程软件成本 0 元。

写在前面：这不是「破解」，是「切换」#

很多人看到「大疆模块改 EC25」以为是什么高深破解。其实一句话就能讲完：

大疆 4G 模块（一代）本质是移远 Quectel EG25-G，但出厂被大疆写成了私有 USB 身份（VID/PID 2ca3:4006），通用驱动不认。我们要做的，只是发一条厂商本来就支持的 AT 配置指令，把它的 USB 身份从大疆改回标准的移远 EC25（2c7c:0125）：

1
AT+QCFG="usbcfg",0x2C7C,0x0125,1,1,1,1,1,0,0

没有刷固件、没有破解加密、没有改 Mac 任何系统文件——芯片本来就会变多种身份，我们只是让它换回标准的那套。改一次，写进模块 NVRAM，终身有效。

为什么是这颗模块#

便宜：大疆无人机拆机件。最早 3040 元，火了之后被炒到 80 元左右，但依然比一颗全新的移远 EC25（100200 元）便宜。
本质是移远 EG25-G：高通平台，LTE Cat 4，标准 AT 指令集齐全。
被大疆「封印」了身份：所以便宜，也所以要改。

代价是它默认的 USB 身份和模式都不是「标准」的，得手动改一次。

我要实现的两个目标#

Mac 独立 4G 上网（学校WIFI你懂得，不想天天开手机热点）
海外卡保号 / 接码（用 VoHive 平台收发短信、看 SIM 状态，甚至以后做 VoWiFi ）

这两个目标对应模块的两种工作模式，不可兼得：

模式	模块在哪	用途
ECM（`usbnet=1`）	Mac	4G 上网（macOS 原生认）
QMI（`usbnet=0`）	虚拟机	VoHive 接码/保号

这就是后面所有折腾的根源：一颗模块、一根 USB，一次只能干一件事、待在一个地方。

材料清单#

项	成本
大疆 4G 模块（一代）	~80 元
一张有流量的 SIM 卡	自备
UTM（虚拟机）	免费
Ubuntu Server 24.04 arm64	免费

第一步：让 Mac 能上网（改 ID + 切 ECM）#

这一步是一次性的，做完以后模块插上 Mac 就是网卡。

核心就是在 Linux 环境（UTM 虚拟机）里，用 socat 往串口发两条指令：

Terminal window

1
# 改身份：大疆 2ca3:4006 → 移远 2c7c:0125
2
AT+QCFG="usbcfg",0x2C7C,0x0125,1,1,1,1,1,0,0
3
# 切模式：QMI(0) → ECM(1)，macOS 才能认
4
AT+QCFG="usbnet",1
5
# 软重启生效
6
AT+CFUN=1,1

模组重启后弹回 Mac，macOS 原生驱动 AppleUSBECM 直接把它认成一张 USB 网卡，自动拨号（APN cmnet）后就能上网了。

第二步：部署 VoHive（保号/接码）#

VoHive 是面向高通 4G 模组的管理平台，网页端收发短信、看信号、管 eSIM。

这里有个重要的坑：VoHive 上游项目已经无限期停维护了，官方 release 的二进制全被清空（最后的 v9.9.9 是 12 字节的告别占位符）。arm64 的二进制只能去 fork 里挖——我花了点功夫，从三个字节完全一致的 fork 里找回了一份，并交叉验证了 sha256。

踩坑记录（这才是真干货）#

这套东西的教程网上很多，但实测和教程对不上的地方不少，逐个锤下来：

usbnet 映射教程写错了：有篇笔记说 usbnet=2 是 ECM，实测这颗模块 2 是 MBIM、1 才是 ECM。照抄 2 会导致 Mac 死活拿不到网卡。
UTM 的命令行直通是坏的：utmctl usb connect 报 -2700「找不到设备」。翻源码发现是 UTM 对「复合设备」（一个 VID/PID 下面挂多个接口）的匹配 bug，GUI 直通走的是另一条路径所以能通——直通只能手动点。
模组会休眠：AT 口闲置一段时间就睡着，前 1~2 次发 AT 唤不醒，要发到第 3 次才回 OK。所以脚本里找 AT 口必须带重试。
stale 文件坑：往串口写指令时如果设备节点刚好不存在，tee 会在 /dev 下误建一个普通文件，挡住真正的设备节点。得先清掉再 mknod 重建。

最终成果#

三个 shell 脚本 + 一个菜单命令，全在 PATH 里：

Terminal window

1
vohive    # 进入菜单，选 1 保号 / 2 上网 / 3 状态

命令	作用
`vohive` → 1	切保号（QMI / VoHive）
`vohive` → 2	切上网（ECM / Mac 蜂窝）
`vohive` → 3	查状态

结语#

从「一颗插上什么都不认的大疆私有模块」到「Mac 的 4G 网卡 + 保号平台」，总成本不到 100 元。核心认知就一句：这不是破解，是让芯片换回它本来的标准身份。 教程不可靠的地方，实测永远能锤出真相。

通信技术基础：先把这些名词搞懂#

这篇文章的重点其实是借这颗 80 块的模块，把移动通信的底层概念讲清楚。下面按「网络 → 频段 → 身份 → 接口 → 实用功能」的顺序，把文中涉及的所有名词一次补齐。看不懂的实操细节，都能在这里找到答案。

一、什么是 LTE#

LTE（Long Term Evolution，「长期演进」）就是俗称的 4G。 名字本身没有「第四代」的意思，只是 3GPP 给这套标准起的代号——因为它是从 3G（UMTS/WCDMA）一路「长期演进」过来的。

手机通信的「代」是这样排的：

代	技术	能干什么
1G	模拟（AMPS 等）	只能打电话
2G	数字 GSM	打电话 + 短信 + 极慢速上网
3G	UMTS / WCDMA / CDMA2000	能真正上网了
4G	LTE	纯 IP 网络，快
5G	NR	更快、更低时延

LTE 的核心变化是彻底 IP 化：把 2G/3G 那套「电路交换」（打电话专用线路）拆掉，语音、数据全部变成 IP 包。正因如此，4G 时代「打电话」要靠 VoLTE（Voice over LTE，走 IMS 的语音），而不是老线路。

LTE 内部又按能力分 Cat（Category，类别）：Cat 1、Cat 4、Cat 6……数字越大越快。这颗 EG25-G 是 Cat 4：下行最高 150 Mbps、上行 50 Mbps，日常上网、刷视频完全够用。

一句话：LTE = 4G 的标准名；Cat 4 = 这颗模块的「档位」。

二、频段（Band）和频率的关系#

这是新手最容易混的一对概念。

频率：无线电波的物理频率，单位 Hz。比如 1800 MHz、2100 MHz——这是真实存在的物理量。
频段（Band）：3GPP 给每段可用频率统一编了号，比如 Band 3 = 1800 MHz、Band 1 = 2100 MHz、Band 8 = 900 MHz、Band 40 = 2300 MHz。这个编号就是「Band」。
关系：Band 是频率的标准化标签。 说「支持 Band 3」，意思就是「支持 1800 MHz 附近那一段」。

为什么要搞 Band 编号？因为同一个频率范围，各国运营商拿到手的「切片」不一样（上下行差多少、带宽多宽），用编号能精确指代「这一整段」，而不只是「中心频率」一句话。

另外，移动网络大多是 FDD 双工（见下一节）：上行和下行用不同的频率，所以一个 Band 里同时定义了上行段和下行段。比如 Band 3：

上行（手机 → 基站）：1710–1785 MHz
下行（基站 → 手机）：1805–1880 MHz

模块支持的 Band 越多，跨国漫游越稳。EG25-G 标称支持包括国内 B1/B3/B5/B8/B39/B40/B41 在内的多种 FDD + TDD 频段。

三、信道（Channel）#

如果说 Band 是「一整段马路」，信道就是这条马路上划出的一条具体车道。

在 Band 内部，运营商会把频率再切成一个个更窄的「信道」，每个信道一个中心频率、一个编号。
GSM 时代的信道编号叫 ARFCN，LTE 时代叫 EARFCN。手机/模块「搜网」时，就是在逐个扫描信道，看哪个上面有基站的广播信号。
日常使用你几乎不用直接跟信道打交道——模块会自动扫信道、选信道。但当你用工具看「当前驻留的频点」时，看到的那串数字（EARFCN）就是信道编号。

四、FDD 与 TDD：中国和外国的「通信模式」#

这里要澄清一个常见误解：「FDD / TDD」不是「中国模式 vs 外国模式」，而是移动网络最底层的「双工（Duplex）方式」——即「上下行怎么错开，避免自己发出的信号撞上自己收到的信号」。

FDD（频分双工）：上行、下行用两条不同频率，同时进行。像一条双向八车道——去的车走左边、来的车走右边，互不干扰。全球绝大多数 4G 网络、欧美日韩的主流，都是 FDD。
TDD（时分双工）：上行、下行用同一条频率，靠时间轮流切换。像单行道按红绿灯交替放行——这一瞬只发、下一瞬只收。省频谱，但需要精确的时钟同步。

那「中国」特殊在哪？——中国三大运营商是 FDD 和 TDD 混着用的：

运营商	4G 主力制式
中国移动	TDD（Band 38/39/40/41）为主
中国联通	FDD（Band 1/3）为主
中国电信	FDD（Band 1/3/5）为主

（后来三家也都拿到了对方制式的牌照，但历史主力如上。）

所以「中国 FDD」这个说法要拆开看：电信、联通走 FDD，移动走 TDD。 而这颗 EG25-G 频段覆盖够全，FDD / TDD 都支持，插哪家卡都能用——这就是「多频多模」的意思。

顺带一提，「外国」并不构成一个统一模式：欧美主流是 FDD，日本部分运营商也用 TDD。真正该记的维度是 FDD vs TDD，而不是「中国 vs 外国」。

五、三张身份证：IMEI / ICCID / IMSI#

移动网络里最容易搞混的三个 ID，恰好分别对应「设备 / 卡 / 用户」三个东西：

	全称	位数	标识谁	读取方式
IMEI	国际移动设备识别码	15 位	设备（这台模块）	`AT+CGSN`
ICCID	集成电路卡识别码	19~20 位	SIM 卡（那张塑料卡）	卡面印着 / `AT+QCCID`
IMSI	国际移动用户识别码	15 位	用户/账户（运营商开的户）	存 SIM 里 / `AT+CIMI`

拆开讲：

IMEI：设备的身份证。厂家出厂烧进去，标识这台硬件唯一。丢手机可以去运营商报失，按 IMEI 把设备拉黑变砖。这颗模块的 IMEI 也能改（AT+EGMR），那是另一个话题。
ICCID：SIM 卡的身份证。每张卡出厂就印了唯一编号，直接印在卡面上那串长数字就是。换卡 = 换 ICCID。
IMSI：账户的身份证。格式 = MCC（国家码，3 位，中国 460）+ MNC（运营商码，2~3 位，移动 00 / 联通 01 / 电信 03，各自还有备用码）+ MSIN（用户号）。网络靠它判断「你是谁、该用谁的套餐」。

一句话记法：IMEI 认设备，ICCID 认卡，IMSI 认人。 换卡不换机，IMSI/ICCID 变、IMEI 不变；换机不换卡，IMEI 变、IMSI/ICCID 不变。

六、模块的四种「工作模式」#

模块和电脑靠 USB 相连，但「USB 上跑什么协议、数据以什么形态出来」有几种可选。这就是 AT+QCFG="usbnet",x 里那个 x 的含义。这颗 EG25-G 支持这四种（usbnet 的取值）：

usbnet	模式	全称	出来的是	谁在用
0	QMI	Qualcomm MSM Interface	高通私有二进制接口	Linux / ModemManager
1	ECM	Ethernet Control Model	一张标准「USB 网卡」	macOS 原生认（本文上网用）
2	MBIM	Mobile Broadband Interface Model	现代 USB 宽带标准接口	Windows 10+ / 新版 Linux
3	RNDIS	Remote NDIS	微软风格的「USB 网卡」	老 Windows / Android

关键区别：

ECM / RNDIS / MBIM 这三类，模块会把蜂窝网络「伪装成一张以太网卡」交给电脑。电脑不用懂 4G，只要会认网卡、会 DHCP 拿 IP 就能上网。区别只在「伪装手法」：ECM 是通用标准（macOS 认），RNDIS 是微软家的，MBIM 是最新最规范的通用标准。
QMI 不是网卡，而是高通芯片的原生控制接口（二进制协议）。它比「网卡」暴露得更多、控制力更强，所以 VoHive 这类要深度管理模块的平台走 QMI。

这就是「一颗模块一次只能选一种身份」的原因：选了 ECM 就是「网卡」，选了 QMI 就是「管理接口」，两者不能同时是。（另外还有一堆 ttyUSB 串口是 AT 命令口，见下——它们与这四种「数据模式」并存，不冲突。）

七、两种「管理模式」：AT 和 QMI——你怎么指挥这颗芯片#

上一节讲「数据怎么出来」，这一节讲「你怎么命令它」。有两套截然不同的「遥控器」：

	AT 命令	QMI
形态	文本指令，人可读	二进制协议，机器读
通道	串口（某个 `ttyUSB`）	USB 的 `cdc-wdm` 设备
例子	`AT+CSQ` 查信号、`AT+QCFG` 改配置	libqmi 库 / ModemManager 调用
优点	简单、通用、能手敲	强大、结构化、能做的事多
谁用	我们（脚本里 `socat` 发的那几条）	VoHive、ModemManager

AT 命令：脱胎于老式调制解调器的「Hayes 指令集」，一行行 AT+... 文本。开头那两条 AT+QCFG 就是 AT 命令。它几乎成了所有蜂窝模组的「通用普通话」——别看形式简单，能做的事其实极多：ATD10086; 拨号打电话、ATA 接电话、ATH 挂电话、AT+CMGS 发短信、AT+CNMI/AT+CMGR 收/读短信、AT+CSQ 查信号、AT+CUSD 拨 USSD、AT+VTS 发 DTMF……整颗模组从打电话到收发短信，几乎每个动作都能用一行文本命令搞定。它唯一的「限制」是形式：一次一条、逐条来。
QMI：高通芯片的私有二进制接口，功能远强于 AT——能并发、结构化地读网络状态、注册事件监听、管理数据通路。代价是复杂，得靠 libqmi 这类库调用，人没法手敲。

本文「改身份、切模式」用 AT（一次性配置），「日常接码管理」用 QMI（VoHive 内部），正好体现分工：AT 做一次性配置，QMI 做持续管理。

八、APN 是什么#

APN（Access Point Name，接入点名称）= 你接入互联网时经过的那个「运营商网关」的名字。

手机网络的出口不直接通公网，而是先经过运营商的一个网关。这样的网关有很多个，各干各的活：

上网流量 → 走「互联网 APN」（移动 cmnet、联通 3gnet、电信 ctnet）
彩信 MMS → 走「彩信 APN」（cmwap 之类，现在基本淘汰）
VoLTE/IMS 语音 → 走「IMS APN」（ims）

APN 就是告诉模块：「我要上网，请把我接到叫 cmnet 的那个网关去。」配置里一般还附带用户名/密码（很多国内 APN 是空的）和鉴权方式。

文章里「自动拨号（APN cmnet）」指的就是：模块建立数据连接时，自动用移动的 cmnet 这个 APN 接入互联网。

九、USSD 是什么#

USSD（Unstructured Supplementary Service Data，非结构化补充业务数据）= 你在拨号键盘按 *100# 之后弹出的那种实时代码菜单。

它是一组短代码，走的是网络的信令信道（不是普通数据/语音信道），所以：不联网也能用、几乎零延迟、实时会话式。
典型用途：查话费余额、查流量、充值、开业务。国外运营商（尤其非洲、印度）的 USSD 菜单尤其丰富，甚至用来做移动支付。
和短信 SMS 的区别：SMS 是「存储转发」的异步消息（发出去对方可能晚收到）；USSD 是「实时会话」（你一按，服务器立刻回，像打电话一样一问一答）。

在模块上，USSD 通过 AT+CUSD 发送和接收。VoHive 这类平台就是靠它触发「查余额」这类即时查询的。（具体代码各家运营商不同，*100# 只是示例。）

十、DTMF 通信是什么#

DTMF（Dual-Tone Multi-Frequency，双音多频）= 你打电话按数字键时发出的「嘟—嘟」声的正式名字。

原理：电话键盘每个键按下时，同时发出两个不同频率的正弦波（一个来自「低频组」、一个来自「高频组」），接收端根据「哪两个频率同时出现」判断按了哪个键。两个音叠加，抗干扰、可靠，所以叫「双音多频」。
一共 16 个键：0-9、*、#，外加 4 个备用键 A/B/C/D（普通人用不到）。
用途：拨号；以及打 IVR 自助语音后「请按 1 转人工」——你按的那个「1」，就是通过 DTMF 传过去的。输银行卡密码、身份证号也是 DTMF。这个过程完全由你的拨号APP完成

在模块上，DTMF 用 AT+VTS 发送（主动按一个键）、AT+DDET 接收/检测（识别对方 IVR 传来的按键）。

十一、VoWiFi 是什么#

VoWiFi（Voice over WiFi，WiFi 通话）= 不靠蜂窝信号，用 WiFi 网络打电话、发短信的技术。

传统打电话走蜂窝网络（2G/3G 电路交换，或 4G 的 VoLTE）。VoWiFi 则把语音/短信打包，通过 WiFi → 互联网 → 运营商 IMS 核心网这条隧道来传。
关键：VoWiFi 走的是运营商自家的 IMS 平台，所以用的是你的手机号、按你的套餐计费（甚至免费），对方来电看到的还是你的号码。它不是微信语音那种「App 到 App」的网络电话。
好处：蜂窝信号差（地下室、海外漫游）但 WiFi 好的地方，照样接打电话。
技术上靠 ePDG（演进分组数据网关）：手机先和运营商的 ePDG 建立一条加密的 IPSec 隧道，再在隧道里跑 IMS 语音。

文章里「以后做 VoWiFi」的意思：VoHive 这类高通模组管理平台，理论上能驱动模块走 ePDG 隧道，让这颗 4G 模块/这张卡在 WiFi 环境下也能「打电话」。这是接码保号之外的一个进阶玩法。

Markdown 入门教程：一篇就够了

Mon, 24 Aug 2026 00:00:00 GMT

Markdown 是一种轻量级标记语言，让你专注于写作内容，不能用于排版。下面是最常用的语法速查。

1. 标题语法#

使用 # 号表示标题，几个 # 就是几级标题。

一级标题#

二级标题#

三级标题#

2. 文字强调#

加粗：使用 **文字** 包裹（快捷键 Ctrl+B）
斜体：使用 *文字* 包裹（快捷键 Ctrl+I）
加粗斜体：使用 ***文字*** 包裹
删除线：使用 ~~文字~~ 包裹（表示废弃或修改）

3. 列表结构#

无序列表（使用 - 或 *）#

苹果
- 红富士（子项缩进 2 或 4 个空格）
香蕉

有序列表（使用数字加点）#

第一步
第二步
1. 子步骤

4. 链接与图片#

点击访问百度 https://www.baidu.com

这是一张示例图片

5. 代码块#

三个反引号，指定语言可以实现语法高亮。

1
System.out.println("Hello World");

TARS — 个人 AI 管家

Fri, 21 Aug 2026 00:00:00 GMT

TARS doesn’t remember you. It learns how to work with you.
不保存用户，而是持续学习用户。

这个项目暂时废了，后期准备包装成obsidina插件发布，文档方式交互。#

一、为什么做 TARS#

TARS 的名字来自《星际穿越》中的战术机器人——可靠、直接、偶尔黑色幽默，绝对忠诚。

作为一个 J 人，我一直希望有一个能辅助规划一切、提供最清晰路径的 AI。但使用现有 AI 的过程中发现一个根本问题：缺少人情味。

这种”活人感”的缺失来自哪里？经过深度思考，我认为核心是：AI 没有确定的立场。 它总是站在最普世的角度思考问题。二选一的问题，它给你”最真诚、最不绕弯子的废话”——所有人都知道收益最大化是什么，但你要的不是这个。

TARS 解决两件事：立场不对称（AI 没有你的立场）和被动性（AI 不会主动找你）。

二、什么是立场#

“屁股决定脑袋”。

你的阅历和所处环境决定了你的想法和行动。没有经历过底层互害，就不会认可社会达尔文主义。笑是你最安全的表情，可能是你对不确定性的排斥导致的。不擅长侃侃而谈，可能是因为过去这么做收益不高。所有外界刺激的总和，构成了你的性格、潜意识、表达风格、决策倾向、价值观。

这个世界上没有绝对的傻子——每个人都在自己立场的最大限度内，被多巴胺刺激做出当下最优的选择。立场是人的根本属性。

如何为 AI 赋予立场？ 提示词切换（“你是英语专家”→“你是风水大师”）恰恰说明 AI 没有确定的立场。TARS 的解决方案是：从记忆系统入手。

立场是记忆的产物。我们每天醒来还记得自己叫什么、经历过什么——立场就是从记忆中解释和抽象出来的。推理能力由大模型提供，但立场存续靠的是记忆架构。在大模型推理模式被下一代技术变革之前，记忆系统是我们实现立场模拟的核心路径。

三、记忆系统#

三种存储，各司其职#

存储	存什么	为什么
SQLite	体重/心情/睡眠（时序）、项目状态、事件日志、每日日记、任务、情绪、承诺、偏好、关系、想法、财务 — 共 30 张表	精确查询——“本周体重中位数”、“哪些项目卡住了”、“3 天没更新的指标”
Chroma 向量库	人生档案分段 + 事件摘要的语义索引	模糊回忆——“我之前提过类似的想法吗”、“大学时我是什么状态”
Markdown 文件	人生档案原文（profile/goals/timeline/worldview）	人类可读、随手能改、git 版本跟踪

三者不可互换——SQL 做不了语义检索，向量做不了精确数值查询，文件做不了结构化统计。

每次 tick 的装填过程#

TARS 不是常驻进程。每次被 macOS 快捷指令或 tars 命令”踹”一脚，Docker 容器启动，从三种存储里拼出一张 ~3500 字的上下文快照喂给 LLM：

1
tars 命令触发容器
2
  │
3
  ├─ 1. 读 Markdown 文件
4
  │     profile.md → "我是谁"
5
  │     goals.md → "我要去哪"
6
  │     worldview.md → "我戴什么眼镜看世界"
7
  │
8
  ├─ 2. 查 SQLite
9
  │     metrics → 体重/心情/睡眠最新值
10
  │     entities → stuck 项目
11
  │     events WHERE pending → 悬而未决的事
12
  │     diaries LIMIT 7 → 近一周摘要
13
  │
14
  ├─ 3. 语义检索 Chroma（基于当前任务）
15
  │
16
  ├─ 4. 拟合 Self Model（行为 vs 声明 gap）
17
  │     条件化规则（IF deadline<3天 THEN 执行力91%）
18
  │
19
  └─ 5. 拼成 system prompt → LLM

展开收起

记忆生命周期#

events 表的 lifecycle 字段控制四态流转：

1
你说"在考虑换工作"
2
  → TARS 写入: event(kind=decision, lifecycle=pending)
3

4
下次 check-in，TARS 查: SELECT * FROM events WHERE lifecycle='pending'
5
  → 主动问："换工作的事有结论了吗？"
6

7
你说"决定再待一年"
8
  → TARS 更新: UPDATE events SET lifecycle='resolved'
9
  → resolved 不再出现在"待追踪"列表
10

11
三个月后你思考职业规划
12
  → RAG 语义召回 → "三个月前你决定再待一年，现在需要重新评估吗？"

pending 留在眼前催你决断，resolved 沉入向量库等待语义召回，fact 和 preference 永远留档。 每天 200 字日记摘要提供”最近发生了什么”的最小上下文。30 天前的日记合并为月摘要——旧的没丢，只是压缩了。

会话间的记忆传递#

TARS 每次醒来不是同一个进程，而是一个全新的 LLM 会话。它之所以感觉有记忆，是因为上一次的 TARS 在退出前调了 save_session——写了日记摘要、更新了实体状态、标记了已解决的 pending。下一次的 TARS 读到这些，就像读到了自己上一次留下的笔记。

四、六层能力栈#

1
Evidence Capture   → 不可变记录。用户说了什么、做了什么、情绪如何
2
Behavior Understanding → 条件化 IF-THEN 规则。不是人格标签，是行为规律
3
Prediction & Learning    → 预测→现实打脸→校准→Meta Learning（曾被推翻的假设未来自动降权）
4
Self Model Evolution     → 月度快照 + 变化速率 + Plasticity（可塑性）
5
Interaction Policy       → Agent 根据对用户的理解调整自己的行为——deadline驱动的人自动拆小目标
6
Adaptive Response        → 不只是理解用户，是学会怎么跟用户协作

五、Intent Parser — 意图分类#

每条消息进入 TARS 时，LLM 先判断它属于什么行为类型，然后走对应通道。

核心边界：问题是关于外部世界的，还是关于用户自己的。

行为类型	例子	lifecycle	后续
emotional_release	“操他妈的""好焦虑”	fact	记情绪。check-in 时泛问恢复，不追问单条
commitment	“我要考雅思""明天学英语”	pending	创建承诺 + 预测成功率。check-in 追问
decision	“要不要读研”	pending	记决策点。季度回顾
self_reflection	“为什么我总拖延”	pending	记自我认知。触发 Self Model 更新
curiosity	“地球为什么是圆的”	fact	回答。不主动追问
meta_cognition	“为什么我总犹豫”	pending	提假设。check-in 跟进
idea_capture	“我突然想到一个产品”	fact	存 Idea 库。90天不提自动归档
data_log	“52kg""背了200单词”	fact	记时序数据。不追问
memory_recall	“我之前是不是说过”	fact	检索旧记忆
identity_question	“你觉得我是怎样的人”	fact	即时回答 Self Model
casual	“哈哈哈""好累""吃饭去了”	fact	只存。默认兜底通道

默认规则：拿不准 → casual → fact → 只存不追问。不丢数据。

六、运行时模型#

TARS 不常驻后台。macOS 快捷指令定时踹，Docker 容器按需启动。

1
你的 MacBook
2
  ├─ 7:00  快捷指令踹 → 生成内参 PDF → 发邮件
3
  ├─ 21:00 快捷指令踹 → 晚间 check-in → Telegram 追问
4
  └─ 随手踹 → 拉 Telegram 消息 → 有新消息进入即时通信 → 30分钟空闲退出

Telegram 场景：你在外面用手机发消息给 TARS bot → 消息在 Telegram 服务器排队 → 回家 MacBook 被踹 → TARS 拉回来处理。

8 个 CLI 命令，tars 封装所有 Docker 参数：

1
tars         日常踹一脚
2
tars setup   安装引导
3
tars talk    对话模式（rich 渲染 Markdown，方向键正常）
4
tars check   系统自检
5
tars pack    打包备份
6
tars migrate 生成完整迁移包（镜像+数据+配置一把带走）

七、技术架构#

组件	选型
LLM	Anthropic SDK + DeepSeek 兼容端点
数据库	SQLite + SQLAlchemy — 30 张表
向量	Chroma + BAAI/bge-small-zh-v1.5
Telegram	python-telegram-bot getUpdates
PDF 报告	Markdown + Jinja2 + WeasyPrint + Noto CJK
终端渲染	rich（Markdown 渲染）+ readline（方向键）
容器	Docker
调度	macOS 快捷指令 + task_dispatcher
版本控制	GitPython + git

代码规模：~6400 行 Python，83 个 MCP 工具，12 条定时任务。

八、定时任务 — Memory 自己生长#

1
凌晨 2:00  nightly  推理验证 + 假设审查 + 归档 + 衰减 + 冲突检测
2
凌晨 3:00  weekly   周模式 + 情绪趋势 + 压缩
3
凌晨 4:00  monthly  月特质 + 行为指标 + 交互策略更新 + Self Model 快照
4
凌晨 5:00  quarterly 季度行为统计 + worldview gap + Plasticity
5
早上 7:00  内参报告 PDF → 邮箱
6
晚上 21:00 check-in  注意力预算 + drift 追问 + 冲突提醒

补跑机制：MacBook 睡眠错过了凌晨任务 → 开机后第一次 tick 自动检测并补跑。不会静默跳过。

九、自我进化#

TARS 可以修改自己的代码。write_file、edit_file、register_task、run_command、git_revert 都在 MCP 工具里。

1
用户说"帮我每天十点提醒喝水"
2
  → TARS 写新工具文件到 layer1/tools/
3
  → 注册定时任务到 tasks.yaml
4
  → git commit
5
  → 下次 tick 自动加载生效
6
  → 改坏了就 git_revert 回滚

内核（layer0）也可修改——安全网是 git，不是权限墙。

十、安装#

Terminal window

1
cd ~/life-agent
2
bash scripts/bootstrap.sh
3
docker build -t life-agent .
4
bash scripts/install.sh
5
tars setup
6
tars talk

前置条件：Docker Desktop、Telegram + API、Telegram bot token。

【小白向】Mac设备音响排查记（扬声器不定时吱吱响破音

Fri, 21 Aug 2026 00:00:00 GMT

最近我的Macbook（M1 pro）不知道为什么，六扬声器在播放声音的时候会莫名有吱吱、噗噗的声音，关键的是响一下就没事了，还不能被手动复现，尤其在突然关闭正在播放声音的标签页、或者播放音量很高时，这种声音很恶心。起初我以为是我玩城市天际线，其内置的unity引擎音频流不兼容，玩的时候吱吱响把音响振膜搞坏了，但在进入安全模式后扬声器又正常了，气爆了，把驱动、Edge、后台进程都检查了个遍，最后发现是Todesk在安装时，也会装一个音频驱动运行在后台，与 macOS 的原生音频核心（Core Audio）存在兼容性问题，尤其是在音频流启动/停止的瞬间。以下是排查修复Mac设备扬声器的一个大概的流程，供各位参考思路，毕竟去线下店或者重装系统代价都不小：

1.重启，（若还有则直接下一步）
2.重启Mac按住 Shift 键直到登录界面，进入安全模式，如果安全模式下完全正常，即可 100% 确定是软件/驱动冲突，而非硬件损坏。（硬件损坏直接做好掏钱的准备吧）

3.终端执行sudo lsof | grep -i "coreaudio"查看音频驱动占用，寻找任何非苹果的驱动文件（.driver）。（在我的案例中，输出显示了 /Library/Audio/Plug-Ins/HAL/ToDeskOutputDriver.driver，这就是元凶）
4.检查系统扩展列表systemextensionsctl list,检查有无audio、virtual、loopback等第三方扩展。
5.在音频MIDI设置中，任何其他多余的虚拟设备都可能是冲突源

6.卸载相关软件，（比如我的Todesk）
7.在/Library/Audio/Plug-Ins/HAL/目录下，删除陌生的.driver文件
8.终端执行sudo killall coreaudiod
rm -rf ~/Library/Preferences/com.apple.audio.*
rm -rf ~/Library/Caches/com.apple.audio.*然后重启

Mac毕竟用户基数少，一般的软件bug修复周期就很缓慢，(比如城市天际线的音频兼容问题至今未修复)。如果还有问题，还是得跑线下啦

博客园同名 https://www.cnblogs.com/snyxz/

我和计算机

Mon, 06 Jul 2026 00:00:00 GMT

我建立本博客的目的只有一个，就是以维护博客为目的广泛的在计算机领域深耕。想想自己从第一次接触电脑开始，从自己第一次拆下电脑内存条到今天也有8年之久了，当时5年级的我，也是同样根据网上博客的教程一点一点的理解每一个硬件究竟是做什么用的，也算是第一次理解冯诺依曼体系。到我后来初一研究Linux，貌似起初是因为当初矿潮为了挖莱特币，专门装了Ubuntu优化性能，尽管现在看来的确没什么用，也受到当时Python引流课的影响，浅浅接触了编程领域。一旦男生接触到这方面的一个边边角角，一定会越陷越深。什么我的世界服务器、Kali CTF网安、vSphere虚拟化、甚至是路由器刷机，我几乎都尝了个遍，到后来初三开发网站给学校部署在线英语听力。不敢想当初到底有多沉迷于此（虽然有些嘉豪），记得中学时期当时有很多奇闻逸事，比如内网装宝塔面板，一路从Windows系统调试到路由器，就是不知道为啥连不通。很多当时看来的奇怪问题，现在想想都挺弱智，几乎我18岁以前的爱好都被这方面锁死了，直到后来顺其自然高考志愿报计算机，也算是业余转职业了，还有很多很多的有趣体验一时想不起来，可能未来某天在跟朋友聊天的时候会猛然想起，然后诉说当年的糗事。只恨几年来，没能养成写博客的习惯，所有这些宝贵的探索没能硬编码下来，但好在时间不晚，今天的我才大一，还有很多时间记录和进化。

我还要重申一遍本博客建立的主要目的是深耕计算机领域，至于竞争力或者未来就业的相关问题，我并没有考虑，我的动机很单纯。幻想一下，你现在30岁，回到家全屋智能家居已经接入你部署在刷完OpenWRT路由器的Home Assistance上，这个智能家居中枢联动了苹果生态Home Kit，几乎可以设置任何你想要的逻辑。同时在你的路由器上部署AdGuard和科学工具，再接入一个Agent Loop。配合你本地NAS上的N8N工作流，每周都会向你汇报家庭内的基本信息，气温、耗电量、博客浏览量和手机上网时间，小到个人体脂控制，大到家庭开支，总结成高效的PDF文档在你离开家后发送到你和家人的邮箱内。摄像头借助OpenCV计算机视觉搭配扫地机器人默默的在你回家之前完成全部家务，通风净化、洗衣烘干、设备自检，有条不紊，如果本地的Agent有需要，它会自动WOL启动我台式机完成重负载任务，一到周末，三五好友在你对智能音箱一声令下后打开全屋观影模式，投影布缓缓落下，随后Jellyfin查找你存在本地的蓝光杜比8K电影，Docker服务配合内网穿透把你远在天边的挚友拉进同一个MC服务器，你默默地站在人群中央，享受着Github开源带来的极致便利和簇拥，手持平板而掌管着这一切。这种淡淡的幸福感才是我等J人极致的追求，一直以来我都认为计算机科学是一门持续带来幸福的科学，想必皆归因于此。

以上是我个人的全部愿景，除此之外，别无二心！

这大概是我干过最逆天的事

Thu, 02 Jul 2026 00:00:00 GMT

如题，这条内容曾经拿到了上千浏览和几百点赞，今天重新写一遍，用现在的眼光回看23年。

原文发布于 QQ 空间，点击查看原文）

背景#

大概是高二，学校统一使用科大讯飞的所谓“AI辅助课堂教学“——每人发一台平板，深度定制 ROM。叫定制其实不算，说是阉割更准确：没浏览器，没原生系统设置，没文件管理器。相册只能看照片，视频播放器直接被砍了。本质上就是一台只能做题和交作业的电子砖头。

突破口#

我没事就翻预装软件，主页一个叫 GeoGebra 的东西很受学生追捧，官方说法是“数学动态画图工具”，数学好的考完试拿它研究最后一道大题，数学差的干脆直接用它当计算器，但我点进去就看出来了—这玩意儿是网页套壳的，很多时候这种非原生软件一眼就能看出来，同时用起来手感顿顿的大概率就是Electron、Tauri此类封装方案，但GeoGebra直接演都不演——纯WebView 套壳。

1
window.open("https://www.bing.com")

跳不出去。系统把 http/https 协议全封了CONNECTION_REFUSED，底层WebView 被魔改。而且输入框有过滤，输入直接吞字或者干扰。

柳暗花明#

第一处：键盘输入会被拦截，可以使用剪切板粘贴，从别处复制粘贴进来不走那条拦截逻辑，最后多输一个回车正好被吞掉，只剩下正确逻辑。

第二处：http不通，那就弃帅保车，使用file协议访问本地文件，好在我大概摸索出 Linux/Android 的目录结构了。

1
window.open("file:///storage/emulated/0/")

原生文件目录直接打开了，我欣喜若狂。能看到文件名、层级导航、文件大小。视频点进去，调用WebView就放了。

今日回首#

ifly的工程师大概是这么想的：把浏览器干掉、把 http/https 封掉、把输入拦截做好，学生就没办法了。

但他们漏了两件事：

WebView 本质上是浏览器。你可以不让它上网，但它读本地文件的权限是 Android 沙箱赋予的，不是 ROM 说了算的。
file 协议不需要网络权限，只读本地存储，你在 WebView 层面拦不住。

说穿了就是攻击面分析的问题：只封了网络层，没考虑本地文件系统层。

引爆#

我把方法整理成教程发到博客，顺手投稿到了表白墙，直接引爆——几百点赞，上千浏览，评论区全是”配享太庙”、“哥你是电教之神”之类，一时之间，风光无量。

开学第一周，级部广播直接点名diss：“我们级部还有个技术高手，掌握了比较高的计算机技术，破解出平板看视频的功能”。

随后发生的事，果不其然超出了我的控制范围，一开始可能只是传着看视频消遣，但后面有人用这个方法在家翻录电影、在宿舍熬夜追剧——一个数学画图工具被用成了娱乐终端。即便我在原博客郑重声明滥用的后果，失控的范围依旧远大于控制的成本，下架就成了唯一的选择。

没制裁我。但说实话，这件事我一直有点愧疚在心。

GeoGebra 是个好软件。数学课上用它画函数图像、做几何演示，确实比课本上的静态图直观太多。我用了快两年，很熟悉它的每一个角落——也正因如此，才看出它是网页套壳。讽刺的是，正因为我太了解它，才让它从全校平板上消失了，后面几届的学弟学妹连用都用不上了。技术上是我的一个高光时刻，但结果上，我带走的远比带来的多。

如果重来一次，我大概还是会发现那个漏洞——一个 WebView 套壳的应用放在一个对计算机充满好奇的高中生手里，这是迟早的事。但我可能不会把教程发到论坛上。

不过换个角度想，这件事之后我开始系统地研究前沿相关的技术，也学会了从”攻击面”的角度去审视一个系统的设计。某种意义上，它比我任何一门课给我的东西都多。

CC操作手册

Tue, 30 Jun 2026 00:00:00 GMT

一、Claude Code是如何工作的？#

Claude Code CLI可以直接api通信，如果是background任务则借助Daemon程序完成会话管理、agents池管理，定时任务等，Daemon开机自启后台活跃，终端内看到的是cli界面，bg任务控制权完全交给Daemon完成。

二、会话的管理#

claude code cli启动agent，默认kind是interactive branch后从当前节点复制出一份，分叉出独立会话 clear源对话归档，就地开启新对话 ba ckground后kind被标记为bg，控制权完全交由daemon exit正常结束，归档进project claude rm删的渣都不剩

三、存储结构#

一共四种记忆方式

history.jsonl 保存全局命令和用户prompt
projects/dir/id.jsonl 按项目隔离完整对话
projects/dir/memory/ 按项目隔离，自动注入新会话
安装目录CLAUDE.md 全局指令注入，项目级CLAUDE.md优先级更高

项目目录~/.claude/projects/ 内 -Users-wjh/ ← 你的项目之一 {id}.jsonl ← 每个会话的完整转录 memory/ ← 跨会话项目记忆（MEMORY.md + 各记忆文件）

根目录~/.claude/内 sessions/ ←当前活跃会话的元数据（pid、状态） session-env/ ← 每会话环境变量（残留，可清） shell-snapshots/ ← Shell 状态备份 file-history/ ← 文件修改前快照（用于 undo） backups/ ← settings.json 写前备份 plugins/ ← 已安装插件 settings.json ← 全局设置（主题、模型、权限） settings.local.json ← 本地覆盖（不参与同步） CLAUDE.md ← 全局指令（每次会话注入） history.jsonl ← 命令历史（↑ 键回溯） stats-cache.json ← 使用统计

四，Agent系统#

主对话（main agent）可派出子代理（sub-agent）最多派分出5层，子代理之间互不认识，只能通过接任务→交结果沟通一共有三级权限： Allow → 直接执行 Ask → 弹窗等你批准 Deny → 绝对不执行

五、对话内命令#

/init 扫描一遍项目目录，生成CLAUDE.md文件 /help General / Command / Custom Command三个界面显示不同的命令和快捷键的用法 /context 显示可视化不同上下文tokens占比，包括系统提示词、工具调用等 /config 总控面板，主题、权限、hook都在里面 /usage 显示token总用量和花费 /status 显示claude code版本、模型、目录和等基本信息 /recap 生成当前会话一句话摘要，走神回来快速回忆 /export 导出对话为纯文本，加文件名直接保存：/export 开发记录.txt /clear 归档原上下文，新开一个本项目空对话 /resume 恢复本项目已经归档的上下文文件 /compact 压缩上下文，在原来基础上压缩，context满时也会自动触发 /btw 单独开一个小对话，复制当前上下文到新session，之后完全独立，除非fork，无法调用工具 /copy 复制agent上一条输出 /diff 交互式 diff 查看器，检查未提交的代码改动，跟git协作使用 /insights 生成个人全局使用分析报告（HTML），含习惯分析、建议、未来工作流 /review 跟github协作，审查pr的效率质量，告诉你哪有毛病 /ultrareview 跟github协作，更狠地告诉你哪有毛病，更贵 /simplify 跟github协作，不废话，直接动手改 /plan 进入plan模式，只能看代码、搜索，不能改文件、不能运行非只读命令 /goal 进入goal模式，不再问要不要继续，不达目标誓不停止。中途/goal查看进度，/goal clear停止 /loop 举例：/loop 5m 检查一下部署状态，每5分钟daemon自动来一句发到对话里，/loop检查进度，/loop clear停止 /rewind 回退上文，注意只能在同一个对话文件内，包括三种 1. Restore conversation：对话和文件改动一起回到所选节点，节点之后的内容全部丢弃 2. Summarize from here：不改动文件，把所选节点之后的对话压缩成摘要，后面聊岔了但还想继续聊 3. Summarize up to here：不改动文件，把所选节点之前的对话压缩成摘要，前面太长，只想留最近清晰上下文 /branch 新建分支对话文件，注意不能用rewind，完全等于/fork /model 选择模型和思考力度（5档） /effort 只能调整思考力度 /fast 要求服务器加急处理推理，更贵 /mcp 管理mcp连接，接入外部服务 /plugin 插件市场，插件就是可以包含多个skill+主题+hooks的套件（hook是触发器，可以在agent工具调用前，会话启停时，停下来等等时设置跑命令，比如设置改文件前，先自动跑语法检查） /skills 管理接入的skill /rename 重命名当前对话 /background 把当前回话扔到后台，注意这是不可逆的，当前对话kind被标记为background，在claude agents中管理 /agents 显示当前会话内派出的子代理，涉及到复杂情景如并行搜索、独立出去干脏活累活时派出或者明确要用子代理去工作 /tasks 显示当前对话里正在跑的后台任务 /exit 关闭当前对话以及子代理

六、终端命令#

claude —bg “任务” 一步启动后台会话 claude —resume 直接恢复上次会话 claude —safe-mode 安全模式，禁用所有自定义项 claude agents 列出/管理所有后台会话 claude rm │ 删除指定会话 claude —print “任务” │ 非交互模式，输出结果到 stdout

[第2章 2.2e1] Palindromes

Sat, 27 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
bool solve(){
6
    string str;
7
    cin>>str;
8
    ll len=str.size();
9
    for(ll i=0;i<len;i++){
10
        if(str[i]!=str[len-i-1])return false;
11
    }
12
    return true;
13
}
14
int main(){
15
    ll t;
16
    cin>>t;
17
    while(t--){
18
        if(solve())cout<<"yes"<<endl;
19
        else cout<<"no"<<endl;
20
    }
21
    return 0;
22
}

展开收起

[第2章 2.2t1] Subsequence

Sat, 27 Jun 2026 00:00:00 GMT

1
2

[第1章 1.1e1] 约瑟夫问题

Fri, 26 Jun 2026 00:00:00 GMT

1
//注意使用erase操作后赋值一定要判断迭代器合法性
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
void solve(){
6
    ll n,m;
7
    cin>>n>>m;
8
    list<ll> nd;
9
    ll nn;
10
    for(ll i=1;i<=n;i++)nd.push_back(i);
11
    ll st=nd.size();
12
    auto it=nd.begin();
13
    while(nd.size()>0){
14
        for(ll i=0;i<m-1;i++){
15
            it++;
16
            nn=*it;
17
            if(it==nd.end())it=nd.begin();
18
        }
19
        if(nd.size()!=st)cout<<" ";
20
        cout<<*it;
21
        it=nd.erase(it);
22
        if(it==nd.end())it=nd.begin();
23
    }
24
    cout<<endl;
25
}
26
int main(){
27
    solve();
28
    return 0;
29
}

展开收起

[第1章 1.1t1] 队列安排

Fri, 26 Jun 2026 00:00:00 GMT

1
//使用结构体数组模拟链表，节省查找时间，实在是高
2
//注意初始化中需要一个虚拟0位置作为全链条最左侧或最右侧
3
#include <bits/stdc++.h>
4
using namespace std;
5
typedef long long ll;
6
const ll MAXN=1e5+5;
7
struct node{
8
    ll l,r;
9
    ll d;
10
}m[MAXN];
11
void solve(){
12
    ll n;
13
    cin>>n;
14
    m[1].d=1;
15
    m[1].l=0,m[1].r=0;
16
    m[0].d=0;
17
    m[0].l=0,m[0].r=1;
18
    for(ll i=2;i<=n;i++){
19
        ll k,p;
20
        cin>>k>>p;
21
        if(p==0){
22
            m[i].r=k;
23
            m[i].l=m[k].l;
24
            m[m[k].l].r=i;
25
            m[k].l=i;
26
        }else{
27
            m[i].l=k;
28
            m[i].r=m[k].r;
29
            m[m[k].r].l=i;
30
            m[k].r=i;
31
        }
32
        m[i].d=1;
33
    }
34
    ll nn;
35
    cin>>nn;
36
    for(ll i=0;i<nn;i++){
37
        ll x;
38
        cin>>x;
39
        m[x].d=0;
40
    }
41
    ll now=m[0].r;
42
    while(now!=0){
43
        if(m[now].d){
44
            if(now!=m[0].r)cout<<" ";
45
            cout<<now;
46
        }
47
        now=m[now].r;
48
    }
49
    cout<<endl;
50
}
51
int main(){
52
    solve();
53
    return 0;
54
}

展开收起

[第1章 1.2e1] 机器翻译

Fri, 26 Jun 2026 00:00:00 GMT

1
//666小数据直接哈希加速，避免了遍历
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
queue<ll> qq;
6
vector<ll> hh(1010,0);
7
int main(){
8
    ll m,n;
9
    cin>>m>>n;
10
    ll cnt=0;
11
    for(ll i=0;i<n;i++){
12
        ll t;
13
        cin>>t;
14
        if(!hh[t]){
15
            hh[t]=1;
16
            qq.push(t);
17
            cnt++;
18
            while(qq.size()>m){
19
                hh[qq.front()]=0;
20
                qq.pop();
21
            }
22
        }
23
    }
24
    cout<<cnt<<endl;
25
    return 0;
26
}

展开收起

[第1章 1.2e2] 单调队列-滑动窗口

Fri, 26 Jun 2026 00:00:00 GMT

1
//666模拟了个优先队列，让这个队列头存当前最值
2
//但队列内存的是位置，便于比较和输出
3
//超出窗口后自动删掉前面多余部分
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
vector<ll> a;
8
int main(){
9
    ll n,k;
10
    cin>>n>>k;
11
    vector<ll> a(n);
12
    for(ll i=0;i<n;i++)cin>>a[i];
13
    deque<ll> lo;
14
    bool fla=false;
15
    for(ll i=0;i<n;i++){
16
        while(!lo.empty()&&a[lo.back()]>a[i])lo.pop_back();
17
        lo.push_back(i);
18
        if(i>=k-1){
19
            while(!lo.empty()&&i-lo.front()>=k)lo.pop_front();
20
            if(fla)cout<<" ";
21
            cout<<a[lo.front()];
22
            fla=true;
23
        }
24
    }
25
    cout<<endl;
26
    lo.clear();
27
    fla=false;
28
    for(ll i=0;i<n;i++){
29
        while(!lo.empty()&&a[lo.back()]<a[i])lo.pop_back();
30
        lo.push_back(i);
31
        if(i>=k-1){
32
            while(!lo.empty()&&i-lo.front()>=k)lo.pop_front();
33
            if(fla)cout<<" ";
34
            cout<<a[lo.front()];
35
            fla=true;
36
        }
37
    }
38
    cout<<endl;
39
    return 0;
40
}

展开收起

[第1章 1.2e3] Max Sum

Fri, 26 Jun 2026 00:00:00 GMT

1
//hdu1003最大字段和问题，以下为贪心解法，注意累计值大于历史最大值时更新左右边界
2
//也可以使用dp，先赋值为初始值，计算包括当前位置与之前的和，大于当前值则要前面的，否则左边界右移
3
//若大于历史最大值，更新边界，一定要注意区间不要带上产生最小值位置
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
void solve(ll ca){
8
    ll n;
9
    cin>>n;
10
    vector<ll>a(n+2);
11
    for(ll i=1;i<=n;i++)cin>>a[i];
12
    ll sum=0;
13
    ll l=1;
14
    ll a1=1,a2=1;
15
    ll ma=a[1];
16
    ll mi=0;
17
    for(ll r=1;r<=n;r++){
18
        sum+=a[r];
19
        ll cal=sum-mi;
20
        if(cal>ma){
21
            ma=cal;
22
            a1=l;
23
            a2=r;
24
        }
25
        if(sum<mi){
26
            mi=sum;
27
            l=r+1;
28
        }
29
    }
30
    cout<<"Case "<<ca<<":"<<endl;
31
    cout<<ma<<" "<<a1<<" "<<a2<<endl;
32
}
33
int main(){
34
    ll t;
35
    cin>>t;
36
    for(ll i=1;i<=t;i++){
37
        if(i!=1)cout<<endl;
38
        solve(i);
39
    }
40
    return 0;
41
}

展开收起

[第1章 1.2t1] 求m区间内的最小值

Fri, 26 Jun 2026 00:00:00 GMT

1
//注意密集使用到endl，就需要像以下这样加速
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n,m;
8
    cin>>n>>m;
9
    vector<ll> a(n+1);
10
    deque<ll> dq;
11
    cout<<0<<'\n';
12
    for(ll i=1;i<=n;i++)cin>>a[i];
13
    for(ll i=1;i<n;i++){
14
        while(!dq.empty()&&a[dq.back()]>a[i])dq.pop_back();
15
        dq.push_back(i);
16
        while(!dq.empty()&&i-dq.front()>=m)dq.pop_front();
17
        cout<<a[dq.front()]<<'\n';
18
    }
19
    return 0;
20
}

展开收起

[第1章 1.2t2] 扫描

Fri, 26 Jun 2026 00:00:00 GMT

1
//注意不要越界和while循环
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n,k;
8
    cin>>n>>k;
9
    vector<ll> num(n+5);
10
    for(ll i=1;i<=n;i++)cin>>num[i];
11
    deque<ll> dq;
12
    for(ll i=1;i<=n;i++){
13
        while(!dq.empty()&&num[dq.back()]<num[i])dq.pop_back();
14
        dq.push_back(i);
15
        if(i>=k){
16
            while(!dq.empty()&&i-dq.front()>=k)dq.pop_front();
17
            cout<<num[dq.front()]<<'\n';
18
        }
19
    }
20
    return 0;
21
}

展开收起

[第1章 1.2t3] 切蛋糕

Fri, 26 Jun 2026 00:00:00 GMT

1
//没想到使用队列，建立一个sum累计数组，注意不要i==dq.front否则出现0污染结果
2
//每增加一个位置，要先检查大小，在运用窗口极小值算出最大值，同ans更新
3
//同时检测用当前值将dq更新成小于它的队列，保证单增，开始位置最小
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    ll n,m;
9
    cin>>n>>m;
10
    ll a;
11
    vector<ll> sum(n+3,0);
12
    for(ll i=1;i<=n;i++){
13
        cin>>a;
14
        sum[i]=sum[i-1]+a;
15
    }
16
    deque<ll> dq;
17
    ll ans=-1e18;
18
    dq.push_back(0);
19
    for(ll i=1;i<=n;i++){
20
        while(!dq.empty()&&i-dq.front()>m)dq.pop_front();
21
        ans=max(ans,sum[i]-sum[dq.front()]);
22
        while(!dq.empty()&&sum[dq.back()]>=sum[i])dq.pop_back();
23
        dq.push_back(i);
24
    }
25
    cout<<ans<<endl;
26
    return 0;
27
}

展开收起

[第1章 1.2t4] 好消息坏消息

Fri, 26 Jun 2026 00:00:00 GMT

1
//本题深入理解了两项
2
//1.针对每个窗口要先清整，再推入，最后判断窗口大小
3
//2.使用sum数组可以解决此类涉及到求和的问题
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    ll n;
9
    cin>>n;
10
    vector<ll> a(2*n+2);
11
    for(ll i=1;i<=n;i++){
12
        cin>>a[i];
13
        a[n+i]=a[i];
14
    }
15
    vector<ll> sum(2*n+2);
16
    sum[0]=0;
17
    for(ll i=1;i<=2*n;i++){
18
        sum[i]=sum[i-1]+a[i];
19
    }
20
    deque<ll> dq;
21
    ll ans=0;
22
    for(ll i=1;i<2*n;i++){
23
        while(!dq.empty()&&sum[dq.back()]>=sum[i])dq.pop_back();
24
        dq.push_back(i);
25
        if(i>=n){
26
            while(!dq.empty()&&i-dq.front()>n)dq.pop_front();
27
            if(sum[dq.front()]-sum[i-n]>=0)ans++;
28
        }
29
    }
30
    cout<<ans<<endl;
31
    return 0;
32
}

展开收起

[第1章 1.2t5] 良好的感觉

Fri, 26 Jun 2026 00:00:00 GMT

1
//单调栈问题注意2个stack与a[n]哨兵
2
//前一个确保top可访问，并且初始位置可被计算
3
//第二个确保最后全部位置都被清算，这里设计的很棒
4
//注意要在本轮res计算完成后push
5
#include <bits/stdc++.h>
6
using namespace std;
7
typedef long long ll;
8
int main(){
9
    ll n;
10
    cin>>n;
11
    vector<ll> a(n+2,0),sum(n+2,0),res(n+2,0);
12
    for(ll i=1;i<=n;i++)cin>>a[i];
13
    n++;
14
    stack<ll> st;
15
    st.push(0);
16
    ll ans=0;
17
    for(ll i=1;i<=n;i++){
18
        sum[i]=sum[i-1]+a[i];
19
        while(!st.empty()&&a[st.top()]>a[i]){
20
            ll tp=st.top();
21
            st.pop();
22
            res[tp]+=(sum[i-1]-sum[tp]);
23
        }
24
        res[i]=(sum[i]-sum[st.top()]);
25
        st.push(i);
26
    }
27
    for(ll i=1;i<=n;i++){
28
        ans=max(ans,res[i]*a[i]);
29
    }
30
    cout<<ans<<endl;
31
    return 0;
32
}

展开收起

[第1章 1.2t6] 机器翻译-NOIP

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
queue<ll> qq;
5
vector<ll> hh(1010,0);
6
int main(){
7
    ll m,n;
8
    cin>>m>>n;
9
    ll cnt=0;
10
    for(ll i=0;i<n;i++){
11
        ll t;
12
        cin>>t;
13
        if(!hh[t]){
14
            hh[t]=1;
15
            qq.push(t);
16
            cnt++;
17
            while(qq.size()>m){
18
                hh[qq.front()]=0;
19
                qq.pop();
20
            }
21
        }
22
    }
23
    cout<<cnt<<endl;
24
    return 0;
25
}

展开收起

[第1章 1.2t7] 跳房子

Fri, 26 Jun 2026 00:00:00 GMT

1
//滑动窗口队列+二分+DP
2
//此处二分当模版记住得了
3
//此处j只有在等到满足left后才++，此处把一个区间掰成2步处理很不错，值得借鉴，同时这也是运用队列的原因
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
const ll INF=1e18;
8
ll n,d,k;
9
vector<ll> x,s;
10
bool check(ll t){
11
    vector<ll> gain(n+1,-INF);
12
    deque<ll> dq;
13
    gain[0]=0;
14
    ll j=0;
15
    ll left=max(1LL,d-t),right=d+t;
16
    for(ll i=1;i<=n;i++){
17
        while(j<i&&x[i]-x[j]>=left){
18
            if(gain[j]!=-INF){
19
                while(!dq.empty()&&gain[dq.back()]<gain[j])dq.pop_back();
20
                dq.push_back(j);
21
            }
22
            j++;
23
        }
24
        while(!dq.empty()&&x[i]-x[dq.front()]>right)dq.pop_front();
25
        if(!dq.empty())gain[i]=gain[dq.front()]+s[i];
26
        else gain[i]=-INF;
27
        if(gain[i]>=k)return true;
28
    }
29
    return false;
30
}
31
int main(){
32
    cin>>n>>d>>k;
33
    x.resize(n+1),s.resize(n+1);
34
    for(ll i=1;i<=n;i++)cin>>x[i]>>s[i];
35
    ll r=1e9,l=0;
36
    ll ans=-1;
37
    while(l<=r){
38
        ll mid=(r+l)/2;
39
        if(check(mid)){
40
            ans=mid;
41
            r=mid-1;
42
        }else{
43
            l=mid+1;
44
        }
45
    }
46
    cout<<ans<<endl;
47
    return 0;
48
}

展开收起

[第1章 1.2t8] 琪露诺

Fri, 26 Jun 2026 00:00:00 GMT

1
//跟上一题有异曲同工之妙，把区间掰成两段，先把满足l的入队并排序
2
//接着消除不满足r的元素，使用dp不断计算每个位置的最大收益
3
//最后注意并非每个位置都可退出游戏，需要在合法i位置取最大值
4
//注意窗口主要维护的是j，i只是比较对象
5
#include <bits/stdc++.h>
6
using namespace std;
7
typedef long long ll;
8
const ll INF=-1e18;
9
int main(){
10
    ll n,l,r;
11
    cin>>n>>l>>r;
12
    vector<ll> a(n+1);
13
    vector<ll> gain(n+1,INF);
14
    gain[0]=0;
15
    deque<ll> qq;
16
    for(ll i=0;i<=n;i++)cin>>a[i];
17
    ll j=0;
18
    ll ans=INF;
19
    for(ll i=1;i<=n;i++){
20
        while(i>=j+l){
21
            if(gain[j]!=INF){
22
                while(!qq.empty()&&gain[qq.back()]<gain[j])qq.pop_back();
23
                qq.push_back(j);
24
            }
25
            j++;
26
        }
27
        while(!qq.empty()&&i-qq.front()>r)qq.pop_front();
28
        if(!qq.empty()){
29
            gain[i]=gain[qq.front()]+a[i];
30
            if(i+r>n)ans=max(ans,gain[i]);
31
        }
32
    }
33
    cout<<ans<<endl;
34
    return 0;
35
}

展开收起

[第1章 1.2t9] 小组队列

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n,m;
8
    cin>>n>>m;
9
    vector<pair<ll,ll>> a(n);
10
    deque<ll> se;
11
    vector<deque<pair<ll,ll>>> num(300);
12
    for(ll i=0;i<n;i++){
13
        cin>>a[i].first;
14
        a[i].second=i;
15
    }
16
    ll t;
17
    cin>>t;
18
    for(ll i=0;i<t;i++){
19
        string str;
20
        cin>>str;
21
        if(str=="push"){
22
            ll nn;
23
            cin>>nn;
24
            ll na=a[nn].first;
25
      ll nb=a[nn].second;
26
            if(num[na].empty()){
27
                se.push_back(na);
28
            }
29
            num[na].push_back({na,nb});
30
        }else{
31
            ll fr=se.front();
32
            cout<<num[fr].front().second<<endl;
33
            if(num[fr].size()==1){
34
                se.pop_front();
35
            }
36
            num[fr].pop_front();
37
        }
38
    }
39
    return 0;
40
}

展开收起

[第1章 1.3e1] Text Reverse

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll t;
7
    cin>>t;
8
    cin.ignore();
9
    while(t--){
10
        string str;
11
        getline(cin,str);
12
        stack<char> st;
13
        string oo;
14
        for(ll i=0;i<=str.size();i++){
15
            if(str[i]==' '||i==str.size()){
16
                while(!st.empty()){
17
                    oo.push_back(st.top());
18
                    st.pop();
19
                }
20
                if(i==str.size())oo.push_back(' ');
21
            }else st.push(str[i]);
22
        }
23
        cout<<oo<<endl;
24
    }
25
    return 0;
26
}

展开收起

[第1章 1.3e2] Look Up S

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll t;
7
    cin>>t;
8
    vector<ll> h(t+2),ans(t+2);
9
    deque<ll> dq;
10
    dq.push_back(t+1);
11
    for(ll i=1;i<=t;i++)cin>>h[i];
12
    h[t+1]=1e18;
13
    for(ll i=t;i>=1;i--){
14
        while(h[i]>=h[dq.back()])dq.pop_back();
15
        if(dq.back()==t+1)ans[i]=0;
16
        else ans[i]=dq.back();
17
        dq.push_back(i);
18
    }
19
    for(ll i=1;i<=t;i++)cout<<ans[i]<<endl;
20
    return 0;
21
}

展开收起

[第1章 1.3t1] 单调栈-模板

Fri, 26 Jun 2026 00:00:00 GMT

1
//单调栈
2
#include <bits/stdc++.h>
3
#define endl '\n'
4
using namespace std;
5
typedef long long ll;
6
int main(){
7
    ll n;
8
    cin>>n;
9
    vector<ll> ans(n+2),a(n+2);
10
    deque<ll> dq;
11
    a[n+1]=1e18;
12
    dq.push_back(n+1);
13
    for(ll i=1;i<=n;i++)cin>>a[i];
14
    for(ll i=n;i>=1;i--){
15
        while(a[dq.back()]<=a[i])dq.pop_back();
16
        if(dq.back()==n+1)ans[i]=0;
17
        else ans[i]=dq.back();
18
        dq.push_back(i);
19
    }
20
    for(ll i=1;i<=n;i++){
21
        if(i!=1)cout<<" ";
22
        cout<<ans[i];
23
    }
24
    cout<<endl;
25
    return 0;
26
}

展开收起

[第1章 1.3t2] 后缀表达式

Fri, 26 Jun 2026 00:00:00 GMT

1
//直接用ac、bc作为临时数据，出现.完成一次计算
2
#include <bits/stdc++.h>
3
#define endl '\n'
4
using namespace std;
5
typedef long long ll;
6
int main(){
7
    string str;
8
    cin>>str;
9
    deque<ll> dq;
10
    ll ac=0,bc=0;
11
    ll a,b;
12
    for(ll i=0;i<str.size();i++){
13
        auto it=str[i];
14
            switch (it){
15
            case '@':
16
                break;
17
            case '.':
18
                dq.push_back(ac);
19
                ac=bc=0;
20
                break;
21
            case '+':
22
                a=dq.back();
23
                dq.pop_back();
24
                b=dq.back();
25
                dq.pop_back();
26
                dq.push_back(a+b);
27
                break;
28
            case '-':
29
                a=dq.back();
30
                dq.pop_back();
31
                b=dq.back();
32
                dq.pop_back();
33
                dq.push_back(b-a);
34
                break;
35
            case '*':
36
                a=dq.back();
37
                dq.pop_back();
38
                b=dq.back();
39
                dq.pop_back();
40
                dq.push_back(a*b);
41
                break;
42
            case '/':
43
                a=dq.back();
44
                dq.pop_back();
45
                b=dq.back();
46
                dq.pop_back();
47
                dq.push_back(b/a);
48
                break;
49
            default:
50
                ac=bc*10+it-'0';
51
                bc=ac;
52
                break;
53
        }
54
    }
55
    cout<<dq.back()<<endl;
56
    return 0;
57
}

展开收起

[第1章 1.3t3] 表达式括号匹配

Fri, 26 Jun 2026 00:00:00 GMT

1
//小心))((
2
//一定要确保操作数据结构时，是非空状态，否则RE
3
#include <bits/stdc++.h>
4
#define endl '\n'
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    string str;
9
    cin>>str;
10
    stack<char> st;
11
    for(ll i=0;i<str.size();i++){
12
        if(str[i]=='(')st.push('(');
13
        else if(str[i]==')'){
14
            if(st.empty()){
15
                cout<<"NO"<<endl;
16
                return 0;
17
            }
18
            st.pop();
19
        }
20
    }
21
    if(!st.empty())cout<<"NO"<<endl;
22
    else cout<<"YES"<<endl;
23
    return 0;
24
}

展开收起

[第1章 1.3t4] 表达式求值

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    string str;
7
    cin>>str;
8
    ll a=0,b=0;
9
    str.push_back(1);
10
    stack<ll> st;
11
    ll acc=1;
12
    ll ans=0;
13
    for(ll i=0;i<=str.size();i++){
14
        auto it=str[i];
15
        ans%=10000;
16
        acc%=10000;
17
        a%=10000;
18
        b%=10000;
19
        if(it=='+'||i==str.size()-1){
20
            ans+=(acc*a);
21
            acc=1;
22
            a=b=0;
23
            if(i==str.size())break;
24
        }else if(it=='*'){
25
            acc*=a;
26
            a=b=0;
27
        }else{
28
            a=b*10+it-'0';
29
            b=a;
30
        }
31
    }
32
    cout<<ans<<endl;
33
    return 0;
34
}

展开收起

[第1章 1.3t5] 表达式的转换

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
ll power(char a){
6
    if(a=='+'||a=='-')return 1;
7
    if(a=='*'||a=='/')return 2;
8
    if(a=='^')return 3;
9
    return 0;
10
}
11
bool isop(string it){
12
    if(it.size()==1&&string{"+-*/^"}.find(it[0])!=string::npos)return true;
13
    return false;
14
}
15
ll kua(ll a,ll b){
16
    ll ans=1;
17
    while(b){
18
        if(b%2)ans*=a;
19
        b/=2;
20
        a*=a;
21
    }
22
    return ans;
23
}
24
ll ca(ll a,ll b,char c){
25
    if(c=='+')return b+a;
26
    if(c=='-')return b-a;
27
    if(c=='*')return b*a;
28
    if(c=='/')return b/a;
29
    if(c=='^')return kua(b,a);
30
}
31
int main(){
32
    string str;
33
    cin>>str;
34
    vector<string> dq;
35
    deque<char> cal;
36
    for(ll i=0;i<str.size();){
37
        char cnt=str[i];
38
        if('0'<=cnt&&cnt<='9'){
39
            string num;
40
            while(i<str.size()&&('0'<=str[i]&&str[i]<='9'))
41
                num+=str[i++];
42
            dq.push_back(num);
43
            continue;
44
        }else if(cnt=='('){
45
            cal.push_back('(');
46
        }else if(cnt==')'){
47
            while(!cal.empty()&&cal.back()!='('){
48
                string tran=string(1,cal.back());
49
                dq.push_back(tran);
50
                cal.pop_back();
51
            }
52
            if(!cal.empty())cal.pop_back();
53
        }else{
54
            while(!cal.empty()&&cal.back()!='('){
55
                if(power(cnt)<=power(cal.back())&&cnt!='^'){
56
                    dq.push_back(string(1,cal.back()));
57
                    cal.pop_back();
58
                }else break;
59
            }
60
            cal.push_back(cnt);
61
        }
62
        i++;
63
    }
64
    while(!cal.empty()){
65
        dq.push_back(string(1,cal.back()));
66
        cal.pop_back();
67
    }
68
    for(ll i=0;i<dq.size();i++){
69
        if(i!=0)cout<<' ';
70
        cout<<dq[i];
71
    }
72
    cout<<endl;
73
    while(dq.size()>1){
74
        for(ll j=0;j<dq.size();j++){
75
            if(isop(dq[j])){
76
                ll a=stoll(dq[j-1]);
77
                ll b=stoll(dq[j-2]);
78
                ll op=dq[j][0];
79
                dq.erase(dq.begin()+j-2,dq.begin()+j+1);
80
                dq.insert(dq.begin()+j-2,to_string(ca(a,b,op)));
81
                break;
82
            }
83
        }
84
        for(ll j=0;j<dq.size();j++){
85
            if(j!=0)cout<<' ';
86
            cout<<dq[j];
87
        }
88
        cout<<endl;
89
    }
90
    return 0;
91
}

展开收起

[第1章 1.4e1] Entropy-熵

Fri, 26 Jun 2026 00:00:00 GMT

1
//能按照树构建的顺序计算出ans的确没想到
2
//string类不存在访问到边界以外的位置导致内存错误
3
#include <bits/stdc++.h>
4
#define endl '\n'
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    string str;
9
    while(getline(cin,str)&&str!="END"){
10
        sort(str.begin(),str.end());
11
        priority_queue<ll,vector<ll>,greater<ll>> pq;
12
        ll num=1;
13
        for(ll i=1;i<=str.size();i++){
14
            if(str[i]!=str[i-1]){
15
                pq.push(num);
16
                num=1;
17
            }else num++;
18
        }
19
        ll ans=0;
20
        if(pq.size()==1)ans=str.size();
21
        while(pq.size()>1){
22
            ll a=pq.top();
23
            pq.pop();
24
            ll b=pq.top();
25
            pq.pop();
26
            ans+=a+b;
27
            pq.push(a+b);
28
        }
29
        printf("%lld %lld %.1lf\n",str.size()*8,ans,double(str.size())*8/ans);
30
    }
31
    return 0;
32
}

展开收起

[第1章 1.4t1] Safe Or Unsafe

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
bool solve(){
6
    ll n;
7
    cin>>n;
8
    string str;
9
    cin>>str;
10
    sort(str.begin(),str.end());
11
    priority_queue<ll,vector<ll>,greater<>> pq;
12
    ll num=1;
13
    for(ll i=1;i<=str.size();i++){
14
        if(str[i-1]!=str[i]){
15
            pq.push(num);
16
            num=1;
17
        }else num++;
18
    }
19
    ll ans=1;
20
    if(pq.size()==1)ans=str.size();
21
    while(pq.size()>1){
22
        ll a=pq.top();pq.pop();
23
        ll b=pq.top();pq.pop();
24
        ans+=a+b;
25
        pq.push(a+b);
26
    }
27
    if(ans<=n)return true;
28
    else return false;
29
}
30
int main(){
31
    ll t;
32
    cin>>t;
33
    while(t--){
34
        if(solve())cout<<"yes"<<endl;
35
        else cout<<"no"<<endl;
36
    }
37
    return 0;
38
}

展开收起

[第1章 1.4t2] FBI树

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
ll len;
6
string ans;
7
vector<ll> num;
8
ll kuai(ll a,ll b){
9
    ll ans=1;
10
    while(b){
11
        if(b%2)ans*=a;
12
        b/=2;
13
        a*=a;
14
    }
15
    return ans;
16
}
17
char cal(ll l,ll r){
18
    if(r==l){
19
        if(num[l])return 'I';
20
        else return 'B';
21
    }
22
    ll mid=(l+r)/2;
23
    char lres=cal(l,mid);
24
    ans.push_back(lres);
25
    char rres=cal(mid+1,r);
26
    ans.push_back(rres);
27
    if(lres==rres&&lres=='I')return 'I';
28
    else if(lres==rres&&lres=='B')return 'B';
29
    else return 'F';
30
}
31
int main(){
32
    ll n;
33
    cin>>n;
34
    len=kuai(2,n);
35
    num.resize(len+1);
36
    for(ll i=1;i<=len;i++){
37
        char c;
38
        cin>>c;
39
        num[i]=c-'0';
40
    }
41
    ans.push_back(cal(1,len));
42
    cout<<ans<<endl;
43
    return 0;
44
}

展开收起

[第1章 1.4t3] 求先序排列

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
void fid(string fr,string be){
6
    if(fr.size()>0){
7
        char root=be.back();
8
        cout<<root;
9
        ll gap=fr.find(root),siz=fr.size();
10
        fid(fr.substr(0,gap),be.substr(0,gap));
11
        fid(fr.substr(gap+1,siz-gap),be.substr(gap,siz-gap-1));
12
    }
13
}
14
int main(){
15
    string fr,be;
16
    cin>>fr>>be;
17
    fid(fr,be);
18
    cout<<endl;
19
    return 0;
20
}

展开收起

[第1章 1.4t4] 新二叉树

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
typedef pair<char,char> pll;
6
unordered_map<char,pll> mp;
7
void fid(char pos){
8
    char l=mp[pos].first,r=mp[pos].second;
9
    cout<<pos;
10
    if(l!='*')fid(l);
11
    if(r!='*')fid(r);
12
}
13
int main(){
14
    ios::sync_with_stdio(false);cin.tie(0);
15
    ll n;
16
    cin>>n;
17
    char root;
18
    for(ll i=0;i<n;i++){
19
        char a,b,c;
20
        cin>>a>>b>>c;
21
        if(i==0)root=a;
22
        mp[a]={b,c};
23
    }
24
    fid(root);
25
    cout<<endl;
26
    return 0;
27
}

展开收起

[第1章 1.4t5] 遍历问题

Fri, 26 Jun 2026 00:00:00 GMT

1
//本题可以辅助理解前中后序遍历，前后遍历强调了根的位置，中序遍历强调了子树位置
2
//仅有前后遍历，无法构造确定的树，比如前序AB，后序BA，根都是A但B无法确定在哪个树上
3
//故如果要找树可能的形态就要找形如以上形式的个数，这是造成差异的原因
4
#include <bits/stdc++.h>
5
#define endl '\n'
6
using namespace std;
7
typedef long long ll;
8
int main(){
9
    string s1,s2;
10
    cin>>s1>>s2;
11
    ll ans=0;
12
    for(ll i=0;i<s1.size();i++){
13
        for(ll j=0;j<s2.size();j++){
14
            if(s1[i]==s2[j+1]&&s1[i+1]==s2[j])ans++;
15
        }
16
    }
17
    cout<<(ll)pow(2,ans)<<endl;
18
    return 0;
19
}

展开收起

[第1章 1.4t6] 对称二叉树

Fri, 26 Jun 2026 00:00:00 GMT

1
#include<bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
typedef pair<ll,ll> pll;
6
vector<ll> v;
7
vector<ll> tree;
8
unordered_map<ll,pll> mp;
9
ll count(ll x){
10
    if(x==-1)return 0;
11
    ll l=mp[x].first;
12
    ll r=mp[x].second;
13
    tree[x]=count(l)+count(r)+1;
14
    return tree[x];
15
}
16
bool mirror(ll x,ll y){
17
    if(x==-1&&y==-1)return true;
18
    if(x==-1||y==-1)return false;
19
    if(v[x]!=v[y])return false;
20
    return mirror(mp[x].first,mp[y].second)&&mirror(mp[x].second,mp[y].first);
21
}
22
int main(){
23
    ios::sync_with_stdio(false);cin.tie(0);
24
    ll n;
25
    cin>>n;
26
    tree.resize(n+1);
27
    v.resize(n+1);
28
    for(ll i=1;i<=n;i++)cin>>v[i];
29
    for(ll i=1;i<=n;i++){
30
        cin>>mp[i].first>>mp[i].second;
31
    }
32
    ll ans=0;
33
    count(1);
34
    for(ll i=1;i<=n;i++){
35
        if(mirror(i,i))ans=max(ans,tree[i]);
36
    }
37
    cout<<ans<<endl;
38
    return 0;
39
}

展开收起

[第1章 1.4t8] 荷马史诗

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
typedef pair<ll,ll> pll;
6
int main(){
7
    ll n,k;
8
    cin>>n>>k;
9
    priority_queue<pll,vector<pll>,greater<>> pq;
10
    for(ll i=1;i<=n;i++){
11
        ll w;
12
        cin>>w;
13
        pq.push({w,0});
14
    }
15
    ll ans=0;
16
    ll ma=0;
17
    while((pq.size()-1)%(k-1)!=0)pq.push({0,0});
18
    while(pq.size()>1){
19
        ll tmp=0;
20
        ll h=0;
21
        for(ll i=0;i<k;i++){
22
            tmp+=pq.top().first;
23
            h=max(h,pq.top().second);
24
            pq.pop();
25
        }
26
        ans+=tmp;
27
        pq.push({tmp,h+1});
28
    }
29
    cout<<ans<<endl<<pq.top().second<<endl;
30
    return 0;
31
}

展开收起

[第1章 1.5e1] 堆-模板

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll n;
7
    cin>>n;
8
    priority_queue<ll,vector<ll>,greater<>>pq;
9
    while(n--){
10
        ll op;
11
        cin>>op;
12
        if(op==1){
13
            ll x;
14
            cin>>x;
15
            pq.push(x);
16
        }else if(op==2)cout<<pq.top()<<endl;
17
        else pq.pop();
18
    }
19
    return 0;
20
}

展开收起

[第1章 1.5t1] 合并果子

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n;
8
    cin>>n;
9
    priority_queue<ll,vector<ll>,greater<>> a;
10
    for(ll i=0;i<n;i++){
11
        ll tmp;
12
        cin>>tmp;
13
        a.push(tmp);
14
    }
15
    ll ans=0;
16
    while(a.size()>1){
17
        ll aa=a.top();a.pop();
18
        ll bb=a.top();a.pop();
19
        ans+=aa+bb;
20
        a.push(aa+bb);
21
    }
22
    cout<<ans<<endl;
23
    return 0;
24
}

展开收起

[第1章 1.5t2] 中位数

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll n;
7
    cin>>n;
8
    priority_queue<ll> r;
9
    priority_queue<ll,vector<ll>,greater<>> l;
10
    ll tmp;
11
    cin>>tmp;
12
    cout<<tmp<<endl;
13
    r.push(tmp);
14
    for(ll i=1;i<n;i++){
15
        cin>>tmp;
16
        if(tmp>r.top())l.push(tmp);
17
        else r.push(tmp);
18
        while(r.size()>l.size()+1){
19
            l.push(r.top());r.pop();
20
        }
21
        while(l.size()>r.size()+1){
22
            r.push(l.top());l.pop();
23
        }
24
        if(i%2==0)cout<<(l.size()>r.size()?l.top():r.top())<<endl;
25
    }
26
    return 0;
27
}

展开收起

[第1章 1.5t3] 最小函数值

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5

6
struct node {
7
    ll w;
8
    ll a, b, c;
9
    ll cntx = 1;
10
};
11

12
struct cmp {
13
    bool operator()(const node &a, const node &b) const {
14
        return a.w > b.w;
15
    }
16
};
17

18
int main() {
19
    ll n, m;
20
    cin >> n >> m;
21
    priority_queue<node, vector<node>, cmp> pq;
22
    for (ll i = 0; i < n; i++) {
23
        ll a, b, c;
24
        cin >> a >> b >> c;
25
        node po;
26
        po.a = a, po.b = b, po.c = c;
27
        po.cntx = 1;
28
        po.w = a + b + c;
29
        pq.push(po);
30
    }
31
    while (m--) {
32
        auto f = pq.top();
33
        pq.pop();
34
        cout << f.w << " ";
35
        f.cntx++;
36
        f.w = f.a * f.cntx * f.cntx + f.b * f.cntx + f.c;
37
        pq.push(f);
38
    }
39
    cout<<endl;
40
    return 0;
41
}

展开收起

[第1章 1.5t4] 蚯蚓

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll n,m,q,u,v,t;
7
    cin>>n>>m>>q>>u>>v>>t;
8
    deque<ll> q1,q2,q3;
9
    for(ll i=0;i<n;i++){
10
        ll tmp;
11
        cin>>tmp;
12
        q1.push_back(tmp);
13
    }
14
    bool bk=false;
15
    sort(q1.begin(),q1.end(),greater<ll>());
16
    for(ll i=0;i<m;i++){
17
        ll ma=LLONG_MIN,lo=0;
18
        if(!q1.empty()&&q1.front()>ma)ma=q1.front(),lo=1;
19
        if(!q2.empty()&&q2.front()>ma)ma=q2.front(),lo=2;
20
        if(!q3.empty()&&q3.front()>ma)ma=q3.front(),lo=3;
21
        if(lo==1)q1.pop_front();
22
        else if(lo==2)q2.pop_front();
23
        else q3.pop_front();
24
        ma+=i*q;
25
        ll res1=ma*u/v,res2=ma-res1;
26
        q2.push_back(res1-q-i*q);
27
        q3.push_back(res2-q-i*q);
28
        if((i+1)%t==0){
29
            if(bk)cout<<' ';
30
            cout<<ma;
31
            bk=false;
32
        }
33
    }
34
    bk=true;
35
    cout<<endl;
36
    for(ll i=0;i<n+m;i++){
37
        ll ma=LLONG_MIN,lo=0;
38
        if(!q1.empty()&&q1.front()>ma)ma=q1.front(),lo=1;
39
        if(!q2.empty()&&q2.front()>ma)ma=q2.front(),lo=2;
40
        if(!q3.empty()&&q3.front()>ma)ma=q3.front(),lo=3;
41
        if(lo==1)q1.pop_front();
42
        else if(lo==2)q2.pop_front();
43
        else q3.pop_front();
44
        if((i+1)%t==0){
45
            if(bk)cout<<' ';
46
            cout<<ma;
47
            bk=false;
48
        }
49
    }
50
    cout<<endl;
51
    return 0;
52
}

展开收起

[第1章 1.5t5] Cow Coupons G

Fri, 26 Jun 2026 00:00:00 GMT

1
//本题为反悔贪心，总结一下堆的知识，着重在于考察利用某些性质管理不同堆解决问题
2
//反悔贪心在于每次都比较一下是硬着头皮上还是选择反悔一次代价最小的
3
//如果是后者回报高，那就付出代价，把仅有的减免机会让给c组
4
//注意使用buy数组同步p和c组内已买过的物品，每一轮都要删掉已买的，保证一致性
5
#include <bits/stdc++.h>
6
#define endl '\n'
7
using namespace std;
8
typedef long long ll;
9
typedef struct{
10
    ll pri,pre;
11
    ll ord;
12
}pll;
13
struct cmp1{
14
    bool operator()(const pll &a,const pll &b){
15
        return a.pri>b.pri;
16
    }
17
};
18
struct cmp2{
19
    bool operator()(const pll &a,const pll &b){
20
        return a.pre>b.pre;
21
    }
22
};
23
int main(){
24
    ll n,k,m;
25
    cin>>n>>k>>m;
26
    vector<bool> buy(n,false);
27
    priority_queue<pll,deque<pll>,cmp1>p;
28
    priority_queue<pll,deque<pll>,cmp2>c;
29
    priority_queue<ll,deque<ll>,greater<>>delta;
30
    for(ll i=0;i<k;i++)delta.push(0);
31
    for(ll i=0;i<n;i++){
32
        pll tmp;
33
        cin>>tmp.pri>>tmp.pre;
34
        tmp.ord=i;
35
        p.push(tmp);
36
        c.push(tmp);
37
    }
38
    ll ans=0;
39
    while(!p.empty()){
40
        while(!p.empty()&&buy[p.top().ord])p.pop();
41
        while(!c.empty()&&buy[c.top().ord])c.pop();
42
        if(p.empty())break;
43
        if(p.top().pri<=c.top().pre+delta.top()){
44
            m-=p.top().pri;
45
            if(m<0)break;
46
            buy[p.top().ord]=true;
47
            ans++;
48
        }else{
49
            m-=delta.top()+c.top().pre;
50
            if(m<0)break;
51
            buy[c.top().ord]=true;
52
            delta.pop();
53
            delta.push(c.top().pri-c.top().pre);
54
            ans++;
55
        }
56
    }
57
    cout<<ans<<endl;
58
    return 0;
59
}

展开收起

Firefly 简单使用指南

Fri, 01 May 2026 00:00:00 GMT

这个博客模板是基于 Astro 构建的。对于本指南中未提及的内容，您可以在 Astro 文档中找到答案。

文章的 Front-matter#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
description: 这是我新 Astro 博客的第一篇文章。
5
image: ./cover.jpg
6
tags: [前端, 开发]
7
category: 前端开发
8
draft: false
9
---

属性	描述
`title`	文章标题。
`published`	文章发布日期。
`updated`	文章更新日期。如果未设置，将默认使用发布日期。
`pinned`	是否将此文章置顶在文章列表顶部。
`description`	文章的简短描述。显示在首页上。
`image`	文章封面图片路径。 1. 以 `http://` 或 `https://` 开头：使用网络图片 2. 以 `/` 开头：`public` 目录中的图片 3. 不带任何前缀：相对于 markdown 文件的路径
`tags`	文章标签。
`category`	文章分类。
`lang`	文章语言代码（如 `zh-CN`）。仅当文章语言与站点默认语言不同时设置。
`licenseName`	文章内容的许可证名称。
`licenseUrl`	文章内容的许可证链接。
`author`	文章作者。
`sourceLink`	文章内容的来源链接或参考。
`draft`	如果这篇文章仍是草稿，则不会显示。
`comment`	是否启用此文章的评论功能。默认为 `true`。
`slug`	自定义文章 URL 路径。如果不设置，将使用文件名作为 URL。
`password`	文章密码。设置后文章内容将被 AES-256-GCM 加密，访客需输入密码才能查看。
`passwordHint`	密码提示。显示在密码输入框上方，帮助访客回忆密码，也可以不加。

文章文件的放置位置#

您的文章文件应放置在 src/content/posts/ 目录中。您也可以创建子目录来更好地组织您的文章和资源。

1
src/content/posts/
2
├── post-1.md
3
└── post-2/
4
    ├── cover.png
5
    └── index.md

自定义文章 URL (Slug)#

什么是 Slug？#

Slug 是文章 URL 路径的自定义部分。如果不设置 slug，系统将使用文件名作为 URL。

Slug 使用示例#

示例 1：使用文件名作为 URL#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/my-first-blog-post

示例 2：自定义 Slug#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
slug: hello-world
5
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/hello-world

示例 3：其他语言文件名使用Slug#

1
---
2
title: 如何使用 Firefly 博客主题
3
published: 2023-09-09
4
slug: how-to-use-firefly-blog-theme
5
---

文件：src/content/posts/如何使用Firefly博客主题.md

URL：/posts/how-to-use-firefly-blog-theme

Slug 使用建议#

使用英文和连字符：my-awesome-post 而不是 my awesome post
保持简洁：避免过长的 slug
具有描述性：让 URL 能够反映文章内容
避免特殊字符：只使用字母、数字和连字符
保持一致性：在整个博客中使用相似的命名模式

注意事项#

Slug 一旦设置并发布，建议不要随意更改，以免影响 SEO 和已存在的链接
如果多个文章使用相同的 slug，后面的文章会覆盖前面的
Slug 会自动转换为小写

Firefly 代码块示例

Fri, 01 May 2026 00:00:00 GMT

在这里，我们将探索如何使用 Expressive Code 展示代码块。提供的示例基于官方文档，您可以参考以获取更多详细信息。

表达性代码#

语法高亮#

语法高亮

常规语法高亮#

1
console.log('此代码有语法高亮!')

渲染 ANSI 转义序列#

Terminal window展开收起

1
Standard ANSI colors:
2
- Dimmed:      Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
3
- Foreground:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
4
- Background:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
5
- Reversed:    Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
6

7
8-bit colors (showing colors 160-171 as an example):
8
- Dimmed:      160  161  162  163  164  165  166  167  168  169  170  171 
9
- Foreground:  160  161  162  163  164  165  166  167  168  169  170  171 
10
- Background:  160  161  162  163  164  165  166  167  168  169  170  171 
11
- Reversed:    160  161  162  163  164  165  166  167  168  169  170  171 
12

13
24-bit colors (full RGB):
14
- Dimmed:      ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
15
- Foreground:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
16
- Background:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
17
- Reversed:    ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
18

19
Font styles:
20
- Default
21
- Bold
22
- Dimmed
23
- Italic
24
- Underline
25
- Reversed
26
- Strikethrough

展开收起

编辑器和终端框架#

编辑器和终端框架

代码编辑器框架#

my-test-file.js

1
console.log('标题属性示例')

src/content/index.html

1
<div>文件名注释示例</div>

终端框架#

Terminal window

1
echo "此终端框架没有标题"

PowerShell 终端示例

1
Write-Output "这个有标题!"

覆盖框架类型#

1
echo "看，没有框架!"

PowerShell Profile.ps1

1
# 如果不覆盖，这将是一个终端框架
2
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
3
New-Alias tail Watch-Tail

文本和行标记#

文本和行标记

标记整行和行范围#

1
// 第1行 - 通过行号定位
2
// 第2行
3
// 第3行
4
// 第4行 - 通过行号定位
5
// 第5行
6
// 第6行
7
// 第7行 - 通过范围 "7-8" 定位
8
// 第8行 - 通过范围 "7-8" 定位

选择行标记类型 (mark, ins, del)#

line-markers.js

1
function demo() {
2
  console.log('此行标记为已删除')
3
  // 此行和下一行标记为已插入
4
  console.log('这是第二个插入行')
5

6
  return '此行使用中性默认标记类型'
7
}

为行标记添加标签#

labeled-line-markers.jsx

1
<button
2
  role="button"
3
  {...props}
4
  value={value}
5
  className={buttonClassName}
6
  disabled={disabled}
7
  active={active}
8
>
9
  {children &&
10
    !active &&
11
    (typeof children === 'string' ? <span>{children}</span> : children)}
12
</button>

在单独行上添加长标签#

labeled-line-markers.jsx展开收起

1
<button
2
  role="button"
3
  {...props}
4

5
  value={value}
6
  className={buttonClassName}
7

8
  disabled={disabled}
9
  active={active}
10
>
11

12
  {children &&
13
    !active &&
14
    (typeof children === 'string' ? <span>{children}</span> : children)}
15
</button>

展开收起

使用类似 diff 的语法#

1
此行将标记为已插入
2
此行将标记为已删除
3
这是常规行

1
--- a/README.md
2
+++ b/README.md
3
@@ -1,3 +1,4 @@
4
+this is an actual diff file
5
-all contents will remain unmodified
6
 no whitespace will be removed either

结合语法高亮和类似 diff 的语法#

1
function thisIsJavaScript() {
2
  // 整个块都会以 JavaScript 高亮显示，
3
  // 并且我们仍然可以为其添加 diff 标记！
4
  console.log('要删除的旧代码')
5
  console.log('新的闪亮代码！')
6
}

标记行内的单独文本#

1
function demo() {
2
  // 标记行内的任何给定文本
3
  return '支持给定文本的多个匹配项';
4
}

正则表达式#

1
console.log('单词 yes 和 yep 将被标记。')

转义正斜杠#

Terminal window

1
echo "Test" > /home/test.txt

选择内联标记类型 (mark, ins, del)#

1
function demo() {
2
  console.log('这些是插入和删除的标记类型');
3
  // return 语句使用默认标记类型
4
  return true;
5
}

自动换行#

自动换行

为每个块配置自动换行#

1
// 启用换行的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// wrap=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

配置换行的缩进#

1
// preserveIndent 示例（默认启用）
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// preserveIndent=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

可折叠部分#

可折叠部分


5 collapsed lines
1
// 所有这些样板设置代码将被折叠
2
import { someBoilerplateEngine } from '@example/some-boilerplate'
3
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'
4

5
const engine = someBoilerplateEngine(evenMoreBoilerplate())
6

7
// 这部分代码默认可见
8
engine.doSomething(1, 2, 3, calcFn)
9

10
function calcFn() {
11
  // 您可以有多个折叠部分
3 collapsed lines
12
  const a = 1
13
  const b = 2
14
  const c = a + b
15

16
  // 这将保持可见
17
  console.log(`计算结果: ${a} + ${b} = ${c}`)
18
  return c
19
}
20

4 collapsed lines
21
// 直到块末尾的所有代码将再次被折叠
22
engine.closeConnection()
23
engine.freeMemory()
24
engine.shutdown({ reason: '示例样板代码结束' })

展开收起

行号#

行号

为每个块显示行号#

1
// 此代码块将显示行号
2
console.log('来自第2行的问候!')
3
console.log('我在第3行')

// 此块禁用行号
console.log('你好?')
console.log('抱歉，你知道我在第几行吗?')

更改起始行号#

5
console.log('来自第5行的问候!')
6
console.log('我在第6行')

Tab 代码块#

由 rehype-code-group 提供，语法与 VitePress 代码组一致：用 ::: code-group labels=[...] 包裹多个代码块，即可合并成一组标签页。

Note

labels=[...] 中的标签按顺序对应组内的代码块，用英文逗号分隔；::: 与 code-group 之间的空格不能省略。

基本用法#

1
::: code-group labels=[code.js, code.py, code.html]
2

3
```js
4
export function greet(name) {
5
  return `Hello, ${name}!`;
6
}
7
```
8

9
```py
10
def greet(name):
11
    return f"Hello, {name}!"
12
```
13

14
```html
15
<p>Hello, world!</p>
16
```
17

18
:::

展开收起

渲染效果：

code.jscode.pycode.html

1
export function greet(name) {
2
  return `Hello, ${name}!`;
3
}

1
def greet(name):
2
    return f"Hello, {name}!"

1
<p>Hello, world!</p>

标签中使用 Emoji#

标签支持 emoji 短代码，构建时会自动转换成 emoji：

1
::: code-group labels=[:package: npm, :package: pnpm, :yarn: yarn]

📦 npm📦 pnpm🧶 yarn

Terminal window

1
npm create astro@latest

Terminal window

1
pnpm create astro@latest

Terminal window

1
yarn create astro

与其他代码块特性组合#

组内仍是普通的 Expressive Code 代码块，标题、行号、行标记、折叠、终端框架等特性都可以照常使用。

配置文件终端折叠

astro.config.mjs

1
export default {
2
  theme: "firefly",
3
  codeGroup: true,
4
};

部署

1
pnpm build && pnpm preview


3 collapsed lines
1
// 这三行默认折叠
2
import { a } from "a";
3
import { b } from "b";
4

5
console.log(a, b);

不止是代码块#

标签页内可以放任意内容，例如文字、列表或图片：

说明列表

这是一段普通的段落内容。

列表项一
列表项二

Tip

标签栏在构建期生成，默认展开第一项；支持鼠标点击与键盘 ← / → / Home / End 切换。

在提醒框内使用（MDX 组件）#

::: code-group 和 ::: tip 等 Docusaurus 风格提醒框都使用 ::: 容器语法，而 micromark-directive 规定父子容器的冒号数必须不同，因此 ::: code-group 无法嵌套在 ::: tip 等提醒框内（整块会失效）。

这种情况改用 MDX 组件 TabGroup：MDX 组件不经过 ::: 指令解析，在提醒框内外都能正常使用，也方便日后扩展更多 UI 组件。把文章后缀改为 .mdx，从统一入口 @/components/firefly-mdx 引入（可一次引入多个组件）：

1
import { TabGroup } from "@/components/firefly-mdx";
2

3
:::tip
4

5
<TabGroup labels={["test.js", "test.py"]} client:load>
6
  ```js
7
  console.log(1)
8
  ```
9

10
  ```py
11
  print("hello world")
12
  ```
13
</TabGroup>
14

15
:::

展开收起

Tip

labels 数组给每个代码块声明标签，顺序一一对应
组件用 client:load 激活标签切换

Firefly 文章加密

Fri, 01 May 2026 00:00:00 GMT

这是一篇密码保护的示例文章，用于演示文章加密功能。

Firefly 一款清新美观的 Astro 博客主题模板

Fri, 01 May 2026 00:00:00 GMT

🌟 项目概述#

Firefly 是一款基于 Astro 框架和 Fuwari 模板开发的清新美观且现代化个人博客主题模板，专为技术爱好者和内容创作者设计。该主题融合了现代 Web 技术栈，提供了丰富的功能模块和高度可定制的界面，让您能够轻松打造出专业且美观的个人博客网站。

🖥️在线预览： Firefly - Demo site

📝Firefly使用文档： https://docs-firefly.cuteleaf.cn

⭐Firefly开源地址：https://github.com/CuteLeaf/Firefly

⭐Fuwari开源地址：https://github.com/saicaca/fuwari

CuteLeaf

Firefly

🍀Firefly, fresh and aesthetic Astro blog theme template.

✨A static blog template built with Astro.

—

MIT

Astro

Firefly

🚀 技术架构#

静态站点生成: 基于 Astro ，提供极快的加载速度和优秀的 SEO 优化
TypeScript 支持: 完整的类型安全，提升开发体验和代码质量
响应式设计: 使用 Tailwind CSS 构建，完美适配桌面端和移动端
组件化开发: 支持 Astro、Svelte 组件，灵活可扩展

📖 配置说明#

📚 详细配置文档: 查看 Firefly 使用文档获取完整的配置指南

Firefly 布局系统详解

Fri, 01 May 2026 00:00:00 GMT

📖 概述#

Firefly 提供了灵活的布局系统，允许您根据内容需求和个人喜好自定义博客的视觉呈现方式。布局系统主要包括侧边栏布局和文章列表布局两个维度，它们相互配合，共同决定了页面的整体结构。

本文将详细介绍 Firefly 的各种布局模式、它们的特点、使用场景，以及不同布局组合的效果。

左侧边栏+列表布局

右侧边栏+网格布局

左侧边栏+三列网格布局

双侧边栏+列表布局

双侧边栏+网格布局

双侧边栏+网格瀑布流布局

一、侧边栏布局系统#

侧边栏是博客页面的重要组成部分，用于展示导航、分类、标签、统计信息等辅助内容。Firefly 支持两种侧边栏布局模式。

1.1 单侧边栏模式#

左侧边栏 (position: “left”)#

左侧边栏布局

右侧边栏 (position: “right”)#

右侧边栏布局

特点#

侧边栏固定在页面其中一侧
文章阅读区域体验更佳，更宽敞
更加简约，没有那么紧凑

适用场景#

传统博客风格
强调导航和分类的博客
需要突出用户资料的个人博客
内容为主，辅助信息次之的场景

Tip

可以通过showBothSidebarsOnPostPage配置是否在文章详情页显示双侧边栏

当position为left或right时开启此项后，文章详情页将显示双侧边栏，主页等其他页面保持单侧边栏

适用在只想用单侧栏，但在文章详情页想用对侧栏的目录等组件的场景

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "left", // 左侧边栏
4
  showBothSidebarsOnPostPage: true, // 是否在文章详情页显示双侧边栏
5
};

1.2 双侧边栏模式 (position: “both”)#

特点#

左右两侧同时存在侧边栏
主内容区域位于中间
最大化利用屏幕空间
可以展示更多辅助信息
适合宽屏显示器

布局结构#

双侧边栏+列表布局

双侧边栏+网格布局

适用场景#

宽屏桌面端浏览
信息密集型博客
需要展示大量辅助内容
专业性强的技术博客

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "both", // 双侧边栏

二、文章列表布局系统#

文章列表是博客首页和归档页的核心内容，Firefly 提供两种展示方式，并支持多种网格配置。

2.1 列表模式 (defaultMode: “list”)#

特点#

单列纵向排列
显示文章封面图，可配置在左侧或右侧
展示更多文章摘要
适合深度阅读

列表布局结构#

列表模式布局

封面位置#

列表模式的封面图默认在卡片右侧，可以通过 coverPosition 改到左侧。改到左侧后，标题前的主题色竖线会自动隐藏（它是贴着卡片左边缘的设计），腾出的间距留给正文。

网格模式的封面固定在卡片顶部，不受这项配置影响。

优点#

✅ 视觉冲击力强，封面图吸引眼球
✅ 可以展示更多文章信息（摘要、标签等）
✅ 适合图片内容丰富的博客
✅ 移动端友好，单列更易阅读
✅ 兼容所有侧边栏配置（单侧、双侧）

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "list",    // 列表模式
4
    coverPosition: "right", // 封面图位置："right" 右侧，"left" 左侧
5
  },
6
};

2.2 网格模式 (defaultMode: “grid”)#

特点#

自适应列数，根据浏览器宽度自动调整
紧凑布局，信息密度高
适合快速浏览

自适应网格#

网格模式通过 columnWidth 配置卡片的最小宽度（单位 px），浏览器会根据容器可用宽度自动计算能容纳多少列。

网格布局

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "grid",
4
    grid: {
5
      masonry: true,      // 开启瀑布流
6
      columnWidth: 320,   // 卡片最小宽度(px)，浏览器自动计算列数
7
    },
8
  },
9
};

2.3 瀑布流布局 (Masonry)#

Firefly 的网格模式内置了智能瀑布流布局支持，解决了网格布局中因图文混合文章导致的卡片高度不一致导致的空白问题。

瀑布流布局

智能排版：自动将卡片放置到最短的列，最大化利用垂直空间。
消除空白：通过绝对定位精确计算每个卡片的位置，让卡片紧贴上方卡片，消除垂直方向的空白间隙。
自适应列数：瀑布流同样根据 columnWidth 和容器宽度动态计算列数，无需固定配置。
配置灵活：您可以在 siteConfig.ts 中通过 postListLayout.grid.masonry 选项自由开启或关闭此功能。

三、布局组合指南#

Firefly 允许您自由组合侧边栏和文章列表布局。以下是各种组合的效果说明。

侧边栏模式	文章列表模式	推荐度	适用场景
单侧边栏	列表模式	⭐⭐⭐⭐⭐	摄影、设计、生活类博客，强调图片和沉浸感
单侧边栏	网格模式	⭐⭐⭐⭐⭐	技术、笔记类博客，平衡阅读与检索效率
双侧边栏	列表模式	⭐⭐⭐⭐⭐	需要展示大量侧边栏信息的站点
双侧边栏	网格模式	⭐⭐⭐⭐⭐	极客风格，追求最高信息密度

四、响应式布局行为#

Firefly 的布局系统具有智能的响应式设计，会根据屏幕尺寸自动调整。

为了保证最佳阅读体验，系统会在屏幕变窄时自动调整布局：

网格列数自动减少：网格模式的列数由 columnWidth 和容器宽度自动决定，屏幕越窄列数越少。
列表模式 -> 网格模式：当屏幕宽度小于 380px（超小屏设备）时，列表模式会自动切换为网格模式，以保证卡片内容的可读性。
双侧边栏 -> 单侧边栏：当屏幕宽度小于 1280px 时，会根据tabletSidebar配置显示单侧边栏，隐藏其中一个侧边栏，文章目录导航会切换成浮动目录导航。

五、常见问题#

Q1: 如何调整网格列数？#

A: 通过 columnWidth 配置卡片最小宽度即可。值越小，同等宽度下列数越多；值越大，列数越少。浏览器会自动根据可用宽度计算最佳列数。

六、总结#

Firefly 的布局系统给予了您更大的自由度，您都可以通过简单的配置实现。

我们建议您根据自己的内容类型和目标读者的设备偏好，尝试不同的组合，找到最适合您的博客形态。

Firefly Wiki Link 内部链接示例

Fri, 01 May 2026 00:00:00 GMT

Firefly 支持在 Markdown、MDX 文章中使用 Obsidian 风格的 Wiki Link 内部链接。链接目标填写文章的 slug 或文件路径，都不需要包含扩展名，具体匹配规则见下文「链接目标的三种写法」。

文章链接卡片#

[[slug]] 单独成段时，会自动读取目标文章的标题、描述、发布时间、分类、标签和封面，渲染为链接卡片：

1
[[firefly]]
2

3
[[guide/index]]
4

5
[[markdown-extended]]

Firefly 一款清新美观的 Astro 博客主题模板

Firefly 是一款基于 Astro 框架和 Fuwari 模板开发的清新美观且现代化个人博客主题模板，专为技术爱好者和内容创作者设计。该主题融合了现代 Web 技术栈，提供了丰富的功能模块和高度可定制的界面，让您能够轻松打造出专业且美观的个人博客网站。

2026-05-01博客指南#Markdown#Firefly#博客#主题#模板

Firefly 简单使用指南

如何使用 Firefly 博客模板。

2026-05-01博客指南#Firefly#博客#Markdown#指南

Markdown 扩展功能

了解 Firefly 中的 Markdown 功能

2026-05-01博客指南#演示#示例#Markdown#Firefly

行内链接#

[[slug]] 出现在正文中间时，渲染为普通链接，链接文字自动使用目标文章的标题

1
请参阅 [[firefly]] 了解主题特性。

请参阅 Firefly 一款清新美观的 Astro 博客主题模板了解主题特性。

自定义显示标题#

在 | 后填写链接的显示文字。行内链接会用它替换文章标题；单独成段时依然渲染为卡片，卡片标题使用自定义文字，描述、时间、分类、标签和封面仍然读取目标文章：

1
请参阅 [[firefly|主题介绍]] 了解主题特性。
2

3
[[firefly|Firefly 主题介绍]]

请参阅主题介绍了解主题特性。

Firefly 主题介绍

2026-05-01博客指南#Markdown#Firefly#博客#主题#模板

一个例外：如果 | 后的文字只是把链接目标又抄了一遍（[[guide/index|index]]），会被当作无效别名忽略，仍然显示文章标题。Obsidian 在插入的链接时会自动补上这样的别名，避免笔记里显示一长串路径，这个例外就是为它准备的。

链接目标的三种写法#

用 Obsidian 管理文章时，把 src/content/posts 目录本身作为 Obsidian 仓库（vault）打开。下文提到的「仓库根目录」都指这个目录，它正好也是 Firefly 解析链接路径的起点。

链接目标按以下顺序匹配：

写法	示例	在 Obsidian 中
frontmatter 的 `slug`	`[[firefly-wiki-link]]`	✗ 不支持
文件路径（相对仓库根目录）	`[[guide/firefly-layout-system]]`	✓ 需改设置（推荐）
裸文件名（仓库内唯一时）	`[[firefly-layout-system]]`	✓ 默认即是

第一种：slug#

slug 写法在 Obsidian 中不支持，slug 是 Firefly 自己的概念，Obsidian 不读取 frontmatter 里的 slug，所以按 slug 写的链接在 Obsidian 里既不会自动补全，也点不动，只有构建出的站点上能正常跳转。如果你主要在 Obsidian 里写作，用下面两种写法。

第二种：文件路径（推荐）#

文件路径写法需要改 Obsidian 设置，在 设置 → 文件与链接 → 链接 → 内部链接类型 中选择基于仓库根目录的绝对路径，Obsidian 插入的链接才会带上目录：

1
[[guide/firefly-layout-system|firefly-layout-system]]

Firefly 布局系统详解

深入了解 Firefly 的布局系统，包括侧边栏布局（左侧/双侧）和文章列表布局（列表/网格），以及自适应网格列数。

2026-05-01博客指南#Firefly#布局#博客#指南

因为仓库根目录就是 src/content/posts，Obsidian 写出的这个路径和 Firefly 需要的路径完全一致，不需要任何额外转换。

上面这行末尾的 |firefly-layout-system 是 Obsidian 自动补的别名，Firefly 会忽略它，卡片标题仍然取文章的 title，除非你把它修改和文件名不一致，才会变成你修改后的别名。

内部链接类型下拉框里的基于当前笔记的相对路径只在同目录内可用：它给同目录文章生成的是裸文件名，能正常匹配；但跨目录时会生成 ../ 前缀，Firefly 无法解析，链接会按原文显示。

第三种：裸文件名#

「内部链接类型」的默认值就是尽可能简短的形式：只要文件名在整个仓库里唯一，Obsidian 插入的链接就只有文件名，不带目录。这种写法不需要改任何设置，效果和写完整路径完全一致：

1
[[firefly-layout-system]]

Firefly 布局系统详解

深入了解 Firefly 的布局系统，包括侧边栏布局（左侧/双侧）和文章列表布局（列表/网格），以及自适应网格列数。

2026-05-01博客指南#Firefly#布局#博客#指南

文件名重名时这种写法会失效，构建日志里会给出提示，改用完整文件路径即可，所以推荐直接修改 Obsidian 内部链接类型设置为基于仓库根目录的绝对路径，使用第二种文件路径写法，一劳永逸

链接到其他文章的标题#

在文章 slug 后添加 #标题。带标题锚点的链接始终渲染为普通链接：

查看代码块语法高亮

Firefly 布局系统详解#相关链接

1
[[code-examples#语法高亮|查看代码块语法高亮]]
2

3
[[guide/firefly-layout-system#相关链接|firefly-layout-system]]

标题锚点使用与页面标题相同的 slug 规则，因此中文、空格和大小写都会按页面实际生成的 ID 处理。

链接到本页标题#

省略文章 slug，只填写标题即可链接到当前文章：

跳转到本页目标

1
[[#本页目标|跳转到本页目标]]

本页目标#

这是本页 Wiki Link 指向的标题。

不支持附件嵌入#

附件嵌入语法目前不会被转换，会按原文显示：

![[image.png]]

行内代码和代码块中的 [[firefly]] 也不会被转换。

KaTeX 数学公式示例

Fri, 01 May 2026 00:00:00 GMT

本文展示了 Firefly 主题对 KaTeX 数学公式的渲染支持。

行内公式 (Inline)#

行内公式使用单个 $ 符号包裹。

例如：欧拉公式 eiπ+1=0e^{i\pi} + 1 = 0eiπ+1=0 是数学中最优美的公式之一。

质能方程 E=mc2E = mc^2E=mc2 也是家喻户晓。

块级公式 (Block)#

块级公式使用两个 $$ 符号包裹，会居中显示。

∫−∞∞e−x2dx=π\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}∫−∞∞e−x2dx=πx=−b±b2−4ac2ax = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}x=2a−b±b2−4ac

复杂示例#

矩阵 (Matrices)#

(abcd)(αβγδ)=(aα+bγaβ+bδcα+dγcβ+dδ)\begin{pmatrix} a & b \\ c & d \end{pmatrix} \begin{pmatrix} \alpha & \beta \\ \gamma & \delta \end{pmatrix} = \begin{pmatrix} a\alpha + b\gamma & a\beta + b\delta \\ c\alpha + d\gamma & c\beta + d\delta \end{pmatrix}(acbd)(αγβδ)=(aα+bγcα+dγaβ+bδcβ+dδ)

极限与求和 (Limits and Sums)#

∑n=1∞1n2=π26\sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6}n=1∑∞n21=6π2lim⁡x→0sin⁡xx=1\lim_{x \to 0} \frac{\sin x}{x} = 1x→0limxsinx=1

麦克斯韦方程组 (Maxwell’s Equations)#

∇⋅E=ρε0∇⋅B=0∇×E=−∂B∂t∇×B=μ0J+μ0ε0∂E∂t\begin{aligned} \nabla \cdot \mathbf{E} &= \frac{\rho}{\varepsilon_0} \\ \nabla \cdot \mathbf{B} &= 0 \\ \nabla \times \mathbf{E} &= -\frac{\partial \mathbf{B}}{\partial t} \\ \nabla \times \mathbf{B} &= \mu_0\mathbf{J} + \mu_0\varepsilon_0\frac{\partial \mathbf{E}}{\partial t} \end{aligned}∇⋅E∇⋅B∇×E∇×B=ε0ρ=0=−∂t∂B=μ0J+μ0ε0∂t∂E

化学方程式 (Chemical Equations)#

\ceCH4+2O2−>CO2+2H2O\ce{CH4 + 2O2 -> CO2 + 2H2O}\ceCH4+2O2−>CO2+2H2O

符号	代码	渲染结果
Alpha	`\alpha`	α\alphaα
Beta	`\beta`	β\betaβ
Gamma	`\Gamma`	Γ\GammaΓ
Pi	`\pi`	π\piπ
Infinity	`\infty`	∞\infty∞
Right Arrow	`\rightarrow`	→\rightarrow→
Partial	`\partial`	∂\partial∂

Markdown 扩展功能

Fri, 01 May 2026 00:00:00 GMT

GitHub 仓库卡片#

您可以添加链接到 GitHub 仓库的动态卡片，在页面加载时，仓库信息会从 GitHub API 获取。

CuteLeaf

Firefly

🍀Firefly, fresh and aesthetic Astro blog theme template.

—

MIT

Astro

使用代码 ::github{repo="CuteLeaf/Firefly"} 创建 GitHub 仓库卡片。

1
::github{repo="CuteLeaf/Firefly"}

提醒框(Admonitions)配置#

Firefly 采用了 rehype-callouts 插件，支持了四种风格的提醒框主题：GitHub、Obsidian、VitePress 和 Docusaurus。您可以在 src/config/siteConfig.ts 中进行配置：

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  // ...
3
  rehypeCallouts: {
4
    // 选项: "github" | "obsidian" | "vitepress" | "docusaurus"
5
    theme: "github",
6
  },
7
  // ...
8
};

注意：更改配置后需要重启开发服务器才能生效。

以下是各个主题支持的类型列表，每个主题风格和语法不同，可根据喜好选择。

1. GitHub 主题风格#

这是 GitHub 官方支持的 5 种基本类型。

GitHub

基本语法

1
> [!NOTE] NOTE
2
> 突出显示用户应该考虑的信息。
3

4
> [!TIP] TIP
5
> 可选信息，帮助用户更成功。
6

7
> [!IMPORTANT] IMPORTANT
8
> 用户成功所必需的关键信息。
9

10
> [!WARNING] WARNING
11
> 关键内容，需要立即注意。
12

13
> [!CAUTION] CAUTION
14
> 行动的负面潜在后果。
15

16
> [!NOTE] 自定义标题
17
> 这是一个带有自定义标题的示例。

展开收起

2. Obsidian 主题风格#

Obsidian 风格支持非常丰富的类型和别名。

点击展开 Obsidian 语法列表

1
> [!NOTE] NOTE
2
> 通用的笔记块。
3

4
> [!ABSTRACT] ABSTRACT
5
> 文章的摘要。
6

7
> [!SUMMARY] SUMMARY
8
> 文章的总结（同 Abstract）。
9

10
> [!TLDR] TLDR
11
> 太长不看（同 Abstract）。
12

13
> [!INFO] INFO
14
> 提供额外信息。
15

16
> [!TODO] TODO
17
> 需要完成的事项。
18

19
> [!TIP] TIP
20
> 实用技巧或提示。
21

22
> [!HINT] HINT
23
> 暗示（同 Tip）。
24

25
> [!IMPORTANT] IMPORTANT
26
> 重要信息（Obsidian 风格通常使用类似的图标）。
27

28
> [!SUCCESS] SUCCESS
29
> 操作成功。
30

31
> [!CHECK] CHECK
32
> 检查通过（同 Success）。
33

34
> [!DONE] DONE
35
> 已完成（同 Success）。
36

37
> [!QUESTION] QUESTION
38
> 提出问题。
39

40
> [!HELP] HELP
41
> 寻求帮助（同 Question）。
42

43
> [!FAQ] FAQ
44
> 常见问题（同 Question）。
45

46
> [!WARNING] WARNING
47
> 警告信息。
48

49
> [!CAUTION] CAUTION
50
> 注意事项（同 Warning）。
51

52
> [!ATTENTION] ATTENTION
53
> 引起注意（同 Warning）。
54

55
> [!FAILURE] FAILURE
56
> 操作失败。
57

58
> [!FAIL] FAIL
59
> 失败（同 Failure）。
60

61
> [!MISSING] MISSING
62
> 缺失内容（同 Failure）。
63

64
> [!DANGER] DANGER
65
> 危险操作警告。
66

67
> [!ERROR] ERROR
68
> 错误信息（同 Danger）。
69

70
> [!BUG] BUG
71
> 报告软件缺陷。
72

73
> [!EXAMPLE] EXAMPLE
74
> 展示一个例子。
75

76
> [!QUOTE] QUOTE
77
> 引用一段话。
78

79
> [!CITE] CITE
80
> 引证（同 Quote）。
81

82
> [!NOTE] 自定义标题
83
> 这是一个带有自定义标题的示例。

展开收起

Obsidian

3. VitePress 主题风格#

VitePress 风格提供了一套现代化的、扁平的默认样式。目前仅包含与 GitHub 一致的 5 种 基础类型。

点击展开 VitePress 语法列表

1
> [!NOTE] NOTE
2
> 对应 GitHub 的 Note。
3

4
> [!TIP] TIP
5
> 对应 GitHub 的 Tip。
6

7
> [!IMPORTANT] IMPORTANT
8
> 对应 GitHub 的 Important。
9

10
> [!WARNING] WARNING
11
> 对应 GitHub 的 Warning。
12

13
> [!CAUTION] CAUTION
14
> 对应 GitHub 的 Caution。
15

16
> [!TIP] 自定义标题
17
> VitePress 风格同样支持自定义标题。

展开收起

VitePress

4. Docusaurus 主题风格#

Docusaurus 风格提供了一套现代化的提醒框样式，支持 5 种类型。

点击展开 Docusaurus 语法列表

支持以下类型的提醒框：note tip info warning danger

1
:::note
2
突出显示用户应该考虑的信息，即使在快速浏览时也是如此。
3
:::
4

5
:::tip
6
可选信息，帮助用户更成功。
7
:::
8

9
:::info
10
一般信息。
11
:::
12

13
:::warning
14
由于潜在风险需要用户立即注意的关键内容。
15
:::
16

17
:::danger
18
行动的负面潜在后果。
19
:::
20

21
:::tip[自定义标题]
22
可选信息，帮助用户更成功。
23
:::

展开收起

Docusaurus

剧透#

您可以为文本添加剧透。文本也支持 Markdown 语法。

内容被隐藏了哈哈！

1
内容 :spoiler[被隐藏了 **哈哈**]！

图片画廊网格 (Image Grid)#

您可以使用 [grid] 和 [/grid] 标签将多张图片纵向并排展示。这对于展示照片画廊或对比图非常有用。系统会自动根据包裹在其中的图片数量（最多支持并排展示4张）以响应式网格进行布局。

自动补齐图片高度： 同一排中如果有高度、大小或者比例不一的图片，会像「九宫格画廊相册」一样自动撑满。较短或不协调的图片会自动使用 object-cover 进行完美中心裁剪补充视野。图片边框水平彻底对齐无缝隙，但被裁剪后，只有点击图片通过灯箱才能查看完整图片，所以建议尽量避免使用长宽比例不一致的图片在同一排中。

图注恒定底端对齐： 不论上面的图片长宽如何变化，在同一行的所有图像解释文字（图注）都会对标到一条完美的水平基线上了。

示例图片一

示例图片二

基本语法

1
[grid]
2
![示例图片一](https://src.hecloud.top/firefly-tutorial/firefly1.avif)
3
![示例图片二](https://src.hecloud.top/firefly-tutorial/firefly2.avif)
4
![示例图片二](https://src.hecloud.top/firefly-tutorial/firefly3.avif)
5
[/grid]

Markdown Mermaid 图表

Fri, 01 May 2026 00:00:00 GMT

Markdown 中 Mermaid 图表完整指南#

本文演示如何在 Markdown 文档中使用 Mermaid 创建各种复杂图表，包括流程图、时序图、ER 图、类图、状态图、XY 图、甘特图、思维导图等。

Mermaid 图表由 Merman 实现。Firefly 在 Astro 构建阶段生成亮色和深色两套静态 SVG，无需在浏览器中加载 Mermaid 渲染运行时。可以前往 Merman Playground 实时编辑语法并预览渲染结果。

流程图示例#

流程图非常适合表示流程或算法步骤。

是

否

选项 1

选项 2

选项 3

子过程详情

子步骤 1

子步骤 2

子步骤 3

开始

条件检查

处理步骤 1

处理步骤 2

另一个决策

结果 1

结果 2

结果 3

结束

是

否

选项 1

选项 2

选项 3

子过程详情

子步骤 1

子步骤 2

子步骤 3

开始

条件检查

处理步骤 1

处理步骤 2

另一个决策

结果 1

结果 2

结果 3

结束

时序图示例#

时序图显示对象之间随时间的交互。

数据库服务器网页应用用户数据库服务器网页应用用户alt[认证成功][认证失败]提交登录请求发送认证请求查询用户凭据返回用户数据返回认证结果显示欢迎页面请求用户数据获取用户偏好返回偏好设置返回用户数据加载个性化界面显示错误消息提示重新输入

ER 图示例#

ER 图（实体关系图）非常适合表示数据库结构。

writes

posts

has

belongs to

USER

int

string

username

string

datetime

created_at

ARTICLE

int

string

title

text

content

datetime

published

int

author_id

COMMENT

int

text

content

datetime

created_at

int

user_id

int

article_id

类图示例#

类图显示系统的静态结构，包括类、属性、方法及其关系。

写作

发表

拥有

属于

User

+String username

+String password

+String email

+Boolean active

+login()

+logout()

+updateProfile()

Article

+String title

+String content

+Date publishDate

+Boolean published

+publish()

+edit()

+delete()

Comment

+String content

+Date commentDate

+addComment()

+deleteComment()

状态图示例#

状态图显示对象在其生命周期中经历的状态序列。

提交

拒绝

批准

发布

归档

撤回

草稿

审核中

已批准

已归档

已发布

临时隐藏

恢复

活跃

隐藏

提交

拒绝

批准

发布

归档

撤回

草稿

审核中

已批准

已归档

已发布

临时隐藏

恢复

活跃

隐藏

XY 图示例#

XY 图表非常适合展示趋势和对比数据。

月度访问量趋势1月2月3月4月5月6月5000450040003500300025002000150010005000访问量

饼图示例#

饼图适合直观展示各部分在整体中的占比。

45%30%15%10%内容类型占比技术文章 [45]项目记录 [30]生活随笔 [15]其他 [10]

甘特图示例#

甘特图可以按时间轴展示项目阶段、任务依赖和当前进度。

07/0107/0307/0507/0707/0907/1107/1307/1507/17需求整理视觉设计功能实现内容迁移构建检查正式上线准备开发发布博客版本发布计划

思维导图示例#

思维导图适合梳理主题层级和知识结构。

Firefly

内容

技术文章

生活记录

体验

搜索

深色模式

图表

工程

Astro

Svelte

Merman

Firefly

内容

技术文章

生活记录

体验

搜索

深色模式

图表

工程

Astro

Svelte

Merman

时间线示例#

时间线用于按年份或阶段呈现项目的重要事件。

2024建立博客完成基础主题2025加入搜索与图库完善内容系统2026升级 Astro 7使用 Merman 渲染图表Firefly 演进时间线

用户旅程图示例#

用户旅程图能够描述用户在不同阶段的行为和体验评分。

读者

发现内容

发现内容读者

打开首页

打开首页读者

搜索主题

阅读文章

阅读文章读者

浏览正文

浏览正文读者

查看图表

继续探索

继续探索读者

查看相关文章

查看相关文章读者

分享文章

分享文章读者浏览文章的旅程

读者

发现内容

发现内容读者

打开首页

打开首页读者

搜索主题

阅读文章

阅读文章读者

浏览正文

浏览正文读者

查看图表

继续探索

继续探索读者

查看相关文章

查看相关文章读者

分享文章

分享文章读者浏览文章的旅程

Git 图示例#

Git 图可以清晰展示分支、提交和合并历史。

mainfeatureinitadd-diagramspolish-themesmerge-featurerelease

看板示例#

看板适合展示任务在不同工作阶段之间的分布。

待办

进行中

已完成

整理需求

准备示例

接入 Merman

服务端渲染

亮暗主题

待办

进行中

已完成

整理需求

准备示例

接入 Merman

服务端渲染

亮暗主题

Sankey 图示例#

Sankey 图通过连线宽度展示流量在不同节点之间的流向。

Home 1650Post list 1200Search 450Post detail 1220Related posts 260External shares 180

总结#

Mermaid 是在 Markdown 文档中创建各种类型图表的强大工具。本文演示了流程图、时序图、ER 图、类图、状态图、XY 图、饼图、甘特图、思维导图、时间线、用户旅程图、Git 图、看板和 Sankey 图。这些图表可以帮助您更清晰地表达复杂的概念、流程和数据结构。

要使用 Mermaid，只需在代码块中指定 mermaid 语言，并使用简洁的文本语法描述图表。图表会在构建时自动渲染为 SVG，无需客户端 JavaScript 加载。

可以前往 Merman Playground 尝试更多语法，再将图表代码粘贴到文章中。

Markdown PlantUML 图表

Fri, 01 May 2026 00:00:00 GMT

Markdown 中 PlantUML 图表指南#

PlantUML 是一种使用纯文本描述图表的工具。你只需要写一段结构化语法，就可以生成时序图、类图、用例图、活动图等常见工程图。

它特别适合写在技术博客和项目文档里：

图表和正文一起版本管理，便于协作与审阅
修改图只需要改文本，适合频繁迭代
能和 Markdown 无缝结合，保持文档统一

在 Firefly 中，plantuml 代码块会在构建阶段编码并生成服务器 SVG 地址，页面端再根据亮暗主题自动切换图源，并支持缩放、拖拽和全屏交互。

如果你想快速上手，可以记住这个最小模板：

活动图示例#

状态图示例#

用例图示例#

组件图示例#

部署图示例#

ER 图示例#

时序图示例（登录与刷新令牌）#

C4 风格容器图示例#

Markdown 教程

Fri, 01 May 2026 00:00:00 GMT

这是一个展示如何编写 Markdown 文件的示例。本文档汇总了核心语法与常见扩展（GFM）。

块级元素
- 段落与换行
- 标题
- 引用
- 列表
- 代码块
- 分割线
- 表格
内联元素
- 链接
- 强调
- 行内代码
- 图片
- 删除线
杂项
- 自动链接
- 反斜杠转义
内联 HTML

块级元素#

段落与换行#

段落#

HTML 标签：<p>

使用一个或多个空行分隔段落。（仅包含空格或制表符的行也视为空行。）

代码：

1
This will be
2
inline.
3

4
This is second paragraph.

预览：

This will be inline.

This is second paragraph.

换行#

HTML 标签：<br />

在行末添加两个或更多空格来产生换行。

代码：

1
This will be not
2
inline.

预览：

This will be not
inline.

标题#

Markdown 支持两种标题样式：Setext 与 atx。

Setext#

HTML 标签：<h1>，<h2>

使用等号 (=) 表示 <h1>、使用短横线 (-) 表示 <h2>，数量不限，作为“下划线”。

代码：

1
This is an H1
2
=============
3
This is an H2
4
-------------

预览：

This is an H1#

This is an H2#

atx#

HTML 标签：<h1>，<h2>，<h3>，<h4>，<h5>，<h6>

在行首使用 1-6 个井号 (#)，对应 <h1> 至 <h6>。

代码：

1
# This is an H1
2
## This is an H2
3
###### This is an H6

预览：

This is an H1#

This is an H2#

This is an H6#

可选：你可以在行尾“闭合” atx 标题。末尾的井号数量不必与开头一致。

代码：

1
# This is an H1 #
2
## This is an H2 ##
3
### This is an H3 ######

预览：

This is an H1#

This is an H2#

This is an H3#

引用#

HTML 标签：<blockquote>

Markdown 使用邮件风格的 > 作为引用符号。若手动换行并在每行前加 >，显示效果最佳。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4
>
5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
> id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

Markdown 允许“偷懒”：在一个硬换行段落中，只在第一行前加 > 即可。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4

5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

引用可以嵌套（引用中的引用），通过增加 > 层级实现。

代码：

1
> This is the first level of quoting.
2
>
3
> > This is nested blockquote.
4
>
5
> Back to the first level.

预览：

This is the first level of quoting.
This is nested blockquote.
Back to the first level.

引用内可包含其他 Markdown 元素，包括标题、列表与代码块。

代码：

1
> ## This is a header.
2
>
3
> 1.   This is the first list item.
4
> 2.   This is the second list item.
5
>
6
> Here's some example code:
7
>
8
>     return shell_exec("echo $input | $markdown_script");

预览：

This is a header.#

This is the first list item.

This is the second list item.

Here’s some example code:
1
return shell_exec("echo $input | $markdown_script");

列表#

Markdown 支持有序（数字）与无序（圆点）列表。

无序列表#

HTML 标签：<ul>

无序列表可使用 星号 (*)、加号 (+) 或 短横线 (-)。

代码：

1
*   Red
2
*   Green
3
*   Blue

预览：

Red
Green
Blue

等价于：

代码：

1
+   Red
2
+   Green
3
+   Blue

或者：

代码：

1
-   Red
2
-   Green
3
-   Blue

有序列表#

HTML 标签：<ol>

有序列表使用数字加英文句点：

代码：

1
1.  Bird
2
2.  McHale
3
3.  Parish

预览：

Bird
McHale
Parish

注意：像下面这样可能会“意外触发”有序列表：

代码：

1
1986. What a great season.

预览：

What a great season.

你可以用反斜杠转义 (\) 句点：

代码：

1
1986\. What a great season.

预览：

1986. What a great season.

列表中的缩进内容#

列表项里的引用#

在列表项内放置引用，需要将 > 符号整体缩进：

代码：

1
*   A list item with a blockquote:
2

3
    > This is a blockquote
4
    > inside a list item.

预览：

A list item with a blockquote:

This is a blockquote inside a list item.

列表项里的代码块#

在列表项内放置代码块，需要缩进两层——8 个空格或两个 Tab：

代码：

1
*   A list item with a code block:
2

3
        <code goes here>

预览：

A list item with a code block:
```
1
<code goes here>
```

嵌套列表#

代码：

1
* A
2
  * A1
3
  * A2
4
* B
5
* C

预览：

A
- A1
- A2
B
C

代码块#

HTML 标签：<pre>

将代码块中的每行缩进至少4 个空格或1 个制表符。

代码：

1
This is a normal paragraph:
2

3
    This is a code block.

预览：

This is a normal paragraph:

1
This is a code block.

代码块会一直持续，直到遇到未缩进的行（或文末）。

在代码块内，与号 (&) 和尖括号 (< >) 会自动转为 HTML 实体。

代码：

1
    <div class="footer">
2
        &copy; 2004 Foo Corporation
3
    </div>

预览：

1
<div class="footer">
2
    &copy; 2004 Foo Corporation
3
</div>

下文的“围栏代码块”和“语法高亮”属于扩展语法，你也可以用它们来书写代码块。

围栏代码块#

使用成对的反引号围起来（如下所示），就不需要四空格缩进了。

代码：

1
Here's an example:
2

3
```
4
function test() {
5
  console.log("notice the blank line before this function?");
6
}
7
```

预览：

Here’s an example:

1
function test() {
2
  console.log("notice the blank line before this function?");
3
}

语法高亮#

在围栏代码块后添加可选的语言标识，即可启用语法高亮（参见支持语言列表）。

代码：

1
```ruby
2
require 'redcarpet'
3
markdown = Redcarpet.new("Hello World!")
4
puts markdown.to_html
5
```

预览：

1
require 'redcarpet'
2
markdown = Redcarpet.new("Hello World!")
3
puts markdown.to_html

分割线（水平线）#

HTML 标签：<hr /> 一行中放置三个或以上的短横线 (-)、星号 (*) 或下划线 (_)。符号之间允许有空格。

代码：

1
* * *
2
***
3
*****
4
- - -
5
---------------------------------------
6
___

预览：

表格#

HTML 标签：<table>

这是扩展语法。

用竖线 (|) 分隔列，用短横线 (-) 分隔表头，使用冒号 (:) 指定对齐方式。

两侧的竖线 (|) 与对齐可选。用于表头分隔时，每列至少需要 3 个短横线。

代码：

1
| Left | Center | Right |
2
|:-----|:------:|------:|
3
|aaa   |bbb     |ccc    |
4
|ddd   |eee     |fff    |
5

6
 A | B
7
---|---
8
123|456
9

10

11
A |B
12
--|--
13
12|45

预览：

Left	Center	Right
aaa	bbb	ccc
ddd	eee	fff

A	B
123	456

A	B
12	45

内联元素#

链接#

HTML 标签：<a>

Markdown 支持两种链接样式：行内链接与引用式链接。

行内链接#

行内链接格式：[文本](URL "标题")

标题可选。

代码：

1
This is [an example](http://example.com/ "Title") inline link.
2

3
[This link](http://example.net/) has no title attribute.

预览：

This is an example inline link.

This link has no title attribute.

如果引用同一站点的本地资源，可以使用相对路径：

代码：

1
See my [About](/about/) page for details.

预览：

See my About page for details.

引用式链接#

可以预定义链接引用。定义格式：[id]: URL "标题"

标题同样可选。引用时使用：[文本][id]

代码：

1
[id]: http://example.com/  "Optional Title Here"
2
This is [an example][id] reference-style link.

预览：

This is an example reference-style link.

说明：

方括号中包含链接标识（不区分大小写，可在左侧缩进最多三格空格）；
随后是冒号；
再跟一个或多个空格（或 tab）；
然后是链接 URL；
URL 可选地用尖括号包裹；
可选地跟随标题属性，用引号或圆括号包裹。

以下三种定义等价：

代码：

1
[foo]: http://example.com/  "Optional Title Here"
2
[foo]: http://example.com/  'Optional Title Here'
3
[foo]: http://example.com/  (Optional Title Here)
4
[foo]: <http://example.com/>  "Optional Title Here"

如果使用空的方括号，则链接文本本身会作为名称。

代码：

1
[Google]: http://google.com/
2
[Google][]

预览：

Google

强调#

HTML 标签：<em>，<strong>

Markdown 使用 星号 (*) 或 下划线 (_) 表示强调。一个分隔符对应 <em>；两个分隔符对应 <strong>。

代码：

1
*single asterisks*
2

3
_single underscores_
4

5
**double asterisks**
6

7
__double underscores__

预览：

single asterisks

single underscores

double asterisks

double underscores

但如果两侧有空格，则会被视作普通字符而非强调语法。

你可以使用反斜杠进行转义：

代码：

1
\*this text is surrounded by literal asterisks\*

预览：

*this text is surrounded by literal asterisks*

行内代码#

HTML 标签：<code>

用反引号 (`) 包裹。

代码：

1
Use the `printf()` function.

预览：

Use the printf() function.

若行内代码中需要包含反引号字符，可使用多重反引号作为定界符：

代码：

1
``There is a literal backtick (`) here.``

预览：

There is a literal backtick (`) here.

行内代码两侧的定界符允许包含空格（开头一个、结尾一个），方便在代码起始或结尾放置反引号字符：

代码：

1
A single backtick in a code span: `` ` ``
2

3
A backtick-delimited string in a code span: `` `foo` ``

预览：

A single backtick in a code span: `

A backtick-delimited string in a code span: `foo`

图片#

HTML 标签：<img />

Markdown 的图片语法与链接类似，支持行内与引用两种方式。

行内图片#

行内图片语法：![替代文本](URL "标题")

标题可选。

代码：

1
![Alt text](/path/to/img.jpg)
2

3
![Alt text](/path/to/img.jpg "Optional title")

预览：

Alt text

说明：

一个感叹号 !；
后接方括号，放置图片的替代文本；
再接圆括号，内含图片 URL/路径，及可选的标题（引号包裹）。

引用式图片#

引用式图片语法：![替代文本][id]

代码：

1
[img id]: https://s2.loli.net/2024/08/20/5fszgXeOxmL3Wdv.webp  "Optional title attribute"
2
![Alt text][img id]

预览：

Alt text

删除线#

HTML 标签：<del>

这是扩展语法。

GFM 增加了删除线语法。

代码：

1
~~Mistaken text.~~

预览：

Mistaken text.

杂项#

自动链接#

Markdown 支持一种便捷写法来创建“自动链接”（URL 与邮箱地址）：只需用尖括号将其包住即可。

代码：

1
<http://example.com/>
2

3
<address@example.com>

预览：

http://example.com/

address@example.com

GFM 会自动识别标准 URL 并转换为链接。

代码：

1
https://github.com/emn178/markdown

预览：

https://github.com/emn178/markdown

反斜杠转义#

Markdown 允许使用反斜杠来转义那些本用于 Markdown 语法的特殊字符，使其按字面显示。

代码：

1
\*literal asterisks\*

预览：

*literal asterisks*

以下字符可通过反斜杠转义以按字面量输出：

Code:

1
\   backslash
2
`   backtick
3
*   asterisk
4
_   underscore
5
{}  curly braces
6
[]  square brackets
7
()  parentheses
8
#   hash mark
9
+   plus sign
10
-   minus sign (hyphen)
11
.   dot
12
!   exclamation mark

内联 HTML#

对于 Markdown 语法未覆盖的标记，直接使用原生 HTML 即可。无需特别声明从 Markdown 切换到 HTML，直接写标签就行。

代码：

1
This is a regular paragraph.
2

3
<table>
4
    <tr>
5
        <td>Foo</td>
6
    </tr>
7
</table>
8

9
This is another regular paragraph.

预览：

This is a regular paragraph.

Foo

This is another regular paragraph.

请注意：在块级 HTML 标签内不会处理 Markdown 语法。

与块级标签不同，在行内级标签内会处理 Markdown 语法。

代码：

1
<span>**Work**</span>
2

3
<div>
4
    **No Work**
5
</div>

预览：

Work

**No Work**

***

MDX 格式文章示例

Fri, 01 May 2026 00:00:00 GMT

Tip

Firefly 支持 MDX 和 Markdown 两种类型的文章，你可以在文章中混合使用两种格式，如果没有特别复杂内容和需求，推荐使用 Markdown 格式就够了。

Markdown 和 MDX 的区别#

Markdown (MD) 是一种轻量级标记语言，允许用户使用纯文本格式编写文档，然后将其转换为格式化的HTML。它因其简洁易用的语法而广受欢迎，特别适合编写文档和博客文章。
MDX 是一种扩展了 Markdown 语法的格式，允许在 Markdown 文档中无缝地插入 JSX 代码。通过 MDX，用户可以在文档中嵌入 React 组件，从而实现更丰富的交互性和动态性。

特性	Markdown	MDX
基础语法	支持 (CommonMark)	支持 (CommonMark)
HTML 标签	支持	支持 (作为 JSX)
组件导入	不支持	支持 (import)
动态数据	不支持	支持 (JS 表达式)
样式定制	有限 (class/style)	灵活 (className/CSS-in-JS)

Firefly 内置的专属 MDX UI 组件#

这里列出 Firefly 内置的 MDX UI 组件，方便在 MDX 文章中直接使用。

Tab分组：`TabGroup`#

用于创建可切换的标签页，方便在文章中展示不同语言或不同版本的代码等等。

1
<TabGroup labels={["test.js", "test.py"]} client:load>
2
  ```js
3
  console.log(1)
4
  ```
5

6
  ```py
7
  print("hello world")
8
  ```
9
</TabGroup>

test.jstest.py

1
console.log(1)

1
print("hello world")

时间线：`Timeline` / `TimelineItem`#

属性	必填	说明
`date`	否	时间标签，如 “2024-03-10”
`title`	否	条目标题
`type`	否	节点颜色，default 为主题色，其余对应提示框色板（tip / note / important / warning / caution）
`icon`	否	内置图标名，显示在圆点内：star / rocket / git / flag / book / heart / zap / bug / tag / calendar / code / edit
正文	否	`<TimelineItem>` 标签内的内容，支持 Markdown

1
<Timeline>
2
  <TimelineItem date="2026-08-16" title="新版本发布" icon="rocket">
3
    发布了全新版本，带来以下更新：
4

5
    - 新增时间线组件
6
    - 改进暗色主题
7

8
    正文里支持 **Markdown** 内容。
9
  </TimelineItem>
10
  <TimelineItem date="2025-11-02" title="站点上线" type="tip" icon="flag">
11
    欢迎来到我的博客。
12
  </TimelineItem>
13
  <TimelineItem date="2025-06-15" title="项目立项" type="note">
14
    开始规划 Firefly 主题。
15
  </TimelineItem>
16
</Timeline>

展开收起

2026-08-16
新版本发布
发布了全新版本，带来以下更新：
- 新增时间线组件
- 改进暗色主题
正文里支持 Markdown 内容。
2025-11-02
站点上线
欢迎来到我的博客。
2025-06-15
项目立项
开始规划 Firefly 主题。

步骤条：`Steps` / `StepItem`#

编号步骤条，适合教程、部署流程。编号自动生成，无需手动传序号。

属性	必填	说明
`title`	否	步骤标题
`type`	否	编号圆颜色，default 为主题色，其余对应提示框色板（tip / note / important / warning / caution）
`icon`	否	内置图标名，有图标时显示图标而非数字（star / rocket / git / flag / book / heart / zap / bug / tag / calendar / code / edit）
正文	否	`<StepItem>` 标签内的内容，支持 Markdown

1
<Steps>
2
  <StepItem title="安装依赖">
3
    运行 `pnpm install`。
4
  </StepItem>
5
  <StepItem title="启动开发服务器" type="tip" icon="rocket">
6
    运行 `pnpm dev`，打开 `localhost:4321`。
7
  </StepItem>
8
  <StepItem title="编写文章">
9
    在 `src/content/posts/` 新建 `.mdx` 文章。
10
  </StepItem>
11
</Steps>

安装依赖
运行 pnpm install。
启动开发服务器
运行 pnpm dev，打开 localhost:4321。
编写文章
在 src/content/posts/ 新建 .mdx 文章。

徽章：`Badge`#

内联彩色小徽章，可嵌在段落或标题里。

属性	必填	说明
`type`	否	default 为主题色，其余对应提示框色板（tip / note / important / warning / caution）

1
<Badge type="tip">提示</Badge> <Badge type="warning">注意</Badge>

新功能提示笔记重要注意危险

更多信息，请查看 MDX 文档

在文章中嵌入视频

Fri, 01 May 2026 00:00:00 GMT

只需从 YouTube 或其他平台复制嵌入代码，然后将其粘贴到 markdown 文件中。

1
---
2
title: 在文章中嵌入视频
3
published: 2023-10-19
4
// ...
5
---
6

7
<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

hecloud.top

茶叶品类大全

Linux文件系统目录扫盲

公告与固定页面文案维护

📖 本文管什么#

一、侧边栏公告#

改公告文字 → src/config/announcementConfig.ts#

⚠️ 公告是纯文本#

显示 / 隐藏公告 → 不在公告配置里！#

二、固定页面（spec）文案#

改完的发布#

⚠️ 内容同步提醒#

三、站内入口文案（顶部菜单 / 页脚）#

✅ 速记#

碎碎念（动态）维护指南

📖 什么是碎碎念#

一、文件放在哪、怎么命名#

二、frontmatter（只有 3 个字段）#

三、发布：脚手架一行命令（最快）#

想加地点/置顶时#

四、图片怎么放#

五、修改与删除#

✅ 碎碎念速记#

相册与照片墙维护指南

📖 相册的组成（记牢这个模型）#

一、相册对象的字段（配置在 src/config/galleryConfig.ts）#

封面三选一规则#

⚠️ 加密相册的安全提醒#

二、新增一个相册（两步）#

三、照片墙 / 相册页怎么显示（两个机制）#

四、日常维护操作速查#

⚠️ 三个坑#

✅ 速记#

友链·导航书签·站点入口维护

📖 本文管什么#

一、友链（src/config/friendsConfig.ts）#

加 / 改 / 删友链#

⚠️ 头像一定要本地化（重要）#

本站自己在别人站里的信息#

二、导航书签页（src/config/booknavConfig.ts）#

三、顶部导航菜单（src/config/navBarConfig.ts）#

四、简介与社交链接（src/config/profileConfig.ts）#

五、页脚与音乐歌单#

✅ 速记#

内容发布全流程（写文章 + 推送上线）

📖 一句话理解本站内容#

一、内容文件都放在哪#

二、新建一篇文章#

方式 A：脚手架命令（推荐）#

方式 B：手动新建#

常用可选字段#

三、系列字段（series / seriesOrder）#

四、发布：git 三步#

本地预览（发布前检查）#

五、修改与删除文章#

六、Obsidian 写作小贴士（个人习惯）#

✅ 发布清单（自检）#

pnpm 常用指令速查（本地开发与构建）

📖 前置须知#

一、指令速查表#

需要联网才能完成的#

二、内容脚手架#

建文章 pnpm new-post <文件名>#

发碎碎念 pnpm new-dynamic 内容#

三、构建流水线（build 到底做了什么）#

四、本地发布自检流程（每次发布前）#

⚠️ 常见坑#

✅ 速记#

R2 图床运营规范

📖 为什么图片要放图床#

一、上传工具（PicList）#

二、目录与命名规范#

三、缓存规则（配一次，但要知道）#

四、⚠️ 最容易踩的坑：换图必须换文件名#

五、传完图后回正文#

✅ 速记#

00概述

卷一#

卷二#

01Java背景和基本结构

改公告文字 → `src/config/announcementConfig.ts`#

一、相册对象的字段（配置在 `src/config/galleryConfig.ts`）#

一、友链（`src/config/friendsConfig.ts`）#

二、导航书签页（`src/config/booknavConfig.ts`）#

三、顶部导航菜单（`src/config/navBarConfig.ts`）#

四、简介与社交链接（`src/config/profileConfig.ts`）#

建文章 `pnpm new-post <文件名>`#

发碎碎念 `pnpm new-dynamic 内容`#