Bun.fileとBun.writeでファイルを読み書きする速さ

​​Bun​Node.js,TypeScript,パフォーマンス

Bun でファイルを読み書きするには、Bun 独自の Bun.file()・Bun.write() と、Node.js と同じ node:fs の2通りがあります。どちらがどれだけ速いのかを、検証環境で実際に測りました。

設定ファイルや JSON を読む、ログを書き足す、大きなファイルをコピーする、といった場面でどちらを使うかの目安になるよう、1 KB・1 MB・100 MB のファイルの読み書き、コピー、1行ずつの追記で比べています。小さなファイルの書き込みと、ファイルがない状態から1行ずつ書く処理は Bun の API が速く、100 MB のような大きなファイルの書き込みは node:fs のほうが速い、という結果でした。

補足

検証環境は Ubuntu 24.04(x86_64、4 CPU、メモリ 16 GB、ファイルシステムは ext4)、Bun 1.4.4、Node.js 22.23.4 です。コードは TypeScript で書き、bun ファイル名.ts(Node.js では node ファイル名.ts)で実行しました。時間はこの検証用VMでの値で、実行のたびに少しずつ変わります。書き込みのあとに fsync はしておらず、読み込みは書いた直後のファイルで測っています。macOS や Windows、ディスクの種類による違い、Bun.file().stream() での読み込みは試していません。公式ドキュメントは、検証に使った版(タグ bun-v1.4.4)の元ファイルを GitHub で確認し、リンクもそこに張っています。

Bun.file と Bun.write の基本

公式ドキュメントの File I/O のページは、Bun.file と Bun.write を、Bun でファイルを扱うときのおすすめの方法としています。フォルダを作る、一覧を取るといった操作は、node:fs を使います。

速さを測る前に、基本の動きを basics.ts で確かめました。

ts
import { rmSync } from "node:fs";
rmSync("out", { recursive: true, force: true });

// Bun.file() は、作っただけではファイルを読まない
const missing = Bun.file("out/nai.txt");
console.log("ないファイル: size =", missing.size, "type =", missing.type);
console.log("ないファイル: exists() =", await missing.exists());

// Bun.write() は書いたバイト数を返す。親フォルダがなければ作る
const n = await Bun.write("out/sub/neko.txt", "こんにちは、猫の手\n");
console.log("Bun.write の戻り値:", n);

const file = Bun.file("out/sub/neko.txt");
console.log("書いたあと: size =", file.size, "type =", file.type);
console.log("text():", JSON.stringify(await file.text()));
console.log("bytes():", (await file.bytes()).constructor.name, (await file.bytes()).length);

// JSON は json() で読める。拡張子から type が決まる
await Bun.write("out/data.json", JSON.stringify({ name: "tama", age: 3 }));
const json = Bun.file("out/data.json");
console.log("data.json: type =", json.type, "json() =", await json.json());

// createPath: false だと、親フォルダがないときにエラーになる
try {
  await Bun.write("out/nai-folder/a.txt", "x", { createPath: false });
} catch (e) {
  console.log("createPath: false:", (e as Error & { code?: string }).code, (e as Error).message);
}

// ないファイルを読もうとすると、読む時点でエラーになる
try {
  await missing.text();
} catch (e) {
  console.log("ないファイルの text():", (e as Error & { code?: string }).code, (e as Error).message);
}

// ファイルをファイルにコピーする
const copied = await Bun.write("out/copy.txt", Bun.file("out/sub/neko.txt"));
console.log("コピーの戻り値:", copied, "中身:", JSON.stringify(await Bun.file("out/copy.txt").text()));
text
ないファイル: size = 0 type = text/plain;charset=utf-8
ないファイル: exists() = false
Bun.write の戻り値: 28
書いたあと: size = 28 type = text/plain;charset=utf-8
text(): "こんにちは、猫の手\n"
bytes(): Uint8Array 28
data.json: type = application/json;charset=utf-8 json() = {
  name: "tama",
  age: 3,
}
createPath: false: ENOENT ENOENT: no such file or directory, open 'out/nai-folder/a.txt'
ないファイルの text(): ENOENT ENOENT: no such file or directory, open 'out/nai.txt'
コピーの戻り値: 28 中身: "こんにちは、猫の手\n"

Bun.file() は、ファイルを指す入れ物を作るだけで、その時点ではディスクから読みません(公式ドキュメントの Bun.file の説明)。そのため、ないファイルを指定してもエラーにならず、size は0でした。エラーになったのは、text() で中身を読もうとしたときです。

Bun.write() は、書いたバイト数を返しました。「こんにちは、猫の手」は9文字ですが、UTF-8 で1文字3バイトなので、改行と合わせて28バイトです。書き込み先のフォルダがないときは、既定で作ります。createPath: false を付けると、ENOENT のエラーになりました(Bun の型定義にある Bun.write の説明)。

測り方

bench.ts で、同じ処理をくり返し、1回あたりの時間の中央値を出しました。1 KB は2,000回、1 MB は200回、100 MB は10回です。どの処理も、最初の3回は慣らしとして数えていません。中身は ASCII の文字列(neko-no-te のくり返し)と、それを TextEncoder で変換した Uint8Array です。

ts
// 1回あたりの時間(ミリ秒)の中央値を返す
async function measure(times: number, fn: () => unknown): Promise<number> {
  for (let i = 0; i < 3; i++) await fn(); // 慣らし
  const ms: number[] = [];
  for (let i = 0; i < times; i++) {
    const t = performance.now();
    await fn();
    ms.push(performance.now() - t);
  }
  ms.sort((a, b) => a - b);
  return ms[Math.floor(ms.length / 2)];
}

比べたのは、次の書き方です(抜粋。p はファイルのパス、text は文字列、buf は Uint8Array です)。

ts
// 書く
Bun.write(p, text);
Bun.write(p, buf);
writeFile(p, text); // node:fs/promises
writeFile(p, buf);
writeFileSync(p, text); // node:fs

// 読む
Bun.file(p).text();
Bun.file(p).bytes();
readFile(p, "utf8"); // node:fs/promises
readFile(p);
readFileSync(p, "utf8"); // node:fs

bench.ts は Node.js でも動くようにしてあり、Node.js では Bun.file と Bun.write を飛ばして node:fs だけを測ります。Bun と Node.js で3回ずつ実行しました。

書く速さは、ファイルの大きさで逆転した

Bun で書き込みにかかった時間です。bench.ts を3回実行し、左から1回目・2回目・3回目の値を並べました。どの値も、その実行の中での1回あたりの中央値です(µs は100万分の1秒)。

書き方 1 KB 1 MB 100 MB
Bun.write(文字列) 3.9 / 2.6 / 2.6 µs 593.9 / 532.7 / 525.9 µs 60.97 / 59.68 / 62.11 ms
Bun.write(Uint8Array) 3.7 / 2.3 / 3.2 µs 556.9 / 452.1 / 495.6 µs 112.29 / 118.96 / 119.09 ms
fs.promises.writeFile(文字列) 39.7 / 41.4 / 44.0 µs 145.4 / 145.9 / 127.8 µs 32.95 / 32.11 / 35.48 ms
fs.promises.writeFile(Uint8Array) 37.8 / 43.8 / 41.6 µs 128.4 / 116.7 / 92.2 µs 26.01 / 26.49 / 28.63 ms
fs.writeFileSync(文字列) 3.7 / 4.3 / 4.1 µs 74.2 / 73.3 / 50.7 µs 35.31 / 30.43 / 31.34 ms
Bun で1回書くのにかかった時間の横棒グラフ。1 KB では Bun.write 2.6 µs、fs.promises.writeFile 41.4 µs、fs.writeFileSync 4.1 µs。100 MB では Bun.write 61.0 ms、fs.promises.writeFile 33.0 ms、fs.writeFileSync 31.3 ms
Bun で文字列を1回書く時間。3回測った中央値

1 KB の小さなファイルでは、Bun.write は約3 µs で、fs.promises.writeFile の約40 µs より10倍以上速くなりました。同期の fs.writeFileSync とほぼ同じ速さです。

ところが 1 MB と 100 MB では、順番が逆になりました。100 MB の文字列では、Bun.write が約60 ms、fs.promises.writeFile が約33 ms です。Uint8Array を渡したときの差はもっと大きく、Bun.write は約112〜119 ms、fs.promises.writeFile は約26 ms でした。この検証環境では、大きなファイルを1回で書くなら node:fs のほうが速い、という結果です。

バイト列で読む速さは、Bun.file と readFile でほぼ同じだった

Bun で読み込みにかかった時間です(並びは書き込みの表と同じで、左から1〜3回目の実行)。

読み方 1 KB 1 MB 100 MB
Bun.file().text() 43.7 / 38.7 / 40.5 µs 256.9 / 265.6 / 280.5 µs 69.41 / 65.42 / 33.75 ms
Bun.file().bytes() 41.9 / 39.4 / 41.7 µs 141.9 / 116.4 / 122.0 µs 22.39 / 21.19 / 47.21 ms
fs.promises.readFile(utf8) 39.8 / 36.6 / 41.1 µs 177.1 / 179.4 / 193.8 µs 54.33 / 28.96 / 33.33 ms
fs.promises.readFile() 40.5 / 37.1 / 39.9 µs 137.8 / 211.6 / 130.5 µs 22.21 / 20.53 / 21.35 ms
fs.readFileSync(utf8) 1.7 / 1.6 / 1.7 µs 92.8 / 97.3 / 104.8 µs 54.37 / 36.82 / 34.26 ms

バイト列で受け取る Bun.file().bytes() と fs.promises.readFile() は、どの大きさでもほぼ同じ時間でした。100 MB では、3回のうち2回が約21〜22 ms です(bytes() の3回目だけ 47.21 ms)。100 MB の読み込みは、ほかの読み方でも回によってぶれが大きくなりました。

文字列で受け取る読み方では、Bun.file().text() が遅めでした。1 MB では約260〜280 µs で、readFile(utf8) の約180〜190 µs の1.5倍ほどです。100 MB でも、3回のうち2回は約65〜69 ms かかりました。

1 KB では、同期の fs.readFileSync が約1.7 µs で、非同期の約40 µs よりずっと速くなりました。ただし Node.js のドキュメントでは、同期の API は、終わるまでイベントループとほかの JavaScript の実行を止めると説明されています(Node.js のドキュメントにある、同期 API の説明)。

コピーは、Bun.file を渡せば copyFile と同じ速さ

100 MB のファイルのコピーです。

コピーの仕方 3回分
Bun.write(先, Bun.file(元)) 36.21 / 30.34 / 33.65 ms
bytes() で読んでから Bun.write 178.06 / 158.38 / 167.81 ms
fs.promises.copyFile 28.31 / 31.33 / 28.69 ms

Bun.write の2つ目の引数に Bun.file() をそのまま渡すと、copyFile とほぼ同じ速さでした。いったん bytes() で読み込んでから書くと、約5倍の時間がかかりました。

公式ドキュメントには、ファイルからファイルへの書き込みは、Linux では copy_file_range というシステムコールを使うとあります(公式ドキュメントのシステムコールの表)。strace でシステムコールを数えたところ、Bun.write(先, Bun.file(元)) も fs.promises.copyFile も、100 MB を copy_file_range 1回でコピーしていました。

text
$ strace -f -c -e trace=write,pwrite64,copy_file_range,sendfile,splice bun syscall.ts bun-copy
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 99.92    0.033646       33646         1           copy_file_range
  0.08    0.000028          28         1           write
------ ----------- ----------- --------- --------- ----------------
100.00    0.033674       16837         2           total

fs.promises.copyFile の結果も、copy_file_range が1回で同じ形でした。

1行ずつ書くなら FileSink

ファイルに1行ずつ書いていくときは、Bun.file().writer() で取り出す FileSink が使えます。FileSink は書いた内容をいったんためておき、まとめてディスクに書きます(公式ドキュメントの FileSink の説明)。Bun.write のオプションは mode と createPath だけで、書き足すためのオプションはありません(Bun の型定義にある Bun.write のオプション)。同じファイルに2回書くと、1回目の3行は消えて、2回目の1行だけが残りました。

ファイルがない状態から、10万行(1,688,890バイト)を1行ずつ書き、全体にかかった時間を比べました。

ts
const w = Bun.file("bench/log.txt").writer();
for (let i = 0; i < lines; i++) w.write(line(i));
await w.end();
ts
for (let i = 0; i < lines; i++) await appendFile("bench/log.txt", line(i));
書き方 3回分
FileSink(writer()) 14.91 / 14.74 / 17.35 ms
fs.promises.appendFile を1行ごと 4161.23 / 4045.27 / 4227.74 ms

FileSink は約15 ms、appendFile を1行ごとに呼ぶと約4秒かかりました。差は200倍以上です。FileSink は、end() を呼ぶまでプロセスを終わらせないので、書き終えたら end() を呼びます(公式ドキュメントの end と unref の説明)。

中身が2行あるファイルに、writer() で1行書いてみました。

ts
await Bun.write("sink.txt", "前からある1行目\n前からある2行目\n");
const w = Bun.file("sink.txt").writer();
w.write("writer で書いた行\n");
await w.end();
console.log(JSON.stringify(await Bun.file("sink.txt").text()));
text
"writer で書いた行\n前からある2行目\n"
注意

すでに中身があるファイルに writer() で書くと、末尾には足されず、先頭から上書きされました。1行目が書いた行に置き換わり、2行目は消えずに残っています(この例では、元の1行目と書いた行は、どちらも23バイトでした)。既存のログに書き足すときは、FileSink をそのまま使わないでください。

Node.js 22 で動かした node:fs との比較

同じ bench.ts を Node.js 22.23.4 で実行し、node:fs の時間を測りました(抜粋)。

処理 Node.js 22(3回分) Bun の同じ書き方(3回分)
1 KB を fs.promises.writeFile(文字列) 263.3 / 251.5 / 239.4 µs 39.7 / 41.4 / 44.0 µs
100 MB を fs.promises.writeFile(Uint8Array) 91.72 / 90.94 / 84.43 ms 26.01 / 26.49 / 28.63 ms
100 MB を fs.promises.readFile() 88.63 / 80.77 / 84.79 ms 22.21 / 20.53 / 21.35 ms
100 MB を fs.promises.copyFile 80.78 / 84.88 / 92.11 ms 28.31 / 31.33 / 28.69 ms
10万行を fs.promises.appendFile 10861.37 / 10629.33 / 9900.89 ms 4161.23 / 4045.27 / 4227.74 ms

この検証環境では、同じ node:fs の書き方でも、Bun で動かしたほうが Node.js より速くなりました。Node.js から Bun に移すときは、node:fs のコードを Bun.write に書き換えなくても、速くなる場合があります。Bun の API に書き換えて速くなったのは、小さなファイルの書き込み(Bun.write)と、1行ずつ書く処理(FileSink)でした。コピーは copyFile と同じ速さで、大きなファイルの書き込みは node:fs のほうが速くなりました。

​Posted by 86