Bun 运行时特性 #

console.log(Bun);

// Bun 版本信息
Bun.version;           // "1.2.0"
Bun.revision;          // Git commit hash

// 环境变量
Bun.env;               // 环境变量对象
Bun.env.NODE_ENV;      // "development" | "production"

// 当前工作目录
Bun.cwd();             // 当前工作目录

// 主入口文件
Bun.main;              // 入口文件路径

// 命令行参数
Bun.argv;              // 命令行参数数组

// 创建文件引用
const file = Bun.file("./data.txt");

// 获取文件信息
console.log(file.size);        // 文件大小
console.log(file.type);        // MIME 类型
console.log(file.name);        // 文件名
console.log(file.lastModified); // 最后修改时间

// 读取内容
const text = await file.text();
const json = await file.json();
const arrayBuffer = await file.arrayBuffer();
const blob = file.slice(0, 1024);

// 写入文本
await Bun.write("./output.txt", "Hello, Bun!");

// 写入 JSON
await Bun.write("./data.json", { name: "Bun" });

// 写入 Buffer
const buffer = new TextEncoder().encode("Hello");
await Bun.write("./binary.bin", buffer);

// 写入 Blob
const blob = new Blob(["content"], { type: "text/plain" });
await Bun.write("./blob.txt", blob);

// 写入另一个文件
const source = Bun.file("./source.txt");
await Bun.write("./dest.txt", source);

Bun.serve({
  port: 3000,
  fetch(request) {
    return new Response("Hello, Bun!");
  },
});

console.log("Server running on http://localhost:3000");

// 执行命令
const result = await $`echo "Hello, Bun!"`;
console.log(result.text());

// 获取命令输出
const { stdout, stderr, exitCode } = await $`ls -la`;

// 管道
const files = await $`ls`.text();
console.log(files);

// 错误处理
try {
  await $`exit 1`;
} catch (error) {
  console.error("Command failed:", error);
}

// 环境变量
await $`echo $HOME`.env({ HOME: "/custom/path" });

// 工作目录
await $`pwd`.cwd("/tmp");

// 基本用法
const proc = Bun.spawn(["echo", "Hello"]);

// 等待完成
await proc.exited;
console.log(proc.exitCode);

// 获取输出
const proc = Bun.spawn(["ls", "-la"]);
const text = await new Response(proc.stdout).text();
console.log(text);

// 输入输出
const proc = Bun.spawn(["cat"], {
  stdin: "pipe",
  stdout: "pipe",
});

proc.stdin.write("Hello");
proc.stdin.end();

const output = await new Response(proc.stdout).text();
console.log(output);

// 睡眠 1 秒
await Bun.sleep(1000);
await Bun.sleep("1s");

// 睡眠 500 毫秒
await Bun.sleep(500);
await Bun.sleep("500ms");

// GET 请求
const response = await fetch("https://api.example.com/data");
const data = await response.json();

// POST 请求
const response = await fetch("https://api.example.com/users", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ name: "Bun" }),
});

// 处理响应
console.log(response.status);
console.log(response.headers.get("content-type"));
const text = await response.text();
const json = await response.json();
const buffer = await response.arrayBuffer();

const request = new Request("https://api.example.com", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ name: "Bun" }),
});

console.log(request.url);
console.log(request.method);
console.log(request.headers);
const body = await request.json();

// 创建响应
const response = new Response("Hello, World!", {
  status: 200,
  headers: { "Content-Type": "text/plain" },
});

// JSON 响应
const jsonRes = Response.json({ message: "Hello" });

// 重定向
const redirect = Response.redirect("https://example.com", 302);

// 错误响应
const error = Response.error();

const headers = new Headers();
headers.set("Content-Type", "application/json");
headers.append("X-Custom", "value");

console.log(headers.get("Content-Type"));
console.log(headers.has("X-Custom"));
headers.delete("X-Custom");

// 从对象创建
const headers2 = new Headers({
  "Content-Type": "application/json",
  "Authorization": "Bearer token",
});

const url = new URL("https://example.com/path?foo=bar&baz=qux");

console.log(url.protocol);  // "https:"
console.log(url.hostname);  // "example.com"
console.log(url.pathname);  // "/path"
console.log(url.search);    // "?foo=bar&baz=qux"

// 查询参数
console.log(url.searchParams.get("foo"));  // "bar"
url.searchParams.set("new", "value");
console.log(url.toString());

const formData = new FormData();
formData.append("name", "Bun");
formData.append("file", new Blob(["content"]), "file.txt");

// 从表单数据获取
console.log(formData.get("name"));
console.log(formData.get("file"));

// 遍历
for (const [key, value] of formData) {
  console.log(key, value);
}

// 客户端 WebSocket
const ws = new WebSocket("wss://example.com/socket");

ws.onopen = () => {
  console.log("Connected");
  ws.send("Hello!");
};

ws.onmessage = (event) => {
  console.log("Received:", event.data);
};

ws.onerror = (error) => {
  console.error("Error:", error);
};

ws.onclose = () => {
  console.log("Disconnected");
};

// 创建 Blob
const blob = new Blob(["Hello, World!"], { type: "text/plain" });

// 读取内容
const text = await blob.text();
const arrayBuffer = await blob.arrayBuffer();

// 切片
const slice = blob.slice(0, 5);

// 大小和类型
console.log(blob.size);
console.log(blob.type);

// 编码
const encoder = new TextEncoder();
const uint8Array = encoder.encode("Hello, Bun!");

// 解码
const decoder = new TextDecoder();
const text = decoder.decode(uint8Array);

// 流式解码
const streamDecoder = new TextDecoderStream();

// 随机值
const array = new Uint8Array(16);
crypto.getRandomValues(array);

// UUID
crypto.randomUUID();

// 摘要算法
const hashBuffer = await crypto.subtle.digest(
  "SHA-256",
  new TextEncoder().encode("Hello")
);
const hashArray = Array.from(new Uint8Array(hashBuffer));
const hashHex = hashArray.map(b => b.toString(16).padStart(2, "0")).join("");

// 进程信息
process.pid;              // 进程 ID
process.ppid;             // 父进程 ID
process.title;            // 进程标题
process.version;          // Node 版本字符串
process.versions;         // 版本信息对象

// 环境变量
process.env.NODE_ENV;
process.env.PATH;

// 命令行参数
process.argv;             // 参数数组
process.cwd();            // 当前目录

// 标准流
process.stdin;
process.stdout;
process.stderr;

// 退出
process.exit(0);
process.exitCode = 1;

// 事件
process.on("exit", (code) => {
  console.log(`Exiting with code ${code}`);
});

process.on("uncaughtException", (error) => {
  console.error("Uncaught exception:", error);
});

// 创建 Buffer
const buf1 = Buffer.from("Hello");
const buf2 = Buffer.alloc(10);
const buf3 = Buffer.allocUnsafe(10);

// 操作
buf1.write("World");
const str = buf1.toString();
const json = buf1.toJSON();

// 拼接
const combined = Buffer.concat([buf1, buf2]);

// 比较
buf1.equals(buf2);
buf1.compare(buf2);

// 文件系统
import fs from "fs";
import { readFileSync, writeFileSync } from "fs";

// 路径
import path from "path";
import { join, dirname, basename } from "path";

// HTTP
import http from "http";
import https from "https";

// 加密
import crypto from "crypto";

// 事件
import { EventEmitter } from "events";

// 流
import { Readable, Writable, Transform } from "stream";

// 工具
import util from "util";

// URL
import { URL, URLSearchParams } from "url";

// 查询字符串
import qs from "querystring";

import fs from "fs";

// 同步读取
const data = fs.readFileSync("./file.txt", "utf-8");

// 异步读取
fs.readFile("./file.txt", "utf-8", (err, data) => {
  if (err) throw err;
  console.log(data);
});

// Promise 版本
import { promises as fsPromises } from "fs";
const data = await fsPromises.readFile("./file.txt", "utf-8");

// 写入
fs.writeFileSync("./output.txt", "Hello");

// 目录操作
fs.mkdirSync("./new-dir", { recursive: true });
const files = fs.readdirSync("./");
fs.rmSync("./dir", { recursive: true });

// 状态
const stats = fs.statSync("./file.txt");
console.log(stats.isFile());
console.log(stats.isDirectory());
console.log(stats.size);

import path from "path";

// 路径拼接
path.join("/foo", "bar", "baz");       // "/foo/bar/baz"

// 解析路径
path.resolve("./file.txt");            // 绝对路径
path.dirname("/foo/bar/baz.txt");      // "/foo/bar"
path.basename("/foo/bar/baz.txt");     // "baz.txt"
path.extname("/foo/bar/baz.txt");      // ".txt"

// 规范化
path.normalize("/foo//bar/../baz");    // "/foo/baz"

import { EventEmitter } from "events";

const emitter = new EventEmitter();

// 监听事件
emitter.on("message", (data) => {
  console.log("Received:", data);
});

// 触发事件
emitter.emit("message", { text: "Hello" });

// 一次性监听
emitter.once("connect", () => {
  console.log("Connected!");
});

// 移除监听
const handler = (data) => console.log(data);
emitter.on("data", handler);
emitter.off("data", handler);

import { Readable, Writable, Transform } from "stream";

// 可读流
const readable = new Readable({
  read() {}
});

readable.push("Hello");
readable.push("World");
readable.push(null);

// 可写流
const writable = new Writable({
  write(chunk, encoding, callback) {
    console.log(chunk.toString());
    callback();
  }
});

// 转换流
const transform = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

// 管道
readable.pipe(transform).pipe(writable);

// Bun 启动时自动优化
// 1. 预编译 TypeScript
// 2. 缓存模块解析
// 3. 延迟加载

// 查看启动时间
console.time("startup");
// ... 代码
console.timeEnd("startup");

// 手动触发 GC（如果需要）
if (global.gc) {
  global.gc();
}

// 内存使用
const used = process.memoryUsage();
console.log({
  rss: `${used.rss / 1024 / 1024} MB`,
  heapTotal: `${used.heapTotal / 1024 / 1024} MB`,
  heapUsed: `${used.heapUsed / 1024 / 1024} MB`,
});

// 使用 --hot 参数
// bun --hot run server.ts

// 代码变化自动重载
Bun.serve({
  fetch() {
    return new Response(`Time: ${Date.now()}`);
  },
});

// 未捕获异常
process.on("uncaughtException", (error) => {
  console.error("Uncaught Exception:", error);
  process.exit(1);
});

// 未处理的 Promise 拒绝
process.on("unhandledRejection", (reason, promise) => {
  console.error("Unhandled Rejection:", reason);
});

// 警告
process.on("warning", (warning) => {
  console.warn("Warning:", warning);
});

class AppError extends Error {
  constructor(
    public message: string,
    public code: number = 500
  ) {
    super(message);
    this.name = "AppError";
  }
}

try {
  throw new AppError("Something went wrong", 400);
} catch (error) {
  if (error instanceof AppError) {
    console.error(`Error ${error.code}: ${error.message}`);
  }
}