# Xử lý file vài GB của khách mà không làm sập tiến trình Node.js

> Hiểu tín hiệu dừng bằng tay một lần, rồi để pipeline lo việc đó trong code thật.

Bản gốc: https://fdetimes.net/vi/bach-khoa/thuc-hanh-nodejs-streams-xu-ly-csv-ndjson-lon/

Hàm `write()` của một Writable stream trong Node.js trả về một giá trị boolean, và giá trị này rất dễ bị bỏ qua. Với file vài chục MB thì bỏ qua cũng chẳng sao. Nhưng khi khách hàng gửi một bản export đơn hàng nặng vài GB, chính giá trị đó quyết định tiến trình của bạn chạy hết file hay chết giữa chừng vì hết bộ nhớ.

Tài liệu Node.js gọi vấn đề này là backpressure: khi phía nhận chậm hơn nguồn gửi, dữ liệu dồn ứ lại như một chỗ tắc. Ghi xuống ổ đĩa thường chậm hơn đọc từ ổ đĩa nhiều, nên nén hay làm sạch một file rồi ghi ra là tình huống điển hình. Nếu phía đọc không biết dừng, phần chênh lệch sẽ nằm lại trong RAM.

Với FDE, đây không phải bài tập lý thuyết. Thử hình dung ngày đầu tại khách, bạn nhận một file dump: CSV xuất từ ERP, hoặc NDJSON xuất từ hệ thống log. Bài này đi từng bước để dựng một công cụ làm sạch file như vậy, chạy được ngay trên laptop.

## Bạn sẽ xây gì, cần gì

Giả sử khách gửi `orders.ndjson`, mỗi dòng là một đơn hàng. Một số dòng hỏng JSON, một số dòng trống, và file được xuất từ máy Windows. Mục tiêu là ghi ra `orders.clean.ndjson` cùng danh sách số dòng bị lỗi để gửi lại cho khách.

Bạn cần Node.js bản hiện đại, một trình soạn code, và thư viện `csv-parse` cho phần CSV ở cuối bài. Code trong bài dùng ES modules và đã được rút gọn để dễ đọc. Trước khi đưa vào production, hãy đối chiếu lại các tùy chọn với tài liệu chính thức.

## Bước 1: đọc theo dòng, không đọc cả file

Đặc tả NDJSON quy định mỗi dòng là một văn bản JSON độc lập, bên trong không được chứa ký tự xuống dòng. Vì thế đơn vị xử lý tự nhiên là từng dòng, đúng tinh thần của JSON Lines: dữ liệu có cấu trúc, xử lý từng bản ghi một. `readline` là công cụ có sẵn để làm việc đó.

```js
import { createReadStream } from 'node:fs';
import { createInterface } from 'node:readline';

const rl = createInterface({
  input: createReadStream('orders.ndjson'),
  crlfDelay: Infinity,
});

let n = 0;
for await (const line of rl) {
  n++;
}
console.log('Số dòng:', n);
```

Tùy chọn `crlfDelay: Infinity` là thứ tài liệu readline khuyên dùng khi file có `\r\n`, tức file xuất từ Windows. Cách kiểm tra: đếm số dòng bằng một công cụ khác mà bạn tin cậy, rồi so với con số `n`.

Tài liệu readline cảnh báo thẳng một cái bẫy: nếu có thao tác bất đồng bộ nằm giữa lúc tạo interface và lúc bắt đầu `for await`, bạn có thể bị mất dòng. Đừng chen một lệnh `await db.connect()` vào giữa hai đoạn đó. Hãy kết nối trước, tạo interface sau.

## Bước 2: nhìn tận mắt tín hiệu dừng

Trước khi dùng công cụ tự động, nên viết tay một lần để hiểu cơ chế. Khi buffer vượt quá `highWaterMark`, `write()` trả về `false`. Theo tài liệu Node.js, đó là lúc hệ thống backpressure vào cuộc: phía đọc tạm dừng cho tới khi phía ghi sẵn sàng trở lại, báo hiệu bằng sự kiện `'drain'`.

```js
import { createWriteStream } from 'node:fs';

const out = createWriteStream('orders.clean.ndjson');

async function writeLine(text) {
  if (!out.write(text)) {
    await new Promise((resolve) => out.once('drain', resolve));
  }
}
```

Vòng `for await` ở bước 1 chờ xong từng lần lặp, nên khi bạn `await writeLine(...)` bên trong vòng lặp, phía đọc sẽ tự dừng để chờ phía ghi. Nếu bỏ chữ `await`, chương trình vẫn chạy, nhưng với file lớn thì dữ liệu chưa ghi kịp sẽ dồn lại trong bộ nhớ.

Vì phía đọc chịu chờ, RAM chỉ phải chứa phần dữ liệu đang đợi ghi chứ không phải cả file. File nặng 1 GB hay 10 GB, phần đợi ấy vẫn chỉ nhỏ như vậy.

**Điểm mấu chốt:** Code đọc file lớn tốt là code biết dừng lại khi phía sau chưa theo kịp.

## Bước 3: để pipeline gánh phần khó

Viết tay `drain` giúp bạn hiểu cơ chế, nhưng ở code thật nên dùng `pipeline`. Hướng dẫn của Node.js cho thấy nối stream bằng pipe hay pipeline thì phần backpressure được lo sẵn, và ví dụ pipeline trong đó không có dòng code `drain` nào. Khi có sự cố, `pipeline` còn chuyển lỗi về cho bạn và đóng tất cả các stream trong chuỗi.

Đó là khác biệt lớn với `.pipe()`: theo tài liệu Node.js, nếu Readable phát lỗi giữa chừng thì Writable đích không tự đóng, và bạn phải tự dọn để khỏi rò bộ nhớ. Blog kỹ thuật của Platformatic cũng nhấn mạnh `pipeline` tự quản lý lỗi trong chuỗi. Toàn bộ công cụ làm sạch, ở dạng rút gọn, như sau:

```js
import { pipeline } from 'node:stream/promises';
import { createReadStream, createWriteStream } from 'node:fs';
import { createInterface } from 'node:readline';

const badLines = [];

async function* lines() {
  const rl = createInterface({
    input: createReadStream('orders.ndjson'),
    crlfDelay: Infinity,
  });
  for await (const line of rl) yield line; // không await gì xen giữa
}

async function* clean(source) {
  let n = 0;
  for await (const line of source) {
    n++;
    if (line.trim() === '') continue; // quyết định của ta: bỏ dòng trống
    try {
      yield JSON.stringify(JSON.parse(line)) + '\n';
    } catch {
      badLines.push(n);
    }
  }
}

await pipeline(lines, clean, createWriteStream('orders.clean.ndjson'));
console.log('Dòng lỗi:', badLines.length, badLines.slice(0, 20));
```

Kiểm tra sau bước này: tạo một file có vài dòng cố ý làm hỏng, chạy lại, rồi xem `badLines` có đúng các số dòng đó không.

Lưu ý `badLines` sẽ phình ra nếu file hỏng hàng loạt. Bản production nên ghi các dòng lỗi ra một file riêng qua chính pipeline, thay vì giữ chúng trong mảng.

## Bước 4: đừng tin lời hứa, hãy đo

Câu "bộ nhớ không phình theo file" chỉ đáng tin khi bạn tự thấy. Trước hết, sinh một file NDJSON giả vài GB, chẳng hạn gọi hàm `writeLine` ở bước 2 trong một vòng lặp vài chục triệu lần, cài thêm vài dòng hỏng. Sau đó viết bản mà nhiều người viết đầu tiên:

```js
import { readFile } from 'node:fs/promises';

const text = await readFile('orders.ndjson', 'utf8'); // nạp cả file vào RAM
let bad = 0;
for (const line of text.split('\n')) {
  try { if (line.trim()) JSON.parse(line); } catch { bad++; }
}
console.log('Dòng lỗi:', bad);
console.log('RSS (MB):', Math.round(process.memoryUsage().rss / 1e6));
```

Với bản pipeline ở bước 3, in bộ nhớ mỗi giây trong lúc chạy:

```js
const timer = setInterval(() => {
  console.log('RSS (MB):', Math.round(process.memoryUsage().rss / 1e6));
}, 1000);
await pipeline(lines, clean, createWriteStream('orders.clean.ndjson'));
clearInterval(timer);
```

Chạy cả hai với một file khoảng 100 MB, rồi với file vài GB, và ghi lại các con số. Bản `readFile` phải giữ cả nội dung file lẫn mảng các dòng trong RAM, nên mức bộ nhớ của nó buộc phải tăng theo kích thước file, và với file đủ lớn nó có thể không chạy được tới cuối.

Bản pipeline thì chỉ giữ phần đang chờ ghi. Thứ bạn cần thấy là RSS dao động quanh một mức dù file nặng gấp nhiều lần. Nếu con số vẫn leo dần, hãy tìm chỗ code còn giữ dữ liệu lại, mà nghi phạm đầu tiên là mảng `badLines`.

## Bước 5: CSV đi qua cùng một pipeline

Theo tài liệu của `csv-parse`, parser được xây trên chính Readable Stream API gốc của Node.js. Vì vậy nó cắm thẳng được vào giữa `pipeline`, và mọi stream trong chuỗi đều được dọn khi có lỗi.

```js
import { parse } from 'csv-parse';

await pipeline(
  createReadStream('customers.csv'),
  parse(), // mỗi bản ghi là một mảng; tùy chọn header xem tài liệu csv-parse
  async function* (rows) {
    for await (const row of rows) yield JSON.stringify(row) + '\n';
  },
  createWriteStream('customers.ndjson'),
);
```

Đừng tách CSV bằng `split(',')` qua `readline`. Chỉ cần một trường chứa dấu phẩy hoặc dấu xuống dòng trong ngoặc kép là mọi cột phía sau bị lệch, và lỗi kiểu này có thể chỉ lộ ra ở dòng thứ vài triệu.

## Bước 6: công cụ xem trước, và cái bẫy của break

Khi vừa nhận một file lạ, nên xem file có những cột gì trước khi làm bất cứ việc gì khác. Mọi Readable stream trong Node.js đều là async iterable, nên một vòng `for await` in 5 dòng đầu trả lời được ngay câu hỏi đó:

```js
const file = createReadStream('customers.csv');
let i = 0;
for await (const row of file.pipe(parse())) {
  console.log(row);
  if (++i === 5) break;
}
file.destroy(); // tự đóng read stream cho chắc
```

Khi bạn thoát vòng `for await` bằng `break`, `return` hay `throw`, Node.js theo mặc định sẽ destroy stream đang được lặp, tức stream mà `parse()` tạo ra. Muốn giữ stream lại thì phải lặp qua `readable.iterator({ destroyOnReturn: false })`.

Read stream của file thì không phải thứ đang được lặp. Để chắc chắn file 4 GB không bị đọc tiếp, hãy tự đóng nó bằng `file.destroy()` như dòng cuối. Ví dụ nhỏ này dùng `.pipe()` cho gọn, còn job chạy thật vẫn nên đi qua `pipeline` để mọi stream được đóng khi có lỗi.

## Ở chỗ khách, thứ được nhớ là số dòng lỗi

Thử hình dung: chỉ vài phút sau khi nhận file, bạn gửi lại được câu "có 312 dòng hỏng, đây là số dòng", chạy trên chính laptop của bạn, không cần xin thêm máy chủ.

Con số 312 chỉ là ví dụ. Nhưng một báo cáo lỗi kèm số dòng cho đội dữ liệu của khách biết chính xác phải sửa chỗ nào, nên có thể rút ngắn đáng kể vòng hỏi qua hỏi lại.

Chính cảnh đó là thứ đáng mang vào hồ sơ xin việc. Một repo nhỏ tái hiện đúng tình huống ấy, gồm file giả vài GB có cài sẵn dòng hỏng, bản `readFile` chạy cạnh bản `pipeline` và bảng bộ nhớ đo ở bước 4, sẽ kể câu chuyện ngày đầu tại khách thay bạn.

Trong CV, hãy viết kết quả của câu chuyện đó: "xử lý file export nhiều GB với bộ nhớ ổn định, báo lỗi theo từng dòng" cụ thể hơn nhiều so với "thành thạo Node.js". Gặp tin tuyển dụng nhắc tới việc đưa dữ liệu của khách vào hệ thống, đó là lúc dẫn repo này ra.

Khi bộ nhớ đã không còn đi theo kích thước file, một file "hơi nặng" chỉ còn là chuyện chạy lâu hơn vài phút. Câu hỏi đáng hỏi khách lúc đó là dữ liệu của họ hỏng ở đâu.

**Thử ngay tuần này:**

- Tạo một file NDJSON giả vài GB, chạy bản dùng readFile rồi bản dùng pipeline, ghi lại RSS từ process.memoryUsage() của hai bản
- Viết một công cụ head nhỏ in N dòng đầu của file CSV/NDJSON bất kỳ, dùng for await kèm break, nhớ đóng read stream
- Thêm vào README trên GitHub bảng bộ nhớ của hai bản và một đoạn mô tả cách pipeline báo lỗi kèm số dòng, để người xem repo thấy bạn có nghĩ tới việc phản hồi cho khách

## Nguồn

- [Backpressuring in Streams | Node.js Learn](https://nodejs.org/learn/modules/backpressuring-in-streams)

- [Stream | Node.js documentation](https://nodejs.org/api/stream.html)

- [A guide to reading and writing Node.js streams](https://blog.platformatic.dev/a-guide-to-reading-and-writing-nodejs-streams)

- [Readline | Node.js documentation](https://nodejs.org/api/readline.html)

- [GitHub - ndjson/ndjson-spec: Specification](https://github.com/ndjson/ndjson-spec)

- [JSON Lines](https://jsonlines.org/)

- [CSV Parse - Async iterator API](https://csv.js.org/parse/api/async_iterator/)
