<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="/scripts/pretty-feed-v3.xsl" type="text/xsl"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:h="http://www.w3.org/TR/html4/"><channel><title>CCM</title><description>文字沉淀生命, 回忆勾连古今</description><link>https://8cat.life</link><item><title>建站: Excalidraw 组件集成</title><link>https://8cat.life/blog/wasd</link><guid isPermaLink="true">https://8cat.life/blog/wasd</guid><description>在 Astro MDX 中无缝集成 Excalidraw 绘图，专为 Obsidian Excalidraw 插件设计</description><pubDate>Sat, 27 Dec 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;import { Excalidraw } from &apos;@/components/mdx/Excalidraw&apos;
import IconLink from &apos;@/components/IconLink.astro&apos;&lt;/p&gt;
&lt;p&gt;本文介绍了如何在博客中集成自定义的 &lt;code&gt;Excalidraw&lt;/code&gt; 组件，实现在 MDX 文档中直接渲染交互式的白板绘图。本组件&lt;strong&gt;专注于支持 Obsidian Excalidraw 插件生成的 Markdown (.md) 文件&lt;/strong&gt;，实现了从双向链笔记到博客展示的无缝衔接。&lt;/p&gt;
&lt;h2&gt;简介&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;Excalidraw&lt;/code&gt; 组件是一个基于 React 的轻量级渲染器，专为在 MDX 环境中展示白板绘图而设计。为了获得最佳的编辑体验和资源占用，本组件抛弃了传统的 &lt;code&gt;.excalidraw&lt;/code&gt; JSON 格式，直接解析 Obsidian 场景数据中的 &lt;code&gt;compressed-json&lt;/code&gt; 块。&lt;/p&gt;
&lt;h2&gt;处理流程&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;编辑场景&lt;/strong&gt;: 在 Obsidian 中使用 Excalidraw 插件编辑绘图。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;文件分发&lt;/strong&gt;: 复制该 &lt;code&gt;.md&lt;/code&gt; 文件到项目的 &lt;code&gt;public/excalidraw/&lt;/code&gt; 文件夹下。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;组件引用&lt;/strong&gt;: 在 MDX 中通过 &lt;code&gt;&amp;#x3C;Excalidraw snapshotUrl=&quot;/excalidraw/your-file.md&quot; /&gt;&lt;/code&gt; 进行引用。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;核心功能&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Obsidian 原生支持&lt;/strong&gt;: 完美解析 Obsidian Excalidraw 插件生成的 &lt;code&gt;.md&lt;/code&gt; 文件，包含文本、几何图形及公式映射。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;LaTeX 公式增强&lt;/strong&gt;: 自动识别并使用 KaTeX 渲染嵌入的 LaTeX 公式，确保数学排版精准美观。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Magic Flow 信号流动画&lt;/strong&gt;:
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;蓝色虚线&lt;/strong&gt;: 自动触发“能量球轨迹流动”效果，常用于展示系统架构中的数据流向。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;幻灯片演示 (Frames)&lt;/strong&gt;: 自动识别绘图中的 &quot;Frame&quot; (画框)，并支持通过快捷键或导航栏进行 PPT 式的演示切换。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;沉浸式交互&lt;/strong&gt;:
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;平移/缩放&lt;/strong&gt;: 支持平滑的拖拽和平移，控制台实时显示当前的 &lt;strong&gt;缩放比例&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;键盘驱动&lt;/strong&gt;: 支持使用键盘 &lt;strong&gt;左/右方向键&lt;/strong&gt; 快速切换幻灯片页。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;极致性能&lt;/strong&gt;: 直接操作 SVG DOM 节点，无 Canvas 负担，支持 SEO 抓取。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;示例演示&lt;/h2&gt;
&lt;h3&gt;1. 多画框演示 (Obsidian .md)&lt;/h3&gt;
&lt;p&gt;在 Obsidian 中通过 Frame 组织内容，组件会自动生成导航控件。你可以尝试使用 &lt;strong&gt;键盘左右键&lt;/strong&gt; 切换。&lt;/p&gt;
&lt;p&gt;&amp;#x3C;Excalidraw
snapshotUrl=&quot;/excalidraw/test-2.md&quot;
client:only=&quot;react&quot;&lt;/p&gt;
&lt;blockquote&gt;
&lt;/blockquote&gt;
&lt;h2&gt;组件参数 (Props)&lt;/h2&gt;
&lt;p&gt;| 属性名 | 类型 | 默认值 | 说明 |
| :--- | :--- | :--- | :--- |
| &lt;code&gt;snapshotUrl&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | &lt;strong&gt;必填&lt;/strong&gt; | 仅支持 Obsidian 生成的 &lt;code&gt;.md&lt;/code&gt; 文件路径 |
| &lt;code&gt;height&lt;/code&gt; | &lt;code&gt;number \| string&lt;/code&gt; | &lt;code&gt;500&lt;/code&gt; | 容器高度 |
| &lt;code&gt;exc-title&lt;/code&gt; | &lt;code&gt;ReactNode&lt;/code&gt; | &lt;code&gt;undefined&lt;/code&gt; | 标题栏内容 (推荐使用 &lt;code&gt;slot=&quot;exc-title&quot;&lt;/code&gt;) |
| &lt;code&gt;fontFamily&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | &lt;code&gt;system-ui...&lt;/code&gt; | 文本渲染优先使用的字体栈 |&lt;/p&gt;
&lt;h2&gt;技术实现原理&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;格式锁定&lt;/strong&gt;: 组件只接受包含 &lt;code&gt;compressed-json&lt;/code&gt; 代码块的文件。解析器会提取该块并利用 &lt;code&gt;LZString&lt;/code&gt; 还原场景数据。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;LaTeX 集成&lt;/strong&gt;: 组件会扫描 Markdown 头部元数据及 &lt;code&gt;Embedded Files&lt;/code&gt; 区域，利用 KaTeX 生成独立的 SVG 图片对象并注入 Excalidraw 场景缓存。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;SVG 动力学引擎&lt;/strong&gt;: 针对 Magic Flow，通过在路径末尾动态插入 &lt;code&gt;&amp;#x3C;animateMotion&gt;&lt;/code&gt; 物理对象（红色小球），实现不丢帧的匀速流动感。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;视口感知&lt;/strong&gt;: 通过 &lt;code&gt;getBoundingClientRect&lt;/code&gt; 与 SVG &lt;code&gt;viewBox&lt;/code&gt; 的比例关系，精确计算并反馈当前的缩放百分比。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;全局监听&lt;/strong&gt;: 组件激活时会拦截方向键事件，优先响应幻灯片导航，提升演示体验。&lt;/li&gt;
&lt;/ol&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>mirrord：云原生开发的本地调试利器</title><link>https://8cat.life/blog/xgrg</link><guid isPermaLink="true">https://8cat.life/blog/xgrg</guid><description>探索 mirrord 如何实现在本地调试 k8s 集群中的微服务</description><pubDate>Sat, 20 Dec 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;在云原生开发中，调试一直是个痛点。传统的 「 Edit -&gt; Docker build -&gt; Push -&gt; Deploy -&gt; Check logs 」循环不仅效率低下，而且很难进行断点调试。&lt;/p&gt;
&lt;p&gt;它主打的 &lt;strong&gt;&quot;Connect your local process to your cluster&quot;&lt;/strong&gt; 理念，让开发者可以在本地 IDE 中直接运行代码，却仿佛置身于远端的 Kubernetes 集群中。&lt;/p&gt;
&lt;h2&gt;什么是 mirrord？&lt;/h2&gt;
&lt;p&gt;简单来说，mirrord 允许你本地的进程「寄生」在 Kubernetes 集群中的某个 Pod 上。你的本地进程可以：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;窃取或复制（Mirror）&lt;/strong&gt; 发往远端 Pod 的网络流量。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;读取&lt;/strong&gt; 远端 Pod 的文件系统。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;继承&lt;/strong&gt; 远端 Pod 的环境变量。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;发出&lt;/strong&gt; 流量，就像是从远端 Pod 发出的一样。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这样就不再需要为了测试一个微小的改动而反复构建镜像。&lt;/p&gt;
&lt;h2&gt;核心原理与架构&lt;/h2&gt;
&lt;p&gt;mirrord 的黑科技核心在于 &lt;strong&gt;系统调用拦截（Syscall Interception）&lt;/strong&gt; 和 &lt;strong&gt;Agent 转发&lt;/strong&gt;。它的架构主要由两部分组成：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;mirrord-layer (Local)&lt;/strong&gt;: 运行在本地，通过 &lt;code&gt;LD_PRELOAD&lt;/code&gt; (Linux) 或 &lt;code&gt;DYLD_INSERT_LIBRARIES&lt;/code&gt; (macOS) 注入到你的应用程序进程中。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;mirrord-agent (Remote)&lt;/strong&gt;: 作为一个短生命周期的 Pod 运行在 Kubernetes 集群中，通常与目标 Pod 处于同一节点或通过网格通信。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;架构图解&lt;/h3&gt;
&lt;p&gt;import Figure from &apos;@/components/Figure.astro&apos;;
import arch from &apos;./attachments/mirrord_arch.png&apos;;&lt;/p&gt;
&lt;h3&gt;核心机制详解&lt;/h3&gt;
&lt;h4&gt;1. LD_PRELOAD (Syscall Interception)&lt;/h4&gt;
&lt;p&gt;&lt;code&gt;LD_PRELOAD&lt;/code&gt; 是一个环境变量，它允许用户在程序运行之前，指定一个或多个共享库（&lt;code&gt;.so&lt;/code&gt; 文件，在 macOS 上是 &lt;code&gt;.dylib&lt;/code&gt;）加载。这些预加载的库中的函数会覆盖掉程序或其依赖库中同名的函数。&lt;/p&gt;
&lt;p&gt;它的工作原理如下：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;加载顺序优先&lt;/strong&gt;：当一个程序启动时，动态链接器（dynamic linker/loader）会负责解析程序及其依赖的所有符号（函数、变量等）。&lt;code&gt;LD_PRELOAD&lt;/code&gt; 指定的库会在所有其他库（包括系统库）之前被加载。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;符号覆盖&lt;/strong&gt;：如果预加载的库中定义了与程序或其其他依赖库中同名的函数，那么在程序调用该函数时，会优先调用预加载库中的版本。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;实现拦截&lt;/strong&gt;：&lt;code&gt;mirrord-layer&lt;/code&gt; 正是利用了这一点。它是一个共享库，其中包含了对 &lt;code&gt;open&lt;/code&gt;, &lt;code&gt;read&lt;/code&gt;, &lt;code&gt;write&lt;/code&gt;, &lt;code&gt;connect&lt;/code&gt;, &lt;code&gt;bind&lt;/code&gt; 等核心系统调用函数的自定义实现。当你的本地应用启动并被 &lt;code&gt;LD_PRELOAD&lt;/code&gt; 注入了 &lt;code&gt;mirrord-layer&lt;/code&gt; 后，所有对这些系统调用的请求都会先经过 &lt;code&gt;mirrord-layer&lt;/code&gt;。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;通过这种机制，&lt;code&gt;mirrord-layer&lt;/code&gt; 能够在应用程序执行实际的系统操作之前，拦截这些调用并根据 mirrord 的配置决定是执行本地操作、转发到 &lt;code&gt;mirrord-agent&lt;/code&gt; 进行远程操作，还是调用原始的系统函数。这使得 &lt;code&gt;mirrord&lt;/code&gt; 能够在不修改应用程序代码的情况下，透明地改变其行为，实现对文件系统、网络和环境变量的控制。&lt;/p&gt;
&lt;h4&gt;2. 流量与 IO 的“偷梁换柱” (The Hook)&lt;/h4&gt;
&lt;p&gt;mirrord 并不是在网络层（如 VPN 或 Proxy）工作的，而是在&lt;strong&gt;进程级&lt;/strong&gt;工作的。当你的代码尝试执行某些操作时，mirrord-layer 会进行拦截：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;文件操作&lt;/strong&gt;: 当应用调用 &lt;code&gt;open(&quot;/etc/config.yaml&quot;)&lt;/code&gt; 时，mirrord-layer 会拦截这个调用。它会检查配置，决定是读取本地文件，还是通过 Agent 读取远端集群里的文件。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;网络操作&lt;/strong&gt;: 当应用尝试 &lt;code&gt;bind&lt;/code&gt; 端口监听流量，或 &lt;code&gt;connect&lt;/code&gt; 其他服务（如 &lt;code&gt;mysql-service.default&lt;/code&gt;）时，拦截器会将请求转发给 Agent。Agent 在集群内部代为执行 DNS 解析和连接，从而让本地进程拥有了集群内的网络身份。&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;3. 流量镜像与窃取 (Mirror vs Steal)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Mirror (默认)&lt;/strong&gt;: Agent 会通过 packet sniffing (如 libpcap) 或网格层面的机制，复制一份目标 Pod 的流量发送回本地。这对于只读调试非常安全，不会影响生产环境的实际请求处理。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Steal&lt;/strong&gt;: Agent 会修改 iptables 或通过其他机制，将发往目标 Pod 的特定端口流量“劫持”，并转发给本地进程。处理完后，本地进程的响应会返回给调用方。这实际上是用本地进程暂时“顶替”了远端 Pod。
- 同时支持基于 http-header 的流量过滤，确保只有特定流量被镜像或窃取。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;竞品对比：mirrord vs Telepresence vs 其他&lt;/h3&gt;
&lt;p&gt;为了更直观地展示 mirrord 的定位，我们将它与市面上主流的云原生开发工具进行对比：&lt;/p&gt;
&lt;p&gt;| 特性 | mirrord | Telepresence | Nocalhost | KtConnect |
| :--- | :--- | :--- | :--- | :--- |
| &lt;strong&gt;核心原理&lt;/strong&gt; | 进程注入 (&lt;code&gt;LD_PRELOAD&lt;/code&gt;) + 临时 Agent | 网络代理 (VPN-like) + Traffic Manager | 替换 Pod 镜像 (DevContainer) | SOCKS5 代理 / 交换 Deployment |
| &lt;strong&gt;侵入性&lt;/strong&gt; | &lt;strong&gt;极低&lt;/strong&gt; (无需修改 Deployment，Agent 随用随销) | 中 (需安装 Traffic Manager，可能修改 Deployment) | 高 (需将 Pod 替换为开发镜像) | 中 (Exchange 模式需修改 Deployment) |
| &lt;strong&gt;启动速度&lt;/strong&gt; | &lt;strong&gt;快&lt;/strong&gt; (秒级) | 较慢 | 慢 (需重新部署 Pod) | 中等 |
| &lt;strong&gt;调试粒度&lt;/strong&gt; | &lt;strong&gt;进程级&lt;/strong&gt; (只影响当前 IDE 运行的进程) | 容器/网络级 | 容器级 | 容器/网络级 |
| &lt;strong&gt;适用场景&lt;/strong&gt; | 快速排查问题、本地运行轻量级进程 | 复杂的全链路联调 | 沉浸式开发 (In-Cluster Coding) | 简单的网络打通与联调 |
| &lt;strong&gt;活跃度&lt;/strong&gt; | 活跃 | 活跃 | 不维护 | 不维护 |&lt;/p&gt;
&lt;h4&gt;使用体验&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;KtConnect配置复杂, 没有操作界面, 在 istio 环境下没有跑通, 而且很久不维护更新了&lt;/li&gt;
&lt;li&gt;Telepresence 的配置相对复杂, 且需要安装 Traffic Manager, 免费版功能有限&lt;/li&gt;
&lt;li&gt;Nocalhost 有操作界面, 但是这种机制天然就比进程级的机制慢, 且需要将 Pod 替换为开发镜像, 侵入性很大, 且需要重新部署 Pod&lt;/li&gt;
&lt;li&gt;mirrord 的配置非常简单, 但是有个限制是免费版只能单人占用 1 个 pod&lt;/li&gt;
&lt;/ol&gt;</content:encoded><h:img src="/_astro/mirrord.CzTmqA0v.png"/><enclosure url="/_astro/mirrord.CzTmqA0v.png"/></item><item><title>建站: Timeline 组件</title><link>https://8cat.life/blog/etqp</link><guid isPermaLink="true">https://8cat.life/blog/etqp</guid><description>展示 Timeline 组件的用法和效果，用于展示时间线事件</description><pubDate>Fri, 14 Nov 2025 19:32:06 GMT</pubDate><content:encoded>&lt;p&gt;import { Timeline, TimelineItem } from &apos;@/custom/components/user&apos;
import IconLink from &apos;@/components/IconLink.astro&apos;
import MdxRepl from &apos;@/custom/components/user/MdxRepl.astro&apos;&lt;/p&gt;
&lt;p&gt;本页面展示了 &lt;code&gt;&amp;#x3C;Timeline&gt;&lt;/code&gt; 和 &lt;code&gt;&amp;#x3C;TimelineItem&gt;&lt;/code&gt; 组件的各种用法和效果。&lt;/p&gt;
&lt;h2&gt;1. 基础用法 (Basic Usage)&lt;/h2&gt;
&lt;h3&gt;1.1. 简单时间线&lt;/h3&gt;
&lt;h3&gt;1.2. 多行内容&lt;/h3&gt;
&lt;h2&gt;2. 里程碑节点 (Milestone Nodes)&lt;/h2&gt;
&lt;p&gt;里程碑节点使用 &lt;code&gt;milestone&lt;/code&gt; 属性，会有特殊的视觉样式（实心圆点和背景高亮）。&lt;/p&gt;
&lt;h3&gt;2.1. 单个里程碑&lt;/h3&gt;
&lt;h3&gt;2.2. 多个里程碑&lt;/h3&gt;
&lt;h2&gt;3. 在内容中使用其他组件 (Using Other Components)&lt;/h2&gt;
&lt;p&gt;TimelineItem 的内容支持嵌套任意组件，包括 Markdown 语法、HTML 标签和其他 Astro 组件。&lt;/p&gt;
&lt;h3&gt;3.1. 使用 IconLink 组件&lt;/h3&gt;
&lt;h3&gt;3.2. 使用 Markdown 格式&lt;/h3&gt;
&lt;h2&gt;4. 实际应用场景 (Real-world Examples)&lt;/h2&gt;
&lt;h3&gt;4.1. 网站历史记录&lt;/h3&gt;
&lt;h3&gt;4.2. 项目开发时间线&lt;/h3&gt;
&lt;h2&gt;5. 组件属性说明 (Props)&lt;/h2&gt;
&lt;h3&gt;Timeline 组件&lt;/h3&gt;
&lt;p&gt;| 属性 | 类型 | 默认值 | 描述 |
|---|---|---|---|
| &lt;code&gt;class&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | &lt;code&gt;&apos;&apos;&lt;/code&gt; | 自定义 CSS 类 |&lt;/p&gt;
&lt;h3&gt;TimelineItem 组件&lt;/h3&gt;
&lt;p&gt;| 属性 | 类型 | 默认值 | 描述 |
|---|---|---|---|
| &lt;code&gt;date&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | 必需 | 日期字符串 |
| &lt;code&gt;milestone&lt;/code&gt; | &lt;code&gt;boolean&lt;/code&gt; | &lt;code&gt;false&lt;/code&gt; | 是否为里程碑节点（会有特殊样式） |
| &lt;code&gt;class&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | &lt;code&gt;&apos;&apos;&lt;/code&gt; | 自定义 CSS 类 |&lt;/p&gt;
&lt;h2&gt;6. 工作原理 (How It Works)&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Timeline 容器&lt;/strong&gt;：&lt;code&gt;&amp;#x3C;Timeline&gt;&lt;/code&gt; 组件是一个容器，使用 &lt;code&gt;&amp;#x3C;ul&gt;&lt;/code&gt; 元素包裹所有时间线项&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;TimelineItem 项&lt;/strong&gt;：每个 &lt;code&gt;&amp;#x3C;TimelineItem&gt;&lt;/code&gt; 渲染为一个 &lt;code&gt;&amp;#x3C;li&gt;&lt;/code&gt; 元素，包含：
&lt;ul&gt;
&lt;li&gt;左侧的圆点（普通节点为空心，里程碑节点为实心）&lt;/li&gt;
&lt;li&gt;日期标签（&lt;code&gt;&amp;#x3C;samp&gt;&lt;/code&gt; 元素）&lt;/li&gt;
&lt;li&gt;内容区域（支持任意组件和 Markdown）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;连接线&lt;/strong&gt;：通过 CSS &lt;code&gt;::after&lt;/code&gt; 伪元素自动生成连接线，连接相邻的圆点&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;里程碑样式&lt;/strong&gt;：里程碑节点有特殊的背景高亮效果，圆点为实心主色调&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;响应式设计&lt;/strong&gt;：在小屏幕上，日期标签会有背景色和 padding，提升可读性&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;7. 样式特性 (Styling Features)&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;圆点样式&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;普通节点：空心圆点，hover 时会有边框颜色变化和缩放效果&lt;/li&gt;
&lt;li&gt;里程碑节点：实心主色调圆点&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;连接线&lt;/strong&gt;：垂直连接线，对齐圆点中心&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;里程碑高亮&lt;/strong&gt;：渐变背景，从左侧主色调到透明&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;响应式&lt;/strong&gt;：移动端日期标签有背景色，提升可读性&lt;/li&gt;
&lt;/ul&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>建站: IconLink 组件</title><link>https://8cat.life/blog/7f83</link><guid isPermaLink="true">https://8cat.life/blog/7f83</guid><description>展示 IconLink 组件的用法和效果，自动为外部链接添加图标</description><pubDate>Fri, 14 Nov 2025 17:00:16 GMT</pubDate><content:encoded>&lt;p&gt;import IconLink from &apos;@/components/IconLink.astro&apos;
import MdxRepl from &apos;@/custom/components/user/MdxRepl.astro&apos;&lt;/p&gt;
&lt;p&gt;本页面展示了 &lt;code&gt;&amp;#x3C;IconLink&gt;&lt;/code&gt; 组件的各种用法和效果。&lt;/p&gt;
&lt;h2&gt;1. 基础用法 (Basic Usage)&lt;/h2&gt;
&lt;h3&gt;1.1. 外部链接（自动添加图标）&lt;/h3&gt;
&lt;p&gt;Google&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#x3C;/Fragment&gt;
&amp;#x3C;/MdxRepl&gt;

### 1.2. 内部链接（不添加图标）

&amp;#x3C;MdxRepl&gt;
&amp;#x3C;p&gt;
  这是一个 &amp;#x3C;IconLink href=&quot;/about&quot;&gt;内部链接&amp;#x3C;/IconLink&gt;，不会添加图标。
&amp;#x3C;/p&gt;

&amp;#x3C;Fragment slot=&apos;desc&apos;&gt;
````mdx
&amp;#x3C;IconLink href=&quot;/about&quot;&gt;内部链接&amp;#x3C;/IconLink&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;2. 自定义属性 (Custom Attributes)&lt;/h2&gt;
&lt;h3&gt;2.1. 自定义 target 和 rel&lt;/h3&gt;
&lt;h3&gt;2.2. 自定义 CSS 类&lt;/h3&gt;
&lt;h2&gt;3. 自定义图标 (Custom Icons)&lt;/h2&gt;
&lt;h3&gt;3.1. 全局配置&lt;/h3&gt;
&lt;p&gt;你可以在 &lt;code&gt;src/site.config.ts&lt;/code&gt; 中配置全局的自定义图标映射，这样所有使用 &lt;code&gt;&amp;#x3C;IconLink&gt;&lt;/code&gt; 组件的地方都会自动应用这些配置。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;配置示例：&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-typescript&quot;&gt;// src/site.config.ts
export const theme: ThemeUserConfig = {
  // ... 其他配置
  content: {
    externalLinks: {
      customIcons: {
        &apos;github.com&apos;: &apos;github&apos;,        // GitHub 使用 github 图标
        &apos;www.google.com&apos;: &apos;google&apos;,    // Google 使用 google 图标
        &apos;stackoverflow.com&apos;: &apos;stack&apos;,  // Stack Overflow 使用 stack 图标
        // ... 更多配置
      }
    }
  }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;可用的图标名称：&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;常用的图标包括：&lt;code&gt;github&lt;/code&gt;, &lt;code&gt;gitlab&lt;/code&gt;, &lt;code&gt;discord&lt;/code&gt;, &lt;code&gt;youtube&lt;/code&gt;, &lt;code&gt;instagram&lt;/code&gt;, &lt;code&gt;x&lt;/code&gt;, &lt;code&gt;telegram&lt;/code&gt;, &lt;code&gt;rss&lt;/code&gt;, &lt;code&gt;email&lt;/code&gt;, &lt;code&gt;reddit&lt;/code&gt;, &lt;code&gt;bluesky&lt;/code&gt;, &lt;code&gt;tiktok&lt;/code&gt;, &lt;code&gt;weibo&lt;/code&gt;, &lt;code&gt;steam&lt;/code&gt;, &lt;code&gt;bilibili&lt;/code&gt;, &lt;code&gt;zhihu&lt;/code&gt;, &lt;code&gt;coolapk&lt;/code&gt;, &lt;code&gt;netease&lt;/code&gt;, &lt;code&gt;link&lt;/code&gt;, &lt;code&gt;qrcode&lt;/code&gt;, &lt;code&gt;copyright&lt;/code&gt;, &lt;code&gt;receive-money&lt;/code&gt;, &lt;code&gt;alipay&lt;/code&gt;, &lt;code&gt;wechat-pay&lt;/code&gt; 等。&lt;/p&gt;
&lt;p&gt;完整的图标列表请参考 &lt;code&gt;packages/pure/libs/icons.ts&lt;/code&gt; 文件中的 &lt;code&gt;BuiltInIcons&lt;/code&gt; 对象。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;优先级说明：&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;图标获取的优先级顺序为：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;组件级别的 &lt;code&gt;customIcons&lt;/code&gt; prop（最高优先级）&lt;/li&gt;
&lt;li&gt;全局配置中的 &lt;code&gt;customIcons&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;favicon 服务（&lt;code&gt;https://favicon.im/{hostname}&lt;/code&gt;）&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;3.2. 使用全局配置的自定义图标&lt;/h3&gt;
&lt;h3&gt;3.3. 组件级别的自定义图标&lt;/h3&gt;
&lt;p&gt;组件级别的配置会覆盖全局配置，适用于需要为特定链接使用不同图标的场景。&lt;/p&gt;
&lt;h2&gt;4. 图标大小 (Icon Size)&lt;/h2&gt;
&lt;h3&gt;4.1. 默认大小（16px）&lt;/h3&gt;
&lt;h3&gt;4.2. 自定义图标大小&lt;/h3&gt;
&lt;h2&gt;5. 实际应用场景 (Real-world Examples)&lt;/h2&gt;
&lt;h3&gt;5.1. 在段落中使用&lt;/h3&gt;
&lt;h3&gt;5.2. 在列表中使用&lt;/h3&gt;
&lt;h3&gt;5.3. 协议相对链接&lt;/h3&gt;
&lt;h2&gt;6. 组件属性说明 (Props)&lt;/h2&gt;
&lt;p&gt;| 属性 | 类型 | 默认值 | 描述 |
|---|---|---|---|
| &lt;code&gt;href&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | 必需 | 链接地址 |
| &lt;code&gt;target&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | &lt;code&gt;&apos;_blank&apos;&lt;/code&gt; | 链接打开方式 |
| &lt;code&gt;rel&lt;/code&gt; | &lt;code&gt;string \| string[]&lt;/code&gt; | &lt;code&gt;[&apos;nofollow&apos;, &apos;noopener&apos;, &apos;noreferrer&apos;]&lt;/code&gt; | rel 属性 |
| &lt;code&gt;class&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | &lt;code&gt;&apos;&apos;&lt;/code&gt; | 自定义 CSS 类 |
| &lt;code&gt;customIcons&lt;/code&gt; | &lt;code&gt;Record&amp;#x3C;string, string&gt;&lt;/code&gt; | &lt;code&gt;undefined&lt;/code&gt; | 组件级别的自定义图标映射 |
| &lt;code&gt;iconSize&lt;/code&gt; | &lt;code&gt;number&lt;/code&gt; | &lt;code&gt;16&lt;/code&gt; | 图标大小（像素） |&lt;/p&gt;
&lt;h2&gt;7. 工作原理 (How It Works)&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;自动识别外部链接&lt;/strong&gt;：组件会自动判断链接是否为外部链接（绝对 URL 或协议相对 URL）&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;图标获取优先级&lt;/strong&gt;：
&lt;ul&gt;
&lt;li&gt;首先检查组件级别的 &lt;code&gt;customIcons&lt;/code&gt; prop&lt;/li&gt;
&lt;li&gt;然后检查全局配置中的 &lt;code&gt;customIcons&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;最后使用 favicon 服务（&lt;code&gt;https://favicon.im/{hostname}&lt;/code&gt;）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;图标显示&lt;/strong&gt;：图标显示在链接文本的左侧&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;内部链接&lt;/strong&gt;：内部链接不会添加图标，保持普通链接样式&lt;/li&gt;
&lt;/ol&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>如何反驳&apos;人性论&apos;</title><link>https://8cat.life/blog/o2yb</link><guid isPermaLink="true">https://8cat.life/blog/o2yb</guid><description>一些容易理解的反驳人性论的简单例子,便于传播.</description><pubDate>Tue, 28 Oct 2025 20:02:26 GMT</pubDate><content:encoded>&lt;p&gt;import Aside from &apos;@/custom/components/user/Aside.astro&apos;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;那种“人性本私,抱怨不公只是恨自己不是受益者”的犬儒论调之所以有市场,就是因为它简单,刻薄,听起来很“深刻”.要反驳它,我们不能陷入复杂的哲学辩论,而是要用同样简明,但更贴近事实和人心的例子来“解毒”&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2&gt;1. “消防员”论据:用事实反驳“一切行为皆为自利”&lt;/h2&gt;
&lt;p&gt;这是反驳“心理利己主义”（Psychological Egoism）最经典的例子,它简单,有力,且符合直觉.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;当对方说:&lt;/strong&gt; “人做的任何事,归根结底都是为了自己.抱怨不公的人,只是想让自己获利.”&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;你可以回应:&lt;/strong&gt; “那如何解释冲进火场的消防员?按照你的逻辑,他冒着生命危险,不是为了救人,而是为了满足自己‘想当英雄’的欲望,或是为了‘避免良心不安’的痛苦.这个解释是不是太绕了?一个全身心救人的行为,你却非要把它拧巴成自私的.有没有一种更简单的可能:&lt;strong&gt;他就是想救人&lt;/strong&gt;.承认世界上存在‘为他人着想’的动机,比你那个需要打好几个补丁的‘自私论’要简洁得多.”&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;这个例子的核心力量在于:&lt;/strong&gt; 它把举证的责任抛回给了对方.为了维持“一切人皆自私”的理论,犬儒主义者必须为所有利他行为发明一个“隐藏的自私动机”.这种解释往往比“他就是想帮助别人”这个直接解释要复杂得多,也更不自然.这就暴露了他们理论的脆弱性:它不是一个观察结果,而是一个预设的,不可证伪的信仰.&lt;/p&gt;
&lt;h2&gt;2. “游戏规则”比喻:区分“想赢”与“想要公平”&lt;/h2&gt;
&lt;p&gt;这个比喻直接针对“抱怨不公,是恨自己没得利”这一核心论点,清晰地做出切割.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;当对方说:&lt;/strong&gt; “那些天天喊着‘社会不公’的人,如果让他们处在既得利益者的位置,他们会更贪婪.”&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;你可以回应:&lt;/strong&gt; “你混淆了两种抱怨.这就像一场游戏,有人抱怨‘为什么赢家不是我?’,但还有很多人抱怨‘&lt;strong&gt;这个游戏的规则本身就有问题&lt;/strong&gt;’.”
“想象一场棋局,一方开局就拥有双倍的棋子.
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;第一种抱怨者&lt;/strong&gt;说:‘不公平!凭什么他棋子多?我也想要双倍的棋子!’--这确实是你所说的那种人.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;第二种抱怨者&lt;/strong&gt;说:‘这规则不对.一场公平的棋局,双方的棋子应该一样多.我们应该修改规则.’
“历史上的很多变革,比如争取选举权,废除特权,都是第二种人推动的.他们不是想成为新的特权者,而是想&lt;strong&gt;废除特权本身&lt;/strong&gt;.你的理论,完全无视了第二种人的存在,把所有对正义的呼唤都贬低为第一种人的嫉妒.”&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;这个比喻的核心力量在于:&lt;/strong&gt; 它揭示了对方的逻辑谬误--“以偏概全”.犬儒主义者看到了第一种人（投机者）的存在,就断言所有抱怨者都是第一种人,这在逻辑上是站不住脚的.&lt;/p&gt;
&lt;h2&gt;3. “花园与荒地”比喻:反驳“顺应‘自然’就是对的”&lt;/h2&gt;
&lt;p&gt;这个比喻用来反驳社会达尔文主义及其变体,即“弱肉强食是自然法则,所以社会也应该如此”的论调.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;当对方说:&lt;/strong&gt; “物竞天择,适者生存,这是自然规律.社会竞争残酷是正常的,帮助弱者反而违反了自然.”&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;你可以回应:&lt;/strong&gt; “你的意思是,我们应该像对待一块荒地一样对待社会吗?荒地上,杂草疯长,害虫遍地,这确实很‘自然’.但&lt;strong&gt;文明的全部意义,不就是开垦荒地,变成花园吗?&lt;/strong&gt;”
“我们作为‘园丁’,会去锄草,杀虫,施肥,浇水,目的就是为了让我们珍视的花朵（比如公平,怜悯,艺术,科学）得以绽放,而不是任由我们不想要的‘杂草’（暴力,欺诈,压迫）来主宰一切.&lt;strong&gt;用‘自然’来为社会的残酷辩护,就等于说园丁不应该干预荒地.&lt;/strong&gt; 整个文明的进程,恰恰是‘用人为的善’去克服‘自然的恶’的过程.”&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;这个比喻的核心力量在于:&lt;/strong&gt; 它揭示了“自然主义谬误”（Naturalistic Fallacy）[1, 2, 3, 4].即从“是什么”（is）推不出“应该是什么”（ought）[5, 6, 7].自然界存在暴力和竞争,不代表我们就应该在社会中推崇暴力和竞争.文明的本质恰恰在于建立一套不同于丛林法则的价值体系.&lt;/p&gt;
&lt;h2&gt;4. “电脑硬件与软件”比喻:解构僵化的“人性论”&lt;/h2&gt;
&lt;p&gt;这个比喻是你之前思考的“忽略中间环境和过程”的完美延伸,它彻底瓦解了“人性不变,历史轮回”的宿命论.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;当对方说:&lt;/strong&gt; “历史一直在轮回,就是因为人性改不了.不管什么制度,最后都会因为人的自私而败坏.”&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;你可以回应:&lt;/strong&gt; “把‘人性’看作一套写死的,无法修改的程序,这个看法太陈旧了.人性更像是一台电脑的&lt;strong&gt;硬件&lt;/strong&gt;,它有运算的潜能,但本身没有固定的功能.”
“而一个社会的&lt;strong&gt;制度,文化,法律和教育,就像是安装在这台硬件上的软件&lt;/strong&gt;.
&lt;ul&gt;
&lt;li&gt;你给它装上一个鼓励‘内卷’和互害的‘软件’,它就运行出一个充满猜忌和斗争的社会.&lt;/li&gt;
&lt;li&gt;你给它装上一个鼓励合作和信任的‘软件’,它就能运行出一个文明,互助的社会.
“历史的悲剧,不是因为‘硬件’（人性）有无法修复的缺陷,而是因为我们一直在调试和编写更好的‘软件’（社会制度）,这个过程充满了失败和Bug.你说‘人性决定了历史轮回’,就好像一个程序员看到电脑死机了,不断抱怨‘都是CPU的错’,而不是去检查自己写的代码有没有问题.&lt;strong&gt;真正决定我们未来的,不是那个基本不变的硬件,而是我们选择安装什么样的软件.&lt;/strong&gt;”&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;这个比喻的核心力量在于:&lt;/strong&gt; 它提供了一种更动态,更科学的视角.它承认人有自私的潜能,也有合作的潜能 [8].最终哪种潜能被激发,取决于环境和制度（软件）.这有力地反驳了宿命论,并把焦点引向了我们真正可以改变的东西--社会构建.&lt;/p&gt;
&lt;hr&gt;
&lt;h3&gt;总结与传播策略&lt;/h3&gt;
&lt;p&gt;当你想要传播这些观点时,记住:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;先承认,再反驳:&lt;/strong&gt; “你说的有一定道理,确实存在那样的人,&lt;strong&gt;但是……&lt;/strong&gt;” 这样可以减少对方的抵触情绪.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;用提问代替说教:&lt;/strong&gt; “那我们该如何解释消防员呢?” “你觉得这两种抱怨是一回事吗?” 把思考题抛给对方.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;保持简洁:&lt;/strong&gt; 每个比喻都只针对一个核心论点,不要试图用一个例子解决所有问题.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这些例子就像思想上的“疫苗”,它们足够简单,易于理解和复述,可以帮助更多人识别并抵御那些看似深刻实则有害的犬儒思想.&lt;/p&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>&apos;人性论&apos;批判</title><link>https://8cat.life/blog/igv0</link><guid isPermaLink="true">https://8cat.life/blog/igv0</guid><description>梳理和批判现在流行的关于人性论的观点</description><pubDate>Tue, 28 Oct 2025 16:39:09 GMT</pubDate><content:encoded>&lt;p&gt;import Aside from &apos;@/custom/components/user/Aside.astro&apos;
import Badge from &apos;@/components/Badge.astro&apos;&lt;/p&gt;
&lt;p&gt;&amp;#x3C;Badge item={{ key: &apos;丛林法则&apos;}} /&gt;
&amp;#x3C;Badge item={{ key: &apos;人性论&apos;}} /&gt;
&amp;#x3C;Badge item={{ key: &apos;奥威尔&apos;, value: &apos;《动物农场》&apos;}} /&gt;&lt;/p&gt;
&lt;h2&gt;第一部分:关于人类本质的基础性辩论&lt;/h2&gt;
&lt;p&gt;对人性的探讨,即人类在根本上是合作的还是竞争的,并非现代社会的产物,而是一个贯穿东西方思想史的永恒问题.这些古老的哲学辩论为后世更具&quot;科学&quot;色彩的意识形态奠定了基础,并构建了我们理解社会秩序与个人行为的核心框架.通过追溯这些思想的源头,我们可以清晰地看到一条从古代哲学思辨到现代政治理论的知识谱系.&lt;/p&gt;
&lt;h3&gt;1.1 东方轴心:中国古典哲学中的性善与性利之辩&lt;/h3&gt;
&lt;p&gt;在中国先秦时期,儒家内部围绕人性本质展开了一场影响深远的辩论,其核心人物是孟子和荀子.这场辩论不仅关乎道德的起源,更深刻地触及了社会秩序的来源——秩序是源于人内在的道德潜能,还是必须通过外在的文明力量来强加?这一核心张力,预示了数世纪后西方思想中霍布斯与卢梭等人探讨的类似主题.&lt;/p&gt;
&lt;h4&gt;孟子与性善论&lt;/h4&gt;
&lt;p&gt;孟子主张人性本善(性善论),认为每个人与生俱来都拥有道德的&quot;四端&quot;或&quot;萌芽&quot;.这四端分别是:恻隐之心,仁之端也;羞恶之心,义之端也;辞让之心,礼之端也;是非之心,智之端也.在孟子看来,这些与生俱来的倾向并非已经完全成形的德性,而是必须通过后天反思和精心培育才能充分发展的潜能.他将这一过程比作树木的成长:在适宜的条件下,树木会自然长成其应有的形态.因此,善是这些内在萌芽发展的必然结果.&lt;/p&gt;
&lt;p&gt;孟子的理论是一种以&quot;行动者为中心&quot;的德性伦理学,强调个体的自我修养.它为人类道德提供了一个乐观的基础:尽管并非所有人最终都成为善人,但所有人都有成为善人的能力.这套理论将道德责任置于个体及其所处的环境之上,认为社会的角色是创造条件,让这些善良的萌芽得以茁壮成长.&lt;/p&gt;
&lt;h4&gt;荀子与性恶论&lt;/h4&gt;
&lt;p&gt;与孟子截然相反,荀子提出了人性本&quot;恶&quot;（性恶论)的观点.这里的&quot;恶&quot;（è)更准确地应理解为&quot;不良&quot;或&quot;原始&quot;,指的是人与生俱来的,动物性的欲望,特别是对利益（profit)和感官满足的追求.荀子认为,如果放任这些天性发展,必然会导致人与人之间的争夺和社会的混乱.因此,荀子主张,善并非源于天性,而是后天&quot;伪&quot;（wěi)的结果.&quot;伪&quot;在这里意为&quot;人为&quot;或&quot;有意识的努力&quot;,特指通过圣人所创立的礼仪（禮; li)和法度进行的教育与规训.他用一个生动的比喻来阐释这一观点:人性好比未经雕琢的原始木料,必须经过工匠的加工才能成为有用的器物,如椅子.这种基于规则,注重结果的理论,强调外部力量在塑造个人品德和社会秩序中的决定性作用.&lt;/p&gt;
&lt;p&gt;荀子的思想并非主张人性全然败坏,而是一种务实的政治哲学.他承认人有向善的内在动力,但认为这种动力必须由外部的礼法来引导和塑造.这种强调外部规范和稳定社会秩序的思想,深刻影响了后来兴起的法家.法家哲学建立在对人性的深刻不信任之上,它摒弃了对统治者或民众个人道德的依赖,转而诉诸明确,客观且非个人化的法律和规章来维持秩序.&lt;/p&gt;
&lt;h4&gt;综合与比较&lt;/h4&gt;
&lt;p&gt;尽管孟子和荀子的观点看似水火不容,但他们同属儒家思想体系,共同相信人可以通过后天修养达到完善,并都以建立和谐的社会秩序为最终目标.他们争论的核心是人性的起点,而非终点或修养的必要性.这场辩论揭示了一个根本性的张力:社会的功能究竟是培育一种与生俱来的善,还是约束一种与生俱来的恶?&lt;/p&gt;
&lt;p&gt;这一古老的东方辩论,实际上触及了政治哲学的核心问题:秩序的来源.孟子的&quot;性善论&quot;暗示,一个道德社会的原材料已经存在于每个人的内心.因此,社会秩序可以从内部涌现,其关键在于创造适宜的环境以促进道德萌芽的成长.相比之下,荀子的&quot;性恶论&quot;则认为,人性是导致混乱的根源,而秩序是一种由外部圣人创造的&quot;人为&quot;技术,必须通过礼法强加于混乱的人性之上.这种&quot;秩序源于内部&quot;与&quot;秩序源于外部&quot;的对立,构成了政治理论的一个基本分水岭.&lt;/p&gt;
&lt;p&gt;数百年后,这一分歧在西方思想中以不同的形式重现.例如,无政府主义思想家克鲁泡特金在其&quot;互助论&quot;中,从生物学层面提出了一个类似孟子的观点:合作的本能是生物固有的,为社会秩序提供了自然基础.而托马斯·霍布斯则在其《利维坦》中,提出了一个与荀子遥相呼应的论点:在没有一个外在的绝对主权者强加秩序的情况下,人类的自然状态便是&quot;一切人对一切人的战争&quot;.因此,孟荀之辩远非一场抽象的哲学讨论,它为政治理论史上一个最核心的问题提供了早期的深刻阐述.&lt;/p&gt;
&lt;h3&gt;1.2 西方轴心:自然状态与社会契约&lt;/h3&gt;
&lt;p&gt;西方哲学传统中,最具影响力的思想实验之一便是&quot;自然状态&quot;.这一概念试图通过剥离文明的层层外衣,来探寻一种&quot;纯粹&quot;的人性,从而为各种政治理论提供一个强有力的（尽管是假设性的)基础.&lt;/p&gt;
&lt;h4&gt;托马斯·霍布斯与《利维坦》:一个永久战争的世界&lt;/h4&gt;
&lt;p&gt;深受其时代科学机械论的影响,霍布斯构建了一个基于唯物主义和心理利己主义的人性观.他认为,人类行为的根本驱动力是永不休止地追求权力的欲望（animus dominandi)以及对自我保存的渴望.在霍布斯的理论中,自然状态（State of Nature)是指在没有一个&quot;共同权力使大家畏服&quot;的社会里,人类的自然状况.这种状态并非田园牧歌,而是一场&quot;一切人对一切人的战争&quot;（bellum omnium contra omnes).在这种状态下,生命是&quot;孤独,贫困,卑污,残忍而短寿的&quot;.这并非因为人性本&quot;恶&quot;,而是因为在一个无政府和资源稀缺的环境中,出于理性的自保,人们必然会相互猜疑并采取先发制人的攻击.对暴死的恐惧和对安宁生活的渴望,促使理性的,自利的个体相互订立一项社会契约.他们同意放弃自己&quot;为所欲为&quot;的自然权利,将这些权利转让给一个绝对的君主或主权实体——即&quot;利维坦&quot;（Leviathan),以换取和平与秩序.这个主权者本身并非契约的一方,而是契约的执行者和保障者,因此其权力是绝对的,凌驾于法律之上.&lt;/p&gt;
&lt;h4&gt;对比性观点:洛克与卢梭&lt;/h4&gt;
&lt;p&gt;与霍布斯的悲观论调不同,其他社会契约论者提出了更为温和的构想.约翰·洛克认为,自然状态并非混乱的战场,而是由理性所揭示的自然法所支配.在此状态下,个体拥有生命,自由和财产权等不可剥夺的自然权利.人们之所以需要建立政府,并非为了逃离战争,而是为了更方便地解决争端,设立一个公正的裁判者.让-雅克·卢梭则激烈地批判霍布斯,认为他将文明社会的种种恶习错误地投射到了自然人身上.在卢梭看来,处于自然状态的&quot;野蛮人&quot;是孤独,和平且道德中立的生物,其行为仅由自我保存的本能和一种天生的怜悯心（pitié)所驱动.是私有制的出现和社会的发展败坏了人性的纯良,造成了不平等与冲突.&lt;/p&gt;
&lt;h4&gt;古希腊的先声:柏拉图与亚里士多德&lt;/h4&gt;
&lt;p&gt;尽管古希腊哲学家没有使用&quot;自然状态&quot;这一概念,但他们的思想为后世提供了重要的参照.柏拉图和亚里士多德认为,人并非前社会的孤立个体,而是在本性上就是社会性和政治性的动物（zoon politikon).亚里士多德明确指出,城邦（polis)是自然形成的,因为只有在城邦这种政治共同体中,人才能充分实现其潜能,过上&quot;优良的生活&quot;（eudaimonia).他甚至断言,一个脱离城邦的人,&quot;他若非神明,即是野兽&quot;.这种目的论的观点认为,国家并非解决前社会问题的&quot;人造&quot;工具,而是人类发展的自然归宿.&lt;/p&gt;
&lt;p&gt;柏拉图在其《理想国》中构想了一个理想的城邦,其社会结构严格对应人类灵魂的三个部分:理性,激情和欲望.在这个城邦里,由哲学王（代表理性)统治护卫者（代表激情)和生产者（代表欲望).无论是对个人还是对城邦而言,正义即是这三部分的和谐有序.这与霍布斯将国家视为仅为约束自利个体的容器的观点形成了鲜明对比.&lt;/p&gt;
&lt;p&gt;霍布斯的思想框架为后来的社会达尔文主义和现实主义等意识形态提供了核心的&quot;操作系统&quot;.在前霍布斯时代,西方政治思想深受亚里士多德和基督教传统的影响,普遍认为人性是趋向社会合作与共同善的.霍布斯则完成了一次革命性的断裂.他将&quot;自然法&quot;重新定义为不包含道德约束的,为自我保存可以采取任何手段的自由,从而将人类互动从一个道德问题重构成一个战略问题.这个由&quot;无政府体系,自利行为体,为求生存和权力而进行的理性计算&quot;构成的逻辑框架,被后来的思想家们反复应用.社会达尔文主义者将这种个体为生存而斗争的逻辑,从纯粹的理性推演移植到了生物学的基础之上.而国际关系中的现实主义者,则将完全相同的逻辑应用于国家之间的互动,并明确地将国际体系描述为&quot;无政府状态&quot;.因此,霍布斯的《利维坦》不仅是众多理论中的一种,更是提供了一套核心逻辑软件的思想先驱,这套软件在19世纪的资本主义或20世纪的地缘政治等不同的&quot;硬件&quot;环境中被反复运行和实践.&lt;/p&gt;
&lt;h4&gt;表1:人性与社会比较框架&lt;/h4&gt;
&lt;p&gt;| 思想家/学派 | 对人性的先天看法 | 对社会冲突的诊断 | 国家/社会的角色 | 核心概念 |
|-------------|-----------------|-----------------|-----------------|---------|
| 孟子 | 内在善良;拥有道德的&quot;四端&quot; | 未能培养与生俱来的善 | 通过教育和仁政环境培育善的萌芽 | 性善, 四端 |
| 荀子 | 内在自利;被欲望驱动 | 不受约束的欲望导致纷争 | 通过外在的人为努力（礼法)来约束天性,创造善 | 性恶, 礼, 伪 |
| 亚里士多德 | &quot;政治的动物&quot;;天生具有社会性 | 生活在城邦之外;未能实现全部潜能 | 提供城邦（polis)框架,使公民实现&quot;优良的生活&quot;（eudaimonia) | Polis, Eudaimonia |
| 霍布斯 | 利己,竞争,追求权力 | 无政府自然状态下的&quot;一切人对一切人的战争&quot; | 通过绝对主权者（利维坦)强加秩序与安全 | 自然状态, Bellum omnium contra omnes |
| 卢梭 | 天性善良且有同情心;被社会败坏 | 私有财产和社会不平等 | 建立基于&quot;公意&quot;的社会契约,恢复自由与平等 | 高贵的野蛮人, 公意 |
| 克鲁泡特金 | 内在合作;受&quot;互助&quot;驱动 | 国家和私有制破坏了自然的合作机制 | 在无国家,共产主义的社会中让自然的社会性得以发展 | 互助 |&lt;/p&gt;
&lt;h2&gt;第二部分:&quot;科学&quot;斗争意识形态的兴起&lt;/h2&gt;
&lt;p&gt;19世纪,关于竞争的哲学思想经历了一次深刻的转变,它们被包装成看似客观的科学教条.查尔斯·达尔文的生物进化论被不当地挪用,催生了社会达尔文主义;而&quot;丛林法则&quot;这样的文学比喻也被扭曲,以服务于特定的意识形态.这一部分将深入探讨这些概念之间的关联,并分析它们被社会广泛接受的原因.&lt;/p&gt;
&lt;h3&gt;2.1 社会达尔文主义:进化论在社会领域的误用&lt;/h3&gt;
&lt;p&gt;社会达尔文主义并非达尔文自己的理论,而是19世纪末一些思想家对其理论的曲解和滥用.它将生物界的生存竞争法则机械地套用到人类社会,为当时的社会不公与政治野心提供了&quot;科学&quot;的伪装.&lt;/p&gt;
&lt;h4&gt;起源与核心信条&lt;/h4&gt;
&lt;p&gt;社会达尔文主义的核心人物是英国哲学家赫伯特·斯宾塞,而非达尔文.斯宾塞创造了&quot;适者生存&quot;（survival of the fittest)这一著名短语.他的思想更多地受到拉马克&quot;获得性遗传&quot;理论的影响,而非达尔文的自然选择学说.因此,社会达尔文主义从一开始就是对达尔文生物学理论的一种挪用,旨在为特定的社会,政治和经济议程服务.&lt;/p&gt;
&lt;p&gt;其核心信条包括:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;生存斗争&lt;/strong&gt;:认为人类社会与动植物界一样,是一个个体之间为生存而激烈竞争的场所.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;自由放任&lt;/strong&gt;:主张政府不应干预这种&quot;自然&quot;的竞争过程,例如通过福利政策救助穷人,因为这会妨碍&quot;优胜劣汰&quot;的自然法则.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;为不平等辩护&lt;/strong&gt;:它为社会中巨大的权力与财富差距提供了合理化解释.成功者（如富有的商人,强大的国家或&quot;优等&quot;种族)之所以成功,被认为是其内在&quot;适应性&quot;更强的证明.&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;被接受的社会政治背景&lt;/h4&gt;
&lt;p&gt;社会达尔文主义的兴起并非偶然,它完美地契合了19世纪末的时代精神.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;工业革命与镀金时代&lt;/strong&gt;:在自由放任资本主义盛行的&quot;镀金时代&quot;,工业化带来了巨大的财富,也造成了前所未有的贫富分化.社会达尔文主义为这种现象提供了看似科学的解释,成为&quot;成功商人们一种慰藉人心的想法&quot;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;殖民主义与帝国主义&lt;/strong&gt;:它为欧洲的殖民扩张提供了道德和理性的借口.殖民者将自己描绘成&quot;优等&quot;种族,认为统治&quot;劣等&quot;的被殖民民族是自然选择的必然结果,甚至是他们的&quot;责任&quot;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;民族主义与军国主义&lt;/strong&gt;:在德国等国家,社会达尔文主义与民族主义相结合,催生了军国主义思想.一些人认为,战争是检验一个国家&quot;适应性&quot;的终极&quot;生物学必需品&quot;,是推动人类进步的工具.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;优生学&lt;/strong&gt;:这种思想为优生学运动提供了理论基础.优生学试图通过人为干预（如强制绝育)来阻止所谓的&quot;不适者&quot;（如穷人,残疾人或特定种族)繁衍后代,以期&quot;改良&quot;人类种群.在其最极端的形式下,这种思想最终导向了纳粹的大屠杀.&lt;/p&gt;
&lt;p&gt;用户提出的问题——这类思想的被接受是&quot;群体的认识问题还是环境的问题&quot;——在此得到了深刻的解答.证据表明,这是一种共生关系,但环境是主要的驱动力.19世纪&quot;镀金时代&quot;的社会环境（极端的经济不平等,快速的工业化,残酷的殖民扩张)为一种能够使现状合法化的意识形态创造了巨大的需求.社会达尔文主义恰好满足了这一需求,它提供了完美的供给.它的被接受,与其说是因为其内在的认知说服力,不如说是因为它对于当时的统治集团而言是一种在社会和经济上极为有用的工具.&lt;/p&gt;
&lt;p&gt;这一过程可以这样理解:首先,19世纪的社会剧变造成了合法性危机.面对巨大的贫富差距和殖民掠夺,传统的宗教或道德辩护在新兴的科学时代显得日益苍白.其次,达尔文于1859年发表的《物种起源》提供了一套革命性的,极具威望的科学词汇,如&quot;生存斗争&quot;,&quot;自然选择&quot;等.最后,斯宾塞等人扮演了意识形态企业家的角色,他们挪用这套科学语言,创造出一种新的社会理论,完美地解释并合理化了当时的社会秩序.富人并非贪婪,而是&quot;更适应环境&quot;;穷人并非被剥削,而是&quot;不适应环境&quot;;殖民主义并非侵略,而是进化的自然进程.因此,&quot;认知问题&quot;（相信这套有缺陷的理论)是次要的,它是由&quot;环境问题&quot;（即合理化一个在道德上难以辩护的社会秩序的迫切需要)所驱动的.&lt;/p&gt;
&lt;h3&gt;2.2 &quot;丛林法则&quot;:一个比喻的腐化&lt;/h3&gt;
&lt;p&gt;&quot;丛林法则&quot;这一短语的演变,生动地展示了意识形态形成的一个关键机制:文化概念的简化与扭曲.它从一个倡导合作的复杂法则,沦为了残酷竞争的代名词.&lt;/p&gt;
&lt;h4&gt;流行的误解&lt;/h4&gt;
&lt;p&gt;在当今语境下,&quot;丛林法则&quot;（law of the jungle)通常指一种残酷无情,不受约束的竞争状态,其中&quot;弱肉强食&quot;,&quot;强权即公理&quot;,最强者通过牺牲弱者来生存.这种理解使其与社会达尔文主义的世界观高度一致.&lt;/p&gt;
&lt;h4&gt;拉迪亚德·吉卜林的本意&lt;/h4&gt;
&lt;p&gt;然而,这一短语的本意却截然相反.它由英国作家吉卜林在其著作《丛林之书》（1894年)和《丛林之书二》（1895年)中首创.在吉卜林的原文中,&quot;丛林法则&quot;绝非无政府状态的同义词,而是一套确保狼群社会合作与稳定的复杂行为准则.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;核心原则是相互依存&lt;/strong&gt;:&quot;狼群的力量在于孤狼,而孤狼的力量在于狼群&quot;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;法则包含对弱者的保护&lt;/strong&gt;:它为有幼崽的母狼和年轻的狼规定了权利,构成了一套&quot;基础的福利服务体系&quot;.它是&quot;个人主义与集体主义的审慎结合&quot;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;法则禁止无谓的杀戮&lt;/strong&gt;:它甚至禁止为了运动或贪食而杀戮.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&quot;丛林法则&quot;从合作准则到竞争代名词的转变,是一个绝佳的案例,展示了一个引人入胜的比喻如何被剥离其细微之处,并被武器化以支持一种主导意识形态.这一过程揭示了一个关键原理:在思想的市场上,一个概念最吸引人,在意识形态上最方便的解释,往往会战胜其更复杂,更原始的含义.&lt;/p&gt;
&lt;p&gt;19世纪末的主导意识形态是强调竞争的社会达尔文主义.吉卜林的短语&quot;丛林法则&quot;朗朗上口,意象生动.然而,它合作,社会责任,保护弱者的真实含义,与社会达尔文主义的世界观直接相悖.为了让这个短语服务于该世界观,其含义必须被颠倒.人们强调了&quot;丛林&quot;的野蛮意象,而忽略了&quot;法则&quot;的秩序内涵.它被重新解释为没有法则,而不是一套特定的法则.这个被扭曲的新含义,与早已存在的霍布斯式和社会达尔文主义式的&quot;自然状态&quot;观念产生了共鸣,为一个复杂的信仰体系提供了一个简单易记的标签.这个短语的流行,证明了它被用来服务的竞争性世界观的强大力量.&lt;/p&gt;
&lt;h3&gt;2.3 自然主义谬误:一个根本性的批判&lt;/h3&gt;
&lt;p&gt;对社会达尔文主义最致命的哲学批判,来自于对其核心逻辑错误的揭示.理解这一点至关重要,因为它说明了为何这类理论不仅在道德上令人反感,在智识上也是站不住脚的.&lt;/p&gt;
&lt;h4&gt;G.E. 摩尔与&quot;是&quot;与&quot;应该&quot;的问题&lt;/h4&gt;
&lt;p&gt;英国哲学家G.E. 摩尔在其1903年的著作《伦理学原理》中,指出了所谓的&quot;自然主义谬误&quot;（naturalistic fallacy).这一谬误指的是试图用某种自然属性（如&quot;令人愉悦的&quot;,&quot;更进化的&quot;或&quot;适应的&quot;)来定义&quot;善&quot;这一概念的错误.这实际上是休谟早已提出的&quot;是-应该问题&quot;（is-ought problem)的一个版本,即我们无法从一个关于&quot;是什么&quot;的事实陈述,逻辑上推导出一个关于&quot;应该是什么&quot;的价值陈述.&lt;/p&gt;
&lt;p&gt;摩尔用&quot;开放问题论证&quot;（open-question argument)来阐明这一点.对于任何一个被提议用来定义&quot;善&quot;的自然属性X,我们总能有意义地追问:&quot;但是,X是善的吗?&quot;例如,如果有人将&quot;善&quot;定义为&quot;有助于生存&quot;,我们仍然可以问:&quot;但是,生存是善的吗?&quot;这个问题并非一个像&quot;我知道他是单身汉,但他未婚吗?&quot;那样的封闭,无意义的问题,这一事实证明了&quot;生存&quot;和&quot;善&quot;并非同一概念.&lt;/p&gt;
&lt;h4&gt;在社会达尔文主义中的应用&lt;/h4&gt;
&lt;p&gt;社会达尔文主义以最露骨的方式犯下了自然主义谬误.它观察到一个（被误解的)自然过程——&quot;生存斗争&quot;和&quot;适者生存&quot;——然后得出结论,认为这个过程在道德上是善的,并且应该成为社会的组织原则.诸如&quot;资本主义是善的,因为它是适者生存的体现&quot;这样的论断,是这一谬误的典型例子.摩尔只需反问:&quot;但是,适者生存是善的吗?&quot;这仍然是一个有效的,开放的伦理问题,从而揭示了其逻辑跳跃的无效性.&lt;/p&gt;
&lt;p&gt;尽管自然主义谬误在逻辑上存在缺陷,但它却持续存在,这揭示了一种根深蒂固的人类认知偏见:我们渴望将道德和社会价值观（&quot;应该&quot;)建立在可感知的,客观的自然世界（&quot;是&quot;)之上.这种做法为我们的信念提供了一种确定性和必然性.道德和政治问题复杂,充满争议,缺乏简单的答案,它们属于&quot;应该&quot;的范畴.而科学和自然事实,则感觉坚实,客观,不容否认,它们属于&quot;是&quot;的范畴.社会达尔文主义这类意识形态之所以在心理上具有吸引力,正是因为它们承诺通过将不确定的&quot;应该&quot;锚定在确定的&quot;是&quot;之上,来解决这种不确定性.它们将一场混乱的伦理辩论,转变为一个简单的自然法则问题.正如摩尔所揭示的,此举是错误的,但在修辞上却极为强大.它允许其拥护者宣称:&quot;我所偏好的社会秩序并非仅仅是我的观点,它是一个自然事实.反对它,就是反对现实本身.&quot;&lt;/p&gt;
&lt;p&gt;因此,自然主义谬误不仅是一个逻辑学家的难题,更是一个强大的修辞工具,被用来将高度政治化,充满争议的价值判断,伪装成客观事实的外衣,从而压制辩论.&lt;/p&gt;
&lt;h2&gt;第三部分:在文化,政治与心理学中的现代体现&lt;/h2&gt;
&lt;p&gt;这些关于人性的古老思想并未停留在历史的尘埃中,它们持续地塑造着我们的现代世界.从文学寓言到国际政治理论,再到个体心理剖析,竞争与权力的逻辑以各种形式不断重现.&lt;/p&gt;
&lt;h3&gt;3.1 奥威尔的寓言:《动物农场》中的等级与权力&lt;/h3&gt;
&lt;p&gt;乔治·奥威尔的《动物农场》不仅是对斯大林主义的尖锐讽刺,更是一个普适的寓言,揭示了权力斗争如何腐蚀任何意识形态,其内在逻辑与社会达尔文主义在政治领域的实践遥相呼应.&lt;/p&gt;
&lt;h4&gt;平等的颠覆&lt;/h4&gt;
&lt;p&gt;小说的情节直接影射了俄国革命及其被斯大林主义背叛的过程.动物们基于&quot;所有动物一律平等&quot;的理想发起了反叛,但很快就陷入了以猪为首的新的暴政之中.作为&quot;脑力劳动者&quot;,猪迅速将自己确立为新的统治阶级,并以农场的整体利益为名,将它们的特权（如独占牛奶和苹果)合理化.这与社会达尔文主义者基于所谓的优越&quot;适应性&quot;来为精英地位辩护的逻辑如出一辙.智力劳动与体力劳动之间的自然分工,迅速演变为一个压迫性的新阶级结构.&lt;/p&gt;
&lt;p&gt;猪的领袖拿破仑通过暴力手段夺取权力,利用他从小驯养的狗作为秘密警察,并铲除政治对手雪球,这正是政治领域中&quot;适者生存&quot;法则的赤裸裸展现.农场的最终原则被篡改为&quot;所有动物一律平等,但有些动物比其他动物更平等&quot;,这精辟地概括了平等主义理想如何被扭曲以服务于等级制度.&lt;/p&gt;
&lt;p&gt;奥威尔本人就是&quot;粗俗达尔文主义&quot;的批判者,他曾指出,达尔文主义被用来为强权政治,自由放任资本主义和种族主义辩护,他称之为一种&quot;神秘的信念&quot;,即生存本身就证明了生存的资格.《动物农场》可以被解读为对这种世界观在实践中产生的破坏性社会后果的叙事性展示.猪的成功并非证明了它们在道德或智力上适合统治,而是证明了它们的冷酷无情和狡猾.&lt;/p&gt;
&lt;p&gt;尽管《动物农场》明确批判的是极权共产主义,但其关于权力动态的深层叙事,也含蓄地批判了社会达尔文主义的逻辑.在奥威尔的描绘中,这两种体系都导向了一个残酷的等级社会:一个自诩为&quot;更适应&quot;的精英阶层通过扭曲的意识形态来剥削大众.其最终状态是相同的:一个由&quot;丛林法则&quot;支配的社会.&lt;/p&gt;
&lt;p&gt;社会达尔文主义假定,&quot;适者&quot;在竞争性斗争中自然会脱颖而出,统治&quot;不适者&quot;.在《动物农场》中,最狡猾,最冷酷的猪登上了权力的顶峰,统治着其他动物,它们正是这个政治丛林中的&quot;适者&quot;.社会达尔文主义使用一种伪科学意识形态来为这种等级制度辩护,而猪则使用一种伪社会主义意识形态（不断被修改的&quot;动物主义&quot;七诫)来为它们的等级制度辩护.然而,其实际结果完全相同:统治精英（猪)剥削劳动阶级（其他动物),并占有他们劳动所创造的剩余价值.&lt;/p&gt;
&lt;p&gt;因此,奥威尔的小说揭示了一个令人警醒的现象:无论最初的意识形态是资本主义还是共产主义,一旦其潜在的运行原则退化为赤裸裸的权力斗争,其结果都将是一个按照&quot;粗俗达尔文主义&quot;原则运作的社会.小说展示了看似对立的政治体系在权力斗争的终极逻辑下,出现了可怕的趋同.&lt;/p&gt;
&lt;h3&gt;3.2 现实主义与全球&quot;自然状态&quot;&lt;/h3&gt;
&lt;p&gt;国际关系中的现实主义理论,是将霍布斯和社会达尔文主义的逻辑直接应用于国家间互动的典范.它将全球舞台视为终极的&quot;丛林&quot;,国家是其中相互竞争的野兽.&lt;/p&gt;
&lt;h4&gt;现实主义的核心信条&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;无政府状态&lt;/strong&gt;:现实主义认为,国际体系是无政府的,即不存在一个凌驾于主权国家之上的中央权威来执行规则.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;国家中心&lt;/strong&gt;:国家是国际关系中最主要,最理性的行为体,其行为动机是追求以权力界定的国家利益.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;自救与生存&lt;/strong&gt;:在无政府状态下,国家必须依靠自身力量来确保生存.因此,安全成为首要目标,这自然导致对军事力量的重视.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;人性根源（古典现实主义)&lt;/strong&gt;:汉斯·摩根索等思想家将这种权力斗争追溯到悲观的人性观,特别是对权力的贪欲（animus dominandi),这直接呼应了霍布斯的思想.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结构根源（新现实主义)&lt;/strong&gt;:肯尼思·沃尔兹则将冲突的根源从人性转向国际体系的无政府结构本身.他认为,无论国家的内部政治或文化如何,这种结构都迫使它们为权力而竞争.&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;现实主义作为全球规模的&quot;丛林法则&quot;&lt;/h4&gt;
&lt;p&gt;现实主义将世界政治视为一场持久的,零和的权力竞争.国家间的合作是困难且短暂的,因为各国都担心被背叛,并高度关注&quot;相对收益&quot;（即不仅关心&quot;我是否获益&quot;,更关心&quot;我是否比你获益更多&quot;).这导致了所谓的&quot;安全困境&quot;:一个国家为增强自身安全而采取的防御性措施（如扩充军备),会被其他国家视为威胁,从而引发对方的军备扩张,形成恶性循环的军备竞赛和持续的紧张状态.这完美地复现了霍布斯所描述的&quot;自然状态&quot;.&lt;/p&gt;
&lt;p&gt;现实主义并非将自己呈现为一种邪恶的意识形态,而是标榜为一种对世界本来面目的成熟,审慎和现实的回应,而非我们所希望的样子.这种修辞定位使其极难被批判.它将与之对立的观点（如自由主义)轻易地斥为天真和理想主义,这与社会达尔文主义将自己标榜为仅仅接受自然&quot;事实&quot;的方式如出一辙.这种自我定位形成了一种强大的修辞防御.任何冲突或背信弃义的事件都被视为现实主义理论的佐证;而任何合作的迹象则被贬低为不改变根本结构的暂时例外.&lt;/p&gt;
&lt;p&gt;这引出了对现实主义作为一种&quot;自我实现的预言&quot;的批判.如果决策者们相信世界是一个霍布斯式的丛林,他们就会以猜疑和侵略性的方式行事,从而创造出一个充满猜疑和侵略的世界,这反过来又&quot;证明&quot;了他们最初的信念.因此,现实主义（及其思想先驱)的真正力量,不仅在于其解释模型,更在于其自我封闭的逻辑和对务实与成熟制高点的占据,这有效地将其他视角边缘化了.&lt;/p&gt;
&lt;h3&gt;3.3 支配的心理画像:马基雅维利主义与竞争丛林信念&lt;/h3&gt;
&lt;p&gt;为了理解为何&quot;丛林法则&quot;意识形态对某些人具有如此大的吸引力,我们需要深入其心理层面,探究那些使个体易于接受这种世界观的人格特质和认知框架.&lt;/p&gt;
&lt;h4&gt;作为人格特质的马基雅维利主义&lt;/h4&gt;
&lt;p&gt;在心理学中,马基雅维利主义（Machiavellianism)并非指尼可罗·马基雅维利的政治哲学,而是&quot;黑暗三人格&quot;（Dark Triad)中的一种人格特质,与自恋和精神病态并列.其核心特征包括:善于操纵,情感冷漠,缺乏同情心,对道德漠不关心,以及对自身利益,权力和地位的精心算计.&quot;高马基雅维利主义者&quot;是战略性的长期规划者,他们将他人视为实现个人目标的工具.&lt;/p&gt;
&lt;h4&gt;竞争丛林信念（CJB)&lt;/h4&gt;
&lt;p&gt;竞争丛林信念（Competitive Jungle Belief, CJB)是一种世界观,也被称为&quot;朴素的社会达尔文主义&quot;.它将社会生活视为一个&quot;强者生存,弱者淘汰的残酷竞争丛林&quot;.其关键信念包括:认为资源是有限的（零和博弈),人性本自私且不诚实,唯一有效的行为方式是冷酷无情和工具化地对待他人.CJB作为一种&quot;合法化神话&quot;,为社会不平等和追求支配地位提供了认知上的合理化.它是预测个体社会支配倾向（Social Dominance Orientation, SDO)——即希望自己所在的群体支配其他群体的欲望——的有力指标.&lt;/p&gt;
&lt;h4&gt;&quot;社会达尔文主义者&quot;的心理画像&lt;/h4&gt;
&lt;p&gt;与人们通常认为的这类信念源于强者地位的假设相反,研究显示,持有高度CJB的个体表现出一种&quot;明显功能失调&quot;的心理特征.他们虽然渴望支配他人,但同时也表现出低自尊,低自我效能感以及在亲密关系中的恐惧型依恋风格.这种对支配地位的追求背后隐藏着一个悖论:一种看似属于强者的意识形态,其心理根源可能在于软弱,恐惧和不安全感.这从根本上重塑了我们对人们为何采纳这些观点的理解.他们之所以信奉&quot;丛林法则&quot;,不一定是因为他们是现实中的&quot;赢家&quot;,并试图为自己的成功辩护;而可能恰恰因为他们是内心深感恐惧的个体,将世界视为一个充满威胁的地方,并相信冷酷地追求权力是获得安全的唯一途径.&lt;/p&gt;
&lt;p&gt;这一发现具有深远意义.一个具有恐惧和不安全心理基础的个体,更有可能将社会世界感知为一个充满威胁的竞争丛林.采纳CJB世界观和马基雅维利主义策略,便成为一种应对机制——一种对抗他们所感知的敌意世界的先发制人的防御.对支配的渴望,实际上是对潜在脆弱感的一种补偿性策略.这意味着,要对抗这些意识形态,仅仅提供逻辑论证（如揭示自然主义谬误)可能是不够的.我们或许还需要处理那些使这种黯淡世界观变得有吸引力的潜在心理不安全感和恐惧.&lt;/p&gt;
&lt;h2&gt;第四部分:反叙事与合作的首要性&lt;/h2&gt;
&lt;p&gt;与将竞争视为人性核心的悲观论调相对,存在着一条同样古老而强大的思想传统,它强调合作与互助才是人类社会乃至整个生物界演化的关键驱动力.这一部分将集中探讨对&quot;丛林法则&quot;世界观的最有力反驳.&lt;/p&gt;
&lt;h3&gt;4.1 互助:演化的一个要素&lt;/h3&gt;
&lt;p&gt;俄国思想家彼得·克鲁泡特金的&quot;互助论&quot;,是针对社会达尔文主义最直接,最科学的驳斥.他认为,合作而非竞争,才是演化过程中的一个主要因素.&lt;/p&gt;
&lt;h4&gt;克鲁泡特金的论点&lt;/h4&gt;
&lt;p&gt;克鲁泡特金是一位博物学家和无政府主义哲学家,他在其1902年的著作《互助论:演化的一个要素》中,直接挑战了社会达尔文主义对竞争的过分强调.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;来自自然的证据&lt;/strong&gt;:基于他在西伯利亚的实地考察,克鲁泡特金得出结论,生物所面临的首要&quot;生存斗争&quot;,并非同类个体之间的斗争,而是物种作为一个整体对抗严酷自然环境的集体斗争.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;合作作为自然法则&lt;/strong&gt;:他认为,合作与&quot;互助&quot;同相互斗争一样,都是&quot;自然法则&quot;.社会性为物种的生存提供了巨大的实际优势,并因此受到自然选择的青睐.他列举了大量来自生物界（如候鸟迁徙)和人类社会（如中世纪的行会,村社)的例子来支持自己的观点.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;科学遗产&lt;/strong&gt;:克鲁泡特金的著作被视为现代生物学中利他主义,亲缘选择和共生理论的先驱.著名生物学家斯蒂芬·杰·古尔德也指出,如果合作能够增加个体存活率,那么它不仅不被自然选择排除,反而会受到鼓励.&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;互助论 vs. 社会达尔文主义&lt;/h4&gt;
&lt;p&gt;克鲁泡特金的理论提供了一个与社会达尔文主义截然相反的视角.社会达尔文主义看到的是一个充满个体竞争的世界,而克鲁泡特金则揭示了一个以集体行动为生存和繁荣关键的世界.他的理论为一种替代性的政治哲学——无政府共产主义——提供了科学基础,该哲学认为,社会秩序可以从合作的本能中自然产生,而无需强制性的国家机器.这直接对抗了霍布斯和荀子所代表的外部强制模型.&lt;/p&gt;
&lt;p&gt;克鲁泡特金的工作迫使我们从根本上重新定义&quot;适应性&quot;（fitness).社会达尔文主义狭隘地将&quot;适应性&quot;等同于个体在竞争中的支配地位.而克鲁泡特金的视角则将这一定义拓宽,将合作能力,建立社会纽带和参与相互支持的能力也包含在内.在许多环境中,&quot;最适应的&quot;可能不是最强壮的个体,而是最善于合作的群体.这一观点彻底颠覆了社会达尔文主义为冷酷个人主义所做的辩护.如果合作也是演化的产物,是生存的关键,那么建立一个合作,平等的社会就不是&quot;违背自然&quot;,而恰恰是表达了我们演化本性中另一个同样根本的方面.&lt;/p&gt;
&lt;h3&gt;4.2 超越二元对立:作为可塑潜能的人性&lt;/h3&gt;
&lt;p&gt;从孟荀之辩到社会达尔文主义与互助论的对峙,关于人性的讨论常常被框定在一个简单的二元对立中:我们天生是善/合作的,还是恶/竞争的?然而,综合所有证据来看,这或许是一个错误的问题.&lt;/p&gt;
&lt;p&gt;一个更准确的观点是,人性是一系列潜能或倾向的集合.我们既有自私和利他的能力,也有竞争和合作的能力.哪一种潜能会占据主导地位,在很大程度上取决于我们所处的环境——包括物质条件,社会结构,以及至关重要的,我们用来描述我们是谁的故事.&lt;/p&gt;
&lt;p&gt;一个围绕稀缺资源和零和博弈构建的社会,一个不断向其成员灌输&quot;生活是一场残酷丛林&quot;观念的社会,很可能会塑造出行为相应的个体.这正是对现实主义和社会达尔文主义&quot;自我实现的预言&quot;的批判所在.相反,一个围绕相互依存和共同目标构建的社会,一个告诉其成员合作是成功关键的社会,则会培育我们的合作潜能.&lt;/p&gt;
&lt;h2&gt;结论&lt;/h2&gt;
&lt;p&gt;&quot;丛林法则&quot;并非对一个不可避免的人类现实的客观描述.它是一种选择,是众多叙事中的一种.它是一种服务于特定利益的意识形态,在特定的历史条件下兴起,旨在为一个特定的社会秩序辩护.它的变体,如社会达尔文主义,通过挪用科学语言,犯下了将&quot;是&quot;等同于&quot;应该&quot;的自然主义谬误,从而将一种价值判断伪装成自然法则.&lt;/p&gt;
&lt;p&gt;从奥威尔的文学寓言到国际关系的现实主义理论,再到马基雅维利主义的心理画像,这种将人类互动简化为权力斗争的悲观世界观,在现代社会中依然具有强大的影响力.然而,正如克鲁泡特金的互助论所揭示的,合作同样是深刻根植于我们生物本性中的一种力量.&lt;/p&gt;
&lt;p&gt;人性并非一个固定的善恶构造,而是一个充满各种可能性的动态过程.我们既有竞争的倾向,也有合作的本能.最终,社会的形态和个体的行为,取决于我们选择放大哪一种倾向,以及我们围绕哪一种叙事来构建我们的制度和文化.&lt;/p&gt;
&lt;p&gt;认识到&quot;丛林法则&quot;是一种被建构的意识形态,而非不可改变的自然法则,赋予了我们选择其他叙事——例如互助的叙事——并建立能够培育我们合作能力而非冲突倾向的社会结构的力量.这不仅是一个哲学上的辨析,更是一个关乎我们共同未来的实践性抉择.&lt;/p&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>建站: Banner组件</title><link>https://8cat.life/blog/yex1</link><guid isPermaLink="true">https://8cat.life/blog/yex1</guid><description>如何使用通用的 Banner 组件来创建页面标题区域</description><pubDate>Fri, 17 Oct 2025 19:45:00 GMT</pubDate><content:encoded>&lt;p&gt;import { MdxRepl, Aside } from &apos;@/custom/components/user&apos;;
import Banner from &apos;@/components/banner/Banner.astro&apos;;
import { Icon } from &apos;@/custom/components/user&apos;;
import bannerImage from &apos;@/assets/cats/banner.png&apos;;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Banner&lt;/code&gt; 是一个通用的页面横幅组件,用于快速创建一个包含左侧内容和右侧图片的标题区域.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Banner&lt;/code&gt; 组件的核心是它的默认插槽. 您可以在组件标签内放置任何有效的 HTML 或 Astro 组件,它们将被渲染在 Banner 的左侧区域. 这通过 Astro 的 &lt;code&gt;slot&lt;/code&gt; (插槽) 特性提供了极高的灵活性.&lt;/p&gt;
&lt;h3&gt;基础用法&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;Banner&lt;/code&gt; 组件接收两个主要属性:&lt;code&gt;image&lt;/code&gt; 和 &lt;code&gt;imageAlt&lt;/code&gt;.您需要将想要在左侧显示的任何内容放置在 &lt;code&gt;&amp;#x3C;Banner&gt;&lt;/code&gt; 和 &lt;code&gt;&amp;#x3C;/Banner&gt;&lt;/code&gt; 标签之间.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#x3C;Banner image={bannerImage} imageAlt=&quot;示例图片&quot;&gt;
  &amp;#x3C;div class=&quot;flex items-center gap-3&quot;&gt;
    &amp;#x3C;Icon name=&quot;book&quot; class=&quot;size-8&quot; /&gt;
    &amp;#x3C;h2 class=&quot;text-3xl font-bold&quot;&gt;这是主标题&amp;#x3C;/h2&gt;
  &amp;#x3C;/div&gt;
  &amp;#x3C;p class=&quot;border-l-2 border-border pl-3 text-muted-foreground mt-2&quot;&gt;
    这是副标题,您可以在这里写一些描述性文字.
  &amp;#x3C;/p&gt;
&amp;#x3C;/Banner&gt;
```
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;MDX 用法&lt;/h3&gt;
&lt;p&gt;在 &lt;code&gt;.mdx&lt;/code&gt; 文件中使用时,您可以直接在插槽中编写 Markdown,如下所示:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;{/* 显然这里不适合有太多的太复杂的内容 */}
&amp;#x3C;Banner image={bannerImage} imageAlt=&quot;MDX Example Image&quot;&gt;
  &gt; This is a Markdown Title

&amp;#x3C;/Banner&gt;
```
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;组件属性 (Props)&lt;/h3&gt;
&lt;p&gt;| 属性 | 类型 | 是否必需 | 描述 |
|---|---|---|---|
| &lt;code&gt;image&lt;/code&gt; | &lt;code&gt;ImageMetadata&lt;/code&gt; | 是 | 用于右侧展示的图片资源, 需要从 &lt;code&gt;src&lt;/code&gt; 目录导入. |
| &lt;code&gt;imageAlt&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | 是 | 图片的替代文本. |
| &lt;code&gt;class&lt;/code&gt; | &lt;code&gt;string&lt;/code&gt; | 否 | 为组件根元素添加额外的 CSS 类. |
| &lt;code&gt;loading&lt;/code&gt; | &lt;code&gt;&apos;lazy&apos; \| &apos;eager&apos;&lt;/code&gt; | 否 | 图片的加载策略,对于首屏的 Banner,推荐设置为 &lt;code&gt;eager&lt;/code&gt;. |&lt;/p&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>建站: Badge组件</title><link>https://8cat.life/blog/z3iy</link><guid isPermaLink="true">https://8cat.life/blog/z3iy</guid><description>一个关于 Badge 组件的详细用法和示例的文档，演示了如何通过 MDX 直接使用该组件。</description><pubDate>Mon, 15 Sep 2025 16:18:26 GMT</pubDate><content:encoded>&lt;p&gt;import MdxRepl from &apos;@/custom/components/user/MdxRepl.astro&apos;
import Badge from &apos;@/components/Badge.astro&apos;
import avatar from &apos;/src/assets/avatar.jpeg&apos;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Badge&lt;/code&gt; 是一个灵活的组件，用于显示各种徽章。在 MDX 中，你可以直接调用该组件并传入 &lt;code&gt;item&lt;/code&gt; 属性来渲染徽章。&lt;/p&gt;
&lt;h2&gt;1. 纯文本徽章&lt;/h2&gt;
&lt;p&gt;最简单的徽章类型，只有一个 &lt;code&gt;key&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;&amp;#x3C;Badge item={{ key: &apos;Featured&apos;, color: &apos;#ea9a45ff&apos; }} /&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#x3C;/Fragment&gt;
&amp;#x3C;/MdxRepl&gt;

## 2. 键值对徽章 (文本)

包含 `key` 和 `value` 的文本徽章。

&amp;#x3C;MdxRepl&gt;
&amp;#x3C;Badge item={{ key: &apos;Author&apos;, value: &apos;Felix&apos; }} /&gt;
&amp;#x3C;Fragment slot=&apos;desc&apos;&gt;
````jsx
import Badge from &apos;@/components/Badge.astro&apos;;

&amp;#x3C;Badge item={{ key: &apos;Author&apos;, value: &apos;Felix&apos; }} /&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;自定义颜色&lt;/h3&gt;
&lt;p&gt;你可以通过 &lt;code&gt;color&lt;/code&gt; 字段覆盖 &lt;code&gt;key&lt;/code&gt; 部分的默认背景色。颜色值可以是任何有效的 CSS 颜色。&lt;/p&gt;
&lt;p&gt;&amp;#x3C;Badge item={{ key: &apos;Author&apos;, value: &apos;Felix&apos;, color: &apos;gray&apos; }} /&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#x3C;/Fragment&gt;
&amp;#x3C;/MdxRepl&gt;

## 3. 图标徽章

徽章可以包含一个图标作为 `key`。

### 3.1. 只有图标的徽章

&amp;#x3C;MdxRepl&gt;
&amp;#x3C;Badge item={{ key: { icon: &apos;github&apos; } }} /&gt;
&amp;#x3C;Fragment slot=&apos;desc&apos;&gt;
````jsx
import Badge from &apos;@/components/Badge.astro&apos;;

&amp;#x3C;Badge item={{ key: { icon: &apos;github&apos; } }} /&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;3.2. 图标 + 文本值的徽章&lt;/h3&gt;
&lt;p&gt;&amp;#x3C;Badge item={{ key: { icon: &apos;deep_seek&apos; }, value: &apos;AI Assistant&apos; }} /&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#x3C;/Fragment&gt;
&amp;#x3C;/MdxRepl&gt;

## 4. 图片徽章

徽章也可以使用图片作为 `key`。

### 4.1. 只有图片的徽章

&amp;#x3C;MdxRepl&gt;
&amp;#x3C;Badge item={{ key: { image: avatar } }} /&gt;
&amp;#x3C;Fragment slot=&apos;desc&apos;&gt;
````jsx
import Badge from &apos;@/components/Badge.astro&apos;;
import avatar from &apos;/src/assets/avatar.jpeg&apos;;

&amp;#x3C;Badge item={{ key: { image: avatar } }} /&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;4.2. 图片 + 文本值的徽章&lt;/h3&gt;
&lt;p&gt;&amp;#x3C;Badge item={{ key: { image: avatar }, value: &apos;CatCodeMe&apos; }} /&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#x3C;/Fragment&gt;
&amp;#x3C;/MdxRepl&gt;

---

**注意:**
- 在 MDX 文件中直接使用 `&amp;#x3C;Badge&gt;` 组件时，`icon` 的值必须是系统中已定义的图标名称。
- `image` 的值是图片的路径。为了确保图片能正确显示和被 Astro 的构建流程优化，**必须**在 MDX 文件顶部导入图片资源，然后将导入的图片对象直接传递给组件。
&lt;/code&gt;&lt;/pre&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>建站: Custom &lt;AdvanceStep&gt; Component Guide</title><link>https://8cat.life/blog/p1jz</link><guid isPermaLink="true">https://8cat.life/blog/p1jz</guid><description>A comprehensive guide and documentation for the AdvanceStep component.</description><pubDate>Thu, 28 Aug 2025 17:31:03 GMT</pubDate><content:encoded>&lt;p&gt;import MdxRepl from &apos;@/custom/components/user/MdxRepl.astro&apos;
import Aside from &apos;@/custom/components/user/Aside.astro&apos;
import AdvanceStep from &apos;@/components/AdvanceStep.astro&apos;;&lt;/p&gt;
&lt;p&gt;The &lt;code&gt;AdvanceStep&lt;/code&gt; component is a powerful tool for creating beautifully rendered, step-by-step guides. It&apos;s a more advanced alternative to the standard &lt;code&gt;Steps&lt;/code&gt; component, offering several ways to automatically structure your content.&lt;/p&gt;
&lt;h2&gt;Core Concept&lt;/h2&gt;
&lt;p&gt;Unlike the basic &lt;code&gt;&amp;#x3C;Steps&gt;&lt;/code&gt; component which requires you to manually write an ordered list, &lt;code&gt;&amp;#x3C;AdvanceStep&gt;&lt;/code&gt; intelligently processes its content based on a mandatory &lt;code&gt;split&lt;/code&gt; property. This property tells the component how to identify and separate each step.&lt;/p&gt;
&lt;p&gt;The &lt;code&gt;split&lt;/code&gt; prop is required and can have one of the following values:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;&apos;ol&apos;&lt;/code&gt;: For styling a standard Markdown ordered list (&lt;code&gt;1.&lt;/code&gt;, &lt;code&gt;2.&lt;/code&gt;, ...).&lt;/li&gt;
&lt;li&gt;&lt;code&gt;&apos;h2&apos;&lt;/code&gt;: Uses Level 2 headings (&lt;code&gt;##&lt;/code&gt;) as step separators.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;&apos;h3&apos;&lt;/code&gt;: Uses Level 3 headings (&lt;code&gt;###&lt;/code&gt;) as step separators.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;&apos;h4&apos;&lt;/code&gt;: Uses Level 4 headings (&lt;code&gt;####&lt;/code&gt;) as step separators.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;&apos;hr&apos;&lt;/code&gt;: Uses horizontal rules (&lt;code&gt;---&lt;/code&gt;) as step separators.&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;h2&gt;Usage by &lt;code&gt;split=&quot;ol&quot;&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;This is the most flexible mode. Use it when you want to style a standard Markdown ordered list. It fully supports complex nested content within each step, including other components.&lt;/p&gt;
&lt;hr&gt;
&lt;h2&gt;Usage by Headings (&lt;code&gt;h2&lt;/code&gt;, &lt;code&gt;h3&lt;/code&gt;, &lt;code&gt;h4&lt;/code&gt;)&lt;/h2&gt;
&lt;p&gt;Use a heading-based split when each of your steps has a clear title. The component will use the specified heading level to separate the steps. Any other heading levels will be treated as regular content.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;### Sub-heading (not a step)
This H3 is just part of Step 1.

## Step 2: Install and Run
Now you can install dependencies and start the project.
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;### Sub-heading (not a step)
This H3 is just part of Step 1.

## Step 2: Install and Run
Now you can install dependencies and start the project.
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h2&gt;Usage by Horizontal Rule (&lt;code&gt;hr&lt;/code&gt;)&lt;/h2&gt;
&lt;p&gt;This mode is perfect for simple steps that don&apos;t require titles. Just separate your content blocks with a horizontal rule (&lt;code&gt;---&lt;/code&gt;).&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;---

Second, do the next thing. You can include code blocks or other elements.
```js
console.log(&quot;Hello, Step 2!&quot;);
```

---

Finally, you are done.
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;---

Second, do the next thing. You can include code blocks or other elements.
```js
console.log(&quot;Hello, Step 2!&quot;);
```
---

Finally, you are done.
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h2&gt;Fallback Behavior&lt;/h2&gt;
&lt;p&gt;If you specify a &lt;code&gt;split&lt;/code&gt; separator that is not found in the content, the component will gracefully render all the content as a single step.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;### Therefore...
All of it, including this H3 heading, will be grouped into a single Step 1.
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;### Therefore...
All of it, including this H3 heading, will be grouped into a single Step 1.
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h2&gt;Nesting Steps&lt;/h2&gt;
&lt;p&gt;You can nest &lt;code&gt;AdvanceStep&lt;/code&gt; components to create complex, multi-level procedures. This works best when the outer component uses &lt;code&gt;split=&quot;ol&quot;&lt;/code&gt;, as this gives you explicit control over the list items (&lt;code&gt;&amp;#x3C;li&gt;&lt;/code&gt;) where you can place a nested component.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;2. **Main Step Two (with Sub-steps)**
   This step contains a nested procedure.
   &amp;#x3C;AdvanceStep split=&quot;h3&quot;&gt;
     ### Sub-step A
     This is the first sub-step, separated by an H3 heading.

     ### Sub-step B
     This is the second sub-step.
   &amp;#x3C;/AdvanceStep&gt;

3. **Main Step Three**
   This is the final primary step.
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;2. **Main Step Two (with Sub-steps)**
   This step contains a nested procedure.
   
   &amp;#x3C;AdvanceStep split=&quot;h3&quot;&gt;
     ### Sub-step A
     This is the first sub-step, separated by an H3 heading.

     ### Sub-step B
     This is the second sub-step.
   &amp;#x3C;/AdvanceStep&gt;

3. **Main Step Three**
   This is the final primary step.
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;2. **Main Step Two (with Sub-steps)**
   This step contains a nested procedure.
   
   &amp;#x3C;AdvanceStep split=&quot;h3&quot;&gt;
     ### Sub-step A
     This is the first sub-step, separated by an H3 heading.
     ```js
        console.log(&quot;Hello, Step 2!&quot;);
     ```

     ### Sub-step B
     This is the second sub-step.
   &amp;#x3C;/AdvanceStep&gt;

3. **Main Step Three**
   This is the final primary step.
&lt;/code&gt;&lt;/pre&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>建站: enhanced &lt;Aside&gt; Component</title><link>https://8cat.life/blog/5pob</link><guid isPermaLink="true">https://8cat.life/blog/5pob</guid><description>A showcase of the &lt;Aside&gt; component, demonstrating its various types, styles, and customization options.</description><pubDate>Wed, 20 Aug 2025 15:10:53 GMT</pubDate><content:encoded>&lt;p&gt;import Aside from &apos;@/custom/components/user/Aside.astro&apos;
import MdxRepl from &apos;@/custom/components/user/MdxRepl.astro&apos;&lt;/p&gt;
&lt;p&gt;本页面展示了 &lt;code&gt;&amp;#x3C;Aside&gt;&lt;/code&gt; 组件的各种用法。&lt;/p&gt;
&lt;h2&gt;1. 标准卡片类型 (Standard Card Types)&lt;/h2&gt;
&lt;h3&gt;1.1. 注意 (Note)&lt;/h3&gt;
&lt;h3&gt;1.2. 信息 (Info)&lt;/h3&gt;
&lt;h3&gt;1.3. 提示 (Tip)&lt;/h3&gt;
&lt;h3&gt;1.4. 警告 (Warning)&lt;/h3&gt;
&lt;h3&gt;1.5. 警示 (Caution)&lt;/h3&gt;
&lt;h3&gt;1.6. 重要 (Important)&lt;/h3&gt;
&lt;h3&gt;1.7. 引用 (Quote)&lt;/h3&gt;
&lt;h2&gt;2. 属性使用示例 (Attribute Usage Examples)&lt;/h2&gt;
&lt;h3&gt;2.1. 可折叠 (Collapsible)&lt;/h3&gt;
&lt;h3&gt;2.2. 自定义图标与标题 (Custom Icons &amp;#x26; Titles)&lt;/h3&gt;
&lt;h4&gt;2.2.1. Emoji 图标&lt;/h4&gt;
&lt;h4&gt;2.2.2. 具名图标&lt;/h4&gt;
&lt;h3&gt;2.3. 极简样式 (Minimalist Styles)&lt;/h3&gt;
&lt;h4&gt;2.3.1. 无类型徽章&lt;/h4&gt;
&lt;h4&gt;2.3.2. 无标题仅徽章&lt;/h4&gt;
&lt;h4&gt;2.3.2. 无标题无徽章&lt;/h4&gt;
&lt;h3&gt;2.4. 嵌套 Aside (Nested Asides)&lt;/h3&gt;
&lt;h3&gt;2.5. 实心样式示例 (Solid Style Examples)&lt;/h3&gt;
&lt;h4&gt;2.5.1. 实心注意&lt;/h4&gt;
&lt;h4&gt;2.5.2. 实心警告 (可折叠)&lt;/h4&gt;
&lt;h2&gt;3. 具名插槽解析行为 (Named Slot Parsing Behavior)&lt;/h2&gt;
&lt;h3&gt;3.1. 空行问题 (Empty Line Issue)&lt;/h3&gt;
&lt;p&gt;当您使用具名插槽（例如 &lt;code&gt;&amp;#x3C;span slot=&quot;title&quot;&gt;...&amp;#x3C;/span&gt;&lt;/code&gt;）并且其后紧跟着一行普通文本而&lt;strong&gt;没有&lt;/strong&gt;空行时，MDX 解析器可能会错误地将插槽内容解释为组件默认内容的一部分，从而不会出现在组件的指定位置（例如，Aside 组件的标题栏）。&lt;/p&gt;
&lt;h4&gt;3.1.1. 问题用法&lt;/h4&gt;
&lt;p&gt;这段普通文本紧随插槽内容。&lt;/p&gt;
&lt;h4&gt;3.1.2. 带空行的正确用法&lt;/h4&gt;
&lt;p&gt;在具名插槽内容后添加一个空行，有助于 MDX 解析器正确识别具名插槽，确保其内容出现在组件的指定插槽区域。
&lt;/p&gt;
&lt;p&gt;这段普通文本与插槽内容之间有一个空行。&lt;/p&gt;
&lt;p&gt;这段普通文本与插槽内容之间有一个空行。&lt;/p&gt;
&lt;h3&gt;3.2. 块级内容后的正确用法 (Correct Usage with Block-Level Content)&lt;/h3&gt;
&lt;p&gt;当具名插槽后跟一个块级元素（例如代码块或 MDX 标题）时，即使没有空行，具名插槽通常也会被正确解析，因为块级元素提供了清晰的边界。&lt;/p&gt;
&lt;h4&gt;3.2.1. 代码块后&lt;/h4&gt;
&lt;h4&gt;3.2.2. MDX 标题后&lt;/h4&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>建站:  &lt;Figure&gt; 图片 Component</title><link>https://8cat.life/blog/zx7r</link><guid isPermaLink="true">https://8cat.life/blog/zx7r</guid><pubDate>Tue, 19 Aug 2025 16:58:21 GMT</pubDate><content:encoded>&lt;p&gt;Write your content here.&lt;/p&gt;
&lt;h2&gt;测试 Figure 组件&lt;/h2&gt;
&lt;p&gt;下面是新创建的 &lt;code&gt;Figure&lt;/code&gt; 组件的所有布局演示，已更新为最新用法。&lt;/p&gt;
&lt;p&gt;import Figure from &apos;@/components/Figure.astro&apos;;
import testImage from &apos;public/images/social-card.png&apos;;&lt;/p&gt;
&lt;h3&gt;默认布局 (支持缩放和Markdown图注)&lt;/h3&gt;
&lt;h3&gt;文字居左在下方&lt;/h3&gt;
&lt;h3&gt;文字居右在下方&lt;/h3&gt;
&lt;h3&gt;图左文右&lt;/h3&gt;
&lt;h3&gt;图右文左&lt;/h3&gt;
&lt;h3&gt;悬浮显示文字 (支持缩放)&lt;/h3&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>位运算技巧整理</title><link>https://8cat.life/blog/test</link><guid isPermaLink="true">https://8cat.life/blog/test</guid><description>位运算技巧java实现</description><pubDate>Wed, 13 Aug 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;import Aside from &apos;@/custom/components/user/Aside.astro&apos;&lt;/p&gt;
&lt;p&gt;import LinkPreview from &apos;@/custom/components/advanced/LinkPreview.astro&apos;
import TabItem from &apos;@/custom/components/user/TabItem.astro&apos;
import Tabs from &apos;@/custom/components/user/Tabs.astro&apos;
import Collapse from &apos;@/custom/components/user/Collapse.astro&apos;&lt;/p&gt;
&lt;h2&gt;1. 计算整数的符号&lt;/h2&gt;
&lt;h2&gt;2. 检测两个整数的符号是否相反&lt;/h2&gt;
&lt;h2&gt;3. 无分支计算整数绝对值&lt;/h2&gt;
&lt;h2&gt;4. 无分支计算最小值和最大值&lt;/h2&gt;
&lt;p&gt;public static int maxWithoutBranch(int x, int y) {
return x ^ ((x ^ y) &amp;#x26; ((x - y) &gt;&gt; 31));
}&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#x3C;/TabItem&gt;
&amp;#x3C;TabItem label=&quot;测试用例&quot;&gt;
```java  showLineNumbers
@Test
@DisplayName(&quot;4. 无分支计算最小值和最大值&quot;)
void testMinMaxWithoutBranch() {
    assertEquals(5, BitHacks.minWithoutBranch(5, 10));
    assertEquals(5, BitHacks.minWithoutBranch(10, 5));
    assertEquals(-10, BitHacks.minWithoutBranch(-5, -10));
    assertEquals(-5, BitHacks.maxWithoutBranch(-5, -10));
    assertEquals(10, BitHacks.maxWithoutBranch(5, 10));
    assertEquals(10, BitHacks.maxWithoutBranch(10, 5));
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;5. 判断一个整数是否是2的幂&lt;/h2&gt;
&lt;h2&gt;6. 符号扩展&lt;/h2&gt;
&lt;h2&gt;7. 无分支地条件性设置或清除位&lt;/h2&gt;
&lt;h2&gt;8. 无分支地条件性取反一个值&lt;/h2&gt;
&lt;h2&gt;9. 根据掩码合并两个值的位&lt;/h2&gt;
&lt;h2&gt;10. 计算置位数 (Kernighan)&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;// 测试1的置位数（二进制0001）
assertEquals(1, BitHacks.countSetBits(1));

// 测试8的置位数（二进制1000）
assertEquals(1, BitHacks.countSetBits(8));

// 测试9的置位数（二进制1001）
assertEquals(2, BitHacks.countSetBits(9));

// 测试Integer.MAX_VALUE的置位数（二进制011...1，共31个1）
assertEquals(31, BitHacks.countSetBits(Integer.MAX_VALUE));

// 测试-1的置位数（二进制全1，共32个1）
assertEquals(32, BitHacks.countSetBits(-1));
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;}&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#x3C;/TabItem&gt;
&amp;#x3C;TabItem label=&quot;jdk实现&quot;&gt;
```java
Integer.bitCount(v)
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;11. 并行计算置位数&lt;/h2&gt;
&lt;p&gt;让我们一步步分解 &lt;code&gt;countSetBitsParallel&lt;/code&gt; 这个函数，看看“并行”体现在哪里：&lt;/p&gt;
&lt;p&gt;假设我们的输入 &lt;code&gt;v&lt;/code&gt; 是一个32位的整数。&lt;/p&gt;
&lt;hr&gt;
&lt;h3&gt;&lt;strong&gt;第一步：并行计算每 2 个比特位的和&lt;/strong&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-java&quot;&gt;v = v - ((v &gt;&gt;&gt; 1) &amp;#x26; 0x55555555);
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;0x55555555&lt;/code&gt; 的二进制是 &lt;code&gt;01010101...&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;v &gt;&gt;&gt; 1&lt;/code&gt; 将 &lt;code&gt;v&lt;/code&gt; 右移一位。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;&amp;#x26; 0x55555555&lt;/code&gt; 会提取出 &lt;code&gt;v&lt;/code&gt; 中所有奇数位上的原始值。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;v - ...&lt;/code&gt; 这一步非常巧妙。它在&lt;strong&gt;一次操作&lt;/strong&gt;中，&lt;strong&gt;同时&lt;/strong&gt;对所有16个“2位组”进行了求和。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;举例说明一个2位组 &lt;code&gt;b1 b0&lt;/code&gt;：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;如果 &lt;code&gt;v&lt;/code&gt; 的这个组是 &lt;code&gt;11&lt;/code&gt; (3)，操作是 &lt;code&gt;(11) - (01) = 10&lt;/code&gt; (2)。结果 &lt;code&gt;10&lt;/code&gt; 正是 &lt;code&gt;1+1&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;如果 &lt;code&gt;v&lt;/code&gt; 的这个组是 &lt;code&gt;10&lt;/code&gt; (2)，操作是 &lt;code&gt;(10) - (01) = 01&lt;/code&gt; (1)。结果 &lt;code&gt;01&lt;/code&gt; 正是 &lt;code&gt;1+0&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;如果 &lt;code&gt;v&lt;/code&gt; 的这个组是 &lt;code&gt;01&lt;/code&gt; (1)，操作是 &lt;code&gt;(01) - (00) = 01&lt;/code&gt; (1)。结果 &lt;code&gt;01&lt;/code&gt; 正是 &lt;code&gt;0+1&lt;/code&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;执行完这行代码后，&lt;code&gt;v&lt;/code&gt; 的每个2位组都存储了原始值在该2位组中 &lt;code&gt;1&lt;/code&gt; 的数量。这个计算是&lt;strong&gt;并行&lt;/strong&gt;发生在所有16个2位组上的。&lt;/p&gt;
&lt;hr&gt;
&lt;h3&gt;&lt;strong&gt;第二步：并行计算每 4 个比特位的和&lt;/strong&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-java&quot;&gt;v = (v &amp;#x26; 0x33333333) + ((v &gt;&gt;&gt; 2) &amp;#x26; 0x33333333);
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;0x33333333&lt;/code&gt; 的二进制是 &lt;code&gt;00110011...&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;(v &amp;#x26; 0x33333333)&lt;/code&gt; 提取出上一步计算出的、位于低位的2位组的和。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;((v &gt;&gt;&gt; 2) &amp;#x26; 0x33333333)&lt;/code&gt; 提取出上一步计算出的、位于高位的2位组的和。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;+&lt;/code&gt; 将它们相加。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;现在，&lt;code&gt;v&lt;/code&gt; 的每个4位组都存储了原始值在该4位组中 &lt;code&gt;1&lt;/code&gt; 的数量。这个加法&lt;strong&gt;并行&lt;/strong&gt;发生在所有8个4位组上。&lt;/p&gt;
&lt;hr&gt;
&lt;h3&gt;&lt;strong&gt;第三步：并行计算每 8 位的和，并得出最终结果&lt;/strong&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-java&quot;&gt;return (((v + (v &gt;&gt;&gt; 4)) &amp;#x26; 0x0F0F0F0F) * 0x01010101) &gt;&gt;&gt; 24;
&lt;/code&gt;&lt;/pre&gt;
&lt;ol&gt;
&lt;li&gt;&lt;code&gt;(v + (v &gt;&gt;&gt; 4)) &amp;#x26; 0x0F0F0F0F&lt;/code&gt;：这一步将4位组的和相加，得到8位组（即一个字节）的和。现在，&lt;code&gt;v&lt;/code&gt; 的4个字节分别存储了原始值对应字节中 &lt;code&gt;1&lt;/code&gt; 的数量。例如，如果 &lt;code&gt;v&lt;/code&gt; 原始值是 &lt;code&gt;0x12345678&lt;/code&gt;，经过这几步后，&lt;code&gt;v&lt;/code&gt; 的4个字节可能变成了 &lt;code&gt;[count(0x12), count(0x34), count(0x56), count(0x78)]&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;* 0x01010101&lt;/code&gt;：这是最神奇的一步。这个乘法利用了进位，&lt;strong&gt;并行地&lt;/strong&gt;将4个字节的和累加到了最高的那个字节中。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;&gt;&gt;&gt; 24&lt;/code&gt;：最后，将包含了总和的最高字节移到最低位，作为最终结果返回。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;&lt;strong&gt;总结&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;与逐位检查的循环方法（比如 Kernighan 算法）不同，这个“并行”算法的每一步都是在&lt;code&gt;整个32位整数&lt;/code&gt;上操作，&lt;code&gt;同时&lt;/code&gt;处理多个独立的比特组。它用固定的、少量的几步就完成了计算，没有任何循环和分支，因此效率非常高。这就是其“并行”的精髓所在。&lt;/p&gt;
&lt;h2&gt;12. 并行计算奇偶校验位&lt;/h2&gt;
&lt;h2&gt;13. 通过异或(XOR)交换两个整数的值&lt;/h2&gt;
&lt;h2&gt;14. 通过异或(XOR)交换一个整数内部的两个位序列&lt;/h2&gt;
&lt;h2&gt;15. 并行反转一个32位整数的所有位&lt;/h2&gt;
&lt;h2&gt;16. 计算 n % d, 其中 d = 2^s - 1&lt;/h2&gt;
&lt;h2&gt;17. 使用 De Bruijn 序列计算log₂&lt;/h2&gt;
&lt;hr&gt;
&lt;h3&gt;&lt;strong&gt;2. &lt;code&gt;31 - Integer.numberOfLeadingZeros(v)&lt;/code&gt; 的原理&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;Integer.numberOfLeadingZeros(v)&lt;/code&gt; 返回 &lt;code&gt;v&lt;/code&gt; 的二进制表示中 &lt;strong&gt;前导 0 的个数&lt;/strong&gt;：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;例如：
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;v = 8 (000...0001000₂)&lt;/code&gt; → &lt;code&gt;numberOfLeadingZeros(8) = 28&lt;/code&gt;（32位整型，前 28 位是 0）&lt;/li&gt;
&lt;li&gt;&lt;code&gt;v = 5 (000...0000101₂)&lt;/code&gt; → &lt;code&gt;numberOfLeadingZeros(5) = 29&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;因此：&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-java&quot;&gt;31 - numberOfLeadingZeros(v)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;计算的是：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;32 - 1 - numberOfLeadingZeros(v)&lt;/code&gt;（因为 &lt;code&gt;log₂(v)&lt;/code&gt; 的范围是 &lt;code&gt;0..31&lt;/code&gt;）&lt;/li&gt;
&lt;li&gt;即 &lt;code&gt;v&lt;/code&gt; 的最高有效位的位置（从 0 开始计数）。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;v = 8 (1000₂)&lt;/code&gt;：
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;numberOfLeadingZeros(8) = 28&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;31 - 28 = 3&lt;/code&gt;（正确，因为 &lt;code&gt;2³ = 8&lt;/code&gt;）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;code&gt;v = 5 (0101₂)&lt;/code&gt;：
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;numberOfLeadingZeros(5) = 29&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;31 - 29 = 2&lt;/code&gt;（正确，因为 &lt;code&gt;2² = 4 ≤ 5&lt;/code&gt;）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;h3&gt;&lt;strong&gt;3. &lt;code&gt;log2WithDeBruijn(v)&lt;/code&gt; 的原理&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;import Steps from &apos;@/custom/components/user/Steps.astro&apos;
import Timeline from &apos;@/custom/components/user/Timeline.astro&apos;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;步骤 1：&lt;code&gt;v |= v &gt;&gt;&gt; 1 | v &gt;&gt;&gt; 2 | ... | v &gt;&gt;&gt; 16&lt;/code&gt;&lt;/strong&gt;
这段代码的目的是 &lt;strong&gt;将 &lt;code&gt;v&lt;/code&gt; 的最高有效位（MSB）以下的所有低位全部置 1&lt;/strong&gt;：&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;例如：
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;v = 5 (0101₂)&lt;/code&gt; → 经过 &lt;code&gt;v |= v &gt;&gt;&gt; 1&lt;/code&gt; → &lt;code&gt;0101 | 0010 = 0111&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;v = 8 (1000₂)&lt;/code&gt; → 经过 &lt;code&gt;v |= v &gt;&gt;&gt; 1&lt;/code&gt; → &lt;code&gt;1000 | 0100 = 1100&lt;/code&gt;，然后 &lt;code&gt;1100 | 0011 = 1111&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;最终 &lt;code&gt;v&lt;/code&gt; 会变成一个形如 &lt;code&gt;000...001111...111&lt;/code&gt; 的数（所有低于 MSB 的位都是 1）。&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;2&quot;&gt;
&lt;li&gt;&lt;strong&gt;步骤 2：&lt;code&gt;(v * 0x07C4ACDD) &gt;&gt;&gt; 27&lt;/code&gt;&lt;/strong&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;0x07C4ACDD&lt;/code&gt; 是一个 &lt;strong&gt;De Bruijn 序列&lt;/strong&gt; 的魔数，它有一个特殊性质：
&lt;ul&gt;
&lt;li&gt;当乘以一个 &lt;code&gt;2ⁿ - 1&lt;/code&gt; 形式的数（即 &lt;code&gt;000...001111...111&lt;/code&gt;）时，高位会包含一个唯一的 5 位模式（因为 &lt;code&gt;32 = 2⁵&lt;/code&gt;）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;code&gt;&gt;&gt;&gt; 27&lt;/code&gt; 提取高 5 位（因为 &lt;code&gt;32 - 5 = 27&lt;/code&gt;），得到一个 &lt;code&gt;0..31&lt;/code&gt; 的索引。&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;3&quot;&gt;
&lt;li&gt;&lt;strong&gt;步骤 3：查表 &lt;code&gt;DE_BRUIJN_TABLE&lt;/code&gt;&lt;/strong&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;DE_BRUIJN_TABLE&lt;/code&gt; 是一个预计算的表，它根据 &lt;code&gt;(v * 0x07C4ACDD) &gt;&gt;&gt; 27&lt;/code&gt; 的结果返回 &lt;code&gt;log₂(v)&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;这个表的设计使得：
&lt;ul&gt;
&lt;li&gt;对于 &lt;code&gt;v = 2ⁿ&lt;/code&gt;，它返回 &lt;code&gt;n&lt;/code&gt;（即 &lt;code&gt;log₂(v)&lt;/code&gt;）。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;示例：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;v = 8 (1000₂)&lt;/code&gt;：
&lt;ul&gt;
&lt;li&gt;经过 &lt;code&gt;v |= v &gt;&gt;&gt; ...&lt;/code&gt; 后，&lt;code&gt;v = 1111&lt;/code&gt;（即 &lt;code&gt;0xF&lt;/code&gt;）&lt;/li&gt;
&lt;li&gt;&lt;code&gt;0xF * 0x07C4ACDD = ...&lt;/code&gt;（计算后高 5 位可能是 &lt;code&gt;3&lt;/code&gt;）&lt;/li&gt;
&lt;li&gt;&lt;code&gt;DE_BRUIJN_TABLE[3] = 3&lt;/code&gt;（因为 &lt;code&gt;2³ = 8&lt;/code&gt;）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;h3&gt;&lt;strong&gt;4. 为什么两者等价？&lt;/strong&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;31 - numberOfLeadingZeros(v)&lt;/code&gt; 直接计算 &lt;code&gt;v&lt;/code&gt; 的二进制位数减 1。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;log2WithDeBruijn(v)&lt;/code&gt; 通过 &lt;strong&gt;De Bruijn 序列的数学技巧&lt;/strong&gt; 间接计算 &lt;code&gt;v&lt;/code&gt; 的二进制位数减 1。&lt;/li&gt;
&lt;li&gt;最终结果相同，但 &lt;code&gt;De Bruijn&lt;/code&gt; 方法在某些 CPU 上可能更快（因为避免了分支）。&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;h3&gt;&lt;strong&gt;5. 总结&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;| 方法 | 原理 | 适用场景 |
|------|------|----------|
| &lt;code&gt;31 - Integer.numberOfLeadingZeros(v)&lt;/code&gt; | 直接计算前导 0 的个数，然后取补 | 代码简单，可读性强 |
| &lt;code&gt;log2WithDeBruijn(v)&lt;/code&gt; | 利用 De Bruijn 序列和查表 | 可能更快（无分支，适合高性能计算） |&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;结论：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;两者数学上等价，都能正确计算 &lt;code&gt;⌊log₂(v)⌋&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;De Bruijn&lt;/code&gt; 方法更底层，可能更快，但可读性较差。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;numberOfLeadingZeros&lt;/code&gt; 方法更直观，推荐在一般代码中使用。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;18. 计算整数的log₁₀&lt;/h2&gt;
&lt;h2&gt;19. 计算末尾连续0的数量&lt;/h2&gt;
&lt;h2&gt;20. 向上取整到下一个2的幂&lt;/h2&gt;
&lt;h2&gt;21. 交错位 (莫顿码)&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;y = (y | (y &amp;#x3C;&amp;#x3C; 8)) &amp;#x26; 0x00FF00FF;
y = (y | (y &amp;#x3C;&amp;#x3C; 4)) &amp;#x26; 0x0F0F0F0F;
y = (y | (y &amp;#x3C;&amp;#x3C; 2)) &amp;#x26; 0x33333333;
y = (y | (y &amp;#x3C;&amp;#x3C; 1)) &amp;#x26; 0x55555555;

return x | (y &amp;#x3C;&amp;#x3C; 1);
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;}&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#x3C;/TabItem&gt;
&amp;#x3C;TabItem label=&quot;测试用例&quot;&gt;
```java  showLineNumbers
@Test
@DisplayName(&quot;56. 交错位 (莫顿码)&quot;)
void testInterleaveBits() {
    // x=1 (0001), y=2 (0010) -&gt; z = ...010010 -&gt; 18
    assertEquals(18, BitHacks.interleaveBits(1, 2));
    // x=2 (0010), y=3 (0011) -&gt; z = ...011010 -&gt; 26
    assertEquals(26, BitHacks.interleaveBits(2, 3));
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;22. 判断一个字中是否含有0字节&lt;/h2&gt;
&lt;h2&gt;23. 判断一个整数中是否有等于n的字节&lt;/h2&gt;
&lt;h2&gt;24. 判断一个字中是否有小于n的字节&lt;/h2&gt;
&lt;h2&gt;25. 计算字典序的下一个位排列&lt;/h2&gt;</content:encoded><h:img src="/_astro/bit_op.CEEDcCEA.png"/><enclosure url="/_astro/bit_op.CEEDcCEA.png"/></item><item><title>建站: code highlight by expressive-code</title><link>https://8cat.life/blog/t3</link><guid isPermaLink="true">https://8cat.life/blog/t3</guid><description>test expressive-code features</description><pubDate>Tue, 12 Aug 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;import MdxRepl from &apos;@/custom/components/user/MdxRepl.astro&apos;
import TabItem from &apos;@/custom/components/user/TabItem.astro&apos;
import Tabs from &apos;@/custom/components/user/Tabs.astro&apos;&lt;/p&gt;
&lt;h2&gt;📌 自定义插件&lt;/h2&gt;
&lt;h3&gt;Focus 插件&lt;/h3&gt;
&lt;p&gt;使用 &lt;code&gt;focus={3-5}&lt;/code&gt; 参数或行内 &lt;code&gt;// [!focus]&lt;/code&gt; 注释，指定行高亮聚焦，其他行淡化：&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-js&quot;&gt;function calculateTotal(items) {
  let total = 0
  for (const item of items) {       // ← 第3行 聚焦
    total += item.price * item.quantity  // ← 第4行 聚焦
  }                                  // ← 第5行 聚焦
  return total
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;行内注释方式（&lt;code&gt;// [!focus]&lt;/code&gt; 会被自动移除）：&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-js&quot;&gt;function processData(data) {
  const validated = validateInput(data)
  const transformed = transformData(validated) // [!focus]
  const result = saveToDatabase(transformed) // [!focus]
  return result
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Python 风格（&lt;code&gt;# [!focus]&lt;/code&gt;）：&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-python&quot;&gt;def calculate_fibonacci(n):
    if n &amp;#x3C;= 1:
        return n
    
    a, b = 0, 1  # [!focus]
    for _ in range(2, n + 1):  # [!focus]
        a, b = b, a + b  # [!focus]
    
    return b
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h3&gt;Footnotes 插件&lt;/h3&gt;
&lt;p&gt;使用 &lt;code&gt;// [!note:N] 注释内容&lt;/code&gt; 添加代码脚注：&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-js&quot;&gt;import express from &apos;express&apos; // [!note:1] Express Web 框架
import cors from &apos;cors&apos; // [!note:3] 跨域处理

const app = express() // [!note:2] 创建实例

app.use(cors())
app.use(express.json()) // [!note:4] 解析 JSON

app.listen(3000)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;自动编号（&lt;code&gt;// [!note]&lt;/code&gt; 不指定编号）：&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-python&quot;&gt;import pandas as pd  # [!note] Pandas 数据分析库
import numpy as np  # [!note] NumPy 数组计算

df = pd.read_csv(&apos;data.csv&apos;)  # [!note] 读取 CSV 文件
df[&apos;norm&apos;] = df[&apos;value&apos;] / df[&apos;value&apos;].max()  # [!note] 归一化处理

print(df.head())
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h2&gt;📌 原生功能演示&lt;/h2&gt;
&lt;h3&gt;基础代码块&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-css&quot;&gt;.flex {
  display: flex;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h3&gt;折叠代码块&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-js&quot;&gt;// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from &apos;@example/some-boilerplate&apos;
import { evenMoreBoilerplate } from &apos;@example/even-more-boilerplate&apos;

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: &apos;End of example boilerplate code&apos; })
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h3&gt;行高亮标记&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-zig&quot;&gt;// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range &quot;7-8&quot;
// Line 8 - targeted by range &quot;7-8&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h3&gt;带标签的行标记&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-jsx&quot;&gt;// labeled-line-markers.jsx
&amp;#x3C;button
  role=&quot;button&quot;
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
&gt;
  {children &amp;#x26;&amp;#x26;
    !active &amp;#x26;&amp;#x26;
    (typeof children === &apos;string&apos; ? &amp;#x3C;span&gt;{children}&amp;#x3C;/span&gt; : children)}
&amp;#x3C;/button&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h3&gt;行号控制&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-js&quot;&gt;// This code block will show line numbers
console.log(&apos;Greetings from line 2!&apos;)
console.log(&apos;I am on line 3&apos;)
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code class=&quot;language-js&quot;&gt;// Line numbers are disabled for this block
console.log(&apos;Hello?&apos;)
console.log(&apos;Sorry, do you know what line I am on?&apos;)
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h3&gt;多语言示例&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-java&quot;&gt;public class HelloWorld {
    public static void main(String[] args) {
        System.out.println(&quot;Hello, World!&quot;);
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code class=&quot;language-yaml&quot;&gt;name: HelloWorld
description: A simple Java program
version: 1.0.0
mainClass: HelloWorld
dependencies:
  - java: 11
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code class=&quot;language-shell&quot;&gt;fatal: refusing to merge unrelated histories
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code class=&quot;language-json&quot;&gt;{
  &quot;name&quot;: &quot;HelloWorld&quot;,
  &quot;description&quot;: &quot;A simple Java program&quot;,
  &quot;version&quot;: &quot;1.0.0&quot;,
  &quot;mainClass&quot;: &quot;HelloWorld&quot;,
  &quot;dependencies&quot;: {
    &quot;java&quot;: &quot;11&quot;
  }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code class=&quot;language-python&quot;&gt;def hello_world():
    print(&quot;Hello, World!&quot;)    
&lt;/code&gt;&lt;/pre&gt;
&lt;hr&gt;
&lt;h3&gt;ANSI 颜色&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-ansi&quot;&gt;[1;4mStandard ANSI colors:[0m
- Dimmed:     [2;30m Black [2;31m Red [2;32m Green [2;33m Yellow [2;34m Blue [2;35m Magenta [2;36m Cyan [2;37m White [0m
- Foreground: [30m Black [31m Red [32m Green [33m Yellow [34m Blue [35m Magenta [36m Cyan [37m White [0m
- Background: [40m Black [41m Red [42m Green [43m Yellow [44m Blue [45m Magenta [46m Cyan [47m White [0m
- Reversed:   [7;30m Black [7;31m Red [7;32m Green [7;33m Yellow [7;34m Blue [7;35m Magenta [7;36m Cyan [7;37m White [0m
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code class=&quot;language-txt&quot;&gt;.starlight-icons/*
!.starlight-icons/safelist.json
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code class=&quot;language-ts&quot;&gt;console.log(&apos;hi&apos;)
&lt;/code&gt;&lt;/pre&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>Test: Markdown Syntax Support</title><link>https://8cat.life/blog/m2</link><guid isPermaLink="true">https://8cat.life/blog/m2</guid><description>Markdown is a lightweight markup language.</description><pubDate>Sat, 26 Jul 2025 08:00:00 GMT</pubDate><content:encoded>&lt;h2&gt;Basic Syntax&lt;/h2&gt;
&lt;p&gt;Markdown is a lightweight and easy-to-use syntax for styling your writing.&lt;/p&gt;
&lt;h3&gt;Headers&lt;/h3&gt;
&lt;p&gt;When the content of the article is extensive, you can use headers to segment:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;# Header 1

## Header 2

## Large Header

### Small Header
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Header previews would disrupt the structure of the article, so they are not displayed here.&lt;/p&gt;
&lt;h3&gt;Bold and Italics&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;_Italic text_ and **Bold text**, together will be **_Bold Italic text_**
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Italic text&lt;/em&gt; and &lt;strong&gt;Bold text&lt;/strong&gt;, together will be &lt;strong&gt;&lt;em&gt;Bold Italic text&lt;/em&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;h3&gt;Links&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;Text link [Link Name](http://link-url)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;Text link &lt;a href=&quot;http://link-url&quot;&gt;Link Name&lt;/a&gt;&lt;/p&gt;
&lt;h3&gt;Inline Code&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;This is an `inline code`
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;This is an &lt;code&gt;inline code&lt;/code&gt;&lt;/p&gt;
&lt;h3&gt;Code Blocks&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;```js
// calculate fibonacci
function fibonacci(n) {
  if (n &amp;#x3C;= 1) return 1
  const result = fibonacci(n - 1) + fibonacci(n - 2) // [\!code --]
  return fibonacci(n - 1) + fibonacci(n - 2) // [\!code ++]
}
```
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-js&quot;&gt;// calculate fibonacci
function fibonacci(n) {
  if (n &amp;#x3C;= 1) return 1
  const result = fibonacci(n - 1) + fibonacci(n - 2) // [!code --]
  return fibonacci(n - 1) + fibonacci(n - 2) // [!code ++]
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Currently using shiki as the code highlighting plugin. For supported languages, refer to &lt;a href=&quot;https://shiki.matsu.io/languages.html&quot;&gt;Shiki: Languages&lt;/a&gt;.&lt;/p&gt;
&lt;h3&gt;Inline Formula&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;This is an inline formula $e^{i\pi} + 1 = 0$
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;This is an inline formula $e^{i\pi} + 1 = 0$&lt;/p&gt;
&lt;h3&gt;Formula Blocks&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;$$
\hat{f}(\xi) = \int_{-\infty}^{\infty} f(x) e^{-2\pi i x \xi} \, dx
$$
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;$$
\hat{f}(\xi) = \int_{-\infty}^{\infty} f(x) e^{-2\pi i x \xi} , dx
$$&lt;/p&gt;
&lt;p&gt;Currently using KaTeX as the math formula plugin. For supported syntax, refer to &lt;a href=&quot;https://katex.org/docs/supported.html&quot;&gt;KaTeX Supported Functions&lt;/a&gt;.&lt;/p&gt;
&lt;h4&gt;Images&lt;/h4&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;![CWorld](https://cravatar.cn/avatar/1ffe42aa45a6b1444a786b1f32dfa8aa?s=200)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;https://cravatar.cn/avatar/1ffe42aa45a6b1444a786b1f32dfa8aa?s=200&quot; alt=&quot;CWorld&quot;&gt;&lt;/p&gt;
&lt;h4&gt;Strikethrough&lt;/h4&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;~~Strikethrough~~
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;~~Strikethrough~~&lt;/p&gt;
&lt;h3&gt;Lists&lt;/h3&gt;
&lt;p&gt;Regular unordered list&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;- 1
- 2
- 3
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;1&lt;/li&gt;
&lt;li&gt;2&lt;/li&gt;
&lt;li&gt;3&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Regular ordered list&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;1. GPT-4
2. Claude Opus
3. LLaMa
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;GPT-4&lt;/li&gt;
&lt;li&gt;Claude Opus&lt;/li&gt;
&lt;li&gt;LLaMa&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;You can continue to nest syntax within lists.&lt;/p&gt;
&lt;h3&gt;Blockquotes&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;&gt; Gunshot, thunder, sword rise. A scene of flowers and blood.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Gunshot, thunder, sword rise. A scene of flowers and blood.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;You can continue to nest syntax within blockquotes.&lt;/p&gt;
&lt;h3&gt;Line Breaks&lt;/h3&gt;
&lt;p&gt;Markdown needs a blank line to separate paragraphs.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;If you don&apos;t leave a blank line
it will be in one paragraph

First paragraph

Second paragraph
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;If you don&apos;t leave a blank line
it will be in one paragraph&lt;/p&gt;
&lt;p&gt;First paragraph&lt;/p&gt;
&lt;p&gt;Second paragraph&lt;/p&gt;
&lt;h3&gt;Separators&lt;/h3&gt;
&lt;p&gt;If you have the habit of writing separators, you can start a new line and enter three dashes &lt;code&gt;---&lt;/code&gt; or asterisks &lt;code&gt;***&lt;/code&gt;. Leave a blank line before and after when there are paragraphs:&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;---
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;hr&gt;
&lt;h2&gt;Advanced Techniques&lt;/h2&gt;
&lt;h3&gt;Inline HTML Elements&lt;/h3&gt;
&lt;p&gt;Currently, only some inline HTML elements are supported, including &lt;code&gt;&amp;#x3C;kdb&gt; &amp;#x3C;b&gt; &amp;#x3C;i&gt; &amp;#x3C;em&gt; &amp;#x3C;sup&gt; &amp;#x3C;sub&gt; &amp;#x3C;br&gt;&lt;/code&gt;, such as&lt;/p&gt;
&lt;h4&gt;Key Display&lt;/h4&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;Use &amp;#x3C;kbd&gt;Ctrl&amp;#x3C;/kbd&gt; + &amp;#x3C;kbd&gt;Alt&amp;#x3C;/kbd&gt; + &amp;#x3C;kbd&gt;Del&amp;#x3C;/kbd&gt; to reboot the computer
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;Use Ctrl + Alt + Del to reboot the computer&lt;/p&gt;
&lt;h4&gt;Bold Italics&lt;/h4&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;&amp;#x3C;b&gt; Markdown also applies here, such as _bold_ &amp;#x3C;/b&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt; Markdown also applies here, such as &lt;em&gt;bold&lt;/em&gt; &lt;/p&gt;
&lt;h3&gt;Other HTML Writing&lt;/h3&gt;
&lt;h4&gt;Foldable Blocks超长的标题中文Foldable Blocks超长的标题中文&lt;/h4&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;&amp;#x3C;details&gt;&amp;#x3C;summary&gt;Click to expand&amp;#x3C;/summary&gt;It is hidden&amp;#x3C;/details&gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;h3&gt;Tables&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;| Header1  | Header2  |
| -------- | -------- |
| Content1 | Content2 |
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;| Header1  | Header2  |
| -------- | -------- |
| Content1 | Content2 |&lt;/p&gt;
&lt;h3&gt;Footnotes&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;Use [^footnote] to add a footnote at the point of reference.

Then, at the end of the document, add the content of the footnote (it will be rendered at the end of the article by default).

[^footnote]: Here is the content of the footnote
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;Use [^footnote] to add a footnote at the point of reference.&lt;/p&gt;
&lt;p&gt;Then, at the end of the document, add the content of the footnote (it will be rendered at the end of the article by default).&lt;/p&gt;
&lt;p&gt;[^footnote]: Here is the content of the footnote&lt;/p&gt;
&lt;h3&gt;To-Do Lists&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;- [ ] Incomplete task
- [x] Completed task
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;[ ] Incomplete task&lt;/li&gt;
&lt;li&gt;[x] Completed task&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;Symbol Escaping&lt;/h3&gt;
&lt;p&gt;If you need to use markdown symbols like _ # * in your description but don&apos;t want them to be escaped, you can add a backslash before these symbols, such as &lt;code&gt;\_&lt;/code&gt; &lt;code&gt;\#&lt;/code&gt; &lt;code&gt;\*&lt;/code&gt; to avoid it.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-markdown&quot;&gt;\_Don&apos;t want the text here to be italic\_

\*\*Don&apos;t want the text here to be bold\*\*
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Preview:&lt;/p&gt;
&lt;p&gt;_Don&apos;t want the text here to be italic_&lt;/p&gt;
&lt;p&gt;**Don&apos;t want the text here to be bold**&lt;/p&gt;
&lt;hr&gt;
&lt;h2&gt;Embedding Astro Components&lt;/h2&gt;
&lt;p&gt;See &lt;a href=&quot;/docs/integrations/components&quot;&gt;User Components&lt;/a&gt; and &lt;a href=&quot;/docs/integrations/advanced&quot;&gt;Advanced Components&lt;/a&gt; for details.&lt;/p&gt;
&lt;pre&gt;&lt;code class=&quot;language-text&quot;&gt;---
config:
  sankey:
    showValues: false
---
sankey-beta

Agricultural &apos;waste&apos;,Bio-conversion,124.729
Bio-conversion,Liquid,0.597
Bio-conversion,Losses,26.862
Bio-conversion,Solid,280.322
Bio-conversion,Gas,81.144
Biofuel imports,Liquid,35
Biomass imports,Solid,35
Coal imports,Coal,11.606
Coal reserves,Coal,63.965
Coal,Solid,75.571
District heating,Industry,10.639
District heating,Heating and cooling - commercial,22.505
District heating,Heating and cooling - homes,46.184
Electricity grid,Over generation / exports,104.453
Electricity grid,Heating and cooling - homes,113.726
Electricity grid,H2 conversion,27.14
Electricity grid,Industry,342.165
Electricity grid,Road transport,37.797
Electricity grid,Agriculture,4.412
Electricity grid,Heating and cooling - commercial,40.858
Electricity grid,Losses,56.691
Electricity grid,Rail transport,7.863
Electricity grid,Lighting &amp;#x26; appliances - commercial,90.008
Electricity grid,Lighting &amp;#x26; appliances - homes,93.494
Gas imports,Ngas,40.719
Gas reserves,Ngas,82.233
Gas,Heating and cooling - commercial,0.129
Gas,Losses,1.401
Gas,Thermal generation,151.891
Gas,Agriculture,2.096
Gas,Industry,48.58
Geothermal,Electricity grid,7.013
H2 conversion,H2,20.897
H2 conversion,Losses,6.242
H2,Road transport,20.897
Hydro,Electricity grid,6.995
Liquid,Industry,121.066
Liquid,International shipping,128.69
Liquid,Road transport,135.835
Liquid,Domestic aviation,14.458
Liquid,International aviation,206.267
Liquid,Agriculture,3.64
Liquid,National navigation,33.218
Liquid,Rail transport,4.413
Marine algae,Bio-conversion,4.375
Ngas,Gas,122.952
Nuclear,Thermal generation,839.978
Oil imports,Oil,504.287
Oil reserves,Oil,107.703
Oil,Liquid,611.99
Other waste,Solid,56.587
Other waste,Bio-conversion,77.81
Pumped heat,Heating and cooling - homes,193.026
Pumped heat,Heating and cooling - commercial,70.672
Solar PV,Electricity grid,59.901
Solar Thermal,Heating and cooling - homes,19.263
Solar,Solar Thermal,19.263
Solar,Solar PV,59.901
Solid,Agriculture,0.882
Solid,Thermal generation,400.12
Solid,Industry,46.477
Thermal generation,Electricity grid,525.531
Thermal generation,Losses,787.129
Thermal generation,District heating,79.329
Tidal,Electricity grid,9.452
UK land based bioenergy,Bio-conversion,182.01
Wave,Electricity grid,19.013
Wind,Electricity grid,289.366
&lt;/code&gt;&lt;/pre&gt;</content:encoded><h:img src="/_astro/thumbnail.HAXFr_hw.jpg"/><enclosure url="/_astro/thumbnail.HAXFr_hw.jpg"/></item><item><title>建站: inner-link,wiki-link</title><link>https://8cat.life/blog/inner-link-test</link><guid isPermaLink="true">https://8cat.life/blog/inner-link-test</guid><description>站内链接预览、仿 obsidian 双链引用</description><pubDate>Tue, 01 Jul 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;strong&gt;我 bqweq&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;== b 高 ==&lt;/p&gt;
&lt;p&gt;&lt;a href=&quot;http://bilibili.com&quot;&gt;bddsfdsfsddffds&lt;/a&gt;
&lt;a href=&quot;http://github.com&quot;&gt;g&lt;/a&gt;
&lt;a href=&quot;http://x.com&quot;&gt;x&lt;/a&gt;
&lt;a href=&quot;http://youtube.com&quot;&gt;y&lt;/a&gt;
&lt;a href=&quot;http://acm.com&quot;&gt;a&lt;/a&gt;
&lt;a href=&quot;http://localhost:4321&quot;&gt;d&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;wikilink&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;内部链接：[[blog/test_inner|测试用的内部链接_可以自定义显示文本]]&lt;/li&gt;
&lt;li&gt;内部链接：[[blog/test/x|not found]]&lt;/li&gt;
&lt;li&gt;blog 下不同子文件夹同名： [[blog/m2|en md]]&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;mermaid&lt;/h2&gt;
&lt;pre&gt;&lt;code class=&quot;language-text&quot;&gt;graph TD
  A[Start] --&gt; B{Is it working?}
  B -- Yes --&gt; C[Great!]
  B -- No --&gt; D[Fix it]
  D --&gt; B
  C --&gt; E[End]
&lt;/code&gt;&lt;/pre&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item><item><title>建站: &lt;Paper&gt; Component</title><link>https://8cat.life/blog/paper-test</link><guid isPermaLink="true">https://8cat.life/blog/paper-test</guid><description>test</description><pubDate>Wed, 19 Mar 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;import Paper from &apos;@/custom/components/pages/Paper.astro&apos;
import Aside from &apos;@/custom/components/user/Aside.astro&apos;&lt;/p&gt;
&lt;p&gt;&amp;#x3C;Paper paper={{
id: &apos;attention-is-all-you-need&apos;,
data: {
title: &apos;Attention Is All You Need&apos;,
subTitle: &apos;Introducing the Transformer architecture&apos;,
publishDate: &apos;2017-12-06&apos;,
citations: 123456,
tags: [&apos;Transformer&apos;, &apos;Attention Mechanism&apos;, &apos;Neural Networks&apos;]
},
index: 1
}} /&gt;&lt;/p&gt;
&lt;p&gt;&amp;#x3C;Paper paper={{
id: &apos;attention-is-all-you-need&apos;,
data: {
title: &apos;Attention Is All You Need Attention  You NeedAttention Is &apos;,
publishDate: &apos;2017-12-06&apos;,
journal: &apos;NeurIPS 2017&apos;,
star: 6,
publisher: &apos;arxiv&apos;,
tags: [&apos;Transformer&apos;, &apos;Attention Mechanism&apos;, &apos;Neural Networks Neural Networks Neural Networks Neural Networks Neural Networks&apos;,]
},
index: 1002
}} /&gt;&lt;/p&gt;
&lt;h2&gt;核心创新点&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;纯注意力机制&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;完全抛弃了循环和卷积结构&lt;/li&gt;
&lt;li&gt;通过自注意力机制实现并行计算&lt;/li&gt;
&lt;li&gt;显著提高了训练效率&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;多头注意力&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;允许模型关注不同的表示子空间&lt;/li&gt;
&lt;li&gt;增强了模型的表达能力&lt;/li&gt;
&lt;li&gt;提供了更丰富的特征提取能力&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;关键架构设计&lt;/h2&gt;
&lt;h3&gt;Encoder-Decoder 结构&lt;/h3&gt;
&lt;pre&gt;&lt;code class=&quot;language-text&quot;&gt;graph TD
    H[Encoder-Decoder Attention]
    I[Feed Forward]
    end
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;位置编码&lt;/h3&gt;
&lt;p&gt;位置编码使用正弦和余弦函数：&lt;/p&gt;
&lt;p&gt;$$
PE_{(pos,2i)} = sin(pos/10000^{2i/d_{model}})
$$&lt;/p&gt;
&lt;p&gt;$$
PE_{(pos,2i+1)} = cos(pos/10000^{2i/d_{model}})
$$&lt;/p&gt;
&lt;h2&gt;实验结果&lt;/h2&gt;
&lt;p&gt;| 模型 | BLEU 分数 | 训练时间 |
|-----|-----------|---------|
| Transformer (base) | 27.3 | 12 小时 |
| Transformer (big) | 28.4 | 3.5 天 |
| ConvS2S | 26.4 | N/A |
| GNMT + RL | 26.3 | N/A |&lt;/p&gt;
&lt;h2&gt;个人思考&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Transformer 架构的优势：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;并行计算能力强&lt;/li&gt;
&lt;li&gt;可以捕获长距离依赖&lt;/li&gt;
&lt;li&gt;模型可解释性较好&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;潜在局限：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;计算复杂度随序列长度呈平方增长&lt;/li&gt;
&lt;li&gt;位置编码方案可能不够优雅&lt;/li&gt;
&lt;li&gt;在某些特定任务上可能不如专门设计的模型&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;影响与启发&lt;/h2&gt;
&lt;p&gt;这篇论文开创了 NLP 领域的新范式，影响深远：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;GPT 系列模型都基于 Transformer 架构&lt;/li&gt;
&lt;li&gt;BERT 等双向编码模型的基础&lt;/li&gt;
&lt;li&gt;启发了 ViT 等计算机视觉模型&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;[!tip] 推荐阅读
如果你对 Transformer 感兴趣，强烈推荐阅读 &quot;The Annotated Transformer&quot; 这篇博客，它提供了详细的代码实现讲解。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2&gt;参考资源&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;a href=&quot;https://arxiv.org/abs/1706.03762&quot;&gt;论文原文&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;http://nlp.seas.harvard.edu/2018/04/03/attention.html&quot;&gt;The Annotated Transformer&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://jalammar.github.io/illustrated-transformer/&quot;&gt;Transformer 可视化&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;</content:encoded><h:img src="/_astro/paper.Np8abW3Z.png"/><enclosure url="/_astro/paper.Np8abW3Z.png"/></item><item><title>建站: 测试用的站内链接</title><link>https://8cat.life/blog/test_inner</link><guid isPermaLink="true">https://8cat.life/blog/test_inner</guid><description>astro-theme-pure Personalized Customization Guide</description><pubDate>Mon, 27 Jan 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;我是内部的页面&lt;/p&gt;</content:encoded><h:img src="undefined"/><enclosure url="undefined"/></item></channel></rss>