Bun 简介 #

什么是 Bun？ #

Bun 是一个现代化的高性能 JavaScript 和 TypeScript 运行时，由 Jarred Sumner 于 2021 年创建。Bun 使用 Zig 语言编写，基于 Apple 的 JavaScriptCore 引擎，旨在成为 Node.js 的更快替代品。

核心定位 #

text

┌─────────────────────────────────────────────────────────────┐
│                         Bun                                  │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │   运行时     │  │   打包器     │  │  测试运行器  │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │  包管理器    │  │  TypeScript │  │   SQLite    │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
└─────────────────────────────────────────────────────────────┘

Bun 的历史 #

发展历程 #

text

2021年 ─── Bun 项目启动
    │
    │      Jarred Sumner 开发
    │      使用 Zig 语言编写
    │      基于 JavaScriptCore
    │
2022年 ─── Bun 0.1 发布
    │
    │      公开发布
    │      社区开始关注
    │      性能惊艳众人
    │
2023年 ─── Bun 1.0 发布
    │
    │      生产就绪版本
    │      完整的 Node.js 兼容
    │      包管理器功能
    │
2024年 ─── Bun 1.1+
    │
    │      Windows 支持
    │      更多 API 完善
    │      生态持续扩展
    │
至今   ─── 快速发展
    │
    │      GitHub 70k+ Stars
    │      活跃的社区
    │      持续性能优化

里程碑版本 #

版本	时间	重要特性
0.1	2022.07	首次发布，基础运行时功能
0.5	2023.03	包管理器功能
0.6	2023.04	测试运行器
0.7	2023.07	Windows 预览版
1.0	2023.09	生产就绪版本
1.1	2024.04	Windows 正式支持
1.2	2024.12	更多 API 和性能优化

为什么选择 Bun？ #

Node.js 的痛点 #

传统 Node.js 开发面临的问题：

javascript

// 需要多个工具配合
// package.json
{
  "devDependencies": {
    "typescript": "^5.0.0",      // TypeScript 编译
    "ts-node": "^10.0.0",        // TS 运行
    "nodemon": "^3.0.0",         // 热重载
    "jest": "^29.0.0",           // 测试
    "esbuild": "^0.19.0",        // 打包
    "eslint": "^8.0.0",          // 代码检查
    "prettier": "^3.0.0"         // 格式化
  }
}

// 启动慢、配置复杂
// 运行 TypeScript 需要 ts-node 或编译

Bun 的解决方案 #

javascript

// 一个工具搞定所有
// 无需安装额外依赖

// 直接运行 TypeScript
bun run index.ts

// 内置测试
bun test

// 内置打包
bun build ./src/index.ts --outdir ./dist

// 包管理（比 npm 快 25 倍）
bun install

Bun 的核心特点 #

1. 极致性能 #

Bun 的性能远超 Node.js 和 Deno：

text

┌─────────────────────────────────────────────────────────────┐
│                    性能对比（相对速度）                       │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  Node.js   ████████████████████████████████████  1x         │
│                                                              │
│  Deno      ██████████████████████████           1.5x        │
│                                                              │
│  Bun       █                                  4x+           │
│                                                              │
└─────────────────────────────────────────────────────────────┘

启动速度对比 #

bash

# Node.js 启动时间
time node -e "console.log('hello')"
# real    0m0.080s

# Bun 启动时间
time bun -e "console.log('hello')"
# real    0m0.015s

测试运行对比 #

bash

# Jest 运行 100 个测试
time jest
# real    0m5.234s

# Bun 运行相同测试
time bun test
# real    0m0.876s

2. TypeScript 原生支持 #

无需配置，直接运行 TypeScript：

typescript

// index.ts - 直接运行，无需编译
interface User {
  name: string;
  age: number;
}

function greet(user: User): string {
  return `Hello, ${user.name}!`;
}

const user: User = { name: "Bun", age: 3 };
console.log(greet(user));

// 运行: bun run index.ts

3. JSX 支持 #

内置 JSX 转换，支持 React：

tsx

// app.tsx
function App({ name }: { name: string }) {
  return <h1>Hello, {name}!</h1>;
}

console.log(<App name="Bun" />);

// 运行: bun run app.tsx

4. Web 标准 API #

内置现代 Web API：

javascript

// fetch API - 无需 node-fetch
const response = await fetch("https://api.example.com/data");
const data = await response.json();

// WebSocket - 无需 ws 库
const ws = new WebSocket("wss://example.com");
ws.onmessage = (event) => console.log(event.data);

// FormData - 无需 form-data
const formData = new FormData();
formData.append("file", new Blob(["content"]), "file.txt");

// URL、URLSearchParams
const url = new URL("https://example.com?foo=bar");
console.log(url.searchParams.get("foo"));

5. 内置 SQLite #

高性能 SQLite 数据库：

javascript

import { Database } from "bun:sqlite";

const db = new Database(":memory:");

db.run(`
  CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT
  )
`);

db.run("INSERT INTO users (name) VALUES (?)", ["Bun"]);

const users = db.query("SELECT * FROM users").all();
console.log(users);

6. 热重载 #

开发模式自动重载：

bash

# 使用 --hot 参数
bun --hot run server.ts

# 文件修改后自动重载
# 无需 nodemon

Bun 与其他运行时对比 #

Bun vs Node.js #

特性	Bun	Node.js
启动速度	极快	较慢
TypeScript	✅ 原生支持	❌ 需要工具
JSX	✅ 原生支持	❌ 需要 Babel
测试运行器	✅ 内置	❌ 需要 Jest
打包器	✅ 内置	❌ 需要 Webpack
包管理器	✅ 内置	❌ 需要 npm/yarn
fetch API	✅ 内置	✅ v18+
SQLite	✅ 内置	❌ 需要库
生态成熟度	🔄 发展中	✅ 成熟

Bun vs Deno #

特性	Bun	Deno
语言	Zig	Rust
引擎	JavaScriptCore	V8
npm 兼容	✅ 原生	✅ 兼容层
性能	极快	快
配置文件	package.json	deno.json
安全模型	无限制	权限系统
内置工具	全面	全面

Bun 的架构 #

技术栈 #

text

┌─────────────────────────────────────────────────────────────┐
│                      Bun 架构                                │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────────────────────────────────────────────────┐  │
│  │                    用户代码                            │  │
│  │         JavaScript / TypeScript / JSX                 │  │
│  └──────────────────────────────────────────────────────┘  │
│                           │                                  │
│                           ▼                                  │
│  ┌──────────────────────────────────────────────────────┐  │
│  │                    Bun Runtime                        │  │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐    │  │
│  │  │Transpiler│ │ Bundler │ │ Tester  │ │ Pkg Mgr │    │  │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘    │  │
│  └──────────────────────────────────────────────────────┘  │
│                           │                                  │
│                           ▼                                  │
│  ┌──────────────────────────────────────────────────────┐  │
│  │                 JavaScriptCore (JSC)                  │  │
│  │              Apple 的 JavaScript 引擎                  │  │
│  └──────────────────────────────────────────────────────┘  │
│                           │                                  │
│                           ▼                                  │
│  ┌──────────────────────────────────────────────────────┐  │
│  │                      Zig 层                           │  │
│  │           系统调用、IO、网络操作                        │  │
│  └──────────────────────────────────────────────────────┘  │
│                                                              │
└─────────────────────────────────────────────────────────────┘

为什么选择 Zig 和 JavaScriptCore？ #

技术	选择原因
Zig	无隐藏控制流、手动内存管理、编译时执行、易于与 C 交互
JavaScriptCore	Safari 的 JS 引擎、启动快、内存效率高、经过生产验证

Bun 的应用场景 #

1. Web API 服务 #

typescript

// server.ts
Bun.serve({
  port: 3000,
  async fetch(req) {
    const url = new URL(req.url);
    
    if (url.pathname === "/api/users") {
      return Response.json({ users: [] });
    }
    
    return new Response("Not Found", { status: 404 });
  },
});

console.log("Server running on http://localhost:3000");

2. 全栈应用 #

tsx

// 使用 Elysia 或 Hono 框架
import { Elysia } from "elysia";

new Elysia()
  .get("/", () => "Hello Bun!")
  .get("/users/:id", ({ params }) => `User ${params.id}`)
  .listen(3000);

3. CLI 工具 #

typescript

// cli.ts
const args = process.argv.slice(2);

if (args[0] === "init") {
  console.log("Initializing project...");
  // 创建项目结构
}

// 运行: bun run cli.ts init

4. 脚本任务 #

typescript

// scripts/build.ts
import { $ } from "bun";

await $`echo "Building..."`;
await $`bun build ./src/index.ts --outdir ./dist`;
console.log("Build complete!");

Bun 的核心概念 #

全局对象 #

javascript

// Bun 特有全局
Bun.serve();           // HTTP 服务器
Bun.file();            // 文件操作
Bun.write();           // 写入文件
Bun.env;               // 环境变量
Bun.$;                 // Shell 命令

// Node.js 兼容
process;               // 进程对象
Buffer;                // Buffer 类

内置模块 #

javascript

// Bun 特有模块
import { Database } from "bun:sqlite";
import { spawn } from "bun";
import { serve } from "bun";

// Node.js 兼容模块
import fs from "fs";
import path from "path";
import http from "http";

Bun 的局限性 #

已知限制 #

生态成熟度：部分 npm 包可能不兼容
原生模块：某些 Node.js 原生模块需要适配
Windows 支持：部分功能仍在完善
社区规模：相比 Node.js 社区较小

解决方案 #

javascript

// 使用 --bun 强制使用 Bun 运行
bun --bun run script.js

// 使用 node fallback
// Bun 会自动尝试 Node.js 兼容模式

学习路径 #

text

入门阶段
├── 安装与配置
├── 运行第一个脚本
├── TypeScript 基础
└── 包管理基础

进阶阶段
├── HTTP 服务开发
├── 文件操作
├── SQLite 数据库
└── 网络请求

高级阶段
├── 打包配置
├── 测试编写
├── Worker 多线程
└── 性能优化

实战阶段
├── Web API 服务
├── 全栈应用
├── CLI 工具
└── 微服务架构

下一步 #

现在你已经了解了 Bun 的基本概念，接下来学习安装与配置开始实际使用 Bun！