别再只会用 Node.js 了，Bun 才是现代 JavaScript 开发的最优解
在 JavaScript 的世界里，Node.js 长期以来一直是服务端开发的代名词。然而，随着技术的演进和开发者需求的不断提升，一个全新的选手正在悄然改变游戏规则。它不仅重新定义了 JavaScript 运行时的性能标准，更将打包器、测试框架、包管理器等功能集于一身，真正实现了”All in One”的开发体验。
这个选手就是 Bun。
如果你对 JavaScript 开发还停留在”安装 Node.js、配置 npm、写代码”的固有流程中，那么这篇文章将带你进入一个全新的世界。在这里，构建速度以毫秒计算，依赖安装眨眼完成，测试运行流畅如飞。Bun 不仅仅是一个运行时的替代品，它代表了一种更高效、更现代的开发哲学。
接下来，我将用最详尽的讲解和最实用的示例，带你从零开始掌握 Bun。无论你是刚入门的前端新人，还是经验丰富的后端老兵，这篇文章都将帮助你重新认识 JavaScript 开发的无限可能。
为什么 Bun 值得关注
JavaScript 开发工具链的现状与痛点
在深入了解 Bun 之前，让我们先回顾一下当前 JavaScript 开发生态中的常见问题。当我们创建一个新的前端项目时，通常需要经历这样的流程：首先安装 Node.js，然后安装包管理器（npm、yarn 或 pnpm），接着安装构建工具（如 webpack、vite、esbuild 或 rollup），再安装测试框架（jest、vitest 或 mocha），最后才能开始编写业务代码。
这个流程存在的问题显而易见。每一个工具都是独立的，它们之间需要复杂的配置才能协同工作。更糟糕的是，这些工具之间的兼容性问题和配置复杂性，往往成为新手开发者入门的第一道门槛。
性能瓶颈是另一个长期困扰开发者的痛点。即使是简单的项目，热更新时间也可能需要好几秒。依赖安装受限于网络速度和包管理器的效率。大型项目的构建时间更是以分钟计，严重影响了开发效率和体验。
此外，维护多套工具链的一致性也是一大挑战。当某个工具更新版本时，其他工具可能需要相应的调整才能兼容。这种复杂的依赖关系增加了项目的维护成本，也埋下了潜在的兼容性隐患。
Bun 的诞生与核心理念
Bun 是一个用 Zig 语言编写的 JavaScript 运行时、打包器、测试框架和包管理器。它的诞生目标非常明确：用更快的执行速度、更简洁的工具链、更低的资源消耗，来解决 JavaScript 开发中的种种痛点。
与 Node.js 不同，Bun 从设计之初就将性能和开发者体验放在首位。它并不是简单地重写现有功能，而是从底层架构开始重新思考整个 JavaScript 开发流程。这种设计理念使得 Bun 能够在多个维度上实现突破性的改进。
Bun 的核心优势体现在以下几个方面。首先是极致的速度表现，无论是在运行时执行、包安装还是项目构建方面，Bun 都展现出了远超传统工具的效率。其次是开箱即用的功能集成，开发者无需额外配置就能使用打包、测试、运行脚本等常用功能。第三是对 Node.js 生态的广泛兼容，大多数 npm 包和 Node.js API 都能在 Bun 中直接运行，大大降低了迁移成本。
从技术架构的角度看，Bun 采用了多项创新技术来实现其性能目标。它使用了 JavaScriptCore 引擎而非 V8，在某些场景下能够提供更好的性能表现。它内置了 SQLite 数据库，使得某些依赖本地存储的应用可以直接运行而无需额外安装数据库服务。同时，它对 TypeScript 和 JSX 的原生支持，使得开发者可以直接运行这些文件而无需额外的转译步骤。
环境搭建：快速开始你的 Bun 之旅
系统要求与准备工作
在开始安装 Bun 之前，我们需要确保你的系统满足基本的运行环境要求。Bun 目前支持 macOS、Linux 和 Windows 系统（包括 WSL 环境）。对于硬件配置，由于 Bun 本身非常轻量，对硬件的要求并不苛刻，但建议至少具备 4GB 内存以确保流畅的开发体验。
在操作系统层面，macOS 用户需要确保使用的是 macOS 10.15 或更高版本。Linux 用户建议使用 Ubuntu 18.04 或更高版本，以及其他基于 glibc 的发行版。Windows 用户可以通过 WSL2 或直接在 Windows 原生环境下运行 Bun，但使用 WSL2 通常能获得更好的性能和兼容性。
安装 Bun 的几种方式
Bun 提供了多种安装方式，以适应不同用户的使用习惯和环境条件。让我们逐一介绍这些安装方法。
使用安装脚本是最简单快捷的方式。打开终端，执行以下命令即可完成安装：
curl -fsSL https://bun.sh/install | bash
这个命令会下载并执行 Bun 的官方安装脚本。安装完成后，脚本会提示你将 Bun 的路径添加到环境变量中。按照提示操作后，你就可以在终端中直接使用 bun 命令了。
对于使用 Homebrew 的 macOS 用户，可以通过包管理器来安装 Bun：
brew install oven-sh/bun/bun
这种方式的优势在于可以方便地通过 brew upgrade 命令来更新 Bun 到最新版本。
如果你已经安装了 npm，可以使用 npm 来全局安装 Bun：
npm install -g bun
这种方式对于习惯使用 Node.js 生态的用户来说更加亲切，安装过程也更加熟悉。
Docker 用户可以选择使用官方提供的 Docker 镜像：
docker pull oven/bun
docker run --rm -it oven/bun
这种方式特别适合在容器化环境中使用 Bun，可以避免在主机上安装额外工具。
验证安装与基础命令
安装完成后，我们需要验证 Bun 是否正确安装。执行以下命令可以查看 Bun 的版本信息：
bun --version
如果安装成功，终端会显示类似 “Bun v1.x.x” 的版本号。
让我们来了解一些 Bun 的基础命令。bun –help 命令可以查看所有可用的命令选项和简要说明：
bun --help
运行这个命令后，你会看到 Bun 支持的主要功能，包括运行脚本（bun run）、安装依赖（bun install）、执行测试（bun test）、构建项目（bun build）等。
要了解特定子命令的详细用法，可以使用 bun help
bun help run
bun help install
bun help test
这些帮助信息会列出命令的所有选项和参数说明，是学习 Bun 功能的重要参考。
核心功能详解：深入理解 Bun 的能力
JavaScript 运行时：速度与兼容性的完美平衡
Bun 作为 JavaScript 运行时，核心职责是执行 JavaScript 代码。但与 Node.js 不同的是，Bun 在兼容 Node.js API 的同时，提供了显著更高的执行效率。
让我们通过一个简单的示例来感受 Bun 的运行能力。首先创建一个 JavaScript 文件：
// hello-bun.js
// 这是一个简单的计时测试程序
function fibonacci(n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
console.log("开始计算斐波那契数列...");
const startTime = Date.now();
for (let i = 0; i < 30; i++) {
fibonacci(i);
}
const endTime = Date.now();
console.log(`计算完成，耗时: ${endTime - startTime} 毫秒`);
console.log("Bun 运行时的性能表现令人印象深刻！");
运行这个文件：
bun run hello-bun.js
你会发现执行速度非常快。这只是一个小例子，但足以展示 Bun 在运行时优化方面的优势。
Bun 对 Node.js API 的兼容性是其成功的关键因素之一。大多数为 Node.js 编写的代码可以直接在 Bun 中运行，无需修改。这意味着你现有的项目可以逐步迁移到 Bun，而不需要一次性重写整个代码库。
以下是 Bun 兼容的主要 Node.js 模块：
// 内置模块的使用示例
const fs = require('fs');
const path = require('path');
const http = require('http');
const crypto = require('crypto');
// 文件读取
const content = fs.readFileSync('package.json', 'utf-8');
console.log("当前目录:", path.resolve('.'));
// 创建 HTTP 服务器
const server = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello from Bun!');
});
server.listen(3000, () => {
console.log("服务器运行在 http://localhost:3000");
});
这段代码在 Node.js 和 Bun 中的行为完全一致，展示了 Bun 对 Node.js API 的良好兼容性。
包管理器：极速依赖管理体验
Bun 内置的包管理器是其最令人惊叹的功能之一。与 npm、yarn 或 pnpm 相比，Bun 的包安装速度可以达到传统工具的十倍甚至百倍。
理解 Bun 的安装机制有助于更好地使用它。Bun 直接使用 npm registry 获取包信息，但安装过程采用了多线程并行下载和硬链接等技术，极大地提升了效率。Bun 还会自动管理依赖的版本，确保在不同环境下的一致性。
让我们创建一个项目来体验 Bun 的包管理功能：
mkdir my-bun-project
cd my-bun-project
bun init -y
执行完这些命令后，会在当前目录创建一个新的 Bun 项目，默认会生成 package.json 和 tsconfig.json 文件。
现在，让我们安装一个常用的 HTTP 客户端库 axios 来体验包安装的速度：
bun add axios
这个安装过程几乎是瞬间完成的。你可以通过查看 package.json 来确认依赖已正确添加：
{
"name": "my-bun-project",
"version": "1.0.0",
"main": "dist/index.js",
"type": "module",
"dependencies": {
"axios": "^1.6.0"
}
}
安装完成后，我们可以在项目中使用这个包：
// src/api.ts
// 使用 axios 发送 HTTP 请求的示例
import axios from 'axios';
async function fetchData(url) {
try {
console.log(`正在请求: ${url}`);
const response = await axios.get(url);
console.log(`状态码: ${response.status}`);
console.log(`数据长度: ${JSON.stringify(response.data).length} 字符`);
return response.data;
} catch (error) {
console.error("请求失败:", error.message);
throw error;
}
}
// 测试 API 调用
fetchData('https://jsonplaceholder.typicode.com/posts/1');
运行这个脚本：
bun run src/api.ts
你会看到 Bun 快速地处理了 HTTP 请求，并输出了预期的结果。
Bun 还支持 package.json 中的 scripts 字段，我们可以添加自定义脚本来简化日常操作：
{
"name": "my-bun-project",
"version": "1.0.0",
"scripts": {
"dev": "bun run --watch src/index.ts",
"start": "bun run src/index.ts",
"test": "bun test",
"build": "bun build src/index.ts --outdir=dist"
},
"dependencies": {
"axios": "^1.6.0"
}
}
添加开发依赖也非常简单：
bun add -d typescript @types/node
使用 -d 或 –dev 标志可以将包添加到 devDependencies 中。
打包器：构建优化从未如此简单
Bun 内置的打包器是另一个强大的功能。它能够将 JavaScript/TypeScript 代码及其依赖打包成单个文件或多个文件，支持多种输出格式，适用于浏览器、服务端或_worker环境。
让我们通过一个实际例子来了解 Bun 打包器的使用。首先创建一个包含多个模块的项目：
// src/utils/math.ts
// 数学工具函数
export function add(a, b) {
return a + b;
}
export function subtract(a, b) {
return a - b;
}
export function multiply(a, b) {
return a * b;
}
export function divide(a, b) {
if (b === 0) {
throw new Error("除数不能为零");
}
return a / b;
}
export function power(base, exponent) {
return Math.pow(base, exponent);
}
export function sqrt(num) {
return Math.sqrt(num);
}
// src/utils/string.ts
// 字符串处理工具
export function capitalize(str) {
if (!str) return '';
return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
}
export function reverse(str) {
return str.split('').reverse().join('');
}
export function truncate(str, maxLength) {
if (str.length <= maxLength) return str;
return str.slice(0, maxLength - 3) + '...';
}
export function slugify(str) {
return str.toLowerCase()
.replace(/[^\w\s-]/g, '')
.replace(/[\s_-]+/g, '-')
.replace(/^-+|-+$/g, '');
}
// src/index.ts
// 主入口文件
import { add, multiply, power } from './utils/math';
import { capitalize, slugify } from './utils/string';
console.log("=== 数学运算 ===");
console.log("2 + 3 =", add(2, 3));
console.log("4 * 5 =", multiply(4, 5));
console.log("2^10 =", power(2, 10));
console.log("\n=== 字符串处理 ===");
const name = "hello world";
console.log(`"${name}" 首字母大写后:`, capitalize(name));
console.log(`"${name}" 转换为 URL 友好格式:`, slugify(name));
现在使用 Bun 来打包这个项目：
bun build src/index.ts --outdir=dist --format=esm
这条命令会将 src/index.ts 及其所有依赖打包成 ESM 格式，输出到 dist 目录。
Bun 打包器支持多种输出格式，可以通过 –format 参数指定：
# 打包为 ES Module 格式
bun build src/index.ts --outfile=bundle.js --format=esm
# 打包为 CommonJS 格式
bun build src/index.ts --outfile=bundle.cjs --format=cjs
# 打包为 IIFE 格式（适合浏览器直接引用）
bun build src/index.ts --outfile=bundle.iife.js --format=iife
# 打包为浏览器可用的格式（自动处理 Node.js 内置模块）
bun build src/index.ts --outfile=bundle.browser.js --format=esm --target=browser
打包器还支持代码分割功能，可以将代码分割成多个 chunk 以实现更好的缓存策略：
bun build src/index.ts --outdir=dist --format=esm --splitting
对于生产环境构建，可以启用压缩来减小输出文件的大小：
bun build src/index.ts --outfile=bundle.min.js --minify
测试框架：单元测试从未如此高效
Bun 内置的测试框架是基于 Jest 的 API 设计，但运行速度远超 Jest。它利用了 Bun 运行时的高效性，使得测试执行几乎是瞬时完成的。
让我们创建一些测试来体验 Bun 的测试功能：
// src/utils/math.test.ts
// 数学工具函数的测试
import { describe, test, expect } from 'bun:test';
import { add, subtract, multiply, divide, power, sqrt } from './math';
describe("数学运算测试套件", () => {
describe("加法", () => {
test("正数相加", () => {
expect(add(2, 3)).toBe(5);
});
test("负数相加", () => {
expect(add(-1, -1)).toBe(-2);
});
test("浮点数相加", () => {
expect(add(0.1, 0.2)).toBeCloseTo(0.3);
});
});
describe("减法", () => {
test("基本减法", () => {
expect(subtract(5, 3)).toBe(2);
});
test("结果为负数", () => {
expect(subtract(1, 5)).toBe(-4);
});
});
describe("乘法", () => {
test("基本乘法", () => {
expect(multiply(3, 4)).toBe(12);
});
test("与零相乘", () => {
expect(multiply(100, 0)).toBe(0);
});
});
describe("除法", () => {
test("正常除法", () => {
expect(divide(10, 2)).toBe(5);
});
test("除以零抛出错误", () => {
expect(() => divide(1, 0)).toThrow("除数不能为零");
});
});
describe("幂运算", () => {
test("正整数指数", () => {
expect(power(2, 10)).toBe(1024);
});
test("零的零次方", () => {
expect(power(0, 0)).toBe(1);
});
});
describe("平方根", () => {
test("完全平方数", () => {
expect(sqrt(16)).toBe(4);
});
test("非完全平方数", () => {
expect(sqrt(2)).toBeCloseTo(1.414);
});
});
});
// src/utils/string.test.ts
// 字符串处理工具的测试
import { describe, test, expect } from 'bun:test';
import { capitalize, reverse, truncate, slugify } from './string';
describe("字符串处理测试套件", () => {
describe("首字母大写", () => {
test("正常字符串", () => {
expect(capitalize("hello")).toBe("Hello");
});
test("全大写字符串", () => {
expect(capitalize("HELLO")).toBe("Hello");
});
test("空字符串", () => {
expect(capitalize("")).toBe("");
});
});
describe("字符串反转", () => {
test("正常字符串", () => {
expect(reverse("hello")).toBe("olleh");
});
test("单词反转", () => {
expect(reverse("hello world")).toBe("dlrow olleh");
});
});
describe("字符串截断", () => {
test("不需要截断", () => {
expect(truncate("hi", 10)).toBe("hi");
});
test("需要截断", () => {
expect(truncate("hello world", 8)).toBe("hello...");
});
});
describe("URL 友好格式转换", () => {
test("基本转换", () => {
expect(slugify("Hello World")).toBe("hello-world");
});
test("特殊字符处理", () => {
expect(slugify("Hello! World? Test")).toBe("hello-world-test");
});
});
});
运行所有测试：
bun test
测试结果会即时显示，你能看到每个测试用例的执行状态。得益于 Bun 的高性能，整个测试过程几乎是瞬间完成的。
Bun 的测试框架还支持快照测试、模拟函数、异步测试等高级功能：
// src/services/api.test.ts
// 异步 API 测试示例
import { describe, test, expect, vi } from 'bun:test';
// 模拟 fetch 函数
const mockFetch = vi.fn();
global.fetch = mockFetch;
describe("API 服务测试", () => {
beforeEach(() => {
mockFetch.mockReset();
});
test("成功获取数据", async () => {
const mockData = { id: 1, name: "测试用户" };
mockFetch.mockResolvedValueOnce({
ok: true,
json: async () => mockData
});
const response = await fetch('https://api.example.com/users/1');
const data = await response.json();
expect(data).toEqual(mockData);
expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/users/1');
});
test("处理网络错误", async () => {
mockFetch.mockRejectedValueOnce(new Error("网络连接失败"));
await expect(
fetch('https://api.example.com/users/1')
).rejects.toThrow("网络连接失败");
});
});
TypeScript 支持：开箱即用的类型安全
Bun 对 TypeScript 提供了原生支持，你无需安装额外的编译器或配置复杂的构建步骤，就能直接运行 TypeScript 代码。
让我们创建一个 TypeScript 项目来体验这个功能：
// src/types/user.ts
// 用户相关类型定义
export interface User {
id: number;
name: string;
email: string;
age?: number;
roles: string[];
createdAt: Date;
}
export interface CreateUserDTO {
name: string;
email: string;
age?: number;
}
export interface UpdateUserDTO {
name?: string;
email?: string;
age?: number;
}
// src/services/userService.ts
// 用户服务层
import type { User, CreateUserDTO, UpdateUserDTO } from '../types/user';
export class UserService {
private users: User[] = [];
createUser(dto: CreateUserDTO): User {
const newUser: User = {
id: this.users.length + 1,
name: dto.name,
email: dto.email,
age: dto.age,
roles: ['user'],
createdAt: new Date()
};
this.users.push(newUser);
return newUser;
}
getUserById(id: number): User | undefined {
return this.users.find(user => user.id === id);
}
getAllUsers(): User[] {
return [...this.users];
}
updateUser(id: number, dto: UpdateUserDTO): User | undefined {
const userIndex = this.users.findIndex(user => user.id === id);
if (userIndex === -1) {
return undefined;
}
const user = this.users[userIndex];
const updatedUser: User = {
...user,
name: dto.name ?? user.name,
email: dto.email ?? user.email,
age: dto.age ?? user.age
};
this.users[userIndex] = updatedUser;
return updatedUser;
}
deleteUser(id: number): boolean {
const userIndex = this.users.findIndex(user => user.id === id);
if (userIndex === -1) {
return false;
}
this.users.splice(userIndex, 1);
return true;
}
}
// 导出单例实例
export const userService = new UserService();
// src/index.ts
// 应用入口
import { userService } from './services/userService';
import type { CreateUserDTO, UpdateUserDTO } from './types/user';
function printUser(user: any) {
console.log("---");
console.log(`ID: ${user.id}`);
console.log(`姓名: ${user.name}`);
console.log(`邮箱: ${user.email}`);
console.log(`年龄: ${user.age ?? '未设置'}`);
console.log(`角色: ${user.roles.join(', ')}`);
console.log(`创建时间: ${user.createdAt.toISOString()}`);
}
console.log("=== 创建用户 ===");
const newUser: CreateUserDTO = {
name: "张三",
email: "zhangsan@example.com",
age: 28
};
const createdUser = userService.createUser(newUser);
printUser(createdUser);
console.log("\n=== 更新用户 ===");
const updateData: UpdateUserDTO = {
age: 29,
roles: ['user', 'admin']
};
const updatedUser = userService.updateUser(1, updateData);
if (updatedUser) {
printUser(updatedUser);
}
console.log("\n=== 获取所有用户 ===");
const allUsers = userService.getAllUsers();
console.log(`共有 ${allUsers.length} 个用户`);
allUsers.forEach(printUser);
直接运行 TypeScript 文件：
bun run src/index.ts
Bun 会自动识别 .ts 文件并进行类型检查和转译，整个过程对开发者完全透明。
实战教程：一步步构建真实应用
创建一个 RESTful API 服务
现在让我们运用前面学到的知识，创建一个完整的 RESTful API 服务。这个服务将包含用户管理的完整 CRUD 操作，并使用 Bun 的内置 HTTP 服务器。
首先安装必要的开发依赖：
bun add express
bun add -d @types/express
接下来创建项目的目录结构和各个模块：
// src/types/index.ts
// 统一导出所有类型定义
export interface User {
id: number;
name: string;
email: string;
age?: number;
createdAt: string;
updatedAt: string;
}
export interface CreateUserRequest {
name: string;
email: string;
age?: number;
}
export interface UpdateUserRequest {
name?: string;
email?: string;
age?: number;
}
export interface ApiResponse<T = any> {
success: boolean;
message: string;
data?: T;
error?: string;
}
// src/store/userStore.ts
// 简单的内存数据存储
import type { User, CreateUserRequest, UpdateUserRequest } from '../types';
let users: User[] = [
{
id: 1,
name: "张三",
email: "zhangsan@example.com",
age: 28,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString()
},
{
id: 2,
name: "李四",
email: "lisi@example.com",
age: 32,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString()
}
];
let nextId = 3;
export const userStore = {
findAll(): User[] {
return users;
},
findById(id: number): User | undefined {
return users.find(user => user.id === id);
},
create(data: CreateUserRequest): User {
const now = new Date().toISOString();
const user: User = {
id: nextId++,
name: data.name,
email: data.email,
age: data.age,
createdAt: now,
updatedAt: now
};
users.push(user);
return user;
},
update(id: number, data: UpdateUserRequest): User | undefined {
const index = users.findIndex(user => user.id === id);
if (index === -1) {
return undefined;
}
const existingUser = users[index];
const updatedUser: User = {
...existingUser,
name: data.name ?? existingUser.name,
email: data.email ?? existingUser.email,
age: data.age ?? existingUser.age,
updatedAt: new Date().toISOString()
};
users[index] = updatedUser;
return updatedUser;
},
delete(id: number): boolean {
const index = users.findIndex(user => user.id === id);
if (index === -1) {
return false;
}
users.splice(index, 1);
return true;
}
};
// src/routes/userRoutes.ts
// 用户路由处理
import { Router } from 'express';
import { userStore } from '../store/userStore';
import type { CreateUserRequest, UpdateUserRequest, ApiResponse } from '../types';
const router = Router();
// 获取所有用户
router.get('/', (req, res) => {
const users = userStore.findAll();
const response: ApiResponse = {
success: true,
message: '获取用户列表成功',
data: users
};
res.json(response);
});
// 获取单个用户
router.get('/:id', (req, res) => {
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
const response: ApiResponse = {
success: false,
message: '无效的用户ID'
};
return res.status(400).json(response);
}
const user = userStore.findById(id);
if (!user) {
const response: ApiResponse = {
success: false,
message: '用户不存在'
};
return res.status(404).json(response);
}
const response: ApiResponse = {
success: true,
message: '获取用户成功',
data: user
};
res.json(response);
});
// 创建用户
router.post('/', (req, res) => {
const body = req.body as CreateUserRequest;
// 简单的验证
if (!body.name || !body.email) {
const response: ApiResponse = {
success: false,
message: '姓名和邮箱是必填项'
};
return res.status(400).json(response);
}
// 验证邮箱格式
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
if (!emailRegex.test(body.email)) {
const response: ApiResponse = {
success: false,
message: '邮箱格式不正确'
};
return res.status(400).json(response);
}
const user = userStore.create(body);
const response: ApiResponse = {
success: true,
message: '用户创建成功',
data: user
};
res.status(201).json(response);
});
// 更新用户
router.put('/:id', (req, res) => {
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
const response: ApiResponse = {
success: false,
message: '无效的用户ID'
};
return res.status(400).json(response);
}
const body = req.body as UpdateUserRequest;
// 如果提供了邮箱，验证格式
if (body.email) {
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
if (!emailRegex.test(body.email)) {
const response: ApiResponse = {
success: false,
message: '邮箱格式不正确'
};
return res.status(400).json(response);
}
}
const user = userStore.update(id, body);
if (!user) {
const response: ApiResponse = {
success: false,
message: '用户不存在'
};
return res.status(404).json(response);
}
const response: ApiResponse = {
success: true,
message: '用户更新成功',
data: user
};
res.json(response);
});
// 删除用户
router.delete('/:id', (req, res) => {
const id = parseInt(req.params.id, 10);
if (isNaN(id)) {
const response: ApiResponse = {
success: false,
message: '无效的用户ID'
};
return res.status(400).json(response);
}
const deleted = userStore.delete(id);
if (!deleted) {
const response: ApiResponse = {
success: false,
message: '用户不存在'
};
return res.status(404).json(response);
}
const response: ApiResponse = {
success: true,
message: '用户删除成功'
};
res.json(response);
});
export default router;
// src/app.ts
// Express 应用配置
import express from 'express';
import userRoutes from './routes/userRoutes';
const app = express();
// 中间件
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
// 请求日志中间件
app.use((req, res, next) => {
const start = Date.now();
res.on('finish', () => {
const duration = Date.now() - start;
console.log(`${req.method} ${req.path} - ${res.statusCode} (${duration}ms)`);
});
next();
});
// 健康检查端点
app.get('/health', (req, res) => {
res.json({
success: true,
message: '服务运行正常',
timestamp: new Date().toISOString()
});
});
// API 路由
app.use('/api/users', userRoutes);
// 404 处理
app.use((req, res) => {
res.status(404).json({
success: false,
message: '请求的接口不存在'
});
});
// 错误处理中间件
app.use((err, req, res, next) => {
console.error('服务器错误:', err);
res.status(500).json({
success: false,
message: '服务器内部错误'
});
});
export default app;
// src/index.ts
// 应用入口
import app from './app';
const PORT = process.env.PORT || 3000;
const server = app.listen(PORT, () => {
console.log("===================================");
console.log(" Bun RESTful API 服务已启动");
console.log(` 监听端口: http://localhost:${PORT}`);
console.log("===================================");
console.log("\n可用端点:");
console.log(" GET /health - 健康检查");
console.log(" GET /api/users - 获取所有用户");
console.log(" GET /api/users/:id - 获取指定用户");
console.log(" POST /api/users - 创建用户");
console.log(" PUT /api/users/:id - 更新用户");
console.log(" DELETE /api/users/:id - 删除用户");
console.log("");
});
// 优雅关闭
process.on('SIGTERM', () => {
console.log('收到 SIGTERM 信号，正在关闭服务器...');
server.close(() => {
console.log('服务器已关闭');
process.exit(0);
});
});
process.on('SIGINT', () => {
console.log('收到 SIGINT 信号，正在关闭服务器...');
server.close(() => {
console.log('服务器已关闭');
process.exit(0);
});
});
运行服务器：
bun run src/index.ts
现在我们可以测试 API 的各项功能。打开另一个终端，使用 curl 命令进行测试：
# 健康检查
curl http://localhost:3000/health
# 获取所有用户
curl http://localhost:3000/api/users
# 获取单个用户
curl http://localhost:3000/api/users/1
# 创建新用户
curl -X POST http://localhost:3000/api/users \
-H "Content-Type: application/json" \
-d '{"name":"王五","email":"wangwu@example.com","age":25}'
# 更新用户
curl -X PUT http://localhost:3000/api/users/1 \
-H "Content-Type: application/json" \
-d '{"age":29,"roles":["user","admin"]}'
# 删除用户
curl -X DELETE http://localhost:3000/api/users/3
构建前端应用
接下来，让我们使用 Bun 创建一个简单的前端应用，并体验 Bun 打包器的强大功能。
首先，创建一个用于前端的 HTML 文件：
<!-- public/index.html -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Bun 前端应用示例</title>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
min-height: 100vh;
padding: 20px;
}
.container {
max-width: 800px;
margin: 0 auto;
}
h1 {
color: white;
text-align: center;
margin-bottom: 30px;
font-size: 2.5rem;
text-shadow: 2px 2px 4px rgba(0,0,0,0.2);
}
.card {
background: white;
border-radius: 12px;
padding: 24px;
box-shadow: 0 10px 40px rgba(0,0,0,0.1);
margin-bottom: 20px;
}
.card h2 {
color: #333;
margin-bottom: 16px;
font-size: 1.5rem;
}
.user-list {
list-style: none;
}
.user-item {
padding: 12px;
border-bottom: 1px solid #eee;
display: flex;
justify-content: space-between;
align-items: center;
}
.user-item:last-child {
border-bottom: none;
}
.user-info {
flex: 1;
}
.user-name {
font-weight: bold;
color: #333;
font-size: 1.1rem;
}
.user-email {
color: #666;
font-size: 0.9rem;
}
.user-age {
background: #667eea;
color: white;
padding: 4px 12px;
border-radius: 20px;
font-size: 0.85rem;
}
.form-group {
margin-bottom: 16px;
}
label {
display: block;
margin-bottom: 6px;
color: #555;
font-weight: 500;
}
input {
width: 100%;
padding: 12px;
border: 2px solid #e0e0e0;
border-radius: 8px;
font-size: 1rem;
transition: border-color 0.3s;
}
input:focus {
outline: none;
border-color: #667eea;
}
button {
background: #667eea;
color: white;
border: none;
padding: 12px 24px;
border-radius: 8px;
font-size: 1rem;
cursor: pointer;
transition: background 0.3s, transform 0.2s;
width: 100%;
}
button:hover {
background: #5a6fd6;
transform: translateY(-2px);
}
button:active {
transform: translateY(0);
}
.status {
padding: 12px;
border-radius: 8px;
margin-top: 16px;
text-align: center;
}
.status.success {
background: #d4edda;
color: #155724;
}
.status.error {
background: #f8d7da;
color: #721c24;
}
.status.loading {
background: #fff3cd;
color: #856404;
}
</style>
</head>
<body>
<div class="container">
<h1>用户管理系统</h1>
<div class="card">
<h2>用户列表</h2>
<ul id="userList" class="user-list">
<li style="text-align: center; color: #666;">加载中...</li>
</ul>
</div>
<div class="card">
<h2>添加新用户</h2>
<form id="addUserForm">
<div class="form-group">
<label for="name">姓名</label>
<input type="text" id="name" name="name" required placeholder="请输入姓名">
</div>
<div class="form-group">
<label for="email">邮箱</label>
<input type="email" id="email" name="email" required placeholder="请输入邮箱">
</div>
<div class="form-group">
<label for="age">年龄</label>
<input type="number" id="age" name="age" placeholder="请输入年龄">
</div>
<button type="submit">添加用户</button>
<div id="formStatus" class="status" style="display: none;"></div>
</form>
</div>
</div>
<script type="module" src="/bundle.js"></script>
</body>
</html>
创建前端的主要 JavaScript 文件：
// src/client/main.js
// 前端主逻辑
const API_BASE = 'http://localhost:3000/api/users';
// DOM 元素
const userList = document.getElementById('userList');
const addUserForm = document.getElementById('addUserForm');
const formStatus = document.getElementById('formStatus');
// 显示状态消息
function showStatus(message, type) {
formStatus.textContent = message;
formStatus.className = `status ${type}`;
formStatus.style.display = 'block';
if (type === 'success') {
setTimeout(() => {
formStatus.style.display = 'none';
}, 3000);
}
}
// 渲染用户列表
function renderUsers(users) {
if (users.length === 0) {
userList.innerHTML = '<li style="text-align: center; color: #666;">暂无用户</li>';
return;
}
userList.innerHTML = users.map(user => `
<li class="user-item" data-id="${user.id}">
<div class="user-info">
<div class="user-name">${escapeHtml(user.name)}</div>
<div class="user-email">${escapeHtml(user.email)}</div>
</div>
${user.age ? `<span class="user-age">${user.age}岁</span>` : ''}
</li>
`).join('');
}
// HTML 转义，防止 XSS
function escapeHtml(text) {
const div = document.createElement('div');
div.textContent = text;
return div.innerHTML;
}
// 获取用户列表
async function fetchUsers() {
try {
userList.innerHTML = '<li style="text-align: center; color: #666;">加载中...</li>';
const response = await fetch(API_BASE);
const result = await response.json();
if (result.success) {
renderUsers(result.data);
} else {
userList.innerHTML = `<li style="text-align: center; color: #e74c3c;">
加载失败: ${result.message}
</li>`;
}
} catch (error) {
userList.innerHTML = `<li style="text-align: center; color: #e74c3c;">
网络错误，请确保 API 服务正在运行
</li>`;
}
}
// 提交表单
async function handleFormSubmit(event) {
event.preventDefault();
const formData = new FormData(addUserForm);
const data = {
name: formData.get('name'),
email: formData.get('email'),
age: formData.get('age') ? parseInt(formData.get('age'), 10) : undefined
};
showStatus('正在提交...', 'loading');
try {
const response = await fetch(API_BASE, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(data)
});
const result = await response.json();
if (result.success) {
showStatus('用户创建成功！', 'success');
addUserForm.reset();
fetchUsers();
} else {
showStatus(`创建失败: ${result.message}`, 'error');
}
} catch (error) {
showStatus('网络错误，请重试', 'error');
}
}
// 事件监听
addUserForm.addEventListener('submit', handleFormSubmit);
// 初始化
document.addEventListener('DOMContentLoaded', () => {
fetchUsers();
});
现在使用 Bun 的打包器将前端代码打包：
bun build src/client/main.js --outdir=public --target=browser
或者使用 watch 模式进行开发：
bun build src/client/main.js --outdir=public --target=browser --watch
配置开发脚本可以更方便地管理项目：
{
"name": "bun-fullstack-app",
"scripts": {
"dev:server": "bun run --watch src/index.ts",
"dev:client": "bun build src/client/main.js --outdir=public --target=browser --watch",
"dev": "bun run dev:server",
"build": "bun build src/client/main.js --outdir=public --target=browser --minify",
"start": "bun run src/index.ts"
}
}
常见使用场景与最佳实践
Web 开发全栈方案
Bun 的”All in One”特性使其成为现代 Web 开发的理想选择。无论是前端还是后端，Bun 都能提供出色的开发体验。
在后端开发中，Bun 的 HTTP 服务器性能卓越，可以直接处理高并发请求。以下是一个使用 Bun 原生 HTTP 服务器的示例：
// src/server.ts
// 使用 Bun 原生 HTTP 服务器
const server = Bun.serve({
port: 3000,
async fetch(req) {
const url = new URL(req.url);
// 路由处理
if (url.pathname === '/api/hello') {
const name = url.searchParams.get('name') || 'World';
return Response.json({
message: `你好, ${name}!`,
timestamp: new Date().toISOString()
});
}
if (url.pathname === '/api/time') {
return Response.json({
time: new Date().toLocaleTimeString('zh-CN', {
timeZone: 'Asia/Shanghai'
})
});
}
// 返回静态文件
const staticFile = Bun.file(`public${url.pathname}`);
if (await staticFile.exists()) {
return new Response(staticFile);
}
// 返回 index.html（单页应用支持）
const indexFile = Bun.file('public/index.html');
if (await indexFile.exists()) {
return new Response(indexFile);
}
return new Response('Not Found', { status: 404 });
},
error(error) {
return new Response(`<html>
<body>
<h1>500 - 服务器错误</h1>
<pre>${error.message}</pre>
</body>
</html>`, {
headers: { 'Content-Type': 'text/html' }
});
}
});
console.log(`Bun 原生服务器已启动: http://localhost:${server.port}`);
脚本与工具开发
Bun 也是编写脚本和命令行工具的绝佳选择。它的快速启动时间和友好的脚本执行体验使其比 Node.js 更加高效。
// scripts/generate-data.ts
// 数据生成脚本
interface UserData {
name: string;
email: string;
age: number;
city: string;
registeredAt: Date;
}
// 生成随机用户数据
function generateRandomUser(): UserData {
const names = ['张三', '李四', '王五', '赵六', '钱七', '孙八', '周九', '吴十'];
const cities = ['北京', '上海', '深圳', '广州', '杭州', '成都', '武汉', '西安'];
const randomName = names[Math.floor(Math.random() * names.length)];
const randomCity = cities[Math.floor(Math.random() * cities.length)];
return {
name: randomName,
email: `${Date.now()}-${Math.random().toString(36).substring(7)}@example.com`,
age: Math.floor(Math.random() * 40) + 18,
city: randomCity,
registeredAt: new Date(Date.now() - Math.random() * 365 * 24 * 60 * 60 * 1000)
};
}
// 主函数
async function main() {
const count = parseInt(process.argv[2] || '10', 10);
console.log(`正在生成 ${count} 条用户数据...`);
const users: UserData[] = [];
for (let i = 0; i < count; i++) {
users.push(generateRandomUser());
}
// 输出为 JSON
console.log(JSON.stringify(users, null, 2));
// 统计信息
console.log('\n=== 数据统计 ===');
console.log(`总人数: ${users.length}`);
const avgAge = users.reduce((sum, u) => sum + u.age, 0) / users.length;
console.log(`平均年龄: ${avgAge.toFixed(1)} 岁`);
const cityCount = new Set(users.map(u => u.city)).size;
console.log(`涉及城市: ${cityCount} 个`);
}
main();
运行这个脚本：
bun run scripts/generate-data.ts 20
自动化任务与构建流程
Bun 可以完美替代传统的 npm scripts，用于各种自动化任务和构建流程。
{
"name": "automation-project",
"scripts": {
"clean": "rm -rf dist coverage",
"prebuild": "bun run clean",
"build": "bun run build:client && bun run build:server",
"build:client": "bun build src/client.ts --outdir=dist/client --target=browser --minify",
"build:server": "bun build src/server.ts --outdir=dist/server --target=bun",
"test": "bun test",
"test:coverage": "bun test --coverage",
"lint": "echo '运行代码检查...'",
"format": "echo '格式化代码...'",
"precommit": "bun run lint && bun run test",
"deploy": "bun run build && echo '部署完成!'"
}
}
数据库操作
Bun 内置了 SQLite 支持，使得轻量级数据库操作变得极其简单：
// src/database.ts
// Bun 内置 SQLite 数据库操作
import { Database } from 'bun:sqlite';
const db = new Database('app.db');
// 创建表
db.exec(`
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
email TEXT UNIQUE NOT NULL,
age INTEGER,
created_at TEXT DEFAULT CURRENT_TIMESTAMP
)
`);
// 插入数据
const insertUser = db.prepare(`
INSERT INTO users (name, email, age) VALUES (?, ?, ?)
`);
function createUser(name: string, email: string, age?: number) {
try {
const result = insertUser.run(name, email, age ?? null);
return {
id: Number(result.lastInsertRowid),
name,
email,
age
};
} catch (error) {
console.error('插入失败:', error.message);
return null;
}
}
// 查询数据
const getUsers = db.prepare('SELECT * FROM users ORDER BY created_at DESC');
const getUserById = db.prepare('SELECT * FROM users WHERE id = ?');
function findAllUsers() {
return getUsers.all();
}
function findUserById(id: number) {
return getUserById.get(id);
}
// 更新数据
const updateUser = db.prepare(`
UPDATE users SET name = ?, age = ? WHERE id = ?
`);
function modifyUser(id: number, name: string, age?: number) {
const result = updateUser.run(name, age ?? null, id);
return result.changes > 0;
}
// 删除数据
const deleteUser = db.prepare('DELETE FROM users WHERE id = ?');
function removeUser(id: number) {
const result = deleteUser.run(id);
return result.changes > 0;
}
// 测试数据库操作
console.log('=== 数据库操作测试 ===\n');
console.log('创建用户:');
const newUser = createUser('测试用户', 'test@example.com', 25);
console.log(newUser);
console.log('\n查询所有用户:');
console.log(findAllUsers());
console.log('\n查询指定用户:');
console.log(findUserById(1));
console.log('\n更新用户:');
modifyUser(1, '更新后的用户名', 30);
console.log(findUserById(1));
export {
db,
createUser,
findAllUsers,
findUserById,
modifyUser,
removeUser
};
运行这个脚本：
bun run src/database.ts
高级技巧与性能优化
热模块替换与开发体验
Bun 支持热模块替换（HMR），可以显著提升开发体验：
// src/hmr-example.ts
// 热模块替换示例
let state = {
count: 0,
messages: [] as string[]
};
// 打印初始状态
function render() {
console.clear();
console.log('=== 状态演示 ===');
console.log(`计数器: ${state.count}`);
console.log(`消息数量: ${state.messages.length}`);
console.log('---');
state.messages.forEach((msg, i) => {
console.log(`${i + 1}. ${msg}`);
});
console.log('---');
console.log('提示: 修改此文件并保存，状态将自动更新');
}
// 模拟更新
function increment() {
state.count++;
render();
}
function addMessage(message: string) {
state.messages.push(message);
render();
}
// Bun 的 HMR 支持
if (process.env.BUN_ENV === 'development') {
// 使用 Bun 的 HMR API
const handleUpdate = () => {
console.log('\n📦 检测到文件变更，正在重新加载...');
// 重新导入模块会触发这里的逻辑
};
// 这是一个占位示例，实际 HMR 需要配合特定的框架使用
// Bun 内置的 HMR 主要通过 bun --hot 参数实现
}
// 初始渲染
render();
// 每秒自动递增计数器演示状态更新
setInterval(() => {
increment();
}, 1000);
使用 bun –hot 参数运行可以启用热重载功能：
bun --hot run src/hmr-example.ts
环境配置与多环境支持
合理的环境配置可以让应用在不同的运行环境中表现出最佳状态：
// src/config.ts
// 环境配置管理
interface AppConfig {
env: 'development' | 'test' | 'production';
port: number;
database: {
host: string;
port: number;
name: string;
};
api: {
baseUrl: string;
timeout: number;
};
features: {
enableCache: boolean;
enableLogging: boolean;
debugMode: boolean;
};
}
const configs: Record<string, AppConfig> = {
development: {
env: 'development',
port: 3000,
database: {
host: 'localhost',
port: 5432,
name: 'app_dev'
},
api: {
baseUrl: 'http://localhost:3000',
timeout: 5000
},
features: {
enableCache: false,
enableLogging: true,
debugMode: true
}
},
test: {
env: 'test',
port: 3001,
database: {
host: 'localhost',
port: 5432,
name: 'app_test'
},
api: {
baseUrl: 'http://localhost:3001',
timeout: 10000
},
features: {
enableCache: true,
enableLogging: true,
debugMode: false
}
},
production: {
env: 'production',
port: process.env.PORT ? parseInt(process.env.PORT, 10) : 8080,
database: {
host: process.env.DB_HOST || 'prod-db.example.com',
port: parseInt(process.env.DB_PORT || '5432', 10),
name: process.env.DB_NAME || 'app_prod'
},
api: {
baseUrl: process.env.API_URL || 'https://api.example.com',
timeout: 30000
},
features: {
enableCache: true,
enableLogging: false,
debugMode: false
}
}
};
export function getConfig(): AppConfig {
const env = (process.env.NODE_ENV || 'development') as string;
return configs[env] || configs.development;
}
export function isProduction(): boolean {
return getConfig().env === 'production';
}
export function isDevelopment(): boolean {
return getConfig().env === 'development';
}
export function isTest(): boolean {
return getConfig().env === 'test';
}
// 使用示例
const config = getConfig();
console.log('当前环境:', config.env);
console.log('服务器端口:', config.port);
性能分析与优化
Bun 提供了内置的性能分析工具，可以帮助我们识别性能瓶颈：
// src/performance.ts
// 性能测试与分析
// 模拟一个需要性能优化的函数
function slowOperation(size: number): number[] {
const result: number[] = [];
for (let i = 0; i < size; i++) {
// 模拟复杂的计算
let sum = 0;
for (let j = 0; j < 1000; j++) {
sum += Math.sqrt(j) * Math.sin(j);
}
result.push(sum);
}
return result;
}
// 优化的版本
function fastOperation(size: number): Float64Array {
const result = new Float64Array(size);
for (let i = 0; i < size; i++) {
let sum = 0;
for (let j = 0; j < 1000; j++) {
sum += Math.sqrt(j) * Math.sin(j);
}
result[i] = sum;
}
return result;
}
// 使用 Bun 的性能 API
function measurePerformance(label: string, fn: () => void) {
const start = Bun.nanoseconds();
fn();
const end = Bun.nanoseconds();
const duration = (end - start) / 1_000_000; // 转换为毫秒
console.log(`${label}: ${duration.toFixed(2)} ms`);
}
// 性能对比测试
console.log('=== 性能对比测试 ===\n');
console.log('测试 1: 数组操作');
measurePerformance('慢速版本 (数组)', () => {
slowOperation(100);
});
measurePerformance('快速版本 (TypedArray)', () => {
fastOperation(100);
});
console.log('\n测试 2: 字符串拼接');
measurePerformance('字符串 += 拼接 (10000次)', () => {
let str = '';
for (let i = 0; i < 10000; i++) {
str += 'test';
}
});
measurePerformance('数组 join 拼接 (10000次)', () => {
const arr: string[] = [];
for (let i = 0; i < 10000; i++) {
arr.push('test');
}
arr.join('');
});
console.log('\n测试 3: JSON 序列化');
const testData = {
users: Array.from({ length: 1000 }, (_, i) => ({
id: i,
name: `用户${i}`,
email: `user${i}@example.com`,
scores: Array.from({ length: 100 }, () => Math.random())
}))
};
measurePerformance('JSON.stringify (1000用户)', () => {
JSON.stringify(testData);
});
measurePerformance('JSON.parse (1000用户)', () => {
JSON.parse(JSON.stringify(testData));
});
运行性能测试：
bun run src/performance.ts
总结与展望
通过这篇详尽的教程，我们全面探索了 Bun 这个革命性的 JavaScript 运行时和开发工具链。Bun 不仅仅是一个 Node.js 的替代品，它代表了一种全新的开发理念——将分散的工具统一在同一个高效的核心之下。
让我们回顾一下 Bun 带给我们的核心价值。首先是令人惊叹的执行速度，从包安装到代码运行，从测试执行到项目构建，Bun 在每个环节都展现出了压倒性的性能优势。其次是极简的工具链，一个 Bun 命令行工具就能完成过去需要多个独立工具才能实现的所有功能。第三是对现有生态的友好兼容，大多数为 Node.js 编写的代码可以直接在 Bun 中运行，无需大规模重写。
在实际应用中，Bun 的使用场景非常广泛。你可以用它来开发高性能的 Web 服务器，利用 Bun 原生的 HTTP 服务器或 Express 框架创建响应迅速的后端服务。你可以用它来构建现代前端应用，Bun 的打包器能够高效地将你的 TypeScript、React 或 Vue 代码转换为浏览器可执行的产物。你还可以用 Bun 来编写自动化脚本和命令行工具，其快速的启动速度让脚本执行变得异常流畅。
展望未来，Bun 的发展潜力令人期待。团队正在持续完善其生态系统，包括更多的内置 API、更完善的框架支持以及更强大的调试工具。随着 Bun 1.0 的正式发布以及后续版本的迭代，我们有理由相信它将在 JavaScript 生态中扮演越来越重要的角色。
对于开发者而言，拥抱 Bun 意味着拥抱更高效的开发流程和更优质的用户体验。无论你是刚入门的新手还是经验丰富的老兵，现在都是开始学习和使用 Bun 的最佳时机。
下面是一些进一步学习的资源链接，你可以深入了解 Bun 的更多特性：
Bun 官方文档提供了最权威、最全面的使用指南，涵盖从入门到进阶的所有知识点。Bun 的 GitHub 仓库中有完整的源代码和详细的开发文档，你可以通过阅读源码深入理解 Bun 的实现原理。Awesome Bun 列表收集了大量 Bun 相关的优质项目和资源，可以帮助你快速找到需要的工具和参考。
Bun Discord 社区是一个活跃的开发者交流平台，你可以在这里与其他 Bun 用户交流经验、解决问题。Bun 的官方博客会定期发布版本更新、新功能介绍和最佳实践文章。
最后，让我们再次强调：技术的选择应该服务于实际需求。虽然 Bun 展现了强大的潜力，但它并不是所有场景的最优解。在决定是否采用 Bun 时，你应该综合考虑项目需求、团队技能、长期维护成本等因素，做出最适合自己项目的选择。
祝你在 Bun 的世界中探索愉快，开发出更加出色的应用！
评论区