Cụm bài Regex: 1. Cú pháp, Java API và bài tập validate · 2. Bài tập: cấu hình mạng, log sang CSV, lookbehind, dòng trùng · 3. Engine, backtracking và catastrophic backtracking · 4. ReDoS trong Java: sự cố và phòng thủ
Backend đụng regex ở nhiều chỗ (@Pattern, tách field trong log, rule Nginx, grep); viết regex khớp ví dụ trước mặt thì dễ, viết regex không khớp nhầm và đọc lại được sau ba tháng mới khó. Bài này đi qua cú pháp cốt lõi, Pattern/Matcher cùng các method của String hay gây bug, rồi giải ba bài validate (tên file ảnh, số, email); mọi pattern đã chạy trên JDK 21. Bài tập lớn hơn ở bài 2, engine ở bài 3, ReDoS và cách phòng ở bài 4; kiến thức String ở bài mảng và chuỗi.
Sơ đồ tóm tắt:
mindmap
root((Regex trong Java))
Flavor: thử regex101
Cú pháp
Lớp ký tự, quantifier
Anchor, lookaround, group
Java API
Pattern static final
matches tự neo, find thì không
split nhận regex, dùng quote
w và d chỉ ASCII
Engine
Backtracking, không timeout
1. Regex là gì, và vì sao mỗi ngôn ngữ một kiểu
Ý chính: regex là một ngôn ngữ nhỏ mô tả hình dạng của chuỗi. Phần lõi giống nhau ở mọi nơi, nhưng mỗi engine khác nhau ở chi tiết, nên phải thử đúng biến thể sẽ chạy.
Đầu vào là chuỗi và pattern; đầu ra là các đoạn khớp (match) cùng các nhóm con bên trong. Bốn việc hay dùng: validate (mã đơn hàng, email có đúng dạng không), tìm kiếm (dòng log có ERROR và mã PAY-\d+), parse (tách timestamp, user id, voucher id khỏi dòng log), biến đổi (đổi 2023-09-12 thành 12/09/2023 trên cả file).
Java (java.util.regex), JavaScript, PCRE (PHP, Nginx), Python re, POSIX (grep, sed), RE2 (Go) khác nhau ở những chỗ như: có lookbehind không, \w có gồm chữ có dấu không, $ có khớp trước \n cuối chuỗi không, có possessive quantifier không. Mỗi biến thể gọi là một flavor. Trên regex101, chọn flavor của nơi regex sẽ chạy.
2. Cú pháp cốt lõi
Ý chính: regex ghép từ vài viên gạch: lớp ký tự (khớp một ký tự), quantifier (lặp), anchor và lookaround (khớp một vị trí, không ăn ký tự), group (gom và nhớ), flag (đổi nghĩa vài ký hiệu).
2.1. Ký tự, escape và lớp ký tự
Ký tự thường khớp chính nó: car khớp “car”. Metacharacter (ký tự có nghĩa đặc biệt) . ^ $ * + ? ( ) [ ] { } | \ phải escape bằng \ để khớp nghĩa đen: \. là dấu chấm.
Lớp ký tự [...] khớp một ký tự thuộc tập:
| Cú pháp | Ý nghĩa | Ví dụ khớp |
|---|---|---|
[abc] |
một trong a, b, c (như a|b|c nhưng gọn và nhanh hơn) |
b |
[a-z], [0-9], [a-zA-Z0-9] |
một ký tự trong khoảng | q, 7 |
[^abc] |
một ký tự không thuộc tập (phủ định) | x, 1 |
[a-z.] |
trong lớp ký tự, . là dấu chấm thật, không cần escape |
. |
Slide gọi [abc] là “optional item”; tên đúng là character class. ^ ở đầu pattern là anchor, ở đầu lớp ký tự là phủ định.
2.2. Shorthand class và dấu chấm
| Shorthand | Mặc định trong Java | Phủ định |
|---|---|---|
\d |
[0-9] |
\D |
\w |
[a-zA-Z_0-9] |
\W |
\s |
[ \t\n\x0B\f\r] |
\S |
\h |
khoảng trắng ngang (space, tab, …) | \H |
\R |
một xuống dòng bất kỳ: \n, \r\n, \r, … |
|
. |
mọi ký tự trừ ký tự xuống dòng |
2.3. Quantifier
| Quantifier | Ý nghĩa |
|---|---|
* |
0 lần trở lên |
+ |
1 lần trở lên |
? |
0 hoặc 1 lần |
{n} |
đúng n lần |
{n,} |
ít nhất n lần |
{n,m} |
từ n đến m lần |
Quantifier áp lên phần tử ngay trước nó: ab+ là a rồi nhiều b, (ab)+ là nhiều cặp ab. Mặc định là greedy (ăn nhiều nhất rồi nhả dần); thêm ? thành lazy (*?, +?), thêm + thành possessive (*+, ++). Ba kiểu khác nhau thế nào bên trong engine là nội dung chính của bài 3.
2.4. Anchor và word boundary
Anchor khớp một vị trí, không ăn ký tự nào:
^: đầu chuỗi (đầu mỗi dòng khi bậtMULTILINE).$: cuối chuỗi (cuối mỗi dòng khi bậtMULTILINE). Không bật cờ,$của Java còn khớp ngay trước một\ncuối chuỗi; muốn đúng cuối chuỗi dùng\z.\b: ranh giới từ, một bên là\w, bên kia không.\bcar\bkhớp “car” trong “my car” nhưng không khớp trong “carpet”.
Thiếu anchor là lỗi validate phổ biến nhất: \d{6} dùng với find() “khớp” cả "abc1234567xyz".
2.5. Group, alternation và backreference
(...): capturing group, gom một cụm để áp quantifier hay alternation, và nhớ đoạn khớp (group(1)).(?<name>...): named group, lấy bằnggroup("name"); dễ đọc hơn hẳn khi có từ ba nhóm.(?:...): non-capturing group, chỉ gom, không nhớ.|: alternation, khớp một trong các nhánh. Ưu tiên thấp nhất:^cat|dog$là(^cat)|(dog$), không phải^(cat|dog)$.\1,\k<name>: backreference, khớp lại đúng đoạn text nhóm đã bắt.\b(\w+) \1\btìm từ lặp như “is is”.
2.6. Lookaround
Lookaround kiểm tra điều kiện tại một vị trí mà không ăn ký tự, nên phần được kiểm tra không nằm trong match:
| Cú pháp | Tên | Nghĩa |
|---|---|---|
X(?=Y) |
positive lookahead | X, nếu ngay sau là Y |
X(?!Y) |
negative lookahead | X, nếu ngay sau không phải Y |
(?<=Y)X |
positive lookbehind | X, nếu ngay trước là Y |
(?<!Y)X |
negative lookbehind | X, nếu ngay trước không phải Y |
Ví dụ: \d+(?= VND) trên “Bob added 2000 VND” khớp 2000, không kèm “ VND”; trên “$2000 fly” không khớp gì. Trong Java, lookbehind phải có độ dài tối đa xác định, và kiểu IF-THEN mà slide nhắc tới không tồn tại.
Conditional IF-THEN và lookbehind không giới hạn trong Java
Slide nhắc kiểu IF điều kiện THEN biểu thức: đó là conditional (?(1)then|else), chỉ có ở PCRE, .NET, Python. Java ném PatternSyntaxException: Unknown inline modifier, JavaScript cũng không có. Trong Java, thay bằng alternation hoặc tách thành hai pattern.
2.7. Flag
| Flag (JS) | Java | Inline | Tác dụng |
|---|---|---|---|
i |
CASE_INSENSITIVE |
(?i) |
không phân biệt hoa thường |
m |
MULTILINE |
(?m) |
^, $ khớp ở đầu và cuối mỗi dòng |
s |
DOTALL |
(?s) |
. khớp cả xuống dòng |
g |
(không có) | trả về mọi match thay vì dừng ở match đầu | |
UNICODE_CHARACTER_CLASS |
(?U) |
\w, \d, \b theo Unicode |
|
COMMENTS |
(?x) |
bỏ qua khoảng trắng, cho phép # comment trong pattern |
Cờ g của JavaScript và nhầm lẫn MULTILINE với DOTALL
3. Regex trong Java
Ý chính: compile Pattern một lần rồi dùng lại; tạo Matcher mới cho mỗi lần so khớp. Các method split, replaceAll của String nhận regex chứ không phải text, nên ký tự đặc biệt trong delimiter hay chuỗi thay thế là nguồn bug.
3.1. Pattern và Matcher
Pattern bất biến và thread-safe; Matcher giữ trạng thái của một lần so khớp nên không thread-safe.
private static final Pattern ORDER_ID = Pattern.compile("ORD-(?<year>\\d{4})-(?<seq>\\d{6})");
Matcher m = ORDER_ID.matcher("refund ORD-2026-000123 approved");
if (m.find()) {
String year = m.group("year"); // "2026"
String seq = m.group("seq"); // "000123"
int start = m.start(); // vị trí bắt đầu của match
}
Ba cách so khớp khác nhau ở chỗ phải khớp bao nhiêu phần input:
| Method | Nghĩa | \d+ trên "abc123" |
\d+ trên "123abc" |
|---|---|---|---|
matches() |
toàn bộ input phải khớp | false | false |
lookingAt() |
khớp từ đầu input, không cần hết | false | true |
find() |
tìm match tiếp theo ở bất kỳ đâu | true | true |
matches() tự neo hai đầu nên không cần ^...$; dùng find() để validate thì bắt buộc có anchor. Lấy mọi match thành stream (Java 9+):
List<String> ids = ORDER_ID.matcher(text).results()
.map(r -> r.group(2)) // MatchResult không có group(String) trước Java 20
.toList();
3.2. Thay thế, quote và split
"2023-09-12".replaceAll("(?<y>\\d{4})-(?<m>\\d{2})-(?<d>\\d{2})", "${d}/${m}/${y}"); // "12/09/2023"
Trong chuỗi thay thế, $1 và ${name} là tham chiếu nhóm, \ là ký tự escape.
3.3. Escape trong string literal
Regex nằm trong string literal nên mỗi \ của regex thành \\: \d+\.\d+ viết "\\d+\\.\\d+", còn một dấu \ thật cần "\\\\".
Pattern dài: regex101, text block và cờ COMMENTS
- Copy từ regex101 (flavor Java) và để IDE tự escape khi paste vào string (IntelliJ làm việc này).
- Tách thành nhiều đoạn có tên, hoặc dùng cờ
COMMENTSđể chú thích. - Pattern nhiều dòng đặt trong text block. Text block không bỏ được việc escape
\, chỉ đỡ phải nối chuỗi.
private static final Pattern LOG_LINE = Pattern.compile("""
^(?<ts>\\S+)\\s+ # timestamp ISO-8601
(?<level>INFO|WARN|ERROR)\\s+
(?<pid>\\d+)\\s+
(?<logger>\\w+):\\s
(?<msg>.*)$
""", Pattern.COMMENTS | Pattern.MULTILINE);
Với cờ COMMENTS, khoảng trắng trong pattern bị bỏ qua; khoảng trắng cần khớp thật phải viết \s hoặc \ .
4. “Engine regex của Java không tốt”?
Ý chính: nhận định này sai. java.util.regex là engine backtracking đầy đủ tính năng; cái khác JavaScript là API và cách escape, còn điểm yếu thật (backtracking, không có timeout) thì cả hai cùng có.
Slide khuyên chọn engine JavaScript trên regex101 vì “engine Java chạy không tốt”. Thực ra Java có những thứ JavaScript mới có hoặc chưa có: possessive quantifier, atomic group (?>...), \R, \h, \G, \z, \p{...}, giao và trừ lớp ký tự ([a-z&&[^aeiou]]). regex101 có flavor Java 8: dùng nó.
Bảng khác biệt thật giữa Java và JavaScript
Đây là nguồn gốc của cảm giác “Java không chạy”:
| Chủ đề | Java | JavaScript |
|---|---|---|
| Lấy mọi match | vòng lặp find(), results() |
cờ g, matchAll |
| Validate | matches() tự neo cả chuỗi |
phải tự viết ^...$ |
| Escape | \\ trong string literal |
/\d/ viết thẳng |
| Lookbehind | độ dài tối đa phải xác định | cho độ dài tuỳ ý |
\w, \d |
ASCII, trừ khi bật (?U) |
ASCII, cờ u không đổi \w |
| Possessive, atomic | có | không có possessive; atomic chưa phổ biến |
| Tham chiếu nhóm khi thay thế | $1, ${name} |
$1, $<name> |
Điểm yếu thật của Java (và của JavaScript, PCRE, Python): chúng đều là engine backtracking (thử một nhánh, sai thì lùi lại thử nhánh khác), nên vài pattern chạy rất lâu trên input xấu, và Java không có timeout sẵn. Đó là chủ đề của bài 3 và bài 4.
Bài tập
Mọi lời giải đã chạy trên JDK 21 (java Exercises.java); output ghi trong lời giải.
Bài 1: Tìm tên file ảnh
Cho danh sách tên file, mỗi dòng một tên (.git, students.json, flowers.jpg, deers.png, index.html, river.jpeg, db.sql). Tìm những tên là file ảnh.
Lời giải Bài 1
static final Pattern IMAGE = Pattern.compile(
"^[^/\\s]+\\.(?:jpe?g|png|gif|webp)$",
Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
IMAGE.matcher(files).results().map(MatchResult::group).toList();
// [flowers.jpg, deers.png, river.jpeg]
MULTILINEđể^và$neo theo từng dòng;CASE_INSENSITIVEđể nhận cảPHOTO.JPG.[^/\s]+thay cho.+: tên file không chứa/hay khoảng trắng. Lớp phủ định nói rõ cái gì không được phép, và không bao giờ vượt qua ranh giới dòng.jpe?ggộpjpgvàjpeg. Phần đuôi đặt trong(?:...)vì chỉ cần gom, không cần lấy ra.- Kiểm tra đuôi file không chứng minh được file là ảnh. Khi nhận upload, đọc magic bytes hoặc dùng thư viện như Apache Tika.
Bài 2: Tìm số
Mỗi dòng một chuỗi: 1, 123, 1234.56, 57890, 1,234.78, 1234A56. Tìm các dòng là số hợp lệ, gồm số nguyên, số thập phân, và số có dấu phẩy ngăn cách hàng nghìn; loại 1234A56.
Lời giải Bài 2
static final Pattern NUMBER = Pattern.compile(
"^(?:\\d{1,3}(?:,\\d{3})+|\\d+)(?:\\.\\d+)?$", Pattern.MULTILINE);
// [1, 123, 1234.56, 57890, 1,234.78]
Phần nguyên có hai nhánh: có dấu phẩy thì phải đúng nhóm ba chữ số (1,234, 12,345,678, không nhận 12,34), không có dấu phẩy thì \d+. Phần thập phân (?:\.\d+)? là tuỳ chọn. Anchor hai đầu là thứ loại 1234A56: bỏ anchor thì find() sẽ khớp 1234 bên trong nó.
Trong code thật, đừng dừng ở regex: sau khi validate, parse bằng new BigDecimal(s.replace(",", "")). Dấu phẩy và dấu chấm còn phụ thuộc locale (người Việt và người Đức viết 1.234,78); dữ liệu đa locale thì dùng NumberFormat theo locale đó.
Bài 3: Validate email
Khớp hoanghai34@gmail.com, re123@ronin-engineer.com, abc.65@example.com, tree@earth.solar.uni; không khớp admin@, deer@forest, @ronin.dev, a%v@example.com.
Lời giải Bài 3
static final Pattern EMAIL = Pattern.compile(
"^[A-Za-z0-9._-]+@[A-Za-z0-9-]+(?:\\.[A-Za-z0-9-]+)*\\.[A-Za-z]{2,}$");
// 4 địa chỉ đầu: true; 4 địa chỉ sau: false
- Local part: chữ, số,
.,_,-, ít nhất một ký tự (loại@ronin.dev). - Domain: các label nối bằng dấu chấm, bắt buộc có một TLD từ hai chữ cái trở lên (loại
deer@forestvàadmin@).
Ghi nhớ
- Giải thích được vì sao
.không khớp\n, vàMULTILINEkhácDOTALLở đâu. - Biết khi nào dùng
matches(),find(),lookingAt(), và vì sao validate bằngfind()phải có anchor. - Kể được ba bẫy của
String:split("."),$trong chuỗi thay thế củareplaceAll, compile lại pattern mỗi lần gọi. - Phản biện được câu “engine Java không tốt” và nói được điểm yếu thật là gì.
- Biết cách validate email thực tế: regex lỏng cộng email xác nhận.
Câu hỏi phỏng vấn
Junior
matches(), find() và lookingAt() khác nhau thế nào?
matches() đòi toàn bộ input khớp, lookingAt() đòi khớp từ đầu input, find() tìm match tiếp theo ở bất kỳ đâu.
matches() tự neo hai đầu; lookingAt() không cần khớp đến cuối; find() gọi lặp để lấy các match kế tiếp. Validate dùng matches(); tìm hoặc trích xuất dùng find() hay results(). Dùng find() để validate mà quên ^...$ là bug kinh điển: \d{6} sẽ chấp nhận "abc1234567".
Vì sao "a.b.c".split(".") trả về mảng rỗng?
Vì tham số của split là regex, và . khớp mọi ký tự.
Mọi ký tự đều là delimiter nên mọi phần tử đều rỗng, và split bỏ chuỗi rỗng ở cuối, còn lại mảng rỗng. Sửa: split("\\.") hoặc split(Pattern.quote(".")). Cùng loại bẫy: |, $, +, *.
Capturing group, non-capturing group và named group dùng khi nào?
(...) khi cần lấy lại đoạn khớp, (?:...) khi chỉ cần gom, (?<name>...) khi pattern có nhiều nhóm.
(...) vừa gom vừa nhớ đoạn khớp để lấy ra (group(1)) hoặc tham chiếu lại (\1, $1). (?:...) chỉ gom, dùng khi cần áp quantifier hay alternation cho một cụm. (?<name>...) lấy bằng group("name"), thay thế bằng ${name}; thêm nhóm mới không làm lệch số thứ tự của các nhóm đã có.
^ và $ nghĩa là gì, và cờ MULTILINE thay đổi gì?
Mặc định ^ là đầu input, $ là cuối input; với MULTILINE, chúng khớp ở đầu và cuối mỗi dòng.
Trong Java, $ còn khớp trước một \n cuối cùng; dùng \z cho “đúng cuối”. MULTILINE không làm . khớp xuống dòng; việc đó là của DOTALL.
Mid
Lookahead và lookbehind là gì? Cho một ví dụ cần đến chúng.
Lookaround kiểm tra một điều kiện tại vị trí hiện tại mà không ăn ký tự, nên phần được kiểm tra không nằm trong match.
Ví dụ: lấy số hộ chiếu khi số hộ chiếu và số căn cước cùng định dạng 8 chữ số: (?<=passport (?:number|no): )\d{8}. Ví dụ khác: mật khẩu có ít nhất một chữ số: ^(?=.*\d).{8,}$. Trong Java, lookbehind phải có độ dài tối đa xác định được; khi có thể, một capturing group thường đơn giản và portable hơn.
Vì sao replaceAll với chuỗi thay thế đến từ người dùng có thể ném exception?
Vì trong chuỗi thay thế, $n là tham chiếu nhóm và \ là ký tự escape; bọc giá trị bằng Matcher.quoteReplacement.
Giá trị như "$5" hay "C:\path" sẽ ném IndexOutOfBoundsException hoặc IllegalArgumentException, hoặc âm thầm ra kết quả sai. Không cần regex thì dùng String.replace. Chiều ngược lại: khi đưa text của người dùng vào pattern, bọc bằng Pattern.quote để ký tự đặc biệt không thành cú pháp regex.
Pattern có thread-safe không? Nên khai báo thế nào?
Có: Pattern bất biến, nên khai báo private static final Pattern X = Pattern.compile(...) và dùng chung; Matcher thì không thread-safe.
Tạo Matcher mới cho mỗi lần dùng bằng X.matcher(input), việc này rẻ. String.matches, replaceAll, split (trừ đường tắt một ký tự) compile lại pattern mỗi lần gọi, nên tránh dùng trên đường xử lý nóng.
Validate email bằng regex: bạn làm thế nào?
Không viết regex “đúng RFC”; dùng kiểm tra lỏng rồi gửi email xác nhận.
Regex đúng RFC rất dài, các RFC còn lệch nhau, và không chứng minh được hộp thư tồn tại. Mình dùng kiểm tra lỏng (một @, domain có dấu chấm, giới hạn độ dài, hoặc @Email của Bean Validation), chuẩn hoá (trim, lowercase phần domain), rồi gửi email xác nhận. Không chặn ký tự hợp lệ như +, vì người dùng thật hay dùng me+tag@gmail.com.
Senior
Một đồng nghiệp nói “engine regex của Java không tốt, cứ dùng JavaScript trên regex101”. Bạn phản hồi thế nào?
Engine Java không kém; khác biệt nằm ở API và cách escape, nên thử trên flavor JavaScript rồi copy sang Java chính là cách sinh bug.
java.util.regex có nhiều tính năng (possessive, atomic group, lớp Unicode, \R, giao lớp ký tự); khác JavaScript ở API (không có cờ g, matches() tự neo), escape trong string literal, và giới hạn lookbehind. Nên thử trên flavor Java 8 của regex101 và khoá hành vi bằng unit test. Điểm yếu thật là backtracking: có pattern chạy theo thời gian mũ hoặc đa thức bậc cao, và Java không có timeout sẵn. JavaScript, Python, PCRE cũng vậy, nên đổi flavor không giải quyết được; cần thiết kế pattern cẩn thận, giới hạn độ dài input, hoặc dùng engine thời gian tuyến tính như RE2/J.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu tiếng Anh dùng trong phỏng vấn |
|---|---|---|---|
| regular expression | /ˈreɡjələr ɪkˈspreʃn/ | biểu thức chính quy | “A regular expression describes the shape of a string, not its meaning.” |
| flavor | /ˈfleɪvər/ | biến thể cú pháp của một engine | “Always test the pattern in the same flavor that runs in production.” |
| character class | /ˈkærəktər klæs/ | lớp ký tự [...] |
“A negated character class is safer than a dot here.” |
| quantifier | /ˈkwɒntɪfaɪər/ | bộ đếm số lần lặp | “The quantifier applies only to the token right before it.” |
| anchor | /ˈæŋkər/ | neo vị trí (^, $, \b) |
“Without anchors, find() accepts any string that merely contains a match.” |
| word boundary | /wɜːrd ˈbaʊndri/ | ranh giới từ | “I added word boundaries so that car no longer matches inside carpet.” |
| capturing group | /ˈkæptʃərɪŋ ɡruːp/ | nhóm bắt | “Named capturing groups make the extraction code self-documenting.” |
| backreference | /ˈbækˌrefrəns/ | tham chiếu lại nhóm | “A backreference matches the same text, so it needs anchors to compare whole lines.” |
| lookahead / lookbehind | /ˈlʊkəhed/ /ˈlʊkbɪhaɪnd/ | kiểm tra phía sau / phía trước | “Lookbehind asserts the label without including it in the match.” |
| greedy / lazy | /ˈɡriːdi/ /ˈleɪzi/ | tham / lười | “The greedy dot swallowed both quoted values; the lazy version stopped at the first quote.” |
| escape | /ɪˈskeɪp/ | thoát ký tự đặc biệt | “Use Pattern.quote when the delimiter comes from configuration.” |
| replacement string | /rɪˈpleɪsmənt strɪŋ/ | chuỗi thay thế | “Dollar signs in the replacement string are group references.” |
Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.