Tối ưu hiệu năng Node.js: đo trước, sửa sau để tìm chỗ chậm
Tối ưu hiệu năng Node.js bằng cách đo: đọc log tìm request chậm, dùng --cpu-prof tìm đúng hàm tốn thời gian, sửa bằng Map và kiểm chứng bằng số đo và test.
Muốn tối ưu hiệu năng Node.js, hãy đo trước khi sửa: dùng log để biết request nào chậm, rồi dùng profiler để biết hàm nào tốn thời gian. Đoán chỗ chậm thường sai. Bạn đã bao giờ sửa nhầm chỗ chỉ vì "chắc là tại nó" chưa? Cùng mình xem một ví dụ nhé!
Log nói request nào chậm, nhưng chưa nói chậm ở đâu
Ở bài trước, máy chủ đơn hàng của quán Mộc được thêm log JSON: mỗi request có một dòng tóm tắt gồm mã trạng thái và số mili giây xử lý. (Quán Mộc là nhân vật minh họa của series này.) Mình kết thúc bài đó bằng một câu hỏi: khi có request chậm, log chỉ cho biết request nào chậm, không cho biết chậm ở dòng code nào.
Giờ chủ quán nhờ thêm một trang báo cáo: mỗi khách đã đặt mấy đơn và tổng bao nhiêu tiền, khách chi nhiều nhất đứng đầu. Mình thêm đường GET /bao-cao vào máy chủ của bài trước, bằng một hàm bốn dòng:
// Trong hàm route: if (request.url === "/bao-cao") return sendReport(response, orders);
// Báo cáo tổng chi tiêu theo khách, cho trang quản lý của chủ quán.
function sendReport(response: ServerResponse, orders: Order[]): void {
response.writeHead(200, JSON_HEADERS).end(JSON.stringify(baoCaoTheoKhach(orders)));
}Mình thử với 50.000 đơn trong bộ nhớ (đủ lớn để thấy vấn đề, và là số mình tự chọn, không phải số đơn thật của quán), gọi /don-hang rồi /bao-cao, và đây là hai dòng log tóm tắt:
{"level":"info","msg":"request","path":"/don-hang","status":200,"ms":30}
{"level":"info","msg":"request","path":"/bao-cao","status":200,"ms":1984}Cùng một số đơn, một đường mất 30 ms, đường kia gần hai giây. Log đã làm đúng việc của nó: chỉ ra /bao-cao. Còn việc chậm ở đâu thì phải tìm tiếp.
Mình đoán trước, và đoán sai
Cách làm tự nhiên nhất là đoán. Mình nghĩ ngay tới hai nghi phạm: định dạng tiền bằng toLocaleString("vi-VN"), vì nó nghe có vẻ nặng, và JSON.stringify một mảng gần 18.000 dòng. Trước khi sửa gì, mình đo riêng hai thứ đó. Để bạn làm theo được, mình dựng lại phần cần thiết trong một thư mục mới, không cần máy chủ:
bao-cao/
package.json
src/orders.ts
src/tao-du-lieu.ts
src/bao-cao.ts (bản đầu, ở mục này)
thu-do.ts
thu-doan.ts
doc-profile.ts
do-nhieu-lan.ts{
"name": "bao-cao",
"private": true,
"type": "module",
"devDependencies": { "vitest": "5.1.0" }
}Bạn cần Node.js 22.18 trở lên, vì từ bản đó Node chạy thẳng file .ts. src/orders.ts chỉ cần kiểu đơn hàng và hàm tính tổng tiền một đơn:
export type Customer = { name: string; phone: string };
export type OrderItem = { name: string; price: number; quantity: number };
export type Order = {
id: number;
createdAt: string;
source: "web" | "may-cu";
customer?: Customer; // đơn bán tại quầy có thể không có khách
items: OrderItem[];
};
export function orderTotal(order: Order): number {
return order.items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}Để có dữ liệu lớn mà mỗi lần chạy đều giống nhau (nếu không thì số đo của bạn và của mình không so được), src/tao-du-lieu.ts sinh đơn giả bằng một bộ sinh số ngẫu nhiên có hạt giống cố định. Khoảng 10% đơn là đơn tại quầy, không có thông tin khách:
// Sinh một danh sách đơn hàng lớn nhưng luôn giống nhau mỗi lần chạy (bộ sinh số ngẫu nhiên có hạt giống cố định).
import type { Order } from "./orders.ts";
// mulberry32: bộ sinh số ngẫu nhiên nhỏ, cùng hạt giống thì ra cùng dãy số.
function sinhSo(hat: number): () => number {
let a = hat;
return () => {
a = (a + 0x6d2b79f5) | 0;
let t = Math.imul(a ^ (a >>> 15), 1 | a);
t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
};
}
const MON: [string, number][] = [["cà phê đen", 25000], ["cà phê sữa", 29000], ["bạc xỉu", 32000], ["cà phê muối", 35000], ["bánh mì trứng", 25000]];
export function taoDonHang(soDon: number, soKhach: number, hat = 42): Order[] {
const ngauNhien = sinhSo(hat);
return Array.from({ length: soDon }, (_, i) => {
const coKhach = ngauNhien() < 0.9; // 10% là đơn tại quầy, không có thông tin khách
const stt = Math.floor(ngauNhien() * soKhach);
const soMon = 1 + Math.floor(ngauNhien() * 3);
return {
id: 10_000 + i,
createdAt: new Date(Date.UTC(2026, 0, 1) + i * 600_000).toISOString(),
source: coKhach ? "web" : "may-cu",
...(coKhach ? { customer: { name: `Khách ${stt}`, phone: `09${String(10_000_000 + stt).padStart(8, "0")}` } } : {}),
items: Array.from({ length: soMon }, () => {
const [name, price] = MON[Math.floor(ngauNhien() * MON.length)];
return { name, price, quantity: 1 + Math.floor(ngauNhien() * 2) };
}),
} satisfies Order;
});
}Đây là hàm báo cáo bản đầu. Mình viết nó cho dễ đọc, và ở quy mô vài trăm đơn thì nó hoàn toàn ổn: với mỗi đơn, tìm xem khách đó đã có dòng trong kết quả chưa, nếu có thì cộng dồn, nếu chưa thì thêm dòng mới:
import { orderTotal, type Order } from "./orders.ts";
export type DongBaoCao = { khach: string; soDon: number; tong: number };
// Báo cáo cho chủ quán: mỗi khách đã đặt mấy đơn và tổng bao nhiêu tiền, khách chi nhiều nhất đứng đầu.
// BẢN ĐẦU, viết cho dễ đọc: với mỗi đơn, tìm xem khách đó đã có dòng trong kết quả chưa.
export function baoCaoTheoKhach(orders: Order[]): DongBaoCao[] {
const ketQua: DongBaoCao[] = [];
for (const order of orders) {
const khach = order.customer?.phone ?? "tại quầy";
const dong = ketQua.find((d) => d.khach === khach);
if (dong) {
dong.soDon += 1;
dong.tong += orderTotal(order);
} else {
ketQua.push({ khach, soDon: 1, tong: orderTotal(order) });
}
}
return ketQua.sort((a, b) => b.tong - a.tong);
}Giờ đến hai script đo. Script thứ nhất đo bản đầu với 50.000 đơn từ 20.000 khách, script thứ hai đo riêng hai nghi phạm:
// Đo thời gian bản đầu của baoCaoTheoKhach với 50.000 đơn. Chạy: node thu-do.ts
import { baoCaoTheoKhach } from "./src/bao-cao.ts";
import { taoDonHang } from "./src/tao-du-lieu.ts";
const orders = taoDonHang(50_000, 20_000);
const batDau = performance.now();
const baoCao = baoCaoTheoKhach(orders);
console.log(`${orders.length} đơn → ${baoCao.length} dòng, mất ${Math.round(performance.now() - batDau)} ms`);
console.log("Đầu bảng:", JSON.stringify(baoCao[0]));// Giả thuyết đầu tiên: "chắc tại định dạng tiền và chuyển JSON". Đo riêng hai phần đó. Chạy: node thu-doan.ts
import { baoCaoTheoKhach } from "./src/bao-cao.ts";
import { taoDonHang } from "./src/tao-du-lieu.ts";
const baoCao = baoCaoTheoKhach(taoDonHang(50_000, 20_000));
let batDau = performance.now();
const tienDaDinhDang = baoCao.map((dong) => `${dong.tong.toLocaleString("vi-VN")}đ`);
console.log(`Định dạng tiền cho ${tienDaDinhDang.length} dòng: ${Math.round(performance.now() - batDau)} ms`);
batDau = performance.now();
const json = JSON.stringify(baoCao);
console.log(`JSON.stringify (${json.length} ký tự): ${Math.round(performance.now() - batDau)} ms`);Chạy hai script này:
node thu-do.ts
node thu-doan.ts50000 đơn → 17890 dòng, mất 1986 ms
Đầu bảng: {"khach":"tại quầy","soDon":4924,"tong":428645000}
Định dạng tiền cho 17890 dòng: 22 ms
JSON.stringify (837333 ký tự): 6 msHai nghi phạm cộng lại chỉ khoảng 28 ms trên gần 2.000 ms. Nếu mình đã "tối ưu" định dạng tiền, ví dụ bằng cách tự viết hàm chèn dấu chấm, mình sẽ mất một buổi, thêm code phải bảo trì, và báo cáo vẫn mất gần hai giây. Đó là lý do mình thích đo trước.
Profiler chỉ ra chỗ nào tốn thời gian?
Khi không còn đoán được, bạn dùng profiler: một công cụ ghi lại, nhiều lần mỗi mili giây, chương trình đang chạy hàm nào. Node.js có sẵn cờ --cpu-prof để ghi một file .cpuprofile khi chương trình kết thúc, và --cpu-prof-dir chọn thư mục ghi. Bạn xem các cờ này trong tài liệu dòng lệnh của Node.js. File có thể mở bằng công cụ trong trình duyệt (Chrome DevTools), nhưng mình thích tự đọc nó bằng một script nhỏ, vì như vậy bạn hiểu nó chứa gì: một danh sách các lần lấy mẫu, mỗi lần ghi hàm nào đang chạy, cùng khoảng thời gian giữa các lần.
// Đọc file .cpuprofile do `node --cpu-prof` ghi ra và in các hàm tốn nhiều thời gian nhất (thời gian "riêng": không tính hàm con).
// Chạy: node doc-profile.ts <file.cpuprofile>
import { readFileSync } from "node:fs";
type Node = { id: number; callFrame: { functionName: string; url: string; lineNumber: number } };
type Profile = { nodes: Node[]; samples: number[]; timeDeltas: number[] };
const file = process.argv[2];
if (!file) throw new Error("Cách dùng: node doc-profile.ts <file.cpuprofile>");
const profile: Profile = JSON.parse(readFileSync(file, "utf8"));
const nodeTheoId = new Map(profile.nodes.map((node) => [node.id, node]));
const microGiayTheoHam = new Map<string, number>();
// Mẫu thứ i kéo dài timeDeltas[i + 1] micro giây (đến lần lấy mẫu kế tiếp).
profile.samples.forEach((nodeId, i) => {
const { functionName, url, lineNumber } = nodeTheoId.get(nodeId)!.callFrame;
const ten = `${functionName || "(vô danh)"} ${url.split("/").slice(-2).join("/")}:${lineNumber + 1}`;
microGiayTheoHam.set(ten, (microGiayTheoHam.get(ten) ?? 0) + (profile.timeDeltas[i + 1] ?? 0));
});
const tong = [...microGiayTheoHam.values()].reduce((a, b) => a + b, 0);
const top = [...microGiayTheoHam].sort((a, b) => b[1] - a[1]).slice(0, 5);
for (const [ten, microGiay] of top) console.log(`${String(Math.round(microGiay / 1000)).padStart(6)} ms ${((microGiay / tong) * 100).toFixed(1).padStart(5)}% ${ten}`);Mình chạy bản đầu qua profiler. Cờ --no-turbo-inlining là cờ của V8 (bộ máy chạy JavaScript của Node), tắt việc gộp hàm nhỏ vào nơi gọi nó. Khi hàm bị gộp, thời gian của nó bị tính vào hàm gọi, và kết quả khó đọc hơn. Tắt đi làm chương trình chạy chậm hơn một chút lúc đo, nhưng cho thấy rõ hơn hàm nào là hàm nào:
node --no-turbo-inlining --cpu-prof --cpu-prof-dir=prof thu-do.ts
node doc-profile.ts prof/*.cpuprofile 1706 ms 50.4% (vô danh) src/bao-cao.ts:11
1251 ms 37.0% baoCaoTheoKhach src/bao-cao.ts:7
225 ms 6.6% (vô danh) 09-tim-cho-cham/thu-do.ts:1
92 ms 2.7% (vô danh) src/tao-du-lieu.ts:19
27 ms 0.8% (garbage collector) :0Cột đầu là thời gian riêng của hàm (không tính hàm con), cột sau là phần trăm trên toàn chương trình. Dòng 11 của src/bao-cao.ts là hàm (d) => d.khach === khach, tức là hàm so sánh bên trong find. Dòng 7 là bản thân baoCaoTheoKhach, nơi vòng lặp bên trong của find chạy (vì find là hàm có sẵn của V8, thời gian của nó được tính cho nơi gọi nó). Cộng hai dòng đầu là gần 88% thời gian, và đều thuộc về một việc: tìm một khách trong danh sách. Phần tạo dữ liệu (dòng thứ tư) chỉ chiếm 2,7%, và tên thư mục 09-tim-cho-cham hiện ra ở dòng ba là tên thư mục demo của mình, thư mục của bạn sẽ khác.
Tại sao một lần find lại tốn vậy? Vì find đi từ đầu danh sách và so sánh từng dòng cho đến khi gặp khách cần tìm. Với 20.000 khách khác nhau, danh sách kết quả dài dần đến gần 18.000 dòng, và mỗi đơn phải duyệt trung bình một nửa danh sách đó, trường hợp xấu nhất là cả danh sách khi khách chưa có. Tổng số phép so sánh cỡ hàng trăm triệu lần. Nói theo ngôn ngữ trong ngành: thời gian tăng theo bình phương số dữ liệu.
Sửa bằng Map, rồi kiểm chứng hai lần
Cách sửa là dùng thứ biết tìm theo khóa mà không phải duyệt từ đầu. Map của JavaScript làm đúng việc đó. Bạn có thể đọc về Map trong tài liệu của MDN; còn việc nó nhanh đến đâu thì bảng đo bên dưới cho thấy. Bản mới thay ketQua.find(...) bằng theoKhach.get(khach):
import { orderTotal, type Order } from "./orders.ts";
export type DongBaoCao = { khach: string; soDon: number; tong: number };
// Báo cáo cho chủ quán: mỗi khách đã đặt mấy đơn và tổng bao nhiêu tiền, khách chi nhiều nhất đứng đầu.
// Dùng Map để tìm dòng của khách trong thời gian gần như không đổi, thay cho find phải duyệt từ đầu danh sách.
export function baoCaoTheoKhach(orders: Order[]): DongBaoCao[] {
const theoKhach = new Map<string, DongBaoCao>();
for (const order of orders) {
const khach = order.customer?.phone ?? "tại quầy";
const dong = theoKhach.get(khach);
if (dong) {
dong.soDon += 1;
dong.tong += orderTotal(order);
} else {
theoKhach.set(khach, { khach, soDon: 1, tong: orderTotal(order) });
}
}
return [...theoKhach.values()].sort((a, b) => b.tong - a.tong);
}Còn bản đầu mình giữ lại để so sánh: đổi tên file cũ thành src/bao-cao-cu.ts, đổi tên hàm trong đó thành baoCaoTheoKhachCu, và thay dòng khai báo kiểu DongBaoCao bằng một dòng import type lấy kiểu đó từ file mới. Đây là file đã đổi:
import { orderTotal, type Order } from "./orders.ts";
import type { DongBaoCao } from "./bao-cao.ts";
// Báo cáo cho chủ quán: mỗi khách đã đặt mấy đơn và tổng bao nhiêu tiền, khách chi nhiều nhất đứng đầu.
// Bản đầu (giữ lại để so sánh kết quả), viết cho dễ đọc: với mỗi đơn, tìm xem khách đó đã có dòng trong kết quả chưa.
export function baoCaoTheoKhachCu(orders: Order[]): DongBaoCao[] {
const ketQua: DongBaoCao[] = [];
for (const order of orders) {
const khach = order.customer?.phone ?? "tại quầy";
const dong = ketQua.find((d) => d.khach === khach);
if (dong) {
dong.soDon += 1;
dong.tong += orderTotal(order);
} else {
ketQua.push({ khach, soDon: 1, tong: orderTotal(order) });
}
}
return ketQua.sort((a, b) => b.tong - a.tong);
}Kiểm chứng lần một: kết quả có đúng không? Trước khi tin vào bất kỳ con số nào về tốc độ, mình muốn chắc là bản nhanh không sai. Test dưới đây đối chiếu hai bản trên 3.000 đơn (kể cả thứ tự các khách có tổng tiền bằng nhau), và kiểm tra thêm ba trường hợp nhỏ:
import { describe, expect, test } from "vitest";
import { baoCaoTheoKhach } from "./bao-cao.ts";
import { baoCaoTheoKhachCu } from "./bao-cao-cu.ts";
import { taoDonHang } from "./tao-du-lieu.ts";
import type { Order } from "./orders.ts";
const don = (id: number, phone: string | undefined, gia: number): Order => ({
id, createdAt: "2026-11-03T08:00:00+07:00", source: "web",
...(phone ? { customer: { name: "Khách", phone } } : {}),
items: [{ name: "Cà phê", price: gia, quantity: 1 }],
});
describe("baoCaoTheoKhach", () => {
test("gộp đơn theo số điện thoại, tổng tiền đúng, khách chi nhiều nhất đứng đầu", () => {
const orders = [don(1, "0901", 25000), don(2, "0902", 70000), don(3, "0901", 25000)];
expect(baoCaoTheoKhach(orders)).toEqual([
{ khach: "0902", soDon: 1, tong: 70000 },
{ khach: "0901", soDon: 2, tong: 50000 },
]);
});
test("đơn tại quầy (không có khách) gộp chung một dòng", () => {
const orders = [don(1, undefined, 25000), don(2, undefined, 29000)];
expect(baoCaoTheoKhach(orders)).toEqual([{ khach: "tại quầy", soDon: 2, tong: 54000 }]);
});
test("danh sách rỗng cho báo cáo rỗng", () => {
expect(baoCaoTheoKhach([])).toEqual([]);
});
test("bản Map cho đúng kết quả của bản đầu trên 3.000 đơn (kể cả thứ tự khi bằng tiền)", () => {
const orders = taoDonHang(3_000, 1_200);
expect(baoCaoTheoKhach(orders)).toEqual(baoCaoTheoKhachCu(orders));
});
});npx vitest run src/bao-cao.test.ts Test Files 1 passed (1)
Tests 4 passed (4)Kiểm chứng lần hai: nhanh hơn bao nhiêu? Script dưới đây chạy mỗi bản năm lần trên bốn cỡ dữ liệu và in trung vị (giá trị ở giữa, để một lần chạy bị nhiễu không làm lệch kết quả):
// So sánh bản đầu và bản dùng Map: mỗi bản chạy 5 lần trên cùng dữ liệu, in thời gian trung vị (giá trị ở giữa).
// Kích thước nhỏ hơn bản cũ chạy nổi, để thấy thời gian tăng theo số đơn thế nào. Chạy: node do-nhieu-lan.ts
import { baoCaoTheoKhach } from "./src/bao-cao.ts";
import { baoCaoTheoKhachCu } from "./src/bao-cao-cu.ts";
import { taoDonHang } from "./src/tao-du-lieu.ts";
function trungVi(chay: () => unknown, soLan = 5): number {
const thoiGian = Array.from({ length: soLan }, () => {
const batDau = performance.now();
chay();
return performance.now() - batDau;
}).sort((a, b) => a - b);
return thoiGian[Math.floor(soLan / 2)];
}
for (const soDon of [5_000, 10_000, 25_000, 50_000]) {
const orders = taoDonHang(soDon, Math.round(soDon * 0.4));
const cu = trungVi(() => baoCaoTheoKhachCu(orders));
const moi = trungVi(() => baoCaoTheoKhach(orders));
console.log(`${String(soDon).padStart(6)} đơn: bản đầu ${String(Math.round(cu)).padStart(5)} ms, bản Map ${moi.toFixed(1).padStart(5)} ms`);
}node do-nhieu-lan.ts 5000 đơn: bản đầu 15 ms, bản Map 0.8 ms
10000 đơn: bản đầu 62 ms, bản Map 1.5 ms
25000 đơn: bản đầu 402 ms, bản Map 2.9 ms
50000 đơn: bản đầu 1547 ms, bản Map 6.5 msHãy nhìn cột bản đầu. Từ 5.000 lên 50.000 đơn, tức nhiều gấp mười lần, thời gian tăng từ 15 ms lên 1.547 ms, tức hơn một trăm lần. Đó là dấu hiệu của thời gian tăng theo bình phương. Bản Map thì tăng gần tuyến tính: mười lần dữ liệu, khoảng tám lần thời gian. Tại 50.000 đơn, bản mới nhanh hơn khoảng 240 lần. Con số cụ thể của bạn sẽ khác tùy máy, nhưng hình dạng của hai cột thì không đổi.
Nên tối ưu đến đâu?
Nhìn dòng đầu của bảng, bạn sẽ thấy ở 5.000 đơn bản đầu chỉ mất 15 ms. Với một quán cà phê vài chục đơn mỗi ngày, bản đầu đã chạy tốt trong nhiều năm, và việc viết nó theo cách dễ đọc là quyết định hợp lý. Theo mình, không ai nên viết Map ở mọi nơi để phòng xa. Cái đáng làm là đo khi có dấu hiệu chậm, như dòng log 1.984 ms ở đầu bài, rồi sửa đúng chỗ mà số đo chỉ ra.
Ba thói quen mình giữ sau bài này. Thứ nhất, luôn có một con số trước khi sửa, để biết sửa xong có tốt lên không. Thứ hai, profile trước khi đoán. Thứ ba, giữ lại một bản chạy được để đối chiếu kết quả, vì tối ưu mà làm sai kết quả thì không phải tối ưu.
Cũng cần nói rõ giới hạn: các số đo trong bài chạy trên máy của mình, với dữ liệu giả có hạt giống cố định và một hình dạng cụ thể (20.000 khách trên 50.000 đơn). Với dữ liệu thật hoặc máy khác, con số sẽ khác. Quy trình đo thì dùng lại được.
Số đơn tăng, và có một file CSV cũ cần nhập
Báo cáo giờ chạy trong vài mili giây, và chủ quán vui. Nhưng chính chủ quán vừa nhắc một chuyện: ngoài dữ liệu đang có, máy bán hàng cũ còn để lại một file CSV với hàng nghìn đơn cũ chưa từng vào hệ thống. File đó do nhiều người nhập tay qua nhiều năm nên không đồng nhất. Cách nhập một file như vậy mà không làm hỏng dữ liệu là việc của các bài viết sau.
Bạn theo dõi cả câu chuyện ở series Nhận dự án cũ. Nếu muốn ôn lại cách đọc lỗi, bài đọc stack trace là điểm bắt đầu, và các câu hỏi về hiệu năng, Node.js có trong ngân hàng câu hỏi phỏng vấn.