File System

fs module สามรูปแบบ

Node มาพร้อม filesystem operations เดียวกันใน API สามแบบที่แตกต่างกัน:

รูปแบบ	Import	ใช้เมื่อไหร่
Callback (async)	import fs from 'node:fs'	code เก่า, Node streams
Synchronous	import fs from 'node:fs'	CLI scripts, config ตอน startup
Promise (async)	import fs from 'node:fs/promises'	server code ทั้งหมดที่เขียนใหม่

🟢 ใช้ fs/promises ใน servers

fs.readFileSync และ function เหล่านั้น block event loop ทั้งหมด — ไม่มี request อื่นได้รับการจัดการเลยขณะที่ OS กำลังอ่านไฟล์ ใน server process ให้ใช้ node:fs/promises API (หรือ callback-based streams) เสมอ เพื่อให้ event loop ว่างพอรับ request พร้อมกัน sync APIs ยอมรับได้ใน CLI scripts หรือตอน startup ของ process (ก่อนที่ server จะเริ่มรับ requests)

การอ่านไฟล์

แบบ Callback

import fs from 'node:fs';

fs.writeFileSync('./hello.txt', 'Hello from Node.js!');

fs.readFile('./hello.txt', 'utf8', function(err, data) {
  if (err) throw err;
  console.log(data);
  fs.unlinkSync('./hello.txt');
});

แบบ Promise (แนะนำ)

Node.jsOpen in StackBlitz ▸

import { writeFile, readFile, readdir, rm } from 'node:fs/promises'; async function demo() { // Write a file await writeFile('/tmp/demo.txt', 'Hello from Node.js!', 'utf8'); console.log('Written: /tmp/demo.txt'); // Read it back var content = await readFile('/tmp/demo.txt', 'utf8'); console.log('Read back:', content); // List /tmp directory var entries = await readdir('/tmp'); console.log('Files in /tmp (first 5):', entries.slice(0, 5)); // Clean up await rm('/tmp/demo.txt'); console.log('Deleted /tmp/demo.txt'); } demo().catch(console.error);

Needs the Node.js runtime — open in StackBlitz to run.

การเขียนไฟล์

writeFile สร้างไฟล์ถ้ายังไม่มี และ แทนที่ เนื้อหาถ้ามีอยู่แล้ว ใช้ appendFile เพื่อเพิ่มต่อจากไฟล์ที่มีอยู่

Node.jsOpen in StackBlitz ▸

import { writeFile, appendFile, readFile, rm } from 'node:fs/promises'; async function demo() { var path = '/tmp/log.txt'; await writeFile(path, 'Line 1\n', 'utf8'); await appendFile(path, 'Line 2\n', 'utf8'); await appendFile(path, 'Line 3\n', 'utf8'); var result = await readFile(path, 'utf8'); console.log('File contents:'); console.log(result); await rm(path); } demo().catch(console.error);

Needs the Node.js runtime — open in StackBlitz to run.

การตรวจสอบการมีอยู่และ stats

Node.jsOpen in StackBlitz ▸

import { stat, writeFile, rm } from 'node:fs/promises'; async function demo() { var path = '/tmp/stat-test.txt'; await writeFile(path, 'stat demo', 'utf8'); var info = await stat(path); console.log('size (bytes):', info.size); console.log('isFile:', info.isFile()); console.log('isDirectory:', info.isDirectory()); console.log('modified:', info.mtime.toISOString()); await rm(path); } demo().catch(console.error);

Needs the Node.js runtime — open in StackBlitz to run.

fs/promises เทียบกับ sync — การ block event loop

readFileSync ไม่ได้แค่ “อ่านไฟล์ช้ากว่า” — มัน รันจนจบก่อนที่สิ่งอื่นใดใน process จะรันได้ รวมถึง timer ที่ถูกตั้งไว้แล้วด้วย delay 0 ms readFile (แบบ promise) ส่งงานอ่านออกไปแล้ว return ทันที ปล่อยให้ code synchronous ที่เหลือ — และ event loop — เดินหน้าต่อไปได้ในขณะที่การอ่านเกิดขึ้นเบื้องหลัง:

Node.jsOpen in StackBlitz ▸

import { readFileSync, writeFileSync, unlinkSync } from 'node:fs'; import { readFile } from 'node:fs/promises'; var path = '/tmp/node-deep-dive-block-demo.txt'; writeFileSync(path, 'x'.repeat(5_000_000)); // ~5 MB — big enough to take real time to read // --- Sync: readFileSync runs to completion before anything else can -- // a pending timer cannot fire mid-read, no matter how short its delay --- var timerFired = false; setTimeout(function() { timerFired = true; }, 0); var syncData = readFileSync(path, 'utf8'); console.log('sync read length:', syncData.length); console.log('timer fired before readFileSync returned:', timerFired); // always false // --- Async: readFile returns a pending Promise immediately -- the very // next line of synchronous code always runs before the read settles --- var order = []; readFile(path, 'utf8').then(function() { order.push('read settled'); }); order.push('next line ran before the read settled'); console.log(order.join(' | ')); await readFile(path, 'utf8'); // let any pending read finish before cleanup unlinkSync(path);

Output (verified on Node 24)

sync read length: 5000000
timer fired before readFileSync returned: false
next line ran before the read settled

🟢 ใน server, readFileSync ตัวเดียวหยุดทุก request ที่กำลังทำงานอยู่

การอ่านแบบ blocking เพียงไม่กี่มิลลิวินาทีมองไม่เห็นใน script เดี่ยว ๆ แต่ใน server ที่จัดการ request พร้อมกันหลายตัว call เดียวกันนั้นจะแช่แข็งทุกการเชื่อมต่อ — ไม่มี request ไหนถูกรับ ไม่มี response ไหนถูกส่ง ไม่มี timer ไหนทำงานได้ — จนกว่าการอ่านจะเสร็จ นี่คือเหตุผลที่ node:fs/promises (หรือ callback API) เป็นกฎสำหรับ server code และ readFileSync สงวนไว้สำหรับงาน startup ครั้งเดียวก่อน server.listen()

readFile เทียบกับ stream สำหรับไฟล์ขนาดใหญ่ — memory

readFile() (sync หรือ promise) จอง buffer หนึ่งก้อนที่เก็บทั้งไฟล์ สำหรับไฟล์ขนาด 50 MB นั่นหมายถึงการจอง 50 MB หนึ่งครั้ง เก็บไว้ใน memory จนกว่าคุณจะใช้เสร็จ stream กลับส่งมอบไฟล์เป็น chunk ที่มีขอบเขต — ดีฟอลต์ไม่เกิน highWaterMark (64 KiB) ต่อครั้ง — ดังนั้นการใช้ memory จึงคงที่โดยประมาณไม่ว่าไฟล์จะขนาดเท่าไหร่:

Node.jsOpen in StackBlitz ▸

import { writeFileSync, unlinkSync, createReadStream } from 'node:fs'; import { readFile } from 'node:fs/promises'; var path = '/tmp/node-deep-dive-large.bin'; writeFileSync(path, Buffer.alloc(50 * 1024 * 1024)); // 50 MB fixture, all zero bytes // readFile: one allocation the size of the whole file var whole = await readFile(path); console.log('readFile() loaded bytes in one buffer:', whole.length); // stream: delivered in bounded highWaterMark-sized chunks, one at a time var chunkCount = 0; var maxChunk = 0; var total = 0; await new Promise(function(resolve, reject) { createReadStream(path) .on('data', function(chunk) { chunkCount++; total += chunk.length; if (chunk.length > maxChunk) maxChunk = chunk.length; }) .on('end', resolve) .on('error', reject); }); console.log('stream delivered bytes across', chunkCount, 'chunks'); console.log('largest single chunk (bytes):', maxChunk); console.log('total bytes match:', total === whole.length); unlinkSync(path);

Output (verified on Node 24)

readFile() loaded bytes in one buffer: 52428800
stream delivered bytes across 800 chunks
largest single chunk (bytes): 65536
total bytes match: true

สำหรับไฟล์ 50 MB readFile ต้องการการจอง 50 MB ที่ต่อเนื่องกันหนึ่งก้อน; stream ไม่เคยถือมากกว่า 64 KiB ต่อครั้ง — ความแตกต่างที่สำคัญเมื่อไฟล์อาจมีขนาดหลายกิกะไบต์ หรือเมื่อ request หลายร้อยตัวกำลังอ่านไฟล์พร้อมกัน

Glob และการเคลียร์ handle ใน Node สมัยใหม่

API ใหม่สองตัวช่วยปลด dependency เก่า: fs.glob (stable ใน Node 22+) แทน package glob และ file handle รองรับ await using (Node 24+) จึงปิดตัวเองได้:

import { writeFileSync, unlinkSync } from 'node:fs';
import { glob, open } from 'node:fs/promises';

writeFileSync('./config.json', JSON.stringify({ port: 3000 })); // demo fixture

// Find files without the `glob` package
for await (const file of glob('src/**/*.test.js')) {
  console.log(file);
}

// The handle is closed when the block exits — even if it throws
{
  await using fh = await open('./config.json');
  const text = await fh.readFile('utf8');
  console.log(JSON.parse(text).port);
}

unlinkSync('./config.json');

Synchronous reads — เฉพาะตอน startup

import { readFileSync, writeFileSync } from 'node:fs';

writeFileSync('./config.json', JSON.stringify({ port: 3000 })); // demo fixture

// Acceptable at startup — process has not yet started accepting requests
const config = JSON.parse(readFileSync('./config.json', 'utf8'));
console.log(config.port);

อย่าเรียก readFileSync ใน request handler, route callback หรือ function ใดที่ถูกเรียกหลังจาก server เริ่มทำงาน

Mental Model

flowchart TB
  Call["fs call"] --> Sync["readFileSync / writeFileSync"]
  Call --> Async["readFile / writeFile (fs/promises)"]
  Sync -->|"runs to completion, no one else can run"| Blocks["blocks the event loop — every other request waits"]
  Async -->|"handed to the threadpool, returns a pending Promise"| Free["event loop keeps handling other work"]
  Blocks -->|"acceptable"| Startup["CLI scripts / before server.listen()"]
  Free -->|"required"| Server["server request handlers"]

fs call แบบ sync รันจนจบและ block ทุกอย่าง; fs call แบบ async ส่งงานไปที่ threadpool แล้ว return ทันที

Trade-offs

ทางเลือก	ข้อดี	ต้นทุน
fs sync (readFileSync)	code ง่ายที่สุด — ไม่มี callback ไม่มี await ไม่มีการไป-กลับกับ threadpool	block ทั้ง process ตลอดระยะเวลาของ call — ยอมรับไม่ได้เมื่อ server เริ่มรับ request แล้ว
fs/promises (readFile)	ไม่เคย block event loop; ประกอบกับ async/await ได้	มีการไป-กลับกับ threadpool เพิ่มอีกหนึ่งครั้งต่อ call — latency สูงกว่า sync เล็กน้อยสำหรับ call เดี่ยวใน script ที่ไม่มีการทำงานพร้อมกัน
readFile() ทั้งไฟล์	code ง่ายที่สุดเท่าที่จะทำได้ — buffer เดียว ไม่ต้อง wire event	การใช้ memory scale ตามขนาดไฟล์; ไฟล์ 1 GB ต้องการ buffer 1 GB
createReadStream()	memory คงที่ไม่ว่าไฟล์ขนาดเท่าไหร่; เริ่มประมวลผลได้ก่อนที่ไฟล์จะอ่านเสร็จ	code มากกว่า — คุณต้องจัดการ 'data'/'end'/'error' เอง (หรือใช้ pipeline ที่ครอบคลุมในโมดูล streams)

Common Misconceptions

• “readFileSync ก็แค่ readFile ที่ช้ากว่า” — ความจริง: ความแตกต่างไม่ใช่ความเร็ว แต่คือ readFileSync block ทั้ง process — ไม่มี timer, ไม่มี request อื่น, ไม่มี I/O callback ไหนทำงานได้จนกว่ามันจะ return
• “readFileSync แบบเร็ว ๆ ไม่เป็นไรเพราะใช้แค่ไม่กี่มิลลิวินาที” — ความจริง: มิลลิวินาทีเหล่านั้นถูกขโมยไปจากทุก request ที่ server กำลังจัดการอยู่ ณ ขณะนั้น ไม่ใช่แค่ตัวที่ทำให้เกิดการอ่าน
• “readFile() กับ stream ใช้ memory พอ ๆ กันเพราะอ่านไฟล์เดียวกัน” — ความจริง: readFile() ถือทั้งไฟล์เป็น buffer เดียว; stream ถือ chunk highWaterMark (ดีฟอลต์ 64 KiB) อย่างมากหนึ่งอันต่อครั้ง ไม่ขึ้นกับขนาดไฟล์ทั้งหมด

อ่านโค้ดที่ AI เขียน

• route handler หรือ function ใดก็ตามที่ถูกเรียกหลัง server.listen() ใช้ readFileSync, writeFileSync หรือ existsSync หรือเปล่า? ตัวไหนก็ตามในนี้ block ทุก request ที่กำลังทำงานพร้อมกันตลอดระยะเวลาของ call
• code โหลดไฟล์ที่อาจมีขนาดใหญ่หรือมาจากผู้ใช้ด้วย readFile() เข้า buffer เดียว แทนที่จะ stream มัน ทั้งที่ไฟล์จะถูกส่งต่อหรือประมวลผลทีละ chunk อยู่แล้วหรือเปล่า?
• file handle ที่เปิดด้วย fs.open()/fsPromises.open() ถูกปิดในทุกเส้นทางที่ออก รวมถึง error ที่ถูก throw หรือเปล่า — หรือ await using (Node 24+) จะทำให้มันเกิดขึ้นอัตโนมัติได้?

🐛 หา bug ในโค้ดนี้

import { readFileSync } from 'node:fs';
import http from 'node:http';

var server = http.createServer(function(req, res) {
// reads the config file from disk on every single request
var config = JSON.parse(readFileSync('./config.json', 'utf8'));
res.end(JSON.stringify({ port: config.port }));
});

server.listen(3000);

เฉลย

readFileSync รันภายใน request handler ดังนั้นทุก request ที่เข้ามา block ทั้ง event loop ตลอดระยะเวลาของการอ่านดิสก์ — ไม่มี request อื่นถูกรับหรือตอบกลับได้ในขณะที่มันทำงานอยู่ แม้แต่ตัวที่ไม่เกี่ยวข้องกับ route นี้เลย วิธีแก้คืออ่าน config ครั้งเดียวตอน startup (ก่อน server.listen() ที่ sync call ยอมรับได้) แล้วใช้ object ที่ parse แล้วซ้ำจากตัวแปรในทุก request หรือใช้ readFile ของ fs/promises พร้อม in-memory cache เล็ก ๆ ถ้าไฟล์เปลี่ยนได้ตอน runtime

🟢 สรุปหนึ่งบรรทัด

ใช้ fs/promises กับทุกอย่างที่รันหลัง server.listen(), ใช้ fs sync เฉพาะตอน startup เท่านั้น — การอ่านแบบ blocking ไม่ได้แค่ทำให้ request ที่เรียกมันช้าลง แต่มันแช่แข็งทุก request อื่นที่ process กำลังจัดการอยู่

ทำไมควรหลีกเลี่ยง fs.readFileSync ใน server request handler?

ต้องการ callback และไม่สามารถใช้กับ async/await ได้ block event loop ทำให้ requests อื่นทั้งหมดไม่สามารถจัดการได้ deprecated ใน Node 24+ ทำงานได้เฉพาะบน Linux เท่านั้น

fs.writeFile ทำอะไรถ้าไฟล์ปลายทางมีอยู่แล้ว?

throw error — ต้องลบไฟล์ก่อน append ต่อจากเนื้อหาที่มีอยู่ replace เนื้อหาไฟล์ทั้งหมด สร้าง backup และเขียนไปยังไฟล์ใหม่

import ใดที่ให้ promise-based fs API?

import fs from "node:fs" import fs from "node:fs/promises" import { promises } from "fs" — นี่คือรูปแบบเดียวที่ถูกต้อง import fs from "node:fs/async"

โค้ดนี้พิมพ์อะไร? var timerFired = false; setTimeout(() => { timerFired = true; }, 0); var data = readFileSync(path, "utf8"); console.log(timerFired);

true — 0 ms แปลว่า timer ทำงานทันที false — readFileSync รันจนจบเสมอก่อนที่ timer callback จะได้คิว ขึ้นอยู่กับขนาดไฟล์ undefined — timerFired ยังไม่ถูกกำหนดค่า

ไฟล์ขนาด 200 MB ถูกอ่านครั้งหนึ่งด้วย fs.readFile() และอีกครั้งด้วย fs.createReadStream() ข้อความไหนเกี่ยวกับการใช้ memory ถูกต้อง?

ใช้ memory เท่ากันเพราะอ่าน byte เดียวกัน readFile() ต้องการการจองประมาณ 200 MB หนึ่งครั้ง; stream ต้องการ chunk highWaterMark (ดีฟอลต์ 64 KiB) ประมาณหนึ่งอันต่อครั้ง stream ใช้ memory มากกว่าเพราะ overhead ของ event data หลายครั้ง readFile() ใช้ memory น้อยกว่าเพราะไม่มี event listener

มีอะไรผิดปกติกับการเรียก readFileSync('./config.json') ภายใน HTTP request handler ที่รันทุก request?

ไม่มีอะไรผิด ตราบใดที่ไฟล์มีขนาดเล็ก มัน throw MODULE_NOT_FOUND ในการเรียกครั้งที่สอง มัน block ทุก request ที่กำลังทำงานพร้อมกันตลอดระยะเวลาของการอ่านแต่ละครั้ง ในทุก request มันทำงานได้แค่ครั้งแรกที่ server เริ่มทำงานเท่านั้น

Submit

Mark as complete