Regex cơ bản: nhập file CSV đơn hàng lộn xộn bằng JavaScript

Học regex cơ bản qua một việc thật: nhập file CSV đơn hàng cũ có ngày, số điện thoại, tiền mỗi kiểu một cách, kèm bẫy regex làm treo máy chủ.

Regex (biểu thức chính quy) là cách mô tả một mẫu chữ để máy tìm hoặc kiểm tra chuỗi. Với dữ liệu nhập tay lộn xộn, dùng regex để chuẩn hóa từng ô, còn việc tách ô CSV nên để code riêng. Bạn muốn học regex qua một việc thật, không phải bảng ký hiệu? Cùng làm nhé.

Có file CSV cũ hàng nghìn đơn, nhập vào hệ thống thế nào?

Ở bài trước, báo cáo của hệ thống đơn hàng quán Mộc từ gần hai giây xuống còn vài mili giây. (Quán Mộc là nhân vật minh họa của series này.) Chủ quán vui, rồi nhắc một chuyện: máy bán hàng cũ còn để lại một file CSV với hàng nghìn đơn 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 mỗi người một kiểu.

Đây là đoạn mẫu của file đó (dữ liệu là minh họa). Nó có chín dòng đơn, mỗi dòng cố ý đại diện cho một kiểu lộn xộn, và dòng đầu là tiêu đề cột:

don-cu.csv
ma_don,ngay,khach,sdt,mon,tong
2001,03/11/2026,"Nguyễn Văn An",0901 000 001,"2 x cà phê sữa; 1 x bánh mì trứng","79.000đ"
2002,3-11-26,  Trần Thị Bình  ,+84 902 000 002,"1 x bạc xỉu","32,000"
2003,2026.11.03,"Lê, Văn Cường","(090)1000003","1x cà phê muối ; 2 x bánh mì trứng",85k
2004,03/11/2026,,,"3 x cà phê đen",75000
2005,31/02/2026,"Phạm Thị Dung",0904000004,"1 x bạc xỉu","32.000"
2006,04/11/2026,"Hoàng Văn Em",09O5000005,"1 x cà phê sữa","29.000"
2007,04/11/2026,"Đỗ Thị Phương",0906000006,"cà phê sữa","29.000"
2008,05/11/2026,"Võ Văn Giang",0907000007,"2 x trà đào",abc
2009,05/11/2026,"Bùi Thị Hà",0908000008,"1 x cà phê sữa",35

Hãy đọc kỹ vài dòng. Ngày được viết ba kiểu (03/11/2026, 3-11-26, 2026.11.03). Số điện thoại có dấu cách, có +84, có ngoặc. Tiền lúc có chữ đ, lúc có dấu phẩy, lúc là 85k, lúc là số trần.

Tên khách ở dòng 2003 có dấu phẩy nằm trong ngoặc kép. Đơn 2004 không có tên lẫn số điện thoại vì là khách mua tại quầy. Đơn 2005 có ngày 31/02, đơn 2006 có chữ O thay cho số 0 trong số điện thoại, đơn 2008 có tổng tiền là "abc", và đơn 2009 có tổng tiền 35, giống hệt kiểu mất dấu chấm của "35.000" ở các bài trước của series.

Có thêm hai thứ bạn không nhìn thấy: file thật bắt đầu bằng dấu BOM (một ký tự vô hình mà Excel hay thêm vào đầu file) và mỗi dòng kết thúc bằng \r\n như file của máy Windows. Nếu bạn gõ lại file này, nó không có hai thứ đó cũng được, vì code bên dưới xử lý cả hai trường hợp.

Mục tiêu của mình: mỗi dòng hoặc thành một đơn có dữ liệu sạch, hoặc bị loại kèm lý do rõ ràng để người kiểm tra tay. Không dòng nào được biến mất âm thầm. Bạn cần Node.js 22.18 trở lên, vì từ bản đó Node chạy thẳng file .ts, và không cần cài thêm gì. Cấu trúc thư mục:

Cấu trúc thư mục
nhap-don-cu/
  package.json
  nhap.ts
  thu-cach-ngay-tho.ts
  thu-redos.ts
  do-toc-do.ts
  src/don-cu.csv
  src/csv.ts
  src/chuan-hoa.ts
  src/nhap-csv.ts
package.json
{
  "name": "don-hang-moc-10",
  "private": true,
  "type": "module",
  "scripts": { "test": "node --test src" }
}

(Đặt file CSV ở trên vào src/don-cu.csv.)

Tách bằng dấu phẩy rồi kiểm tra thẳng: hỏng ở đâu?

Cách làm đầu tiên ai cũng nghĩ tới là split(",") để tách ô, rồi kiểm tra số điện thoại bằng một regex đơn giản ^0\d{9}$, nghĩa là số 0 rồi đúng chín chữ số. Mình thử cả hai trên dòng của đơn 2003:

thu-cach-ngay-tho.ts
// Hai cách làm đầu tiên (đều sai) trên dòng 4 của file don-cu.csv. Chạy: node thu-cach-ngay-tho.ts
import { readFileSync } from "node:fs";

const cacDong = readFileSync("src/don-cu.csv", "utf8").split(/\r?\n/);
const dong4 = cacDong[3]; // đơn 2003, tên khách là "Lê, Văn Cường"

console.log(`Dòng gốc:      ${dong4}`);
const o = dong4.split(",");
console.log(`split(","):    ${o.length} ô (cần 6)`);
console.log(`  ô thứ 3 (khách): ${o[2]}`);
console.log(`  ô thứ 4 (sdt):   ${o[3]}`);
console.log(`  ô thứ 6 (tổng):  ${o[5]}`);

console.log("\nKiểm tra số điện thoại bằng /^0\\d{9}$/ ngay trên ô gốc:");
for (const sdt of ["0901000001", "0901 000 001", "+84 902 000 002", "(090)1000003"]) console.log(`  ${JSON.stringify(sdt).padEnd(20)} → ${/^0\d{9}$/.test(sdt)}`);
Chạy thử
node thu-cach-ngay-tho.ts
Kết quả
Dòng gốc:      2003,2026.11.03,"Lê, Văn Cường","(090)1000003","1x cà phê muối ; 2 x bánh mì trứng",85k
split(","):    7 ô (cần 6)
  ô thứ 3 (khách): "Lê
  ô thứ 4 (sdt):    Văn Cường"
  ô thứ 6 (tổng):  "1x cà phê muối ; 2 x bánh mì trứng"
Kết quả (tiếp)
Kiểm tra số điện thoại bằng /^0\d{9}$/ ngay trên ô gốc:
  "0901000001"         → true
  "0901 000 001"       → false
  "+84 902 000 002"    → false
  "(090)1000003"       → false

Hãy nhìn hai điều. Dòng 2003 bị tách thành bảy ô thay vì sáu, vì dấu phẩy trong "Lê, Văn Cường" cũng bị coi là dấu ngăn cột. Hậu quả là mọi ô phía sau lệch một vị trí: số điện thoại bây giờ là "Văn Cường", và cột tổng tiền chứa danh sách món. Nếu code không đếm ô thì dữ liệu sai được nhập vào mà không có lỗi nào kêu lên.

Điều thứ hai là regex ^0\d{9}$ đúng với "0901000001" nhưng sai với ba kiểu viết còn lại, dù cả ba đều là số điện thoại hợp lệ. Regex không sai, mà mình đã đưa cho nó dữ liệu chưa làm sạch.

Những mẩu regex cơ bản bạn cần cho việc này

Mình không liệt kê cả bảng ký hiệu, chỉ những mẩu có dùng bên dưới. Dấu ^ và $ đánh dấu đầu và cuối chuỗi, nên ^0\d{9}$ buộc cả chuỗi phải khớp chứ không chỉ một đoạn. \d là một chữ số, {9} là đúng chín lần, + là một hoặc nhiều lần, ? là có hoặc không.

Ngoặc vuông [...] là một ký tự bất kỳ trong tập, như [x×] là chữ x hoặc dấu nhân. Ngoặc tròn (...) gom thành nhóm, và (?:...) là nhóm không cần nhớ. Nhóm có tên (?<ngay>...) cho bạn lấy kết quả bằng tên thay vì số thứ tự. Cờ i bỏ qua chữ hoa chữ thường, cờ u bật chế độ Unicode, cần khi dùng ký tự như đ. Cách viết đầy đủ nằm trong hướng dẫn regex của MDN.

Cách làm mình chọn là chia việc thành hai bước. Bước một là làm sạch: bỏ những ký tự mà ta biết là trang trí (dấu cách, ngoặc, dấu chấm trong số điện thoại). Bước hai mới là kiểm tra chặt bằng regex đơn giản. Làm ngược lại (một regex khổng lồ chấp nhận mọi kiểu viết) thì rất khó đọc và khó sửa.

Chuẩn hóa từng ô bằng regex

Mỗi hàm dưới đây nhận một ô thô và trả về giá trị sạch, hoặc ném lỗi kèm lý do bằng tiếng Việt. Mình không để hàm "đoán" khi gặp dữ liệu lạ, vì đoán sai thì còn tệ hơn là báo lỗi:

src/chuan-hoa.ts
// Mỗi hàm chuẩn hóa MỘT ô của file CSV cũ. Đầu vào sai thì ném lỗi có lý do bằng tiếng Việt, không đoán.
export const MIN_TIEN = 1000; // quán Mộc không có đơn nào dưới 1.000đ; nhỏ hơn gần như chắc chắn là mất dấu chấm ("35.000" thành 35)

// "0901 000 001", "+84 902 000 002", "(090)1000003" → "0901000001". Ô trống: khách mua tại quầy, không có số.
export function chuanHoaSdt(goc: string): string | undefined {
  const sach = goc.replace(/[\s.()-]/g, "").replace(/^\+84/, "0");
  if (sach === "") return undefined;
  if (!/^0\d{9}$/.test(sach)) throw new Error(`số điện thoại "${goc.trim()}" không hợp lệ`);
  return sach;
}

// "03/11/2026", "3-11-26", "2026.11.03" → "2026-11-03". Giả định ngày đứng trước tháng (máy bán hàng ở Việt Nam).
export function chuanHoaNgay(goc: string): string {
  const khop = goc.trim().match(/^(?<a>\d{1,4})[/.-](?<b>\d{1,2})[/.-](?<c>\d{1,4})$/);
  if (!khop?.groups) throw new Error(`ngày "${goc.trim()}" không đúng dạng`);
  const { a, b, c } = khop.groups;
  // Số đầu có 4 chữ số thì là năm (yyyy.mm.dd); ngược lại là ngày (dd/mm/yyyy hoặc dd-mm-yy).
  const [nam, thang, ngay] = a.length === 4 ? [a, b, c] : [c.length === 2 ? `20${c}` : c, b, a];
  const ngayThat = new Date(Date.UTC(Number(nam), Number(thang) - 1, Number(ngay)));
  if (nam.length !== 4 || ngayThat.getUTCFullYear() !== Number(nam) || ngayThat.getUTCMonth() !== Number(thang) - 1 || ngayThat.getUTCDate() !== Number(ngay)) {
    throw new Error(`ngày ${goc.trim()} không tồn tại`);
  }
  return `${nam}-${thang.padStart(2, "0")}-${ngay.padStart(2, "0")}`;
}

// "79.000đ", "32,000", "85k", "75000" → số đồng. "abc" hoặc số nhỏ hơn MIN_TIEN thì báo lỗi.
export function chuanHoaTien(goc: string): number {
  const khop = goc.trim().match(/^(?<so>\d{1,3}(?:[.,]\d{3})+|\d+)\s*(?<hau>đ|k)?$/iu);
  if (!khop?.groups) throw new Error(`tổng tiền "${goc.trim()}" không đọc được`);
  const tien = Number(khop.groups.so.replace(/[.,]/g, "")) * (khop.groups.hau?.toLowerCase() === "k" ? 1000 : 1);
  if (tien < MIN_TIEN) throw new Error(`tổng tiền ${tien}đ nhỏ hơn ${MIN_TIEN}đ, nghi mất dấu chấm`);
  return tien;
}

export type Mon = { ten: string; soLuong: number };

// "2 x cà phê sữa; 1x bánh mì trứng" → hai món. Món không ghi số lượng thì tính là 1.
export function tachMon(goc: string): Mon[] {
  const cacMon = goc
    .split(";")
    .map((phan) => phan.trim())
    .filter(Boolean)
    .map((phan) => {
      const khop = phan.match(/^(?:(?<soLuong>\d+)\s*[x×]\s*)?(?<ten>.+)$/iu)!;
      return { ten: khop.groups!.ten.trim(), soLuong: Number(khop.groups!.soLuong ?? 1) };
    });
  if (cacMon.length === 0) throw new Error("đơn không có món nào");
  return cacMon;
}

Mỗi hàm có một vài quyết định đáng giải thích. Với số điện thoại, [\s.()-] là một tập gồm khoảng trắng, dấu chấm, hai ngoặc và gạch nối, và replace với cờ g xóa tất cả những ký tự đó. Sau đó ^\+84 đổi đầu số quốc gia thành số 0. Chữ O ở đơn 2006 không bị xóa, nên ^0\d{9}$ bắt được nó. Nếu mình "tốt bụng" đổi O thành 0 thì lỗi nhập liệu thật sẽ trôi vào hệ thống.

Với ngày, ba kiểu viết dùng chung một regex ba nhóm có tên, ngăn bằng /, . hoặc -. Rồi code xem số đầu có bốn chữ số không: nếu có thì đó là năm (2026.11.03), nếu không thì đó là ngày. Một chỗ dễ bỏ sót là regex chỉ biết hình dạng, không biết 31/02 không tồn tại, nên mình dựng một Date thật rồi so lại ngày, tháng, năm. Dòng đầu của hàm cũng ghi một giả định: ngày đứng trước tháng, vì máy bán hàng ở Việt Nam. Với ngày như 01/02/2026, từ dữ liệu một mình bạn không biết đó là 1 tháng 2 hay 2 tháng 1, nên giả định này phải hỏi chủ file chứ không tự suy ra được.

Với tiền, nhánh đầu của regex \d{1,3}(?:[.,]\d{3})+ khớp số có dấu ngăn hàng nghìn (79.000, 32,000, 1.250.000), nhánh sau \d+ khớp số trần, rồi một hậu tố tùy chọn là đ hoặc k. Số nhỏ hơn MIN_TIEN (1.000đ) bị loại, và đó chính là cách bắt đơn 2009: "35" gần như chắc chắn là "35.000" mất dấu chấm. Cuối cùng hàm tachMon dùng nhóm tùy chọn (?:(?<soLuong>\d+)\s*[x×]\s*)?, nên "cà phê sữa" không có số lượng vẫn được tính là một.

Tách ô CSV thì đừng dùng regex

Đến chỗ này có thể bạn nghĩ mình sẽ viết một regex thật dài để tách ô có ngoặc kép. Mình không làm vậy. Quy tắc của định dạng CSV (mô tả trong RFC 4180) là ô chứa dấu phẩy, ngoặc kép hay xuống dòng thì nên đặt trong ngoặc kép, và một ngoặc kép bên trong được viết thành hai. Quy tắc đó có "trạng thái": đang ở trong hay ngoài ngoặc. Regex diễn tả trạng thái rất kém, còn một vòng lặp qua từng ký tự thì diễn tả rất rõ:

src/csv.ts
// Tách MỘT dòng CSV thành các ô. Hiểu ô nằm trong ngoặc kép (có thể chứa dấu phẩy) và ngoặc kép đôi "" là một dấu ngoặc kép.
// Giới hạn: ô không được chứa xuống dòng. File có ô nhiều dòng thì dùng thư viện đọc CSV.
export function tachDongCsv(dong: string): string[] {
  const cacO: string[] = [];
  let hienTai = "";
  let trongNgoac = false;
  for (let i = 0; i < dong.length; i++) {
    const c = dong[i];
    if (trongNgoac) {
      if (c === '"' && dong[i + 1] === '"') {
        hienTai += '"';
        i++;
      } else if (c === '"') trongNgoac = false;
      else hienTai += c;
    } else if (c === '"') trongNgoac = true;
    else if (c === ",") {
      cacO.push(hienTai);
      hienTai = "";
    } else hienTai += c;
  }
  if (trongNgoac) throw new Error("ngoặc kép không được đóng");
  cacO.push(hienTai);
  return cacO;
}

Hàm này chỉ tách một dòng, nên ô không được chứa xuống dòng. Đó là giới hạn mình chấp nhận cho file này vì đã đọc qua nó. Với file CSV phức tạp hơn, theo mình bạn nên dùng một thư viện đọc CSV đã được nhiều người kiểm chứng thay vì tự viết.

Ghép lại: mỗi dòng hoặc thành đơn, hoặc bị loại có lý do

Hàm nhapCsv làm bước cuối: bỏ BOM bằng replace(/^/, ""), cắt dòng bằng split(/\r?\n/) (nhận cả \r\n lẫn \n), kiểm tra dòng tiêu đề, rồi với mỗi dòng thì tách ô, đếm ô, gọi các hàm chuẩn hóa. Nếu bất kỳ bước nào ném lỗi, dòng đó vào danh sách bị loại cùng số dòng, lý do và nội dung gốc:

src/nhap-csv.ts
// Nhập file CSV đơn cũ: mỗi dòng hoặc thành một đơn hợp lệ, hoặc bị loại KÈM lý do và dòng gốc. Không dòng nào biến mất âm thầm.
import { chuanHoaNgay, chuanHoaSdt, chuanHoaTien, tachMon, type Mon } from "./chuan-hoa.ts";
import { tachDongCsv } from "./csv.ts";

export type DonNhap = { maDon: string; ngay: string; khach?: string; sdt?: string; mon: Mon[]; tong: number };
export type DongBiLoai = { dong: number; lyDo: string; goc: string };
export type KetQuaNhap = { hopLe: DonNhap[]; biLoai: DongBiLoai[] };

const CAC_COT = ["ma_don", "ngay", "khach", "sdt", "mon", "tong"];

export function nhapCsv(noiDung: string): KetQuaNhap {
  // Excel hay thêm dấu BOM () ở đầu file, và máy Windows kết thúc dòng bằng \r\n.
  const [dongDau, ...cacDong] = noiDung.replace(/^/, "").split(/\r?\n/);
  if (tachDongCsv(dongDau).join(",") !== CAC_COT.join(",")) throw new Error(`Dòng tiêu đề phải là: ${CAC_COT.join(",")}`);

  const ketQua: KetQuaNhap = { hopLe: [], biLoai: [] };
  cacDong.forEach((goc, i) => {
    if (goc.trim() === "") return; // dòng trống cuối file
    try {
      const o = tachDongCsv(goc);
      if (o.length !== CAC_COT.length) throw new Error(`có ${o.length} ô, cần ${CAC_COT.length}`);
      const [maDon, ngay, khach, sdt, mon, tong] = o;
      ketQua.hopLe.push({
        maDon: maDon.trim(),
        ngay: chuanHoaNgay(ngay),
        khach: khach.trim().replace(/\s+/g, " ") || undefined,
        sdt: chuanHoaSdt(sdt),
        mon: tachMon(mon),
        tong: chuanHoaTien(tong),
      });
    } catch (loi) {
      ketQua.biLoai.push({ dong: i + 2, lyDo: (loi as Error).message, goc }); // dòng 1 là tiêu đề nên dòng dữ liệu đầu tiên là dòng 2
    }
  });
  return ketQua;
}
nhap.ts
// Nhập file đơn cũ và in báo cáo. Chạy: node nhap.ts src/don-cu.csv
import { readFileSync } from "node:fs";

import { nhapCsv } from "./src/nhap-csv.ts";

const { hopLe, biLoai } = nhapCsv(readFileSync(process.argv[2] ?? "src/don-cu.csv", "utf8"));
console.log(`Đọc ${hopLe.length + biLoai.length} dòng: ${hopLe.length} hợp lệ, ${biLoai.length} bị loại.\n`);
for (const don of hopLe) console.log(`đơn ${don.maDon}  ${don.ngay}  ${(don.khach ?? "(tại quầy)").padEnd(14)} ${(don.sdt ?? "-").padEnd(10)} ${String(don.tong).padStart(6)}đ  ${don.mon.map((m) => `${m.soLuong} ${m.ten}`).join(", ")}`);
console.log("\nDòng bị loại (kèm lý do, để người kiểm tra tay):");
for (const loi of biLoai) console.log(`dòng ${loi.dong}: ${loi.lyDo}`);
Nhập file đơn cũ
node nhap.ts src/don-cu.csv
Kết quả
Đọc 9 dòng: 5 hợp lệ, 4 bị loại.

đơn 2001  2026-11-03  Nguyễn Văn An  0901000001  79000đ  2 cà phê sữa, 1 bánh mì trứng
đơn 2002  2026-11-03  Trần Thị Bình  0902000002  32000đ  1 bạc xỉu
đơn 2003  2026-11-03  Lê, Văn Cường  0901000003  85000đ  1 cà phê muối, 2 bánh mì trứng
đơn 2004  2026-11-03  (tại quầy)     -           75000đ  3 cà phê đen
đơn 2007  2026-11-04  Đỗ Thị Phương  0906000006  29000đ  1 cà phê sữa

Dòng bị loại (kèm lý do, để người kiểm tra tay):
dòng 6: ngày 31/02/2026 không tồn tại
dòng 7: số điện thoại "09O5000005" không hợp lệ
dòng 9: tổng tiền "abc" không đọc được
dòng 10: tổng tiền 35đ nhỏ hơn 1000đ, nghi mất dấu chấm

Hãy đối chiếu với file gốc. Năm đơn hợp lệ có ngày cùng dạng 2026-11-03, số điện thoại cùng dạng mười chữ số, và đơn 2003 giữ nguyên tên "Lê, Văn Cường". Bốn dòng bị loại là đúng bốn dòng mình cố ý làm hỏng (2005, 2006, 2008, 2009), mỗi dòng có lý do mà người kiểm tra tay đọc là hiểu ngay. Dòng 6 là số dòng trong file, tính cả dòng tiêu đề. Tổng 5 cộng 4 là 9, bằng số dòng dữ liệu: không dòng nào biến mất.

Còn tốc độ thì sao? File thật có hàng nghìn dòng nên mình đo thử bằng cách lặp chín dòng dữ liệu đó 400 lần:

do-toc-do.ts
// Nhập một file lớn: lặp 9 dòng dữ liệu của don-cu.csv 400 lần (3.600 dòng) và đo thời gian. Chạy: node do-toc-do.ts
import { readFileSync } from "node:fs";

import { nhapCsv } from "./src/nhap-csv.ts";

const [tieuDe, ...cacDong] = readFileSync("src/don-cu.csv", "utf8").trim().split(/\r?\n/);
const fileLon = [tieuDe, ...Array.from({ length: 400 }, () => cacDong).flat()].join("\n");

const batDau = performance.now();
const { hopLe, biLoai } = nhapCsv(fileLon);
console.log(`${hopLe.length + biLoai.length} dòng: ${hopLe.length} hợp lệ, ${biLoai.length} bị loại, mất ${Math.round(performance.now() - batDau)} ms`);
Đo tốc độ
node do-toc-do.ts
Kết quả (số thời gian trên máy của bạn sẽ khác)
3600 dòng: 2000 hợp lệ, 1600 bị loại, mất 29 ms

3.600 dòng trong 29 ms, nên tốc độ không phải chuyện cần lo ở quy mô này.

Regex cũng có thể làm treo máy chủ

Còn một điều mình muốn bạn biết trước khi dùng regex nhiều hơn. Một số regex trông vô hại nhưng tốn thời gian tăng gấp đôi cho mỗi ký tự thêm vào chuỗi, khi chuỗi không khớp. Hiện tượng này tên là catastrophic backtracking (quay lui thảm họa), và trang ReDoS của OWASP mô tả nó là một kiểu tấn công từ chối dịch vụ. Điều kiện thường gặp là có lặp lồng trong lặp, như (\d+\.?)+.

Mình thử với hai regex cùng ý "chuỗi số, có thể có dấu chấm ngăn". Bản đầu dễ nghĩ ra, bản sau viết sao cho mỗi ký tự chỉ có đúng một cách khớp. Đầu vào là n chữ số 1 rồi một chữ x ở cuối, tức là cố ý không khớp:

thu-redos.ts
// Một biểu thức chính quy trông vô hại có thể treo máy chủ. Chạy: node thu-redos.ts
const DE_HONG = /^(\d+\.?)+$/; // "một hoặc nhiều nhóm: chữ số, rồi có thể có dấu chấm"; chữ số lặp lồng trong nhóm lặp
const AN_TOAN = /^\d+(\.\d+)*$/; // "chữ số, rồi các nhóm: dấu chấm kèm chữ số"; mỗi ký tự chỉ có một cách khớp

// Thời gian trung vị của 3 lần chạy (lần đầu V8 còn đang biên dịch biểu thức nên hay chậm bất thường).
function doThoiGian(mau: RegExp, doan: string): number {
  const cacLan = Array.from({ length: 3 }, () => {
    const batDau = performance.now();
    mau.test(doan);
    return performance.now() - batDau;
  }).sort((a, b) => a - b);
  return cacLan[1];
}

console.log("Đầu vào: n chữ số 1 rồi một chữ 'x' ở cuối (không khớp). Thời gian trung vị, mili giây:");
for (const n of [22, 24, 26, 28]) {
  const doan = `${"1".repeat(n)}x`;
  console.log(`n=${n}  dễ hỏng: ${doThoiGian(DE_HONG, doan).toFixed(1).padStart(8)} ms   an toàn: ${doThoiGian(AN_TOAN, doan).toFixed(3)} ms`);
}
Chạy thử
node thu-redos.ts
Kết quả (số thời gian trên máy của bạn sẽ khác)
Đầu vào: n chữ số 1 rồi một chữ 'x' ở cuối (không khớp). Thời gian trung vị, mili giây:
n=22  dễ hỏng:     18.8 ms   an toàn: 0.023 ms
n=24  dễ hỏng:     74.7 ms   an toàn: 0.000 ms
n=26  dễ hỏng:    302.9 ms   an toàn: 0.000 ms
n=28  dễ hỏng:   1233.8 ms   an toàn: 0.001 ms

Nhìn cột "dễ hỏng": cứ thêm hai ký tự thì thời gian tăng khoảng bốn lần, tức là nhân đôi cho mỗi ký tự. Với 28 ký tự đã mất hơn một giây, và với 40 ký tự thì (ước tính theo đúng đà đó, mình không chạy) sẽ mất hàng giờ. Một ô tiền dài 40 ký tự trong file CSV nhập tay là chuyện hoàn toàn có thể xảy ra. Cột "an toàn" thì gần như không đổi.

Các regex trong chuan-hoa.ts không có lặp lồng kiểu đó: nhóm (?:[.,]\d{3})+ có độ dài cố định nên mỗi ký tự chỉ khớp được một cách. Mình rút ra hai thói quen. Một, khi viết regex mà thấy dấu lặp (+, *) bên trong một nhóm đang được lặp, hãy dừng lại và thử với một chuỗi dài không khớp. Hai, với dữ liệu mà bạn không kiểm soát, chặn độ dài trước khi chạy regex. Hàm của mình chưa làm điều này, và nếu nhập file lạ mình sẽ thêm một dòng từ chối ô quá dài.

Test cho từng hàm, và những gì còn thiếu

Mình viết tám test cho các hàm này (nằm ở repo demo): bốn kiểu viết số điện thoại cùng ra một số, ba kiểu ngày cùng ra dạng ISO, ngày không có thật (31/02, tháng 13, năm ba chữ số), các kiểu tiền, ô CSV có dấu phẩy và ngoặc kép, và nhapCsv trên file mẫu với đúng bốn dòng bị loại. Một test ghi lại giả định ngày đứng trước tháng, để ai đổi nó phải sửa test chứ không âm thầm sửa nghĩa của dữ liệu. Chạy bằng bộ test có sẵn của Node:

Chạy test (trong repo demo)
node --test src/nhap-csv.test.ts
Kết quả
# tests 8
# pass 8
# fail 0

Còn vài thứ bài này chưa làm. Chưa kiểm tra mã đơn trùng: nhập file hai lần sẽ ra đơn đôi. Chưa xử lý ô có xuống dòng. Và chưa có cách để người kiểm tra tay sửa dòng bị loại rồi nhập lại, trong khi đó chính là bước tiếp theo của chủ quán.

Hai người sửa cùng một file thì sao?

Hàm nhập đã chạy. Trong câu chuyện của series, đúng lúc mình viết nó thì anh Khoa cũng sửa chuan-hoa.ts ở một nhánh khác để thêm một kiểu viết tiền mới. Khi hai nhánh cùng đụng một file và cần gộp lại, Git sẽ báo xung đột. Cách đọc và xử lý xung đột mà không làm mất code 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 đo trước khi sửa, bài tối ưu hiệu năng Node.js có quy trình, và các câu hỏi về JavaScript nằm trong ngân hàng câu hỏi phỏng vấn.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.