Bun for Windows 已發布！查看 Bun 1.1 的新功能 →

Bun v1.1.5 已發布！→

Bun 是一個快速的 JavaScript
多合一工具包|

開發、測試、執行和打包 JavaScript 和 TypeScript 專案，所有這些都使用 Bun。Bun 是專為速度而設計的多合一 JavaScript 執行環境和工具包，並配備一個打包器、測試執行器和與 Node.js 相容的套件管理員。

安裝 Bun v1.1.5

curl -fsSL https://bun.dev.org.tw/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.dev.org.tw");

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 倍

npm

慢 29 倍

Yarn

慢 33 倍

安裝 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.dev.org.tw/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 相依性

新增受信任相依性

新增選用相依性

新增開發相依性

在 Artifactory 中使用 bun install

產生人類可讀的鎖定檔

使用工作區設定單一儲存庫

以不同名稱安裝套件

在 GitHub Actions 中使用 Bun 安裝相依性

覆寫 bun install 的預設 npm 登錄

在 Azure Artifacts npm 登錄中使用 bun install

使用 bun install 為組織範圍設定私人登錄

處理程序

從 stdin 讀取

監聽作業系統訊號

產生子處理程序

剖析命令列引數

從子處理程序讀取 stderr

從子處理程序讀取 stdout

取得處理程序上線時間（以奈秒為單位）

產生子處理程序並使用 IPC 通訊

讀取檔案

讀取 JSON 檔案

檢查檔案是否存在

將檔案讀取至 Buffer

將檔案讀取為字串

取得檔案的 MIME 類型

將檔案讀取至 Uint8Array

將檔案讀取至 ArrayBuffer

監控目錄變更

以 ReadableStream 讀取檔案

執行時間

匯入 JSON 檔案

匯入 TOML 檔案

執行 Shell 指令

重新對應匯入路徑

在 Bun 中設定時區

以文字匯入 HTML 檔案

設定環境變數

讀取環境變數

使用網路偵錯工具偵錯 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

取得可執行二進位檔的檔案路徑

休眠固定毫秒數

使用 DEFLATE 壓縮和解壓縮資料

取得目前檔案的絕對路徑

檢查目前檔案是否為進入點

取得目前進入點的絕對路徑

WebSocket

建立一個簡單的 WebSocket 伺服器

針對 WebSocket 訊息啟用壓縮

建立一個發佈訂閱 WebSocket 伺服器

在 WebSocket 上設定每個 socket 的背景資料

寫入檔案

將 Blob 寫入檔案

將檔案寫入 stdout

將內容附加到檔案

將字串寫入檔案

逐步寫入檔案

將 Response 寫入檔案

將檔案複製到另一個位置

將 ReadableStream 寫入檔案