Bun 实战：什么好使、什么不行、什么出乎意料

# 测量启动时间——各运行 100 次
hyperfine --warmup 5 'node -e "console.log(1)"' 'bun -e "console.log(1)"'
 
# 典型结果：
# node:  ~40ms
# bun:   ~6ms

# 全新安装基准测试——先删除 node_modules 和 lockfile
rm -rf node_modules bun.lockb package-lock.json
 
# 计时 npm
time npm install
# Real: ~18.4s（典型中等大小项目）
 
# 计时 bun
time bun install
# Real: ~2.1s

# 用 bombardier 做快速粗糙的基准测试
# 测试简单的 "Hello World" 响应
 
# Bun 服务器
bombardier -c 100 -d 10s http://localhost:3000
# Requests/sec: ~105,000
 
# Node.js（原生 http 模块）
bombardier -c 100 -d 10s http://localhost:3001
# Requests/sec: ~48,000
 
# Node.js（Express）
bombardier -c 100 -d 10s http://localhost:3002
# Requests/sec: ~15,000

// fibonacci.ts——这是受引擎限制的，不是受运行时限制的
function fib(n: number): number {
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
}
 
const start = performance.now();
console.log(fib(42));
console.log(`${(performance.now() - start).toFixed(0)}ms`);

bun run fibonacci.ts   # ~1650ms
node fibonacci.ts      # ~1580ms

# 安装 hyperfine 进行正式基准测试
brew install hyperfine  # macOS
# 或者: cargo install hyperfine
 
# 基准测试你实际应用的启动+执行
hyperfine --warmup 3 \
  'node dist/server.js' \
  'bun src/server.ts' \
  --prepare 'sleep 0.1'
 
# 对于 HTTP 服务器，使用 bombardier 或 wrk
# 重要：使用真实的 payload 测试，而不是 "Hello World"
bombardier -c 50 -d 30s -l http://localhost:3000/api/users
 
# 内存比较
/usr/bin/time -v node server.js  # Linux
/usr/bin/time -l bun server.ts   # macOS

# 从 package.json 安装所有依赖
bun install
 
# 添加依赖
bun add express
 
# 添加开发依赖
bun add -d vitest
 
# 删除依赖
bun remove express
 
# 更新依赖
bun update express
 
# 安装特定版本
bun add express@4.18.2

# 你可以将 lockfile 转储为人类可读格式
bun bun.lockb > lockfile-dump.txt
 
# 或者使用内置的文本输出
bun install --yarn
# 这会在 bun.lockb 旁边生成一个 yarn.lock

{
  "name": "my-monorepo",
  "workspaces": ["packages/*", "apps/*"]
}

# 安装所有 workspace 的依赖
bun install
 
# 在特定 workspace 中运行脚本
bun run --filter packages/shared build
 
# 向特定 workspace 添加依赖
bun add react --filter apps/web

# 步骤 1：删除现有的 lockfile 和 node_modules
rm -rf node_modules package-lock.json yarn.lock pnpm-lock.yaml
 
# 步骤 2：使用 Bun 安装
bun install
 
# 步骤 3：验证你的应用是否仍然正常工作
bun run dev
# 或者: node dist/server.js（Bun 包管理器，Node 运行时）

// 这些在 Bun 中都能按预期工作
import fs from "node:fs";
import path from "node:path";
import crypto from "node:crypto";
import { Buffer } from "node:buffer";
import { EventEmitter } from "node:events";
import { Readable, Writable } from "node:stream";
import http from "node:http";
import https from "node:https";
import { URL, URLSearchParams } from "node:url";
import os from "node:os";
import child_process from "node:child_process";

# 检查一个包是否使用原生插件
ls node_modules/your-package/binding.gyp  # 如果这个文件存在，就是原生的

// 这在 Bun 中不能用——V8 特有
const v8 = require("v8");
v8.serialize({ data: "test" });
 
// 这能用——使用 Bun 的等价物或跨运行时方法
const encoded = new TextEncoder().encode(JSON.stringify({ data: "test" }));

# 对你的项目运行 Bun 内置的兼容性检查
bun --bun node_modules/.bin/your-tool
 
# --bun 标志强制对 node_modules 脚本也使用 Bun 运行时

# 快速兼容性检查——在 Bun 下运行你的完整测试套件
bun test  # 如果你使用 bun test runner
# 或者
bun run vitest  # 如果你使用 vitest

const server = Bun.serve({
  port: 3000,
  fetch(req) {
    const url = new URL(req.url);
 
    if (url.pathname === "/") {
      return new Response("Hello from Bun!", {
        headers: { "Content-Type": "text/plain" },
      });
    }
 
    if (url.pathname === "/api/users") {
      const users = [
        { id: 1, name: "Alice" },
        { id: 2, name: "Bob" },
      ];
      return Response.json(users);
    }
 
    return new Response("Not Found", { status: 404 });
  },
});
 
console.log(`Server running at http://localhost:${server.port}`);

import { Database } from "bun:sqlite";
 
const db = new Database("app.db");
db.run(`
  CREATE TABLE IF NOT EXISTS todos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    completed INTEGER DEFAULT 0,
    created_at TEXT DEFAULT (datetime('now'))
  )
`);
 
const server = Bun.serve({
  port: process.env.PORT || 3000,
 
  async fetch(req) {
    const url = new URL(req.url);
    const method = req.method;
 
    try {
      // GET /api/todos
      if (url.pathname === "/api/todos" && method === "GET") {
        const todos = db.query("SELECT * FROM todos ORDER BY created_at DESC").all();
        return Response.json(todos);
      }
 
      // POST /api/todos
      if (url.pathname === "/api/todos" && method === "POST") {
        const body = await req.json();
 
        if (!body.title || typeof body.title !== "string") {
          return Response.json({ error: "Title is required" }, { status: 400 });
        }
 
        const stmt = db.prepare("INSERT INTO todos (title) VALUES (?) RETURNING *");
        const todo = stmt.get(body.title);
        return Response.json(todo, { status: 201 });
      }
 
      // DELETE /api/todos/:id
      const deleteMatch = url.pathname.match(/^\/api\/todos\/(\d+)$/);
      if (deleteMatch && method === "DELETE") {
        const id = parseInt(deleteMatch[1], 10);
        db.run("DELETE FROM todos WHERE id = ?", [id]);
        return new Response(null, { status: 204 });
      }
 
      return Response.json({ error: "Not found" }, { status: 404 });
    } catch (error) {
      console.error("Request error:", error);
      return Response.json({ error: "Internal server error" }, { status: 500 });
    }
  },
});
 
console.log(`Server running on port ${server.port}`);

// 读取文件
const file = Bun.file("./config.json");
const text = await file.text(); // 读取为字符串
const json = await file.json(); // 直接解析为 JSON
const bytes = await file.arrayBuffer(); // 读取为 ArrayBuffer
const stream = file.stream(); // 读取为 ReadableStream
 
// 文件元数据
console.log(file.size); // 字节大小
console.log(file.type); // MIME 类型（例如 "application/json"）
 
// 写入文件
await Bun.write("./output.txt", "Hello, World!");
await Bun.write("./data.json", JSON.stringify({ key: "value" }));
await Bun.write("./copy.png", Bun.file("./original.png"));
 
// 将 Response body 写入文件
const response = await fetch("https://example.com/data.json");
await Bun.write("./downloaded.json", response);

const server = Bun.serve({
  port: 3000,
 
  fetch(req, server) {
    const url = new URL(req.url);
 
    if (url.pathname === "/ws") {
      const upgraded = server.upgrade(req, {
        data: {
          userId: url.searchParams.get("userId"),
          joinedAt: Date.now(),
        },
      });
 
      if (!upgraded) {
        return new Response("WebSocket upgrade failed", { status: 400 });
      }
      return undefined;
    }
 
    return new Response("Use /ws for WebSocket connections");
  },
 
  websocket: {
    open(ws) {
      console.log(`Client connected: ${ws.data.userId}`);
      ws.subscribe("chat");
    },
 
    message(ws, message) {
      // 广播给所有订阅者
      server.publish("chat", `${ws.data.userId}: ${message}`);
    },
 
    close(ws) {
      console.log(`Client disconnected: ${ws.data.userId}`);
      ws.unsubscribe("chat");
    },
  },
});

import { Database } from "bun:sqlite";
 
// 打开或创建数据库
const db = new Database("myapp.db");
 
// WAL 模式以获得更好的并发读取性能
db.exec("PRAGMA journal_mode = WAL");
 
// 创建表
db.run(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    email TEXT UNIQUE NOT NULL,
    name TEXT NOT NULL,
    created_at TEXT DEFAULT (datetime('now'))
  )
`);
 
// 预编译语句（可复用，重复查询更快）
const insertUser = db.prepare("INSERT INTO users (email, name) VALUES ($email, $name) RETURNING *");
 
const findByEmail = db.prepare("SELECT * FROM users WHERE email = $email");
 
// 使用
const user = insertUser.get({
  $email: "alice@example.com",
  $name: "Alice",
});
console.log(user); // { id: 1, email: "alice@example.com", name: "Alice", ... }
 
// 事务
const insertMany = db.transaction((users: { email: string; name: string }[]) => {
  for (const user of users) {
    insertUser.run({ $email: user.email, $name: user.name });
  }
  return users.length;
});
 
const count = insertMany([
  { email: "bob@example.com", name: "Bob" },
  { email: "carol@example.com", name: "Carol" },
]);
console.log(`Inserted ${count} users`);

// math.test.ts
import { describe, it, expect } from "bun:test";
 
describe("math utilities", () => {
  it("adds numbers correctly", () => {
    expect(1 + 2).toBe(3);
  });
 
  it("handles floating point", () => {
    expect(0.1 + 0.2).toBeCloseTo(0.3);
  });
});

# 运行所有测试
bun test
 
# 运行特定文件
bun test math.test.ts
 
# 运行匹配模式的测试
bun test --test-name-pattern "adds numbers"
 
# 监听模式
bun test --watch
 
# 覆盖率
bun test --coverage

import { describe, it, expect, mock, spyOn } from "bun:test";
import { fetchUsers } from "./api";
 
// Mock 一个模块
mock.module("./database", () => ({
  query: mock(() => [{ id: 1, name: "Alice" }]),
}));
 
describe("fetchUsers", () => {
  it("returns users from database", async () => {
    const users = await fetchUsers();
    expect(users).toHaveLength(1);
    expect(users[0].name).toBe("Alice");
  });
});
 
// Spy 一个对象方法
describe("console", () => {
  it("tracks console.log calls", () => {
    const logSpy = spyOn(console, "log");
    console.log("test message");
    expect(logSpy).toHaveBeenCalledWith("test message");
    logSpy.mockRestore();
  });
});

# 打包单个入口点
bun build ./src/index.ts --outdir ./dist
 
# 为不同目标打包
bun build ./src/index.ts --outdir ./dist --target browser
bun build ./src/index.ts --outdir ./dist --target bun
bun build ./src/index.ts --outdir ./dist --target node
 
# 压缩
bun build ./src/index.ts --outdir ./dist --minify
 
# 生成 sourcemap
bun build ./src/index.ts --outdir ./dist --sourcemap external

const result = await Bun.build({
  entrypoints: ["./src/index.ts", "./src/worker.ts"],
  outdir: "./dist",
  target: "browser",
  minify: {
    whitespace: true,
    identifiers: true,
    syntax: true,
  },
  splitting: true, // 代码分割
  sourcemap: "external",
  external: ["react", "react-dom"], // 不打包这些
  naming: "[dir]/[name]-[hash].[ext]",
  define: {
    "process.env.NODE_ENV": JSON.stringify("production"),
  },
});
 
if (!result.success) {
  console.error("Build failed:");
  for (const log of result.logs) {
    console.error(log);
  }
  process.exit(1);
}
 
for (const output of result.outputs) {
  console.log(`${output.path} — ${output.size} bytes`);
}

// utils.ts
export function used() {
  return "I'll be in the bundle";
}
 
export function unused() {
  return "I'll be tree-shaken away";
}
 
// index.ts
import { used } from "./utils";
console.log(used());

bun build ./src/index.ts --outdir ./dist --minify
# `unused` 函数不会出现在输出中

// build-info.ts——这个文件在构建时运行，不是运行时
export function getBuildInfo() {
  return {
    builtAt: new Date().toISOString(),
    gitSha: require("child_process").execSync("git rev-parse --short HEAD").toString().trim(),
    nodeVersion: process.version,
  };
}

// app.ts
import { getBuildInfo } from "./build-info" with { type: "macro" };
 
// getBuildInfo() 在打包时执行
// 结果作为静态值内联
const info = getBuildInfo();
console.log(`Built at ${info.builtAt}, commit ${info.gitSha}`);

# 使用 Bun 安装依赖，然后使用 Node.js 运行 Next.js
bun install
bun run dev    # 这实际上默认通过 Node.js 运行 "dev" 脚本
bun run build
bun run start

# 强制 Next.js 在 Bun 运行时下运行
bun --bun run dev

# 使用 Bun 运行时构建
bun --bun run build
 
# 使用 Bun 运行时启动生产服务器
bun --bun run start

{
  "scripts": {
    "dev": "next dev --turbopack",
    "build": "next build",
    "start": "next start"
  }
}

# 日常工作流
bun install      # 快速包安装
bun run dev      # 通过 Node.js 运行 "next dev"
bun run build    # 通过 Node.js 运行 "next build"

FROM oven/bun:1 AS base
WORKDIR /app
 
# 安装依赖
FROM base AS deps
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
 
# 构建（如果需要）
FROM base AS build
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun run build
 
# 生产
FROM base AS production
WORKDIR /app
 
# 不要以 root 身份运行
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser
USER appuser
 
COPY --from=deps /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
COPY --from=build /app/package.json ./
 
EXPOSE 3000
CMD ["bun", "run", "dist/server.js"]

# 构建阶段：包含所有依赖的完整 Bun 镜像
FROM oven/bun:1 AS builder
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun build ./src/index.ts --target bun --outdir ./dist --minify
 
# 运行时阶段：更小的基础镜像
FROM oven/bun:1-slim AS runtime
WORKDIR /app
 
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser
USER appuser
 
COPY --from=builder /app/dist ./dist
 
EXPOSE 3000
CMD ["bun", "run", "dist/index.js"]

# 将你的应用编译为单一可执行文件
bun build --compile ./src/server.ts --outfile server
 
# 输出是独立的二进制文件——运行不需要 Bun 或 Node.js
./server

# 使用编译后的二进制文件实现超小 Docker 镜像
FROM oven/bun:1 AS builder
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun build --compile ./src/server.ts --outfile server
 
# 最终镜像——只有二进制文件
FROM debian:bookworm-slim
WORKDIR /app
 
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser
USER appuser
 
COPY --from=builder /app/server ./server
 
EXPOSE 3000
CMD ["./server"]

# Node.js 镜像
docker images | grep node
# node:20-slim    ~180MB
 
# Bun 镜像
docker images | grep bun
# oven/bun:1-slim  ~130MB
 
# 编译后的二进制文件基于 debian:bookworm-slim
# ~80MB 基础 + ~70MB 二进制 = ~150MB 总计
 
# vs. Alpine + Node.js
# node:20-alpine   ~130MB + node_modules

# 将 npm/yarn/pnpm 替换为 bun install
# 修改你的 CI 流水线：
# 之前：
npm ci
 
# 之后：
bun install --frozen-lockfile

# 使用 bun 运行开发脚本
bun run dev
bun run lint
bun run format
 
# 使用 bun 运行一次性脚本
bun run scripts/seed-database.ts
bun run scripts/migrate.ts

# 对简单的测试套件将 vitest/jest 替换为 bun test
bun test
 
# 对复杂的测试设置保留 vitest
# （Testing Library、MSW、自定义环境）

// 新的微服务或 API——从第一天起就用 Bun
Bun.serve({
  port: 3000,
  fetch(req) {
    // 你的新服务写在这里
  },
});

# 只有在经过充分测试之后：
# 将现有服务的 node 替换为 bun
# 之前：
node dist/server.js
 
# 之后：
bun dist/server.js

# .env
DATABASE_URL=postgresql://localhost:5432/myapp
API_KEY=sk-test-12345
PORT=3000

// 无需任何导入即可使用
console.log(process.env.DATABASE_URL);
console.log(process.env.API_KEY);
console.log(Bun.env.PORT); // Bun 特有的替代方式

# Bun 的调试器——与 VS Code 配合使用
bun --inspect run server.ts
 
# Bun 的 inspect-brk——在第一行暂停
bun --inspect-brk run server.ts

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "bun",
      "request": "launch",
      "name": "Debug Bun",
      "program": "${workspaceFolder}/src/server.ts",
      "cwd": "${workspaceFolder}",
      "stopOnEntry": false,
      "watchMode": false
    }
  ]
}

# 比较依赖数量
# 一个典型的 Express + SQLite + WebSocket 项目：
npm ls --all | wc -l
# ~340 个包
 
# 使用 Bun 内置功能实现相同功能：
bun pm ls --all | wc -l
# ~12 个包（只有你的应用代码）

// 使用 Bun.serve() 选项进行生产调优
Bun.serve({
  port: 3000,
 
  // 增加最大请求体大小（默认 128MB）
  maxRequestBodySize: 1024 * 1024 * 50, // 50MB
 
  // 启用开发模式以获得更好的错误页面
  development: process.env.NODE_ENV !== "production",
 
  // 端口重用（对零停机重启有用）
  reusePort: true,
 
  fetch(req) {
    return new Response("OK");
  },
});

// 使用 Bun.Transpiler 进行运行时代码转换
const transpiler = new Bun.Transpiler({
  loader: "tsx",
  target: "browser",
});
 
const code = transpiler.transformSync(`
  const App: React.FC = () => <div>Hello</div>;
  export default App;
`);

# Bun 的内存使用标志
bun --smol run server.ts  # 减少内存占用（稍慢）
 
# 设置最大堆大小
BUN_JSC_forceRAMSize=512000000 bun run server.ts  # ~512MB 限制

// Node.js 18+ 的 fetch 和 Bun 的 fetch 在处理
// 某些 header 和重定向时略有不同
 
// Bun 默认跟随重定向（像浏览器一样）
// Node.js 的 fetch 也跟随重定向，但在某些状态码
// （303、307、308）上行为可能不同
 
const response = await fetch("https://api.example.com/data", {
  redirect: "manual", // 明确指定重定向处理方式
});

// 当事件循环为空时 Bun 会退出
// Node.js 有时由于残留的 handle 而继续运行
 
// 如果你的 Bun 脚本意外退出，说明没有东西
// 在保持事件循环活跃
 
// 这在 Bun 中会立即退出：
setTimeout(() => {}, 0);
 
// 这会保持运行：
setTimeout(() => {}, 1000);
// （Bun 在 timeout 触发后退出）

// Bun 有自己的 tsconfig 默认值
// 如果你在 Bun 和 Node.js 之间共享项目，
// 在 tsconfig.json 中明确指定：
{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "types": ["bun-types"]  // 添加 Bun 类型定义
  }
}

# 安装 Bun 类型
bun add -d @types/bun

# Bun 有内置的监听模式
bun --watch run server.ts
 
# 这在文件更改时重启进程
# 这不是 HMR（热模块替换）——是完整重启
# 但因为 Bun 启动得太快，感觉是即时的

# bunfig.toml——Bun 的配置文件（可选）
 
[install]
# 使用私有注册表
registry = "https://npm.mycompany.com"
 
# 作用域注册表
[install.scopes]
"@mycompany" = "https://npm.mycompany.com"
 
[test]
# 测试配置
coverage = true
coverageReporter = ["text", "lcov"]
 
[run]
# bun run 使用的 shell
shell = "bash"