Bun trong Thực Tế: Điều Gì Hoạt Động, Điều Gì Không, và Điều Gì Khiến Tôi Bất Ngờ | Akousa

bash

# Kiểm tra phiên bản Bun của bạn
bun --version
 
# Chạy file TypeScript trực tiếp — không cần tsconfig, không cần bước biên dịch
bun run server.ts
 
# Cài đặt gói
bun install
 
# Chạy test
bun test
 
# Bundle cho production
bun build ./src/index.ts --outdir ./dist

bash

# Đo thời gian khởi động — chạy mỗi cái 100 lần
hyperfine --warmup 5 'node -e "console.log(1)"' 'bun -e "console.log(1)"'
 
# Kết quả thông thường:
# node:  ~40ms
# bun:   ~6ms

bash

# Benchmark cài đặt sạch — xóa node_modules và lockfile trước
rm -rf node_modules bun.lockb package-lock.json
 
# Đo npm
time npm install
# Real: ~18.4s (dự án cỡ trung bình thông thường)
 
# Đo bun
time bun install
# Real: ~2.1s

bash

# Benchmark nhanh với bombardier
# Test phản hồi "Hello World" đơn giản
 
# Bun server
bombardier -c 100 -d 10s http://localhost:3000
# Requests/sec: ~105,000
 
# Node.js (module http native)
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

typescript

// fibonacci.ts — cái này phụ thuộc engine, không phụ thuộc runtime
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`);

bash

# Cài đặt hyperfine để benchmark đúng cách
brew install hyperfine  # macOS
# hoặc: cargo install hyperfine
 
# Benchmark khởi động + thực thi ứng dụng thực của bạn
hyperfine --warmup 3 \
  'node dist/server.js' \
  'bun src/server.ts' \
  --prepare 'sleep 0.1'
 
# Cho HTTP server, sử dụng bombardier hoặc wrk
# Quan trọng: test với payload thực tế, không phải "Hello World"
bombardier -c 50 -d 30s -l http://localhost:3000/api/users
 
# So sánh bộ nhớ
/usr/bin/time -v node server.js  # Linux
/usr/bin/time -l bun server.ts   # macOS

bash

# Cài đặt tất cả dependencies từ package.json
bun install
 
# Thêm dependency
bun add express
 
# Thêm dev dependency
bun add -d vitest
 
# Xóa dependency
bun remove express
 
# Cập nhật dependency
bun update express
 
# Cài đặt phiên bản cụ thể
bun add express@4.18.2

bash

# Bạn có thể xuất lockfile sang định dạng đọc được
bun bun.lockb > lockfile-dump.txt
 
# Hoặc sử dụng output dạng text tích hợp
bun install --yarn
# Điều này tạo yarn.lock bên cạnh bun.lockb

bash

# Cài đặt dependencies cho tất cả workspace
bun install
 
# Chạy script trong workspace cụ thể
bun run --filter packages/shared build
 
# Thêm dependency vào workspace cụ thể
bun add react --filter apps/web

bash

# Bước 1: Xóa lockfile và node_modules hiện có
rm -rf node_modules package-lock.json yarn.lock pnpm-lock.yaml
 
# Bước 2: Cài đặt với Bun
bun install
 
# Bước 3: Xác nhận ứng dụng vẫn hoạt động
bun run dev
# hoặc: node dist/server.js  (trình quản lý gói Bun, runtime Node)

typescript

// Tất cả những cái này đều hoạt động như mong đợi trong 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";

typescript

// Cái này SẼ KHÔNG hoạt động trong Bun — riêng của V8
const v8 = require("v8");
v8.serialize({ data: "test" });
 
// Cái này SẼ hoạt động — sử dụng tương đương của Bun hoặc cách tiếp cận cross-runtime
const encoded = new TextEncoder().encode(JSON.stringify({ data: "test" }));

typescript

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}`);

typescript

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}`);

typescript

// Đọc file
const file = Bun.file("./config.json");
const text = await file.text(); // Đọc dạng string
const json = await file.json(); // Parse JSON trực tiếp
const bytes = await file.arrayBuffer(); // Đọc dạng ArrayBuffer
const stream = file.stream(); // Đọc dạng ReadableStream
 
// Metadata file
console.log(file.size); // Kích thước tính bằng byte
console.log(file.type); // Loại MIME (vd: "application/json")
 
// Ghi file
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"));
 
// Ghi body Response vào file
const response = await fetch("https://example.com/data.json");
await Bun.write("./downloaded.json", response);

typescript

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) {
      // Broadcast tới tất cả subscriber
      server.publish("chat", `${ws.data.userId}: ${message}`);
    },
 
    close(ws) {
      console.log(`Client disconnected: ${ws.data.userId}`);
      ws.unsubscribe("chat");
    },
  },
});

typescript

import { Database } from "bun:sqlite";
 
// Mở hoặc tạo database
const db = new Database("myapp.db");
 
// Chế độ WAL cho hiệu năng đọc đồng thời tốt hơn
db.exec("PRAGMA journal_mode = WAL");
 
// Tạo bảng
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'))
  )
`);
 
// Prepared statement (có thể tái sử dụng, nhanh hơn cho truy vấn lặp lại)
const insertUser = db.prepare("INSERT INTO users (email, name) VALUES ($email, $name) RETURNING *");
 
const findByEmail = db.prepare("SELECT * FROM users WHERE email = $email");
 
// Sử dụng
const user = insertUser.get({
  $email: "alice@example.com",
  $name: "Alice",
});
console.log(user); // { id: 1, email: "alice@example.com", name: "Alice", ... }
 
// Transaction
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`);

typescript

// 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);
  });
});

bash

# Chạy tất cả test
bun test
 
# Chạy file cụ thể
bun test math.test.ts
 
# Chạy test khớp mẫu
bun test --test-name-pattern "adds numbers"
 
# Chế độ watch
bun test --watch
 
# Coverage
bun test --coverage

typescript

import { describe, it, expect, mock, spyOn } from "bun:test";
import { fetchUsers } from "./api";
 
// Mock một module
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 trên method của object
describe("console", () => {
  it("tracks console.log calls", () => {
    const logSpy = spyOn(console, "log");
    console.log("test message");
    expect(logSpy).toHaveBeenCalledWith("test message");
    logSpy.mockRestore();
  });
});

bash

# Bundle một entry point duy nhất
bun build ./src/index.ts --outdir ./dist
 
# Bundle cho các target khác nhau
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
 
# Minify
bun build ./src/index.ts --outdir ./dist --minify
 
# Tạo sourcemap
bun build ./src/index.ts --outdir ./dist --sourcemap external

typescript

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, // Tách code
  sourcemap: "external",
  external: ["react", "react-dom"], // Không bundle những cái này
  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`);
}

typescript

// 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());

typescript

// build-info.ts — file này chạy tại THỜI ĐIỂM BUILD, không phải runtime
export function getBuildInfo() {
  return {
    builtAt: new Date().toISOString(),
    gitSha: require("child_process").execSync("git rev-parse --short HEAD").toString().trim(),
    nodeVersion: process.version,
  };
}

typescript

// app.ts
import { getBuildInfo } from "./build-info" with { type: "macro" };
 
// getBuildInfo() thực thi tại thời điểm bundle
// Kết quả được inline như giá trị tĩnh
const info = getBuildInfo();
console.log(`Built at ${info.builtAt}, commit ${info.gitSha}`);

bash

# Sử dụng Bun để cài đặt dependency, sau đó dùng Node.js để chạy Next.js
bun install
bun run dev    # Thực ra chạy script "dev" qua Node.js theo mặc định
bun run build
bun run start

dockerfile

FROM oven/bun:1 AS base
WORKDIR /app
 
# Cài đặt dependency
FROM base AS deps
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
 
# Build (nếu cần)
FROM base AS build
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun run build
 
# Production
FROM base AS production
WORKDIR /app
 
# Không chạy với quyền 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"]

dockerfile

# Giai đoạn build: image Bun đầy đủ với tất cả dependency
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
 
# Giai đoạn runtime: base image nhỏ hơn
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"]

bash

# Biên dịch ứng dụng thành file thực thi duy nhất
bun build --compile ./src/server.ts --outfile server
 
# Output là binary độc lập — không cần Bun hoặc Node.js để chạy
./server

dockerfile

# Image Docker siêu tối thiểu sử dụng binary đã biên dịch
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
 
# Image cuối cùng — chỉ binary
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"]

bash

# Image Node.js
docker images | grep node
# node:20-slim    ~180MB
 
# Image Bun
docker images | grep bun
# oven/bun:1-slim  ~130MB
 
# Binary đã biên dịch trên debian:bookworm-slim
# ~80MB base + ~70MB binary = ~150MB tổng
 
# vs. Alpine với Node.js
# node:20-alpine   ~130MB + node_modules

bash

# Sử dụng bun để chạy script phát triển
bun run dev
bun run lint
bun run format
 
# Sử dụng bun cho script chạy một lần
bun run scripts/seed-database.ts
bun run scripts/migrate.ts

json

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

bash

# So sánh số lượng dependency
# Một dự án Express + SQLite + WebSocket điển hình:
npm ls --all | wc -l
# ~340 gói
 
# Cùng chức năng với tính năng tích hợp của Bun:
bun pm ls --all | wc -l
# ~12 gói (chỉ code ứng dụng của bạn)

typescript

// Sử dụng tùy chọn Bun.serve() cho tinh chỉnh production
Bun.serve({
  port: 3000,
 
  // Tăng kích thước body request tối đa (mặc định 128MB)
  maxRequestBodySize: 1024 * 1024 * 50, // 50MB
 
  // Bật chế độ development cho trang lỗi tốt hơn
  development: process.env.NODE_ENV !== "production",
 
  // Tái sử dụng port (hữu ích cho restart không downtime)
  reusePort: true,
 
  fetch(req) {
    return new Response("OK");
  },
});

typescript

// Sử dụng Bun.Transpiler cho chuyển đổi code runtime
const transpiler = new Bun.Transpiler({
  loader: "tsx",
  target: "browser",
});
 
const code = transpiler.transformSync(`
  const App: React.FC = () => <div>Hello</div>;
  export default App;
`);

bash

# Flag sử dụng bộ nhớ của Bun
bun --smol run server.ts  # Giảm memory footprint (hơi chậm hơn)
 
# Đặt kích thước heap tối đa
BUN_JSC_forceRAMSize=512000000 bun run server.ts  # ~512MB limit

typescript

// fetch Node.js 18+ và fetch của Bun hơi khác
// trong cách chúng xử lý một số header và redirect
 
// Bun theo redirect mặc định (giống browser)
// fetch Node.js cũng theo redirect, nhưng hành vi
// với một số status code (303, 307, 308) có thể khác
 
const response = await fetch("https://api.example.com/data", {
  redirect: "manual", // Rõ ràng về xử lý redirect
});

typescript

// Bun thoát khi event loop trống
// Node.js đôi khi tiếp tục chạy do handle còn sót
 
// Nếu script Bun thoát bất ngờ, có thứ gì đó không
// giữ event loop hoạt động
 
// Cái này sẽ thoát ngay trong Bun:
setTimeout(() => {}, 0);
 
// Cái này sẽ tiếp tục chạy:
setTimeout(() => {}, 1000);
// (Bun thoát sau khi timeout kích hoạt)

typescript

// Bun có mặc định tsconfig riêng
// Nếu bạn chia sẻ dự án giữa Bun và Node.js,
// hãy rõ ràng trong tsconfig.json:
{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "types": ["bun-types"]  // Thêm định nghĩa type cho Bun
  }
}

bash

# Bun có chế độ watch tích hợp
bun --watch run server.ts
 
# Cái này restart process khi file thay đổi
# Không phải HMR (Hot Module Replacement) — là restart đầy đủ
# Nhưng vì Bun khởi động rất nhanh, cảm giác tức thì

toml

# bunfig.toml — file config của Bun (tùy chọn)
 
[install]
# Sử dụng registry riêng
registry = "https://npm.mycompany.com"
 
# Registry theo scope
[install.scopes]
"@mycompany" = "https://npm.mycompany.com"
 
[test]
# Cấu hình test
coverage = true
coverageReporter = ["text", "lcov"]
 
[run]
# Shell dùng cho bun run
shell = "bash"

Bun Thực Sự Là Gì

Các Tuyên Bố Về Tốc Độ — Benchmark Trung Thực

Thời Gian Khởi Động

Cài Đặt Gói

Throughput HTTP Server

Nơi Sự Khác Biệt Không Đáng Kể

Cách Chạy Benchmark Của Riêng Bạn

Bun Với Vai Trò Trình Quản Lý Gói

Cơ Bản

Tình Hình Lockfile

Hỗ Trợ Workspace

Tương Thích Với Dự Án Hiện Tại

Tương Thích Node.js

Những Gì Hoạt Động

Những Gì Không Hoạt Động (hoặc Có Vấn Đề)

Trình Theo Dõi Tương Thích

API Tích Hợp Của Bun

Bun.serve() — HTTP Server Tích Hợp

Bun.file() và Bun.write() — I/O File

Hỗ Trợ WebSocket Tích Hợp

SQLite Tích Hợp với bun:sqlite

Bun Test Runner

Sử Dụng Cơ Bản

Mocking

Bun Test vs. Vitest — So Sánh Trung Thực

Bun Bundler

Bundling Cơ Bản

API Lập Trình

Tree-Shaking

Nơi Bun Build Còn Thiếu

Bun Macro

Sử Dụng Bun Với Next.js

Những Gì Hoạt Động Hôm Nay

Những Gì Vẫn Thử Nghiệm

Khuyến Nghị Của Tôi Cho Next.js

Docker Với Bun

Dockerfile Cơ Bản

Build Nhiều Giai Đoạn Cho Image Tối Thiểu

Biên Dịch Thành File Nhị Phân Duy Nhất

So Sánh Kích Thước

Mô Hình Migration

Giai Đoạn 1: Chỉ Trình Quản Lý Gói (Không Rủi Ro)

Giai Đoạn 2: Script và Tooling

Giai Đoạn 3: Test Runner (Rủi Ro Trung Bình)

Giai Đoạn 4: Runtime Cho Service Mới (Rủi Ro Có Tính Toán)

Giai Đoạn 5: Migration Runtime (Nâng Cao)

Biến Môi Trường và Cấu Hình

Xử Lý Lỗi và Debug

Cân Nhắc Bảo Mật

Tinh Chỉnh Hiệu Năng

Các Gotcha Phổ Biến

1. Hành Vi Global Fetch Khác Biệt

2. Hành Vi Thoát Process

3. Cấu Hình TypeScript

4. Hot Reload Trong Development

5. File Cấu Hình bunfig.toml

Kết Luận Của Tôi

Nơi Tôi Sử Dụng Bun Hôm Nay

Nơi Tôi Giữ Node.js

Những Gì Tôi Đang Theo Dõi

Tổng Kết

Bài viết liên quan

Regex Cheat Sheet 2026 — Regular Expressions Made Simple

How to Compress Images Without Losing Quality: The Complete 2026 Guide

5. File Cấu Hình `bunfig.toml`