测试新增加的几个功能

数学公式

数学公式渲染偶尔会渲染不出来

$$
f’(x) = \lim_{\Delta x \to 0} \frac{f(x + \Delta x) - f(x)}{\Delta x}
$$

$$
\int_{a}^{b} f(x) , dx = F(b) - F(a)
$$

$$
\frac{d}{dx}(x^n) = n x^{n-1}
$$

$$
\int u , dv = uv - \int v , du
$$

$$
f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{1}{2}\left(\frac{x-\mu}{\sigma}\right)^2}
$$

$$
\iiint_V (\nabla \cdot \mathbf{F}) , dV = \iint_{\partial V} (\mathbf{F} \cdot \mathbf{n}) , dS
$$

$$
\Gamma(z) = \int_0^\infty t^{z-1} e^{-t} , dt \quad (\operatorname{Re}(z) > 0)
$$

$$
f(x) = \int_{-\infty}^{\infty} \hat{f}(\xi) e^{2\pi i x \xi} , d\xi
$$

$$
f(\mathbf{x}) = \frac{1}{(2\pi)^{k/2} |\boldsymbol{\Sigma}|^{1/2}} \exp \left( -\frac{1}{2} (\mathbf{x} - \boldsymbol{\mu})^T \boldsymbol{\Sigma}^{-1} (\mathbf{x} - \boldsymbol{\mu}) \right)
$$

$$
R_{\mu\nu} - \frac{1}{2} R g_{\mu\nu} + \Lambda g_{\mu\nu} = \frac{8\pi G}{c^4} T_{\mu\nu}
$$

$$
\begin{split}
(a+b)^4 &= (a+b)^2 (a+b)^2 \
&= (a^2 + 2ab + b^2)(a^2 + 2ab + b^2) \
&= a^4 + 4a^3b + 6a^2b^2 + 4ab^3 + b^4
\end{split}
$$

$$
i\hbar \frac{\partial}{\partial t} |\Psi(t)\rangle = \hat{H} |\Psi(t)\rangle
$$

表格

修改了一下表格的样式

Switch 切换 Parameter 参数
open 嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎 filename - the name of the file that is to be modified. It should be a Windows PE file (.exe, .dll etc) or a compiled or uncompiled resouce file (.res or .rc) 文件名——要修改的文件名称。它应该是 Windows PE 文件(.exe、.dll 等)或已编译或未编译的资源文件(.res 或.rc) 嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎
save 嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎 usually a filename for the new or modified file, but can also be a folder when extracting multiple resources 通常为新文件或修改文件命名,但解压多个资源时也可以是文件夹 嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎
resource 嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎 filename - contains a resource being added to the opened file. filename - 包含正在添加到打开文件中的资源 灌灌灌灌灌孤寡孤寡孤寡嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎
action 嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎 action to be performed on the opened file 对已打开的文件执行的操作 ①add - add a resource, but fails if it already exists 添加 - 添加资源,但如果资源已经存在则失败 ②addoverwrite - add a resource, and overwriting if it already exists 增添覆盖 - 添加资源,如果已有资源则覆盖 ③addskip - add a resource, but skipping if it already exists 增添忽略 - 添加资源,但如果已经存在就跳过 ④compile - compiles a resource script file (.rc) to a binary resource file (.res) 编译 - 将资源脚本文件(.rc)编译为二进制资源文件(.res) ⑤delete - delete a resource 删除 - 删除资源 ⑥extract - extract a resource 提取 - 提取资源 ⑦modify - modify a resource 修改 - 修改资源 ⑧changelanguage(langID) - changes the language of ALL resources 更改语言(langID) - 更改所有资源的语言 嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎
mask 灌灌灌灌灌孤寡孤寡孤寡嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎 resource mask - Type,Name,Language 资源掩码 - 类型、名称、语言 commas are mandatory but each of Type, Name & Language are optional 逗号是必加的,但类型、名称和语言中每个内容都是可选的 嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎
log 灌灌灌灌孤寡孤寡孤寡嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎 Filename or CONSOLE or NUL 文件名、CONSOLENUL CONSOLE can be abbreviated to CON CONSOLE 可以缩写为 CON Logs the details of the operation performed 记录作细节 If this switch is omitted, the log will be written to resourcehacker.log 如果省略了该开关,日志将被写入 resourcehacker.log 灌灌灌灌孤寡孤寡孤寡嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎
script 灌灌灌灌孤寡孤寡孤寡嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎 filename - contains a multi-command script, NOT a resource script for more info: -help script filename - 包含一个多命令脚本,而非资源脚本。更多信息是:-help script 灌灌灌灌孤寡孤寡孤寡嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎
help 灌灌灌灌灌孤寡孤寡孤寡嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎 options - command-line or script (always logged to CONSOLE) other switches are ignored. 选项——命令行或脚本(始终记录在控制台),其他交换机则被忽略 灌灌灌灌孤寡孤寡孤寡嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎
物品图标/名称 英文 ID 最大堆叠 获取方式 主要用途 燃烧时间 冶炼产物 稀有度
圆石 cobblestone 64 挖掘石头/刷石机 建筑、合成石器 石头 普通
橡木原木 oak_log 64 砍伐橡树 合成木板、木炭 15秒 木炭 普通
煤炭 coal 64 挖掘煤矿石/击杀凋灵骷髅 熔炉燃料、合成火把 80秒 - 普通
铁锭 iron_ingot 64 冶炼铁矿石/铁傀儡掉落 制作主流装备、工具 - 普通
金锭 gold_ingot 64 冶炼金矿石/猪灵交易 制作动力铁轨、金苹果 - 普通
钻石 diamond 64 钻石矿石/主世界宝箱 制作顶尖装备、附魔台 - 稀有
下界合金锭 netherite_ingot 64 锻造台升级/下界合金碎片 升级钻石装备(防熔岩) - 史诗
黑曜石 obsidian 64 水与源头岩浆混合/挖掘 建造下界传送门、附魔台 - 稀有
语言名称 核心编程范式 类型系统 内存管理机制 运行与执行机制 核心并发模型 绝对优势与擅长领域 杀手级框架/代表作 性能评级 诞生年份
Java 面向对象 静态强类型 自动 GC 编译 + 字节码解释 (JVM) 线程 / 虚拟线程 (Java 21+) 企业级后台、大数据生态、金融系统 Spring Boot, Hadoop ⭐⭐⭐⭐ 1995
Python 多范式 (脚本/OO) 动态强类型 自动 GC 解释执行 (CPython 也有字节码) 协程 (Asyncio) / 多进程 人工智能、数据科学、自动化脚本 PyTorch, Django ⭐⭐ 1991
C++ 多范式 (OO/泛型/底层) 静态强类型 手动管理 (RAII) AOT 编译为机器码 多线程 / 异步 游戏引擎、高频交易、桌面软件 Unreal Engine, Qt ⭐⭐⭐⭐⭐ 1985
C 过程式 / 底层 静态弱类型 手动管理 AOT 编译为机器码 多线程 操作系统内核、嵌入式系统、驱动 Linux Kernel, Redis ⭐⭐⭐⭐⭐ 1972
JavaScript 事件驱动 / 函数式 动态弱类型 自动 GC 解释执行 + JIT (V8引擎) 单线程 (Event Loop) Web 前端、全栈开发、跨平台应用 React, Node.js ⭐⭐⭐ 1995
Go 过程式 / 并发 静态强类型 自动 GC AOT 编译为机器码 轻量级协程 (Goroutine) 云原生组件、微服务后台、高并发网关 Docker, Kubernetes ⭐⭐⭐⭐ 2009
Rust 多范式 / 安全控制 静态强类型 所有权机制 (无 GC) AOT 编译为机器码 多线程 / 异步 (无数据竞争) 极致性能场景、WebAssembly、底层重构 Tauri, Actix ⭐⭐⭐⭐⭐ 2015
C# 面向对象 静态强类型 自动 GC 编译 + 字节码解释 (CLR) 多线程 / Task 异步模型 Windows 生态、企业应用、游戏开发 .NET Core, Unity ⭐⭐⭐⭐ 2000
TypeScript 面向对象 / 函数式 静态渐进式 依赖运行环境 编译(转译)为 JavaScript 依赖运行环境 (JS) 大型复杂前端项目、Node.js 重型后端 Angular, NestJS ⭐⭐⭐ 2012
Kotlin 面向对象 / 函数式 静态强类型 自动 GC 编译 + 字节码解释 (JVM) 协程 (Coroutine) Android 原生开发、现代化 Java 替代方案 Spring, Ktor ⭐⭐⭐⭐ 2011
Swift 多范式 静态强类型 自动引用计数 (ARC) AOT 编译为机器码 GCD / async-await 苹果全家桶生态 (iOS / macOS / watchOS) SwiftUI, Alamofire ⭐⭐⭐⭐ 2014
PHP 脚本 / 过程式 / OO 动态弱类型 自动 GC 解释执行 多进程 (PHP-FPM) 中小型 Web 后端、快速建站 Laravel, WordPress ⭐⭐⭐ 1995
Ruby 纯面向对象 动态强类型 自动 GC 解释执行 + JIT 线程 / 纤程 (Fiber) Web 快速原型开发、DevOps 工具 Ruby on Rails ⭐⭐ 1995
SQL 声明式查询 静态强类型 数据库引擎管理 数据库优化器解析执行 事务与锁机制 (ACID) 关系型数据库查询、数据聚合分析 MySQL, PostgreSQL 视引擎而定 1974
Dart 面向对象 静态强类型 自动 GC JIT (开发) + AOT (生产) 隔离区 (Isolate) / 事件循环 高性能跨平台移动端、大前端 UI Flutter ⭐⭐⭐⭐ 2011
技术组件 核心定位 适用场景 推荐指数
Spring Boot 微服务单体开发框架 企业级后端业务应用快速构建 ⭐⭐⭐⭐⭐
Spring Cloud 微服务分布式治理方案 大规模、高并发分布式系统架构 ⭐⭐⭐⭐⭐
MyBatis 半自动持久层 ORM 框架 关系型数据库的高灵活性 SQL 操作 ⭐⭐⭐⭐
Netty 高性能异步事件驱动网络框架 游戏服务器、聊天室等长连接高并发场景 ⭐⭐⭐⭐
数据库名称 核心类型 是否开源 ACID支持 扩展性 存储介质 查询语言 最佳擅长场景 默认端口 核心厂商/组织 读写性能 备份机制 默认隔离级别 聚集索引 综合评级
MySQL 关系型 完全支持 主从/分库分表 磁盘/内存 SQL 互联网业务、电商、政企 3306 Oracle 强(Binlog) 可重复读(RR) 支持 ⭐⭐⭐⭐⭐
PostgreSQL 关系型 完全支持 读写分离/插件 磁盘/内存 SQL 复杂地理信息、大型企业 5432 PostgreSQL社区 强(WAL) 读已提交(RC) 支持 ⭐⭐⭐⭐⭐
Redis 键值对 弱/单键原子 主从/哨兵/集群 纯内存/持久化 专用命令/Lua 缓存、计数器、分布式锁 6379 Redis 社区 极高 中(RDB/AOF) 不支持 ⭐⭐⭐⭐⭐
MongoDB 文档型 4.0+完备 副本集/分片集群 磁盘(WiredTiger) MQL 动态Schema、日志、内容管理 27017 MongoDB Inc. 中高 中(Oplog) 读已提交(RC) 支持 ⭐⭐⭐⭐
Elasticsearch 倒排索引 自动分片集群 磁盘/内存 DSL / SQL 全文检索、日志分析(ELK) 9200 Elastic 极快(检索) 中(Snapshot) 不支持 ⭐⭐⭐⭐⭐
HBase 列存储 行级支持 强依赖 HDFS HDFS / 内存 Java API/Thrift 海量KV数据、大吞吐写入 16000 Apache 基金会 高(写快) 强(HLog) 不支持 ⭐⭐⭐⭐
Cassandra 宽列/去中心 行级支持 无中心 P2P 集群 磁盘/内存 CQL 高可用、跨机房海量写入 9042 Apache 基金会 极高(写) 中(CommitLog) 不支持 ⭐⭐⭐⭐
ClickHouse 列式OLAP 分布式集群 磁盘 SQL 大数据即席分析、报表查询 8123 ClickHouse Inc 极致(读) 不支持 ⭐⭐⭐⭐⭐
Neo4j 图数据库 社区版开源 完全支持 依赖集群规模 磁盘/内存 Cypher 社交网络、知识图谱、风控 7474 Neo4j Inc. 读已提交(RC) 不支持 ⭐⭐⭐⭐
SQLite 嵌入式 完全支持 单机无分布式 单文件 SQL 移动端、桌面应用、测试环境 公共领域 高(单机) 弱(文件复制) 串行化 支持 ⭐⭐⭐⭐⭐
数据库名称 核心类型 是否开源 ACID支持 扩展性 存储介质 查询语言 最佳擅长场景 默认端口 核心厂商/组织 读写性能 备份机制 默认隔离级别 聚集索引 综合评级 数据库名称 核心类型 是否开源 ACID支持 扩展性
MySQL 关系型 完全支持 主从/分库分表 MySQL磁盘/内存 关系型SQL 是互联网业务、电商、政企 完全支持3306 主从/分库分表Oracle 磁盘/内存高 SQL强(Binlog) 互联网业务、电商、政企可重复读(RR) 3306支持 Oracle⭐⭐⭐⭐⭐ 强(Binlog) 可重复读(RR) 支持 ⭐⭐⭐⭐⭐
PostgreSQL 关系型 完全支持 读写分离/插件 PostgreSQL磁盘/内存 关系型SQL 是复杂地理信息、大型企业 完全支持5432 读写分离/插件PostgreSQL社区 磁盘/内存高 SQL强(WAL) 复杂地理信息、大型企业读已提交(RC) 5432支持 PostgreSQL社区⭐⭐⭐⭐⭐ 强(WAL) 读已提交(RC) 支持 ⭐⭐⭐⭐⭐
Redis 键值对 弱/单键原子 主从/哨兵/集群 Redis纯内存/持久化 键值对专用命令/Lua 是缓存、计数器、分布式锁 弱/单键原子6379 主从/哨兵/集群Redis 社区 纯内存/持久化极高 专用命令/Lua中(RDB/AOF) 缓存、计数器、分布式锁无 6379不支持 Redis 社区⭐⭐⭐⭐⭐ 极高 中(RDB/AOF) 不支持 ⭐⭐⭐⭐⭐
MongoDB 文档型 4.0+完备 副本集/分片集群 MongoDB磁盘(WiredTiger) 文档型MQL 是动态Schema、日志、内容管理 4.0+完备27017 副本集/分片集群MongoDB Inc. 磁盘(WiredTiger)中高 MQL中(Oplog) 动态Schema、日志、内容管理读已提交(RC) 27017支持 MongoDB Inc.⭐⭐⭐⭐ 中高 中(Oplog) 读已提交(RC) 支持 ⭐⭐⭐⭐
Elasticsearch 倒排索引 自动分片集群 Elasticsearch磁盘/内存 倒排索引DSL / SQL 是全文检索、日志分析(ELK) 弱9200 自动分片集群Elastic 磁盘/内存极快(检索) DSL / SQL中(Snapshot) 全文检索、日志分析(ELK)无 9200不支持 Elastic⭐⭐⭐⭐⭐ 极快(检索) 中(Snapshot) 不支持 ⭐⭐⭐⭐⭐
HBase 列存储 行级支持 强依赖 HDFS HBaseHDFS / 内存 列存储Java API/Thrift 是海量KV数据、大吞吐写入 行级支持16000 强依赖 HDFSApache 基金会 HDFS / 内存高(写快) Java API/Thrift强(HLog) 海量KV数据、大吞吐写入无 16000不支持 Apache 基金会⭐⭐⭐⭐ 高(写快) 强(HLog) 不支持 ⭐⭐⭐⭐
Cassandra 宽列/去中心 行级支持 无中心 P2P 集群 Cassandra磁盘/内存 宽列/去中心CQL 是高可用、跨机房海量写入 行级支持9042 无中心 P2P 集群Apache 基金会 磁盘/内存极高(写) CQL中(CommitLog) 高可用、跨机房海量写入无 9042不支持 Apache 基金会⭐⭐⭐⭐ 极高(写) 中(CommitLog) 不支持 ⭐⭐⭐⭐
ClickHouse 列式OLAP 分布式集群 ClickHouse磁盘 列式OLAPSQL 是大数据即席分析、报表查询 弱8123 分布式集群ClickHouse Inc 磁盘极致(读) SQL弱 大数据即席分析、报表查询无 8123不支持 ClickHouse Inc⭐⭐⭐⭐⭐ 极致(读) 不支持 ⭐⭐⭐⭐⭐
Neo4j 图数据库 社区版开源 完全支持 依赖集群规模 Neo4j磁盘/内存 图数据库Cypher 社区版开源社交网络、知识图谱、风控 完全支持7474 依赖集群规模Neo4j Inc. 磁盘/内存中 Cypher中 社交网络、知识图谱、风控读已提交(RC) 7474不支持 Neo4j Inc.⭐⭐⭐⭐ 读已提交(RC) 不支持 ⭐⭐⭐⭐
SQLite 嵌入式 完全支持 单机无分布式 SQLite单文件 嵌入式SQL 是移动端、桌面应用、测试环境 完全支持无 单机无分布式公共领域 单文件高(单机) SQL弱(文件复制) 移动端、桌面应用、测试环境串行化 无支持 公共领域⭐⭐⭐⭐⭐ 高(单机) 弱(文件复制) 串行化 支持 ⭐⭐⭐⭐⭐
数据库名称 核心类型 是否开源 ACID支持 扩展性 存储介质 查询语言 最佳擅长场景 默认端口 核心厂商/组织 读写性能 备份机制 默认隔离级别 聚集索引 综合评级 数据库名称 核心类型 是否开源 ACID支持 扩展性
MySQL 关系型 完全支持 主从/分库分表 MySQL磁盘/内存 关系型SQL 是互联网业务、电商、政企 完全支持3306 主从/分库分表Oracle 磁盘/内存高 SQL强(Binlog) 互联网业务、电商、政企可重复读(RR) 3306支持 Oracle⭐⭐⭐⭐⭐ 强(Binlog) 可重复读(RR) 支持 ⭐⭐⭐⭐⭐
PostgreSQL 关系型 完全支持 读写分离/插件 PostgreSQL磁盘/内存 关系型SQL 是复杂地理信息、大型企业 完全支持5432 读写分离/插件PostgreSQL社区 磁盘/内存高 SQL强(WAL) 复杂地理信息、大型企业读已提交(RC) 5432支持 PostgreSQL社区⭐⭐⭐⭐⭐ 强(WAL) 读已提交(RC) 支持 ⭐⭐⭐⭐⭐
Redis 键值对 弱/单键原子 主从/哨兵/集群 Redis纯内存/持久化 键值对专用命令/Lua 是缓存、计数器、分布式锁 弱/单键原子6379 主从/哨兵/集群Redis 社区 纯内存/持久化极高 专用命令/Lua中(RDB/AOF) 缓存、计数器、分布式锁无 6379不支持 Redis 社区⭐⭐⭐⭐⭐ 极高 中(RDB/AOF) 不支持 ⭐⭐⭐⭐⭐
MongoDB 文档型 4.0+完备 副本集/分片集群 MongoDB磁盘(WiredTiger) 文档型MQL 是动态Schema、日志、内容管理 4.0+完备27017 副本集/分片集群MongoDB Inc. 磁盘(WiredTiger)中高 MQL中(Oplog) 动态Schema、日志、内容管理读已提交(RC) 27017支持 MongoDB Inc.⭐⭐⭐⭐ 中高 中(Oplog) 读已提交(RC) 支持 ⭐⭐⭐⭐
Elasticsearch 倒排索引 自动分片集群 Elasticsearch磁盘/内存 倒排索引DSL / SQL 是全文检索、日志分析(ELK) 弱9200 自动分片集群Elastic 磁盘/内存极快(检索) DSL / SQL中(Snapshot) 全文检索、日志分析(ELK)无 9200不支持 Elastic⭐⭐⭐⭐⭐ 极快(检索) 中(Snapshot) 不支持 ⭐⭐⭐⭐⭐
HBase 列存储 行级支持 强依赖 HDFS HBaseHDFS / 内存 列存储Java API/Thrift 是海量KV数据、大吞吐写入 行级支持16000 强依赖 HDFSApache 基金会 HDFS / 内存高(写快) Java API/Thrift强(HLog) 海量KV数据、大吞吐写入无 16000不支持 Apache 基金会⭐⭐⭐⭐ 高(写快) 强(HLog) 不支持 ⭐⭐⭐⭐
Cassandra 宽列/去中心 行级支持 无中心 P2P 集群 Cassandra磁盘/内存 宽列/去中心CQL 是高可用、跨机房海量写入 行级支持9042 无中心 P2P 集群Apache 基金会 磁盘/内存极高(写) CQL中(CommitLog) 高可用、跨机房海量写入无 9042不支持 Apache 基金会⭐⭐⭐⭐ 极高(写) 中(CommitLog) 不支持 ⭐⭐⭐⭐
ClickHouse 列式OLAP 分布式集群 ClickHouse磁盘 列式OLAPSQL 是大数据即席分析、报表查询 弱8123 分布式集群ClickHouse Inc 磁盘极致(读) SQL弱 大数据即席分析、报表查询无 8123不支持 ClickHouse Inc⭐⭐⭐⭐⭐ 极致(读) 不支持 ⭐⭐⭐⭐⭐

Mermaid图

增加Mermaid,这个可以用typora,因为typora支持mermaid的实时预览

因为mermaid本质是代码块,所以这里和普通代码块做出对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>植物大战僵尸 - 网页微缩版</title>
<style>
body {
margin: 0;
padding: 0;
background: #222;
font-family: 'Microsoft YaHei', sans-serif;
display: flex;
justify-content: center;
align-items: center;
height: 100vh;
color: white;
user-select: none;
}
#game-container {
position: relative;
width: 800px;
height: 500px;
background: #4a752c; /* 草地颜色 */
border: 4px solid #333;
overflow: hidden;
}
/* 顶部状态栏 */
#top-bar {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 60px;
background: rgba(0, 0, 0, 0.6);
display: flex;
align-items: center;
padding: 0 20px;
box-sizing: border-box;
z-index: 10;
}
#sun-score {
font-size: 20px;
font-weight: bold;
color: #ffd700;
margin-right: 40px;
}
/* 卡片样式 */
.card {
width: 70px;
height: 50px;
background: #7b583a;
border: 2px solid #fff;
margin-right: 10px;
border-radius: 4px;
cursor: pointer;
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
font-size: 12px;
font-weight: bold;
}
.card.active {
border-color: #00ff00;
background: #9e7855;
}
.card .cost {
color: #ffd700;
font-size: 11px;
}
/* 草地格子 */
#grid {
position: absolute;
top: 60px;
left: 0;
width: 100%;
height: 440px;
display: grid;
grid-template-columns: repeat(9, 1fr);
grid-template-rows: repeat(5, 1fr);
}
.cell {
border: 1px solid rgba(255, 255, 255, 0.05);
box-sizing: border-box;
position: relative;
cursor: pointer;
}
.cell:hover {
background: rgba(255, 255, 255, 0.1);
}
/* 游戏元素基础样式 */
.sun {
position: absolute;
width: 30px;
height: 30px;
background: #ffd700;
border-radius: 50%;
box-shadow: 0 0 15px #ffcc00;
cursor: pointer;
z-index: 5;
animation: pulse 1s infinite alternate;
}
@keyframes pulse {
from { transform: scale(1); }
to { transform: scale(1.1); }
}
.plant {
position: absolute;
width: 80%;
height: 80%;
top: 10%;
left: 10%;
border-radius: 50%;
display: flex;
justify-content: center;
align-items: center;
font-size: 14px;
font-weight: bold;
color: white;
}
.peashooter { background: #228b22; border: 2px solid #a7ff83; }
.sunflower { background: #ff8c00; border: 2px solid #fff700; }

.zombie {
position: absolute;
width: 40px;
height: 60px;
background: #556b2f;
border: 2px solid #8b0000;
color: white;
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
font-size: 12px;
font-weight: bold;
border-radius: 5px;
z-index: 4;
transition: left 0.1s linear;
}
.hp-bar {
width: 80%;
height: 4px;
background: red;
margin-top: 4px;
}
.pea {
position: absolute;
width: 12px;
height: 12px;
background: #00ff00;
border-radius: 50%;
z-index: 6;
}
/* 游戏结束 */
#game-over {
display: none;
position: absolute;
top: 0; left: 0; width: 100%; height: 100%;
background: rgba(0,0,0,0.8);
z-index: 100;
flex-direction: column;
justify-content: center;
align-items: center;
}
#game-over h1 { color: #ff3333; font-size: 48px; margin-bottom: 20px; }
#game-over button {
padding: 10px 20px; font-size: 18px; cursor: pointer; background: #4a752c; color: white; border: none; border-radius: 5px;
}
</style>
</head>
<body>

<div id="game-container">
<!-- 顶部状态栏 -->
<div id="top-bar">
<div id="sun-score">☀️ 太阳: <span id="sun-val">150</span></div>
<div class="card active" id="card-pea" onclick="selectPlant('peashooter')">
<div>豌豆射手</div>
<div class="cost">100</div>
</div>
<div class="card" id="card-sun" onclick="selectPlant('sunflower')">
<div>向日葵</div>
<div class="cost">50</div>
</div>
</div>

<!-- 游戏草地网格 -->
<div id="grid"></div>

<!-- 游戏结束屏 -->
<div id="game-over">
<h1>僵尸吃掉了你的脑子!</h1>
<button onclick="restartGame()">重新开始</button>
</div>
</div>

<script>
// 游戏配置与状态
const GRID_COLS = 9;
const GRID_ROWS = 5;
let sunCount = 150;
let selectedPlantType = 'peashooter'; // 当前选中的植物
let isGameOver = false;

// 数据存储
let plants = []; // { id, row, col, type, hp, lastActionTime }
let zombies = []; // { id, x, row, hp, maxHp, element }
let peas = []; // { x, y, row, element }

let zombieIdCounter = 0;
let plantIdCounter = 0;

const gridElement = document.getElementById('grid');
const sunValElement = document.getElementById('sun-val');
const gameOverElement = document.getElementById('game-over');

// 初始化网格
function initGrid() {
gridElement.innerHTML = '';
for (let r = 0; r < GRID_ROWS; r++) {
for (let c = 0; c < GRID_COLS; c++) {
const cell = document.createElement('div');
cell.classList.add('cell');
cell.dataset.row = r;
cell.dataset.col = c;
cell.addEventListener('click', () => handleCellClick(r, c));
gridElement.appendChild(cell);
}
}
}

// 切换植物选择卡片
function selectPlant(type) {
selectedPlantType = type;
document.querySelectorAll('.card').forEach(c => c.classList.remove('active'));
if (type === 'peashooter') document.getElementById('card-pea').classList.add('active');
if (type === 'sunflower') document.getElementById('card-sun').classList.add('active');
}

// 更新阳光显示
function updateSunDisplay() {
sunValElement.innerText = sunCount;
}

// 种植植物逻辑
function handleCellClick(row, col) {
if (isGameOver) return;

// 检查格子里是否已经有植物
if (plants.some(p => p.row === row && p.col === col)) return;

let cost = selectedPlantType === 'peashooter' ? 100 : 50;

if (sunCount >= cost) {
sunCount -= cost;
updateSunDisplay();

// 创建植物数据
const cellIndex = row * GRID_COLS + col;
const cell = gridElement.children[cellIndex];

const plantDiv = document.createElement('div');
plantDiv.classList.add('plant', selectedPlantType);
plantDiv.innerText = selectedPlantType === 'peashooter' ? '🌱' : '🌻';
cell.appendChild(plantDiv);

plants.push({
id: plantIdCounter++,
row: row,
col: col,
type: selectedPlantType,
hp: 100,
lastActionTime: Date.now(),
element: plantDiv
});
}
}

// 自然掉落阳光
function spawnNaturalSun() {
if (isGameOver) return;
const x = Math.random() * 700 + 50;
createSunElement(x, 70);
}

// 创建阳光元素
function createSunElement(x, y) {
const sun = document.createElement('div');
sun.classList.add('sun');
sun.style.left = x + 'px';
sun.style.top = y + 'px';

sun.addEventListener('click', (e) => {
e.stopPropagation();
sunCount += 25;
updateSunDisplay();
sun.remove();
});

document.getElementById('game-container').appendChild(sun);

// 自动消失
setTimeout(() => { if(sun) sun.remove(); }, 8000);
}

// 生成僵尸
function spawnZombie() {
if (isGameOver) return;
const row = Math.floor(Math.random() * GRID_ROWS);
const yPosition = 60 + row * 88 + 14; // 根据行计算绝对Y坐标

const zombieDiv = document.createElement('div');
zombieDiv.classList.add('zombie');
zombieDiv.style.left = '750px';
zombieDiv.style.top = yPosition + 'px';
zombieDiv.innerHTML = '🧟<div class="hp-bar"></div>';

document.getElementById('game-container').appendChild(zombieDiv);

zombies.push({
id: zombieIdCounter++,
x: 750,
row: row,
hp: 100,
maxHp: 100,
element: zombieDiv
});
}

// 游戏主循环机制
function gameLoop() {
if (isGameOver) return;

const now = Date.now();

// 1. 植物行为控制
plants.forEach(plant => {
if (plant.type === 'sunflower' && now - plant.lastActionTime > 5000) {
// 向日葵生产阳光
const cellIndex = plant.row * GRID_COLS + plant.col;
const cell = gridElement.children[cellIndex];
const rect = cell.getBoundingClientRect();
const containerRect = document.getElementById('game-container').getBoundingClientRect();
createSunElement(rect.left - containerRect.left + 10, rect.top - containerRect.top + 20);
plant.lastActionTime = now;
}
else if (plant.type === 'peashooter' && now - plant.lastActionTime > 2000) {
// 如果这一行有僵尸,豌豆射手才开火
if (zombies.some(z => z.row === plant.row && z.x > (plant.col * 88))) {
const yPosition = 60 + plant.row * 88 + 30;
const xPosition = plant.col * 88 + 60;

const peaDiv = document.createElement('div');
peaDiv.classList.add('pea');
peaDiv.style.left = xPosition + 'px';
peaDiv.style.top = yPosition + 'px';
document.getElementById('game-container').appendChild(peaDiv);

peas.push({
x: xPosition,
y: yPosition,
row: plant.row,
element: peaDiv
});
plant.lastActionTime = now;
}
}
});

// 2. 移动子弹并进行碰撞检测
for (let i = peas.length - 1; i >= 0; i--) {
let pea = peas[i];
pea.x += 5;
pea.element.style.left = pea.x + 'px';

// 撞击僵尸判定
let hit = false;
for (let j = 0; j < zombies.length; j++) {
let zombie = zombies[j];
if (zombie.row === pea.row && Math.abs(zombie.x - pea.x) < 20) {
zombie.hp -= 20;
// 更新血条
const hpBar = zombie.element.querySelector('.hp-bar');
hpBar.style.width = (zombie.hp / zombie.maxHp * 80) + '%';

hit = true;
break;
}
}

if (hit || pea.x > 800) {
pea.element.remove();
peas.splice(i, 1);
}
}

// 3. 僵尸移动及啃咬判定
for (let i = zombies.length - 1; i >= 0; i--) {
let zombie = zombies[i];

// 检查死掉的僵尸
if (zombie.hp <= 0) {
zombie.element.remove();
zombies.splice(i, 1);
continue;
}

// 检查前方是否有植物
let currentGridCol = Math.floor(zombie.x / 88);
let targetPlant = plants.find(p => p.row === zombie.row && p.col === currentGridCol);

if (targetPlant) {
// 正在啃咬植物
targetPlant.hp -= 0.5;
if (targetPlant.hp <= 0) {
targetPlant.element.remove();
plants = plants.filter(p => p.id !== targetPlant.id);
}
} else {
// 向左移动
zombie.x -= 0.5;
zombie.element.style.left = zombie.x + 'px';
}

// 输赢判定:僵尸突破防线
if (zombie.x < 10) {
endGame();
}
}

requestAnimationFrame(gameLoop);
}

// 停止游戏
function endGame() {
isGameOver = true;
gameOverElement.style.display = 'flex';
}

// 重新启动游戏
function restartGame() {
// 清理界面残留元素
document.querySelectorAll('.sun').forEach(e => e.remove());
document.querySelectorAll('.pea').forEach(e => e.remove());
document.querySelectorAll('.zombie').forEach(e => e.remove());
document.querySelectorAll('.plant').forEach(e => e.remove());

// 重置数据
plants = [];
zombies = [];
peas = [];
sunCount = 150;
isGameOver = false;

updateSunDisplay();
initGrid();
gameOverElement.style.display = 'none';

// 重新驱动循环
requestAnimationFrame(gameLoop);
}

// 启动定时器(生成阳光和僵尸)
setInterval(spawnNaturalSun, 4000);
setInterval(spawnZombie, 7000);

// 游戏首次初始化
initGrid();
updateSunDisplay();
requestAnimationFrame(gameLoop);

</script>
</body>
</html>
flowchart LR
    A[Start]
    B[Process]
    C[Decision]
    D[Success]
    E[Fail]

    A --> B --> C
    C -->|Yes| D
    C -->|No| E

    style A fill:#90CAF9
    style B fill:#A5D6A7
    style C fill:#FFF59D
    style D fill:#81C784
    style E fill:#EF9A9A
journey
    title Player First-Time Experience
    section Login
      Open Game: 5: Player
      Enter Account: 4: Player

    section Gameplay
      Start Tutorial: 5: Player
      Learn Controls: 3: Player
      Finish Tutorial: 5: Player
classDiagram
    class Character {
        +string name
        +int hp
        +move()
        +attack()
    }

    class Player {
        +inventory
        +saveGame()
    }

    class Enemy {
        +aiType
        +patrol()
    }

    Character <|-- Player
    Character <|-- Enemy
gantt
    title Game Development Plan
    dateFormat  YYYY-MM-DD

    section Planning
    Design System      :a1, 2026-05-01, 7d

    section Development
    Core Logic         :a2, after a1, 14d
    UI Implementation  :a3, after a2, 10d

    section Testing
    Bug Fixing         :a4, after a3, 7d
erDiagram
    USER ||--o{ POST : creates
    USER ||--o{ COMMENT : writes
    POST ||--o{ COMMENT : contains

    USER {
        int id
        string name
    }

    POST {
        int id
        string title
    }

    COMMENT {
        int id
        string content
    }
pie title Project Time Allocation
    "Coding" : 45
    "Testing" : 20
    "Debugging" : 15
    "Documentation" : 10
    "Meetings" : 10
sequenceDiagram
    autonumber

    participant Client
    participant API
    participant Order
    participant Inventory
    participant Payment
    participant Shipping
    participant Notification
    participant Saga
    participant EventBus
    participant Audit

    Client->>API: Create Order
    API->>Order: Validate Request

    alt Validation Success
        Order->>Saga: Start Transaction
        Saga->>Inventory: Reserve Stock

        alt Stock Reserved
            Inventory-->>Saga: Success
            Saga->>Payment: Charge Customer

            alt Payment Success
                Payment-->>Saga: Charged
                Saga->>Shipping: Create Shipment

                alt Shipment Success
                    Shipping-->>Saga: Tracking Created
                    Saga->>Order: Confirm Order
                    Order->>EventBus: OrderConfirmed
                    EventBus->>Notification: Send Email
                    EventBus->>Audit: Log Success

                else Shipment Failure
                    Shipping-->>Saga: Failed
                    Saga->>Payment: Refund
                    Saga->>Inventory: Release Stock
                    Saga->>Order: Cancel Order
                    EventBus->>Audit: Compensation Log
                end

            else Payment Failure
                Payment-->>Saga: Failed
                Saga->>Inventory: Release Stock
                Saga->>Order: Cancel
                EventBus->>Audit: Payment Failure
            end

        else Stock Failure
            Inventory-->>Saga: Out of Stock
            Saga->>Order: Reject Order
            EventBus->>Audit: Stock Failure
        end

    else Validation Failed
        API-->>Client: Reject
    end
flowchart TB
    subgraph Client["客户端层"]
        A1[Web App]
        A2[Flutter App]
        A3[Admin Dashboard]
    end

    subgraph Gateway["网关层"]
        B1[Nginx Load Balancer]
        B2[API Gateway]
    end

    subgraph Service["服务层"]
        C1[Auth Service]
        C2[User Service]
        C3[Game Logic Service]
        C4[Notification Service]
    end

    subgraph Middleware["中间件"]
        D1[(Redis Cache)]
        D2[(RabbitMQ)]
    end

    subgraph Database["数据层"]
        E1[(MySQL)]
        E2[(MongoDB)]
        E3[(Object Storage)]
    end

    Client --> Gateway
    Gateway --> Service

    C1 --> D1
    C2 --> D1
    C3 --> D2
    C4 --> D2

    C1 --> E1
    C2 --> E1
    C3 --> E2
    C4 --> E3

    D2 --> C4
stateDiagram-v2
    [*] --> MainMenu

    MainMenu --> Loading : Start Game
    Loading --> WorldMap : Load Complete

    WorldMap --> Exploring
    Exploring --> Battle : Enemy Encounter
    Battle --> Victory : Win
    Battle --> Defeat : Lose

    Victory --> Reward
    Reward --> Exploring

    Defeat --> Respawn
    Respawn --> Exploring

    Exploring --> Pause
    Pause --> Exploring

    WorldMap --> SaveMenu
    SaveMenu --> WorldMap

    Exploring --> [*] : Exit Game
erDiagram
    USER ||--o{ ORDER : places
    USER ||--o{ REVIEW : writes
    PRODUCT ||--o{ REVIEW : receives
    PRODUCT ||--o{ ORDER_ITEM : contains
    ORDER ||--|{ ORDER_ITEM : includes
    ORDER }o--|| PAYMENT : has
    PRODUCT }o--|| CATEGORY : belongs_to

    USER {
        int id
        string username
        string email
        datetime created_at
    }

    ORDER {
        int id
        int user_id
        decimal total_price
        string status
    }

    PRODUCT {
        int id
        string name
        decimal price
        int category_id
    }

    PAYMENT {
        int id
        int order_id
        string method
        string status
    }
flowchart TB

subgraph Users[用户入口层]
    U1[Web用户]
    U2[Mobile App]
    U3[Admin Console]
    U4[Third-party API Clients]
end

subgraph Edge[边缘接入层]
    E1[CDN]
    E2[WAF]
    E3[Load Balancer]
    E4[API Gateway]
end

subgraph Auth[认证中心]
    A1[OAuth2]
    A2[JWT Service]
    A3[Permission Control]
    A4[SSO]
end

subgraph Core[核心业务服务]
    C1[User Service]
    C2[Order Service]
    C3[Inventory Service]
    C4[Payment Service]
    C5[Notification Service]
    C6[Recommendation Engine]
    C7[Analytics Service]
    C8[Search Service]
end

subgraph Async[异步处理]
    Q1[Kafka]
    Q2[RabbitMQ]
    Q3[Event Bus]
end

subgraph Cache[缓存层]
    R1[Redis Cluster]
    R2[Session Store]
    R3[Hot Cache]
end

subgraph DB[数据库集群]
    D1[(User DB)]
    D2[(Order DB)]
    D3[(Inventory DB)]
    D4[(Analytics DB)]
    D5[(Search Index)]
end

subgraph Compute[计算层]
    P1[Realtime Stream Processing]
    P2[Batch Processing]
    P3[ML Training]
end

subgraph Infra[基础设施]
    I1[Kubernetes]
    I2[Monitoring]
    I3[Tracing]
    I4[Logging]
    I5[Alerting]
end

Users --> Edge
Edge --> Auth
Edge --> Core

Auth --> Cache
Auth --> DB

Core --> Cache
Core --> DB
Core --> Async

Async --> Compute
Compute --> DB

Core --> Infra
Compute --> Infra
Auth --> Infra
flowchart TD

A[Source Code] --> B[Lexical Analysis]

B --> C{Token Valid?}

C -->|No| C1[Lexical Error Handler]
C -->|Yes| D[Syntax Parser]

D --> E{AST Valid?}

E -->|No| E1[Syntax Recovery]
E -->|Yes| F[Semantic Analysis]

F --> G{Type Check}

G -->|Fail| G1[Semantic Error Recovery]
G -->|Pass| H[Intermediate Representation]

H --> I[Optimization Phase]

subgraph Optimizer
    I1[Constant Folding]
    I2[Dead Code Elimination]
    I3[Loop Unrolling]
    I4[Inlining]
    I5[Register Allocation]
end

I --> Optimizer

Optimizer --> J{Optimization Stable?}

J -->|No| I
J -->|Yes| K[Code Generation]

K --> L[Assembly Output]

L --> M[Assembler]

M --> N[Object Files]

N --> O[Linker]

O --> P{External Symbols Resolved?}

P -->|No| P1[Link Error]
P -->|Yes| Q[Executable]

Q --> R[Runtime Loader]

R --> S{Dynamic Dependencies?}

S -->|Yes| T[Load Shared Libraries]
S -->|No| U[Execution]

T --> U
stateDiagram-v2

[*] --> Bootstrap

Bootstrap --> Authentication
Authentication --> CharacterSelect
CharacterSelect --> WorldAllocation

WorldAllocation --> ZoneAssignment

state ZoneAssignment {
    [*] --> LoadChunkMap
    LoadChunkMap --> SpawnEntities
    SpawnEntities --> SyncNearbyPlayers
    SyncNearbyPlayers --> InitializePhysics
    InitializePhysics --> ActivateZone
}

ZoneAssignment --> ActiveWorld

state ActiveWorld {

    [*] --> Exploration

    Exploration --> Combat : Enemy Trigger
    Exploration --> Dialogue : NPC Interaction
    Exploration --> ResourceGather : Harvest

    Combat --> SyncCombatState
    SyncCombatState --> DamageResolve
    DamageResolve --> StateReplication

    StateReplication --> Exploration

    Dialogue --> QuestUpdate
    QuestUpdate --> Exploration

    ResourceGather --> InventoryUpdate
    InventoryUpdate --> Exploration

    Exploration --> ZoneBoundary

    ZoneBoundary --> SerializeState
    SerializeState --> TransferNode
    TransferNode --> DeserializeState
    DeserializeState --> Exploration
}

ActiveWorld --> Disconnect

Disconnect --> SaveState
SaveState --> Cleanup
Cleanup --> [*]
flowchart TD

    A[Source Code] --> B[Lexer]
    B --> C[Parser]
    C --> D[AST Builder]

    D --> E{Semantic Check}

    E -->|Fail| E1[Error Recovery]
    E1 --> C

    E -->|Pass| F[IR Generation]

    F --> G[Optimization Pipeline]

    subgraph OPT [Optimizer]
        G1[Constant Folding]
        G2[Dead Code Elimination]
        G3[SSA Transform]
        G4[Loop Optimization]
        G5[Escape Analysis]
        G6[Inline Expansion]

        G1 --> G2
        G2 --> G3
        G3 --> G4
        G4 --> G5
        G5 --> G6
    end

    G --> G1
    G6 --> H{Stable?}

    H -->|No| G
    H -->|Yes| I[Bytecode Emit]

    I --> J[VM Loader]

    J --> K[Interpreter]

    K --> L{Hot Path?}

    L -->|No| M[Execute Bytecode]
    L -->|Yes| N[JIT Compiler]

    N --> O[Machine Code Cache]

    O --> P[Native Execution]

    M --> Q{Allocation?}
    P --> Q

    Q -->|No| R[Continue]
    Q -->|Yes| S[Heap Allocation]

    S --> T{Heap Full?}

    T -->|No| R
    T -->|Yes| U[GC Trigger]

    subgraph GC [Garbage Collector]
        U1[Mark Roots]
        U2[Trace Reachable]
        U3[Sweep Dead Objects]
        U4[Compact Heap]

        U1 --> U2
        U2 --> U3
        U3 --> U4
    end

    U --> U1
    U4 --> R

    R --> V{Program End?}

    V -->|No| K
    V -->|Yes| W[Shutdown VM]