Bun 1.3 深度实战：当 JavaScript 运行时进化为全栈操作系统——从内置 Redis/MySQL 到生产级全栈开发完全指南（2026）

引言：JavaScript 运行时的「大一统」时刻

2026 年的 JavaScript 运行时战场，格局已经发生了根本性变化。Node.js 仍在「稳如老狗」地守护着它的生态系统壁垒，Deno 在安全性和标准兼容性上不断深耕，而 Bun——这个由 Jarred Sumner 领导的团队从零构建的运行时——正在走出一条完全不同的路。

Bun 1.3 的发布，标志着 JavaScript 运行时从「执行代码的容器」正式迈向「全栈开发操作系统」。这不仅仅是一个版本号的增长，而是一次范式转移：当你不再需要安装任何 npm 包就能连接 MySQL、Redis、PostgreSQL、SQLite，当你能用同一个进程同时服务前端和后端，当你能把整个全栈应用编译成一个独立的可执行文件——JavaScript 开发的工作流被彻底重塑了。

这不是夸大其词。让我们用数据和代码说话。

一、架构层面：Bun 1.3 的设计哲学

1.1 从「运行时」到「全栈平台」的战略跃迁

Bun 的核心设计目标一直很清晰：减少依赖、提升性能、统一工具链。1.3 版本将这三个目标推进到了极致：

这组对比揭示了一个关键洞察：Bun 不是在造轮子，而是在消除轮子的存在需求。当你需要的每一个基础设施都内置在运行时中，npm install 的频率就会断崖式下降。

1.2 JavaScriptCore：性能的基因密码

Bun 选择 JavaScriptCore（JSC）而非 V8 作为底层引擎，这不是随意的选择。JSC 是 Safari 和 WebKit 的 JavaScript 引擎，它有几个 V8 不具备的优势：

1. 启动速度：JSC 的解释器启动延迟比 V8 的 Ignition 低约 30%，这对 CLI 工具和 serverless 场景至关重要
2. 内存占用：JSC 的基线内存占用更小，适合同时运行多个实例
3. JIT 策略：JSC 的多层 JIT（LLInt → Baseline → DFG → FTL）在短生命周期任务上表现更优

Bun 1.3 的内置驱动全部用 Zig + C 实现，直接与 JSC 的 C API 交互，避免了 Node.js 原生模块通过 N-API 的额外开销。这意味着：

数据流：JavaScript → JSC C API → Zig/C 原生实现 → 系统/网络 I/O
                                          ↑
                              零拷贝、零序列化、零 N-API 开销

而传统 Node.js 方案的数据流是：

数据流：JavaScript → N-API 边界 → libuv 事件循环 → C++ 原生实现 → 系统/网络 I/O
                    ↑              ↑
              类型转换开销     事件循环调度开销

1.3 Zig 在基础设施层的关键角色

Bun 的大量基础设施代码用 Zig 编写，这不是技术炫技。Zig 提供了几个关键能力：

• 编译时计算（comptime）：SQL 查询的解析和验证可以在编译时部分完成
• 无隐藏控制流：没有隐式异常抛出，错误处理完全显式，这对数据库驱动至关重要
• 与 C 的无缝互操作：直接调用 MySQL、PostgreSQL、Redis 的 C 客户端库，零开销
• 手动内存管理：在高吞吐场景下避免 GC 压力

二、Bun.SQL：统一数据库 API 的深度剖析

2.1 设计理念：一套 API，四种数据库

Bun 1.3 最重磅的特性之一，是将 MySQL/MariaDB 纳入 Bun.SQL 的统一 API。现在你用完全相同的接口操作 PostgreSQL、MySQL、MariaDB 和 SQLite：

import { sql, SQL } from "bun";

// 同一套 API，四种数据库
const postgres = new SQL("postgres://localhost/mydb");
const mysql = new SQL("mysql://localhost/mydb");
const sqlite = new SQL("sqlite://data.db");

// 默认连接使用环境变量 DATABASE_URL
const seniorAge = 65;
const seniorUsers = await sql`
  SELECT name, age FROM users
  WHERE age >= ${seniorAge}
`;

这个设计的精妙之处在于语义一致性。无论底层是 PostgreSQL 的二进制协议还是 MySQL 的文本协议，你写的代码是完全相同的。这在以下场景中价值巨大：

• 多租户系统：不同租户使用不同数据库，业务代码零修改
• 数据库迁移：从 MySQL 迁移到 PostgreSQL，数据访问层不需要重写
• 测试环境：开发用 SQLite，生产用 PostgreSQL，切换只需改连接字符串

2.2 MySQL 客户端：深入连接协议

Bun 的 MySQL 客户端是用 Zig 实现的原生驱动，直接实现了 MySQL 的客户端/服务器协议。我们来剖析它的关键实现细节：

连接握手协议：

Client                          Server
  |                                |
  |  <-- Greeting Packet --------  |  (Server 能力、字符集、认证插件)
  |  --- Handshake Response ---->  |  (客户端能力、认证数据)
  |  <-- Auth Switch Request ---   |  (可选：切换认证方式)
  |  --- Auth Switch Response ->   |
  |  <-- OK/ERR Packet ---------   |
  |                                |
  |  === 连接建立，进入命令阶段 === |

预处理语句的执行流程：

// Bun 内部会自动使用预处理语句
const result = await sql`
  INSERT INTO users (name, email, age)
  VALUES (${"Alice"}, ${"alice@example.com"}, ${30})
`;

这行代码在底层经历了以下步骤：

1. STMT_PREPARE：将 SQL 模板发送给 MySQL 服务器，获取 Statement ID
2. STMT_EXECUTE：绑定参数并执行，使用二进制协议传输参数值
3. 结果解码：将二进制结果集解码为 JavaScript 对象

与 Node.js 的 mysql2 相比，Bun 省去了：

• JavaScript → C++ 的 N-API 边界穿越
• libuv 事件循环的额外调度
• JavaScript 层面的参数序列化/反序列化

实测性能对比（INSERT 操作，10000 次）：

2.3 MySQL 连接池实战

在生产环境中，连接池是必须的。Bun.SQL 内置连接池支持：

import { SQL } from "bun";

const db = new SQL({
  url: "mysql://user:pass@localhost:3306/myapp",
  pool: {
    max: 20,          // 最大连接数
    min: 5,           // 最小保持连接数
    idleTimeout: 30000, // 空闲超时（毫秒）
  }
});

// 并发查询会自动从池中获取连接
const [users, orders] = await Promise.all([
  sql`SELECT * FROM users LIMIT 10`,
  sql`SELECT * FROM orders WHERE status = 'pending' LIMIT 10`,
]);

2.4 PostgreSQL 增强特性详解

Bun 1.3 对 PostgreSQL 客户端进行了全面增强，让我们逐一深入：

2.4.1 Simple Query Protocol：多语句查询

新增的 .simple() 方法允许在单次请求中执行多条 SQL 语句，这在数据库迁移场景中极为实用：

// 数据库迁移：一次网络往返执行全部 DDL
await sql`
  CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL,
    created_at TIMESTAMPTZ DEFAULT NOW()
  );

  CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(id),
    title TEXT NOT NULL,
    content TEXT,
    published BOOLEAN DEFAULT false
  );

  CREATE INDEX idx_posts_user_id ON posts(user_id);
  CREATE INDEX idx_posts_published ON posts(published) WHERE published = true;

  INSERT INTO users (name, email) VALUES ('Admin', 'admin@example.com');
`.simple();

为什么需要 .simple()？ PostgreSQL 有两种查询协议：

• Extended Query Protocol（默认）：使用预处理语句，参数化查询更安全，但每次只能执行一条语句
• Simple Query Protocol：文本协议，支持多语句，适合 DDL 和迁移脚本

2.4.2 禁用预处理语句：PGBouncer 兼容

在使用 PGBouncer 的事务模式时，预处理语句会导致问题，因为不同连接可能使用不同的 Statement ID：

const sql = new SQL({
  url: "postgres://pgbouncer:6432/mydb",
  prepare: false,  // 禁用预处理语句
});

禁用后，所有查询使用 Simple Query Protocol 执行，与 PGBouncer 完全兼容。

2.4.3 Unix Domain Socket 连接

当应用与 PostgreSQL 在同一台机器上时，Unix Socket 连接比 TCP 快约 15-20%（省去了 TCP 握手和协议栈开销）：

await using sql = new SQL({
  path: "/tmp/.s.PGSQL.5432",  // Socket 文件路径
  user: "postgres",
  password: "postgres",
  database: "mydb"
});

注意这里使用了 await using，这是 ECMAScript 显式资源管理提案（Explicit Resource Management）的语法，Bun 原生支持。当 sql 变量离开作用域时，连接会自动关闭。

2.4.4 运行时配置

PostgreSQL 允许在连接级别设置运行时参数，Bun 1.3 完整支持：

await using db = new SQL("postgres://user:pass@localhost:5432/mydb", {
  connection: {
    search_path: "app_schema,public",     // 模式搜索路径
    statement_timeout: "30s",             // 语句超时
    application_name: "my_app",           // 应用标识（用于 pg_stat_activity）
    lock_timeout: "5s",                   // 锁等待超时
    idle_in_transaction_session_timeout: "60s", // 空闲事务超时
  },
  max: 10  // 连接池大小
});

2.4.5 动态列操作

这是我最喜欢的增强之一。以前构建动态 SQL 需要手动拼接字符串，现在有类型安全的 helpers：

// 从对象中选取指定列插入
const user = { name: "Alice", email: "alice@example.com", age: 30, internal: true };
await sql`INSERT INTO users ${sql(user, "name", "email")}`;
// 等价于: INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')

// 动态更新指定字段
const updates = { name: "Alice Smith", email: "alice.smith@example.com" };
await sql`UPDATE users SET ${sql(updates, "name", "email")} WHERE id = ${userId}`;

// WHERE IN 用数组
await sql`SELECT * FROM users WHERE id IN ${sql([1, 2, 3])}`;

// 从对象数组中提取字段
const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
await sql`SELECT * FROM orders WHERE user_id IN ${sql(users, "id")}`;

2.4.6 PostgreSQL 数组类型支持

PostgreSQL 的数组类型一直是 Node.js 驱动的痛点。Bun 1.3 新增 sql.array() helper：

import { sql } from "bun";

// 插入文本数组
await sql`
  INSERT INTO users (name, roles)
  VALUES (${"Alice"}, ${sql.array(["admin", "user"], "TEXT")})
`;

// JSONB 数组
const jsonData = await sql`
  SELECT ${sql.array([{ a: 1 }, { b: 2 }], "JSONB")} as data
`;

// 各种类型支持
await sql`SELECT ${sql.array([1, 2, 3], "INTEGER")} as numbers`;
await sql`SELECT ${sql.array([true, false], "BOOLEAN")} as flags`;
await sql`SELECT ${sql.array([new Date()], "TIMESTAMP")} as dates`;
await sql`SELECT ${sql.array(["192.168.1.1"], "INET")} as addresses`;
await sql`SELECT ${sql.array(["550e8400-e29b-41d4-a716-446655440000"], "UUID")} as ids`;

底层实现上，Bun 将 JavaScript 数组直接编码为 PostgreSQL 的二进制数组格式，避免了 JSON 序列化的开销。

2.5 SQLite 增强

2.5.1 Database.deserialize() 配置选项

SQLite 的 serialize()/deserialize() 允许你将整个数据库序列化为字节流，然后从字节流恢复。Bun 1.3 新增了反序列化的配置选项：

import { Database } from "bun:sqlite";

const db = new Database("production.db");
const serialized = db.serialize();  // 序列化为 Uint8Array

// 从字节流恢复，带配置
const deserialized = Database.deserialize(serialized, {
  readonly: true,       // 只读模式，适合数据分析场景
  strict: true,         // 启用严格模式，类型检查更严格
  safeIntegers: true,   // 大整数返回 BigInt 而非 number，避免精度丢失
});

应用场景：

• 测试快照：将数据库状态序列化保存，测试时快速恢复，比 migration 脚本快 10 倍以上
• 数据传输：将 SQLite 数据库打包为二进制，通过 HTTP 传输，接收端直接反序列化
• 只读副本：从序列化数据创建只读副本，用于报表查询，不影响主库

2.5.2 列类型内省

新增的 columnTypes 和 declaredTypes 属性让你可以在运行时获取查询结果的类型信息：

import { Database } from "bun:sqlite";

const db = new Database(":memory:");
db.run("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)");
db.run("INSERT INTO users VALUES (1, 'Alice', 30)");

const stmt = db.query("SELECT * FROM users");

// DDL 中声明的类型
console.log(stmt.declaredTypes);  // ["INTEGER", "TEXT", "INTEGER"]

// 实际值的存储类型
console.log(stmt.columnTypes);    // ["integer", "text", "integer"]

const row = stmt.get();

这在构建 ORM 或数据验证层时非常有用——你可以在运行时验证数据是否符合 schema 定义。

三、内置 Redis 客户端：高性能缓存与消息传递

3.1 架构设计

Bun 1.3 的 Redis 客户端是对 JavaScript 生态的一次「降维打击」。在传统 Node.js 方案中，你需要安装 ioredis（约 2MB，含 50+ 依赖），而在 Bun 中：

import { redis, RedisClient } from "bun";

// 默认连接：自动读取 REDIS_URL 环境变量，或连接 localhost:6379
await redis.set("foo", "bar");
const value = await redis.get("foo");
console.log(value);  // "bar"

console.log(await redis.ttl("foo"));  // -1（无过期时间）

零依赖，零配置，开箱即用。Bun 的 Redis 客户端支持 66 个命令，覆盖了日常开发的绝大多数场景：

3.2 性能基准

Bun 声称其 Redis 客户端比 ioredis 快得多，而且优势随批量大小增长而增大。我们来分析原因：

为什么更快？

1. 零依赖开销：ioredis 有 JavaScript 层的命令构建器、Pipeline 队列、Cluster 路由等，每层都有开销
2. RESP 协议直接实现：Bun 用 Zig 直接实现了 Redis 的 RESP2/RESP3 协议，省去 JavaScript 层的解析
3. 连接管理优化：自动重连、命令超时、消息队列都在原生层处理，不经过 JavaScript 事件循环

// Pipeline 示例：批量操作
import { redis } from "bun";

// 不需要显式 pipeline，Bun 内部自动批量发送
const results = await Promise.all([
  redis.set("key1", "value1"),
  redis.set("key2", "value2"),
  redis.set("key3", "value3"),
  redis.get("key1"),
  redis.get("key2"),
  redis.get("key3"),
]);

3.3 Pub/Sub 实战

Redis 的 Pub/Sub 是构建实时系统的利器。Bun 1.3 完整支持：

import { RedisClient } from "bun";

// 创建独立的客户端连接
const myRedis = new RedisClient("redis://localhost:6379");

// 订阅者不能发布消息，需要复制连接
const publisher = await myRedis.duplicate();

// 订阅频道
await myRedis.subscribe("notifications", (message, channel) => {
  console.log(`[${channel}] Received:`, message);
});

// 发布消息
await publisher.publish("notifications", "Hello from Bun!");

// 支持模式订阅
await myRedis.psubscribe("user:*", (message, channel) => {
  console.log(`[${channel}] User event:`, message);
});

实战场景：实时通知系统

import { serve, redis, RedisClient } from "bun";

const publisher = new RedisClient("redis://localhost:6379");

serve({
  port: 3000,
  routes: {
    "/events": (req) => {
      // SSE 端点：客户端通过 EventSource 连接
      const stream = new ReadableStream({
        start(controller) {
          const subscriber = new RedisClient("redis://localhost:6379");
          subscriber.subscribe("notifications", (message) => {
            controller.enqueue(`data: ${message}\n\n`);
          });
        },
      });

      return new Response(stream, {
        headers: {
          "Content-Type": "text/event-stream",
          "Cache-Control": "no-cache",
          "Connection": "keep-alive",
        },
      });
    },

    "/notify": {
      POST: async (req) => {
        const { message } = await req.json();
        await publisher.publish("notifications", message);
        return Response.json({ ok: true });
      },
    },
  },
});

3.4 Redis 作为缓存层

将 Redis 与 Bun.SQL 结合，可以构建高性能的缓存层：

import { sql, redis } from "bun";

async function getUserWithCache(id: number) {
  // 先查缓存
  const cached = await redis.get(`user:${id}`);
  if (cached) {
    return JSON.parse(cached);
  }

  // 缓存未命中，查数据库
  const [user] = await sql`SELECT * FROM users WHERE id = ${id}`;
  if (!user) return null;

  // 写入缓存，TTL 5 分钟
  await redis.set(`user:${id}`, JSON.stringify(user), "EX", 300);
  return user;
}

// 批量预热缓存
async function warmupCache() {
  const users = await sql`SELECT * FROM users WHERE active = true`;
  const pipeline = redis.pipeline();  // 如果 Bun 支持显式 pipeline
  for (const user of users) {
    await redis.set(`user:${user.id}`, JSON.stringify(user), "EX", 300);
  }
}

四、全栈开发：前端 + 后端的统一体验

4.1 HTML 即入口：前端开发的新范式

Bun 1.3 允许你直接运行 HTML 文件作为开发服务器：

bun './**/*.html'

输出：

Bun v1.3.14

ready in 6.62ms

http://localhost:3000/

Routes:
  /           ./index.html
  /dashboard  ./dashboard.html

Press h + Enter to show shortcuts

这不是一个静态文件服务器。Bun 会使用其原生的 JavaScript/CSS 转译器和打包器，自动处理你的 React、CSS、JavaScript 和 HTML 文件。

4.2 Hot Module Replacement：原生实现

HMR 是现代前端开发的标配。Bun 1.3 内置了 HMR 支持，包括 React Fast Refresh：

import homepage from "./index.html";
import dashboard from "./dashboard.html";
import { serve } from "bun";

serve({
  development: {
    hmr: true,     // 启用热模块替换
    console: true, // 浏览器 console.log 输出到终端
  },
  routes: {
    "/": homepage,
    "/dashboard": dashboard,
  },
});

文件系统监听的实现：Bun 用原生代码实现了文件监听，使用了平台最快的 API：

• macOS：kqueue
• Linux：inotify
• Windows：ReadDirectoryChangesW

这比 Node.js 生态的 chokidar（基于 fs.watch + 轮询回退）快得多，CPU 占用也更低。

4.3 参数化路由：前后端统一

Bun 1.3 在 Bun.serve() 中新增了参数化路由和通配路由：

import { serve, sql } from "bun";
import App from "./myReactSPA.html";

serve({
  port: 3000,
  routes: {
    // 前端 SPA
    "/*": App,

    // RESTful API
    "/api/users": {
      GET: async () => Response.json(await sql`SELECT * FROM users LIMIT 10`),

      POST: async (req) => {
        const { name, email } = await req.json();
        const [user] = await sql`
          INSERT INTO users ${sql({ name, email })}
          RETURNING *
        `;
        return Response.json(user);
      },
    },

    // 参数化路由
    "/api/users/:id": async (req) => {
      const { id } = req.params;
      const [user] = await sql`SELECT * FROM users WHERE id = ${id} LIMIT 1`;
      if (!user) return new Response("User not found", { status: 404 });
      return Response.json(user);
    },

    // 静态 JSON 响应
    "/healthcheck.json": Response.json({ status: "ok" }),
  },
});

路由匹配算法：Bun 使用基于基数树（Radix Tree）的路由匹配，时间复杂度为 O(k)，k 为路径长度。这比 Express 的线性匹配（O(n)，n 为路由数量）在大量路由时快得多。

4.4 生产构建与独立可执行文件

当开发完成，一条命令构建生产版本：

bun build ./index.html --production --outdir=dist

更令人兴奋的是，你可以把整个全栈应用编译为一个独立的可执行文件：

bun build --compile ./index.html --outfile myapp

这个可执行文件：

• 包含了前端和后端的所有代码
• 可以使用 Bun.serve() 路由、Bun.sql、Bun.redis 等 API
• 不需要安装 Bun、Node.js 或任何运行时
• 适合部署到任何 Linux 服务器、Docker 容器或边缘节点

// 编译后的独立应用依然可以访问数据库和 Redis
import { serve, sql, redis } from "bun";

serve({
  port: process.env.PORT || 3000,
  routes: {
    "/api/data": async () => {
      const cached = await redis.get("api:data");
      if (cached) return Response.json(JSON.parse(cached));

      const data = await sql`SELECT * FROM data LIMIT 100`;
      await redis.set("api:data", JSON.stringify(data), "EX", 60);
      return Response.json(data);
    },
  },
});

与 Docker 结合：

FROM scratch
COPY myapp /myapp
EXPOSE 3000
CMD ["/myapp"]

最终镜像大小可以控制在 50MB 以内（对比 Node.js + Alpine 约 120MB）。

4.5 CORS 问题的终结

前后端同端口的另一个好处是彻底消除了 CORS 问题：

传统方案：
  前端 localhost:5173 (Vite)  →  后端 localhost:3000 (Express)
  → 跨域！需要配置 CORS 中间件
  → Cookie 传递需要额外配置 credentials
  → 预检请求增加延迟

Bun 方案：
  前端 + 后端 localhost:3000 (Bun)
  → 同源！无 CORS 问题
  → Cookie 自然传递
  → 无预检请求

五、WebSocket 改进

5.1 RFC 6455 完整实现

Bun 1.3 的 WebSocket 实现更符合 Web 标准：

// 子协议协商
const ws = new WebSocket("ws://localhost:3000", ["chat", "superchat"]);

ws.onopen = () => {
  console.log(`Connected with protocol: ${ws.protocol}`);  // "chat"
};

5.2 自定义 WebSocket 头

const ws = new WebSocket("ws://localhost:8080", {
  headers: {
    "Host": "custom-host.example.com",
    "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==",
  },
});

这在通过反向代理或需要自定义认证头时非常有用。

5.3 实战：WebSocket 聊天服务器

import { serve, redis } from "bun";

const clients = new Set<WebSocket>();

serve({
  port: 3000,
  routes: {
    "/": new Response(`
      <!DOCTYPE html>
      <html>
        <body>
          <div id="messages"></div>
          <input id="input" autocomplete="off" />
          <script>
            const ws = new WebSocket("ws://localhost:3000/ws");
            ws.onmessage = (e) => {
              const div = document.createElement("div");
              div.textContent = e.data;
              document.getElementById("messages").appendChild(div);
            };
            document.getElementById("input").onkeydown = (e) => {
              if (e.key === "Enter") {
                ws.send(e.target.value);
                e.target.value = "";
              }
            };
          </script>
        </body>
      </html>
    `, { headers: { "Content-Type": "text/html" } }),
  },

  websocket: {
    open(ws) {
      clients.add(ws);
      // 从 Redis 加载历史消息
      redis.lrange("chat:history", 0, 49).then((msgs) => {
        for (const msg of msgs) ws.send(msg);
      });
    },
    message(ws, message) {
      // 广播给所有客户端
      for (const client of clients) {
        client.send(message);
      }
      // 持久化到 Redis
      redis.lpush("chat:history", message);
      redis.ltrim("chat:history", 0, 99);  // 保留最近 100 条
    },
    close(ws) {
      clients.delete(ws);
    },
  },
});

六、性能调优与生产部署

6.1 连接池调优

import { SQL, RedisClient } from "bun";

// 数据库连接池
const db = new SQL({
  url: process.env.DATABASE_URL!,
  pool: {
    max: 20,
    min: 5,
    idleTimeout: 30000,
  },
});

// Redis 连接
const redis = new RedisClient({
  url: process.env.REDIS_URL!,
  // 自动重连
  reconnect: true,
  // 命令超时
  commandTimeout: 5000,
});

6.2 查询性能优化技巧

1. 使用预处理语句缓存

// Bun 自动缓存预处理语句，重复查询只编译一次
for (const user of users) {
  // 同一条 SQL 只 prepare 一次，后续 execute
  await sql`INSERT INTO users ${sql(user, "name", "email")}`;
}

2. 批量操作

// 批量插入：单次网络往返
const values = users.map(u => sql({ name: u.name, email: u.email }));
// 使用 UNNEST 或 VALUES 列表
await sql`INSERT INTO users (name, email) SELECT * FROM ${sql.array(values)}`;

3. 连接复用

// 使用事务减少网络往返
await sql`BEGIN`;
try {
  await sql`INSERT INTO users ${sql({ name: "Alice", email: "alice@test.com" })}`;
  await sql`INSERT INTO audit_log ${sql({ action: "create_user", target: "Alice" })}`;
  await sql`COMMIT`;
} catch (e) {
  await sql`ROLLBACK`;
  throw e;
}

6.3 错误处理最佳实践

Bun 1.3 导出了所有数据库错误类，支持类型安全的错误处理：

import { PostgresError, MySQLError, SQLiteError } from "bun";

try {
  await sql`INSERT INTO users (email) VALUES (${duplicateEmail})`;
} catch (err) {
  if (err instanceof PostgresError) {
    if (err.code === "23505") {  // unique_violation
      return Response.json({ error: "Email already exists" }, { status: 409 });
    }
  }
  if (err instanceof MySQLError) {
    if (err.code === "ER_DUP_ENTRY") {
      return Response.json({ error: "Email already exists" }, { status: 409 });
    }
  }
  throw err;  // 其他错误向上抛出
}

6.4 优雅关闭

import { sql, redis } from "bun";

// 进程信号处理
process.on("SIGTERM", async () => {
  console.log("Shutting down gracefully...");

  // 关闭数据库连接
  await sql.close();

  // 关闭 Redis 连接
  await redis.quit();

  process.exit(0);
});

6.5 生产部署清单

• 使用 bun build --compile 生成独立可执行文件
• 配置 DATABASE_URL 和 REDIS_URL 环境变量
• 设置连接池参数（max、idleTimeout）
• 启用 PGBouncer 时设置 prepare: false
• 配置 Unix Domain Socket（如果同机部署）
• 设置 statement_timeout 防止慢查询
• 实现优雅关闭（SIGTERM 处理）
• 添加健康检查端点 /healthcheck.json
• 使用 readonly: true 的 SQLite 副本处理报表查询
• 监控 Redis 连接状态和命令延迟

七、与 Node.js 生态的兼容性

7.1 渐进式采用策略

Bun 最聪明的设计决策之一是「渐进式采用」。你不必一次性切换整个项目：

# 只用 Bun 的包管理器（替代 npm/yarn/pnpm）
bun install

# 只用 Bun 的测试运行器（替代 Jest）
bun test

# 只用 Bun 的运行时执行单个脚本
bun run my-script.ts

# 完整全栈开发
bun dev

7.2 Node.js 兼容性改进

Bun 1.3 在 Node.js 兼容性上又迈出了重要一步。主要改进包括：

• 更完整的 node: 协议支持
• fs 模块的流式操作改进
• child_process 的更多边界情况处理
• net 和 tls 模块的兼容性增强
• worker_threads 的稳定性提升

7.3 迁移路径

对于现有的 Express/Fastify 项目，迁移路径是：

1. Phase 1：用 bun 替换 node 运行，验证兼容性
2. Phase 2：将 pg/mysql2 替换为 Bun.SQL
3. Phase 3：将 ioredis 替换为 Bun.redis
4. Phase 4：将 Express 路由迁移到 Bun.serve() 路由
5. Phase 5：添加前端 HTML 导入，实现全栈统一

// Phase 2: 替换数据库驱动
// 之前
import pg from "pg";
const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });
const result = await pool.query("SELECT * FROM users WHERE id = $1", [userId]);

// 之后
import { sql } from "bun";
const result = await sql`SELECT * FROM users WHERE id = ${userId}`;

八、Bun 1.3 的局限与未来方向

8.1 当前局限

作为技术人，我们既要看到亮点，也要正视局限：

1. Redis 集群尚不支持：目前只支持单实例和 Valkey，集群支持在开发中
2. Redis Streams 未实现：消息队列场景暂不可用
3. Lua 脚本支持待开发：复杂原子操作仍需依赖服务端
4. MySQL 的预处理语句还不够完善：某些边缘情况可能需要回退到文本协议
5. 前端开发工具链：虽然 Midjourney 在使用，但相比 Vite 的插件生态仍有差距
6. Windows 支持稳定性：部分原生功能在 Windows 上的稳定性仍需提升

8.2 未来路线图

根据 Bun 团队的公开信息，1.3 系列将重点关注：

• Redis 集群、Streams、Lua 脚本
• 更完善的 WebSocket 服务端 API
• 前端开发工具链的持续增强
• Node.js 兼容性的持续改进
• 性能的持续优化

九、实战：30 分钟构建一个全栈应用

让我们把所有知识串联起来，构建一个完整的全栈待办事项应用：

9.1 项目初始化

bun init --react=tailwind todo-app
cd todo-app

9.2 数据库 Schema

// db/migrate.ts
import { sql } from "bun";

await sql`
  CREATE TABLE IF NOT EXISTS todos (
    id SERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    completed BOOLEAN DEFAULT false,
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
  );

  CREATE INDEX IF NOT EXISTS idx_todos_completed ON todos(completed) WHERE completed = false;
`.simple();

console.log("Migration complete!");

9.3 全栈服务器

// server.ts
import { serve, sql, redis } from "bun";
import App from "./index.html";

serve({
  port: 3000,

  development: {
    hmr: true,
    console: true,
  },

  routes: {
    "/*": App,

    "/api/todos": {
      GET: async () => {
        // 先查 Redis 缓存
        const cached = await redis.get("todos:all");
        if (cached) return Response.json(JSON.parse(cached));

        // 缓存未命中，查数据库
        const todos = await sql`SELECT * FROM todos ORDER BY created_at DESC`;
        await redis.set("todos:all", JSON.stringify(todos), "EX", 30);
        return Response.json(todos);
      },

      POST: async (req) => {
        const { title } = await req.json();
        const [todo] = await sql`
          INSERT INTO todos ${sql({ title })}
          RETURNING *
        `;
        // 使缓存失效
        await redis.del("todos:all");
        return Response.json(todo, { status: 201 });
      },
    },

    "/api/todos/:id": {
      PATCH: async (req) => {
        const { id } = req.params;
        const { title, completed } = await req.json();
        const updates: Record<string, any> = {};
        if (title !== undefined) updates.title = title;
        if (completed !== undefined) updates.completed = completed;

        const [todo] = await sql`
          UPDATE todos
          SET ${sql(updates, ...Object.keys(updates))}, updated_at = NOW()
          WHERE id = ${id}
          RETURNING *
        `;
        if (!todo) return new Response("Not found", { status: 404 });
        await redis.del("todos:all");
        return Response.json(todo);
      },

      DELETE: async (req) => {
        const { id } = req.params;
        await sql`DELETE FROM todos WHERE id = ${id}`;
        await redis.del("todos:all");
        return new Response(null, { status: 204 });
      },
    },

    "/healthcheck.json": Response.json({ status: "ok" }),
  },
});

9.4 前端组件

// src/App.tsx
import { useState, useEffect } from "react";

interface Todo {
  id: number;
  title: string;
  completed: boolean;
}

export default function App() {
  const [todos, setTodos] = useState<Todo[]>([]);
  const [input, setInput] = useState("");

  useEffect(() => {
    fetch("/api/todos")
      .then((r) => r.json())
      .then(setTodos);
  }, []);

  const addTodo = async () => {
    if (!input.trim()) return;
    const res = await fetch("/api/todos", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ title: input }),
    });
    const todo = await res.json();
    setTodos([todo, ...todos]);
    setInput("");
  };

  const toggleTodo = async (id: number, completed: boolean) => {
    await fetch(`/api/todos/${id}`, {
      method: "PATCH",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ completed: !completed }),
    });
    setTodos(todos.map((t) => (t.id === id ? { ...t, completed: !completed } : t)));
  };

  return (
    <div className="max-w-md mx-auto mt-8 p-4">
      <h1 className="text-2xl font-bold mb-4">Todo App (Bun Full-Stack)</h1>
      <div className="flex gap-2 mb-4">
        <input
          value={input}
          onChange={(e) => setInput(e.target.value)}
          onKeyDown={(e) => e.key === "Enter" && addTodo()}
          className="flex-1 border rounded px-2 py-1"
          placeholder="Add a todo..."
        />
        <button onClick={addTodo} className="bg-blue-500 text-white px-4 py-1 rounded">
          Add
        </button>
      </div>
      {todos.map((todo) => (
        <div key={todo.id} className="flex items-center gap-2 py-1">
          <input
            type="checkbox"
            checked={todo.completed}
            onChange={() => toggleTodo(todo.id, todo.completed)}
          />
          <span className={todo.completed ? "line-through text-gray-400" : ""}>
            {todo.title}
          </span>
        </div>
      ))}
    </div>
  );
}

9.5 编译为独立可执行文件

bun build --compile ./index.html --outfile todo-app
./todo-app  # 直接运行！

十、总结：JavaScript 全栈开发的「iPhone 时刻」

Bun 1.3 不仅仅是一个 JavaScript 运行时的新版本，它代表了全栈 JavaScript 开发的一个拐点——就像 iPhone 不是第一部手机，但它重新定义了手机。

三个关键洞察：

1. 依赖最小化：当 Redis、MySQL、PostgreSQL、SQLite 都是内置的，node_modules 的膨胀就有了天然的上限。这不是减少依赖，而是消除依赖的需求。

2. 工具链统一：前端开发服务器、HMR、生产构建、HTTP 服务器、数据库驱动、缓存客户端——全部来自同一个运行时。版本兼容性问题不复存在。

3. 部署极简化：bun build --compile 将整个全栈应用打包为一个二进制文件。Docker 镜像从 120MB+ 降到 50MB，部署时间从分钟级降到秒级。

谁应该关注 Bun 1.3？

• 创业团队：减少基础设施选择，加速从 0 到 1
• 全栈独立开发者：一个人就是一支军队
• Serverless 场景：更小的冷启动时间和内存占用
• 内部工具：快速构建，无需复杂的基础设施

谁暂时应该观望？

• 大型 Node.js 单体应用：迁移成本可能大于收益
• 依赖 Node.js 原生插件（特别是 C++ addon）的项目
• 需要 Redis 集群的场景
• Windows 为主力开发环境的团队

Bun 1.3 传递了一个清晰的信号：JavaScript 运行时的竞争，已经从「谁更快」升级为「谁能让开发者更少地离开运行时」。这个方向，值得每一个 JavaScript 开发者认真思考。

参考资源：

• Bun 1.3 官方发布公告
• Bun SQL 文档
• Bun Redis 文档
• Bun 前端开发文档