Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Java CoreMid20 phút đọc

Regex: cú pháp, Java API và các bài tập validate cơ bản

Ôn 19 thẻ
Trong bài này

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ật MULTILINE).
  • $: cuối chuỗi (cuối mỗi dòng khi bật MULTILINE). Không bật cờ, $ của Java còn khớp ngay trước một \n cuố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\b khớ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ằng group("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\b tì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?g gộp jpg và 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@forest và admin@).

Ghi nhớ

  • Giải thích được vì sao . không khớp \n, và MULTILINE khác DOTALL ở đâu.
  • Biết khi nào dùng matches(), find(), lookingAt(), và vì sao validate bằng find() phải có anchor.
  • Kể được ba bẫy của String: split("."), $ trong chuỗi thay thế của replaceAll, 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.