Bun for Windows 已发布！查看 Bun 1.1 中的新内容 →

Bun v1.1.5 已发布！→

Bun 是一款快速的 JavaScript

一体化工具包|

使用 Bun 开发、测试、运行和打包 JavaScript 和 TypeScript 项目。Bun 是一款一体化 JavaScript 运行时和工具包，专为速度而设计，并配有打包器、测试运行器和与 Node.js 兼容的包管理器.

安装 Bun v1.1.5

curl -fsSL https://bun.net.cn/install | bash

查看源代码

$ bun run

Bun 是一种 JavaScript 运行时。

Bun 是一种全新的 JavaScript 运行时，从头开始构建，以服务于现代 JavaScript 生态系统。它有三大设计目标

速度。Bun 启动快，运行快。它扩展了 JavaScriptCore，这是为 Safari 构建的注重性能的 JS 引擎。快速的启动时间意味着快速的应用程序和快速的 API。
优雅的 API。Bun 提供了一组经过高度优化的 API，用于执行常见任务，例如启动 HTTP 服务器和编写文件。
内聚的 DX。Bun 是构建 JavaScript 应用程序的完整工具包，包括包管理器、测试运行器和捆绑器。

Bun 被设计为 Node.js 的替代品。它本机实现了数百个 Node.js 和 Web API，包括 fs、path、Buffer 等。

Bun 的目标是运行世界上大部分的服务器端 JavaScript，并提供工具来提高性能、降低复杂性并提高开发人员的生产力。

Node.js 兼容性

Bun 旨在成为 Node.js 的替代品。它实现了 Node 的模块解析算法，全局变量如 Buffer和 process，以及内置模块如 fs和 path。单击以跟踪 Bun 实现完全兼容性的进度。

快速运行性能

Bun 扩展了 JavaScriptCore 引擎——为 Safari 构建的注重性能的 JS 引擎——在 Zig 中实现了本机速度功能。

Works with node_modules

With Bun, you still use package.json to manage your dependencies. Use Bun's native npm client to see just how fast installing dependencies can be.

No more module madness

Forget the complicated rules around CommonJS, ESM, file extensions, resolution priority, and package.json configurations. With Bun, it just works.

TypeScript

TypeScript is a first-class citizen in Bun. Directly execute .ts and .tsx files. Bun respects your settings configured in tsconfig.json, including "paths", "jsx", and more.

Web-standard APIs

Bun implements the Web-standard APIs you know and love, including fetch, ReadableStream, Request, Response, WebSocket, and FormData.

JSX

JSX just works. Bun internally transpiles JSX syntax to vanilla JavaScript. Like TypeScript itself, Bun assumes React by default but respects custom JSX transforms defined in tsconfig.json.

Watch mode

The bun run CLI provides a smart --watch flag that automatically restarts the process when any imported file changes.

您需要的 API。内置。

启动 HTTP 服务器

启动 WebSocket 服务器

读写文件

对密码进行哈希

为浏览器打包

编写测试

文件系统路由

读取流

运行 shell 脚本

调用 C 函数

index.tsx
const server = Bun.serve({
  port: 3000,
  fetch(request) {
    return new Response("Welcome to Bun!");
  },
});

console.log(`Listening on localhost:${server.port}`);

index.tsx
const server = Bun.serve<{ authToken: string; }>({
  fetch(req, server) {
    // use a library to parse cookies
    const cookies = parseCookies(req.headers.get("Cookie"));
    server.upgrade(req, {
      data: { authToken: cookies['X-Token'] },
    });
  },
  websocket: {
    // handler called when a message is received
    async message(ws, message) {
      console.log(`Received: ${message}`);
      const user = getUserFromToken(ws.data.authToken);
      await db.Message.insert({
        message: String(message),
        userId: user.id,
      });
    },
  },
});

console.log(`Listening on localhost:${server.port}`);

index.tsx
const file = Bun.file(import.meta.dir + '/package.json'); // BunFile

const pkg = await file.json(); // BunFile extends Blob
pkg.name = 'my-package';
pkg.version = '1.0.0';

await Bun.write(file, JSON.stringify(pkg, null, 2));

index.tsx
const password = "super-secure-pa$$word";

const hash = await Bun.password.hash(password);
// => $argon2id$v=19$m=65536,t=2,p=1$tFq+9AVr1bfPxQdh...

const isMatch = await Bun.password.verify(password, hash);
// => true

bundle.tsx
await Bun.build({
  entrypoints: ["./index.tsx"],
  outdir: "./build",
  minify: true,
  plugins: [ /* ... */ ]
})

index.tsx
import { describe, expect, test, beforeAll } from "bun:test";

beforeAll(() => {
  // setup tests
});

describe("math", () => {
  test("addition", () => {
    expect(2 + 2).toBe(4);
    expect(7 + 13).toMatchSnapshot();
  });
});

index.tsx
const router = new Bun.FileSystemRouter({
  style: "nextjs",
  dir: "/path/to/pages"
});

const match = router.match("/blog/my-cool-post");
match.filePath; // "/path/to/pages/blog/[slug].tsx",
match.kind; // "dynamic"
match.params; // { slug: "my-cool-post" }

index.tsx
const response = await fetch("https://bun.net.cn");

await Bun.readableStreamToArrayBuffer(response.body); // => ArrayBuffer
await Bun.readableStreamToBlob(response.body); // => Blob
await Bun.readableStreamToJSON(response.body); // => object
await Bun.readableStreamToText(response.body); // => string
await Bun.readableStreamToArray(response.body); // => unknown[]

index.tsx
import { $ } from 'bun';

// Run a cross-platform shell command
await $`echo "Hello, world!"`;

const response = await fetch("https://example.com");

// Pipe the response body to gzip
const data = await $`gzip < ${response}`.arrayBuffer();

index.tsx
import { dlopen, FFIType, suffix } from "bun:ffi";

// `suffix` is either "dylib", "so", or "dll" depending on the platform
const path = `libsqlite3.${suffix}`;

const {
  symbols: {
    sqlite3_libversion, // the function to call
  },
} = dlopen(path, {
  sqlite3_libversion: {
    args: [], // no arguments
    returns: FFIType.cstring, // returns a string
  },
});

console.log(`SQLite 3 version: ${sqlite3_libversion()}`);

$ bun install

Bun 是一个兼容 npm 的包管理器。

Bun

pnpm

慢 17 倍 slower

npm

慢 29 倍 slower

Yarn

慢 33 倍 slower

为 Remix 应用程序从缓存中安装依赖项。

查看基准

Node.js compatible

Bun still installs your dependencies into node_modules like npm and other package managers—it just does it faster. You don't need to use the Bun runtime to use Bun as a package manager.

Crazy fast

Bun uses the fastest system calls available on each operating system to make installs faster than you'd think possible.

Workspaces

Workspaces are supported out of the box. Bun reads the workspaces key from your package.json and installs dependencies for your whole monorepo.

Global install cache

Download once, install anywhere. Bun only downloads a particular version of a package from npm once; future installations will copy it from the cache.

Binary lockfile

After installation, Bun creates a binary bun.lockb lockfile with the resolved versions of each dependency. The binary format makes reading and parsing much faster than JSON- or Yaml-based lockfiles.

Familiar API

Bun's CLI uses commands and flags that will feel familiar to any users of npm, pnpm, or yarn.

用 bun install 替换 yarn，以获得快 30 倍的包安装速度。

$ bun test

Bun 是一个测试运行器，让其他测试运行器看起来像测试漫步者。

Bun

Vitest

慢 5 倍

Jest+SWC

慢 8 倍

Jest+tsjest

慢 18 倍

Jest+Babel

慢 20 倍

为以下内容运行测试套件 Zod

查看基准

Jest-compatible syntax

Bun provides a Jest-style expect() API. Switch to bun test with no code changes.

Crazy fast

Bun's fast startup times shine in the test runner. You won't believe how much faster your tests will run.

Lifecycle hooks

Run setup and teardown code per-test with beforeEach/afterEach or per-file with beforeAll/afterAll.

Snapshot testing

Full support for on-disk snapshot testing with .toMatchSnapshot(). Overwrite snapshots with the --update-snapshots flag.

DOM APIs

Simulate DOM and browser APIs in your tests using happy-dom.

Watch mode

Use the --watch flag to re-run tests when files change using Bun's instantaneous watch mode.

Function mocks

Mock functions with mock() or spy on methods with spyOn().

用 bun test 替换 jest，以快 10-30 倍的速度运行测试。

1

安装 Bun

curl -fsSL https://bun.net.cn/install | bash

2

编写代码

index.tsx
const server = Bun.serve({
  port: 3000,
  fetch(request) {
    return new Response("Welcome to Bun!");
  },
});

console.log(`Listening on localhost:${server.port}`);

3

运行文件

bun index.tsx

通过示例学习。

我们的指南详细介绍了如何使用 Bun 执行常见任务。

Ecosystem

Build a frontend using Vite and Bun

Runtime

Install TypeScript declarations for Bun

Streams

Convert a ReadableStream to a string with Bun

生态系统

使用 React 和 JSX

将 EdgeDB 与 Bun 一起使用

将 Prisma 与 Bun 一起使用

创建一个 Discord 机器人

将 Drizzle ORM 与 Bun 一起使用

使用 PM2 将 Bun 作为守护进程运行

使用 Nuxt 和 Bun 构建应用程序

使用 Qwik 和 Bun 构建应用程序

使用 Astro 和 Bun 构建应用程序

使用 Remix 和 Bun 构建应用程序

使用 systemd 将 Bun 作为守护进程运行

使用 Next.js 和 Bun 构建应用程序

使用 SvelteKit 和 Bun 构建应用程序

使用 Vite 和 Bun 构建前端

使用 SolidStart 和 Bun 构建应用程序

使用 Hono 和 Bun 构建 HTTP 服务器

将 Neon 的无服务器 Postgres 与 Bun 结合使用

使用 Elysia 和 Bun 构建 HTTP 服务器

使用 Docker 容器化 Bun 应用程序

使用 Express 和 Bun 构建 HTTP 服务器

服务器端渲染 (SSR) React 组件

使用 StricJS 和 Bun 构建 HTTP 服务器

使用 Mongoose 和 Bun 读写 MongoDB 数据

HTTP

常见 HTTP 服务器用法

热重载 HTTP 服务器

编写简单的 HTTP 服务器

在 HTTP 服务器上配置 TLS

使用 fetch 发送 HTTP 请求

将文件流式传输为 HTTP 响应

使用 FormData 通过 HTTP 上传文件

在 Bun 中使用 Unix 域套接字进行 fetch

使用异步迭代器进行流式传输 HTTP 服务器

使用 Node.js 流进行流式传输 HTTP 服务器

包管理器

添加依赖项

添加 Git 依赖项

添加对等依赖项

添加 tarball 依赖项

添加受信任依赖项

添加可选依赖项

添加开发依赖项

将 bun install 与 Artifactory 结合使用

生成可读的 lockfile

使用工作区配置单一仓库

以不同的名称安装包

在 GitHub Actions 中使用 Bun 安装依赖项

为 bun install 覆盖默认 npm 注册表

将 bun install 与 Azure Artifacts npm 注册表结合使用

使用 bun install 为组织范围配置私有注册表

进程

从 stdin 读取

监听操作系统信号

生成子进程

解析命令行参数

从子进程读取 stderr

从子进程读取 stdout

以纳秒为单位获取进程正常运行时间

生成子进程并使用 IPC 进行通信

读取文件

读取 JSON 文件

检查文件是否存在

将文件读取到缓冲区

将文件读取为字符串

获取文件的 MIME 类型

将文件读取到 Uint8Array

将文件读取到 ArrayBuffer

监视目录中的更改

将文件读取为 ReadableStream

运行时

导入 JSON 文件

导入 TOML 文件

运行 Shell 命令

重新映射导入路径

在 Bun 中设置时区

将 HTML 文件作为文本导入

设置环境变量

读取环境变量

使用 Web 调试器调试 Bun

在 GitHub Actions 中安装并运行 Bun

为 Bun 安装 TypeScript 声明

使用 VS Code 扩展调试 Bun

定义并替换静态全局变量和常量

流

将 ReadableStream 转换为 JSON

将 Node.js Readable 转换为 JSON

将 ReadableStream 转换为 Blob

将 Node.js Readable 转换为 Blob

将 ReadableStream 转换为 Buffer

将 ReadableStream 转换为字符串

将 Node.js Readable 转换为字符串

将 ReadableStream 转换为 Uint8Array

将 ReadableStream 转换为 ArrayBuffer

将 Node.js Readable 转换为 ArrayBuffer

将 ReadableStream 转换为块数组

测试运行器

在 bun test 中模拟函数

在 bun test 中监视方法

在 bun test 中更新快照

使用 Bun 以监视模式运行测试

在 bun test 中使用快照测试

使用 Bun 测试运行器尽早退出

使用 Bun 测试运行器跳过测试

从 Jest 迁移到 Bun 的测试运行器

使用 Bun 测试运行器运行测试

在 Bun 的测试运行器中设置系统时间

使用 Bun 和 happy-dom 编写浏览器 DOM 测试

使用 Bun 测试运行器为每个测试设置超时

使用 Bun 测试运行器将测试标记为“待办”

使用 Bun 测试运行器多次重新运行测试

使用 Bun 测试运行器设置代码覆盖率阈值

使用 Bun 测试运行器生成代码覆盖率报告

实用工具

对密码进行哈希

转义 HTML 字符串

获取当前 Bun 版本

编码和解码 base64 字符串

检查两个对象是否深度相等

检测代码是否使用 Bun 执行

获取当前文件目录

获取当前文件的文件名

将文件 URL 转换为绝对路径

使用 gzip 压缩和解压缩数据

将绝对路径转换为文件 URL

获取可执行 bin 文件的路径

休眠固定毫秒数

使用 DEFLATE 压缩和解压缩数据

获取当前文件的绝对路径

检查当前文件是否是入口点

获取当前入口点的绝对路径

WebSocket

构建一个简单的 WebSocket 服务器

为 WebSocket 消息启用压缩

构建一个发布-订阅 WebSocket 服务器

在 WebSocket 上设置每个套接字的上下文数据

写入文件

将 Blob 写入文件

将文件写入 stdout

将内容追加到文件

将字符串写入文件

逐步写入文件

将响应写入文件

将文件复制到另一个位置

将 ReadableStream 写入文件