Tạo Regex

Tạo Regex - Trình Xây Dựng và Kiểm Tra Biểu Thức Chính Quy Trực Quan

Biểu thức chính quy là ngôn ngữ phổ quát của khớp mẫu, được phát minh bởi nhà toán học Stephen Kleene năm 1951 và được nhúng vào hầu hết mọi công cụ xử lý văn bản từng được viết — grep, sed, awk, thư viện chuỗi của mọi ngôn ngữ lập trình hiện đại, mọi cơ sở dữ liệu có mệnh đề LIKE, mọi framework kiểm tra biểu mẫu, mọi công cụ tìm-và-thay-thế của trình soạn thảo code. Trình xây dựng này loại bỏ hai vấn đề chính khi viết regex bằng tay: quên cú pháp chính xác cho lớp ký tự/định lượng/neo, và không bao giờ chắc chắn mẫu của bạn thực sự làm gì cho đến khi test với chuỗi thực. Thư viện cung cấp 12 mẫu sẵn sàng cho production bao phủ 80% trường hợp (email RFC 5322, URL HTTP/HTTPS, số điện thoại US/quốc tế, IPv4, ngày ISO, giờ 24h, tên người dùng, mật khẩu mạnh, màu hex, thẻ tín dụng, ZIP US, thẻ HTML). Các Thành Phần Nhanh cho phép nhấp để chèn \d \w \s . ^ $ \b * + ? () [] | {n} {n,m} vào mẫu tại vị trí con trỏ — không cần ghi nhớ cú pháp. Tester trực tiếp chạy mẫu so với đầu vào khi bạn gõ, highlight kết quả khớp, hiển thị nhóm đã bắt, và tạo giải thích bằng tiếng Việt rõ ràng cho từng thành phần. Khi hài lòng, nút Tạo Code xuất ra đoạn mã đúng chuẩn cho JavaScript, Python (module re), PHP (preg_match), Java (Pattern/Matcher), Ruby và Go (gói regexp) — dán thẳng vào dự án.

Biểu Thức Chính Quy là gì?

**Biểu Thức Chính Quy (Regex)** là công cụ khớp mẫu mạnh mẽ dùng để tìm kiếm, kiểm tra và xử lý văn bản.

**Ứng Dụng Phổ Biến:**

1. **Kiểm Tra:**
• Địa chỉ email
• Số điện thoại
• Mật khẩu
• URL
• Thẻ tín dụng

2. **Xử Lý Văn Bản:**
• Tìm và thay thế
• Trích xuất dữ liệu
• Phân tích log
• Làm sạch văn bản

3. **Kiểm Tra Dữ Liệu:**
• Input form
• Tham số API
• Định dạng file
• File cấu hình

**Cú Pháp Cơ Bản:**

• **Chữ Thường:** Khớp ký tự chính xác
- `abc` khớp "abc"

• **Lớp Ký Tự:**
- `\d` = chữ số (0-9)
- `\w` = ký tự từ (a-z, A-Z, 0-9, _)
- `\s` = khoảng trắng
- `.` = bất kỳ ký tự nào

• **Bộ Định Lượng:**
- `*` = 0 hoặc nhiều
- `+` = 1 hoặc nhiều
- `?` = 0 hoặc 1 (tùy chọn)
- `{n}` = chính xác n lần
- `{n,m}` = từ n đến m lần

• **Điểm Neo:**
- `^` = đầu dòng
- `$` = cuối dòng
- `\b` = ranh giới từ

• **Nhóm:**
- `(...)` = nhóm bắt
- `(?:...)` = nhóm không bắt

• **Tập Ký Tự:**
- `[abc]` = khớp a, b, hoặc c
- `[a-z]` = khớp chữ thường bất kỳ
- `[^abc]` = khớp bất kỳ ngoại trừ a, b, c

**Ví Dụ:**

```regex
# Kiểm tra email
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

# Số điện thoại (US)
^\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})$

# URL
^https?:\/\/[\w\-]+(\.[\w\-]+)+[/#?]?.*$

# Mật khẩu mạnh
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
```

Cách dùng công cụ Tạo Regex này?

**Hướng Dẫn Từng Bước:**

**1. Chọn Điểm Bắt Đầu:**

**Tùy Chọn A - Thư Viện Mẫu:**
• Duyệt mẫu phổ biến (email, URL, phone, v.v.)
• Nhấp mẫu để tải
• Chỉnh sửa theo nhu cầu

**Tùy Chọn B - Xây Dựng Từ Đầu:**
• Gõ mẫu trực tiếp vào ô nhập
• Dùng Thành Phần Nhanh để chèn cú pháp
• Nhấp thành phần để thêm tại con trỏ

**2. Đặt Cờ:**

• **g (Toàn Cục):** Tìm tất cả kết quả, không chỉ đầu tiên
• **i (Không Phân Biệt Hoa Thường):** Bỏ qua hoa thường (A = a)
• **m (Nhiều Dòng):** ^ và $ khớp ngắt dòng
• **s (Dấu Chấm Tất Cả):** . khớp xuống dòng

**3. Kiểm Tra Mẫu:**

• Nhập văn bản test vào vùng Đầu Vào Kiểm Tra
• Nhấp "Kiểm Tra Mẫu"
• Xem kết quả được highlight thời gian thực
• Xem số lượng và vị trí khớp
• Kiểm tra nhóm đã bắt

**4. Hiểu Mẫu Của Bạn:**

• Nhấp "Giải Thích Mẫu"
• Xem phân tích từng thành phần
• Học ý nghĩa từng ký hiệu
• Hiểu cấu trúc mẫu

**5. Tạo Code:**

• Nhấp "Tạo Code"
• Nhận code sẵn sàng dùng trong:
- JavaScript
- Python
- PHP
- Java
- Ruby
- Go
• Sao chép vào dự án

**Mẹo:**

✓ Bắt đầu với ví dụ từ thư viện mẫu
✓ Kiểm tra với nhiều biến thể input
✓ Dùng Giải Thích để học cú pháp
✓ Test các trường hợp biên
✓ Giữ mẫu đơn giản khi có thể
✓ Dùng nhóm không bắt (?:) cho hiệu năng
✓ Escape ký tự đặc biệt: \. \* \+ \? v.v.

Mẫu Regex Phổ Biến và Trường Hợp Sử Dụng

**Mẫu Kiểm Tra:**

**1. Địa Chỉ Email:**
```regex
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
```
• Kiểm tra email cơ bản
• Cho phép ký tự đặc biệt thông dụng
• Yêu cầu @ và đuôi domain

**2. URL (HTTP/HTTPS):**
```regex
^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/\/=]*)$
```
• Khớp URL web
• Tiền tố www tùy chọn
• Hỗ trợ query string và anchor

**3. Số Điện Thoại:**
```regex
# Định dạng US
^\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})$

# Quốc tế
^\+?[1-9]\d{1,14}$
```

**4. Mật Khẩu Mạnh:**
```regex
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
```
• Tối thiểu 8 ký tự
• Ít nhất một chữ hoa
• Ít nhất một chữ thường
• Ít nhất một chữ số
• Ít nhất một ký tự đặc biệt

**Trích Xuất Dữ Liệu:**

**5. Định Dạng Ngày:**
```regex
# YYYY-MM-DD (ISO)
^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])$

# MM/DD/YYYY
^(?:0[1-9]|1[0-2])\/(?:0[1-9]|[12][0-9]|3[01])\/\d{4}$

# DD-MM-YYYY
^(?:0[1-9]|[12][0-9]|3[01])-(?:0[1-9]|1[0-2])-\d{4}$
```

**6. Địa Chỉ IP:**
```regex
# IPv4
^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

# IPv6 (đơn giản)
^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$
```

**7. Thẻ Tín Dụng:**
```regex
# Visa, MasterCard, Amex, Discover
^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9][0-9])[0-9]{12})$
```

**Xử Lý Văn Bản:**

**8. Trích Hashtag:**
```regex
#[a-zA-Z0-9_]+
```

**9. Trích Mention:**
```regex
@[a-zA-Z0-9_]+
```

**10. Thẻ HTML:**
```regex
<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)
```

**11. Xóa Khoảng Trắng Thừa:**
```regex
\s+
# Thay bằng khoảng trắng đơn
```

**Mẫu Code:**

**12. Biến JavaScript:**
```regex
(var|let|const)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=
```

**13. Mã Màu Hex:**
```regex
^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$
```

**14. Đuôi File:**
```regex
\.(jpg|jpeg|png|gif|pdf|doc|docx)$
```

**Mẹo:**

• Test mẫu với các trường hợp biên
• Dùng regex tester online để debug
• Cân nhắc hiệu năng cho văn bản lớn
• Đơn giản thường tốt hơn
• Ghi chú mẫu phức tạp

Giải Thích Cờ Regex

**Cờ Biểu Thức Chính Quy:**

Cờ thay đổi cách engine regex xử lý mẫu.

**1. Cờ Toàn Cục (g):**

```javascript
const text = 'cat bat rat';
const regex1 = /at/; // Không toàn cục
const regex2 = /at/g; // Toàn cục

text.match(regex1); // ['at'] - chỉ kết quả đầu
text.match(regex2); // ['at', 'at', 'at'] - tất cả
```

**Dùng khi:**
• Tìm tất cả xuất hiện
• Thay tất cả instance
• Đếm kết quả

**2. Cờ Không Phân Biệt Hoa Thường (i):**

```javascript
const regex1 = /hello/; // Phân biệt hoa thường
const regex2 = /hello/i; // Không phân biệt

regex1.test('Hello'); // false
regex2.test('Hello'); // true
regex2.test('HELLO'); // true
```

**Dùng khi:**
• Kiểm tra input người dùng
• Tìm kiếm không phân biệt hoa thường
• Khớp linh hoạt

**3. Cờ Nhiều Dòng (m):**

```javascript
const text = `line 1
line 2
line 3`;

const regex1 = /^line/; // Khớp đầu string
const regex2 = /^line/m; // Khớp đầu mỗi dòng

text.match(regex1); // ['line'] - một kết quả
text.match(regex2); // ['line', 'line', 'line'] - ba kết quả
```

**Hiệu Ứng:**
• `^` khớp đầu mỗi dòng (không chỉ string)
• `$` khớp cuối mỗi dòng (không chỉ string)

**Dùng khi:**
• Xử lý văn bản nhiều dòng
• Kiểm tra từng dòng
• Phân tích file log

**4. Cờ Dấu Chấm Tất Cả (s):**

```javascript
const text = 'hello\nworld';

const regex1 = /hello.world/; // . không khớp \n
const regex2 = /hello.world/s; // . khớp tất cả

regex1.test(text); // false
regex2.test(text); // true
```

**Hiệu Ứng:**
• `.` khớp ký tự xuống dòng
• Thường `.` khớp mọi thứ ngoại trừ `\n`

**Dùng khi:**
• Khớp qua các dòng
• Phân tích HTML/XML
• Trích xuất nội dung nhiều dòng

**Kết Hợp Cờ:**

```javascript
// Nhiều cờ cùng lúc
const regex = /pattern/gim;
// g = toàn cục
// i = không phân biệt hoa thường
// m = nhiều dòng

// Kết hợp phổ biến:
/email/gi // Tìm tất cả email, bất kỳ hoa thường
/^error/gim // Tìm tất cả dòng bắt đầu "error", bất kỳ hoa thường
/.*?/gs // Khớp mọi thứ qua dòng, lazy
```

**Thực Hành Tốt:**

✓ Chỉ dùng cờ cần thiết
✓ Cờ toàn cục cho replace/count
✓ Không phân biệt hoa thường cho input người dùng
✓ Nhiều dòng cho xử lý văn bản
✓ Test có và không có cờ
✓ Ghi chú việc dùng cờ trong code

Tại sao regex của tôi khớp quá nhiều hoặc quá ít? (Tham lam vs Lười)

Mặc định, mọi bộ định lượng (* + ? {n,m}) trong regex đều THAM LAM (greedy) — nó nắm bắt càng nhiều ký tự càng tốt trong khi vẫn cho phép phần còn lại của mẫu khớp. Cái bẫy kinh điển: với đầu vào '<b>foo</b><i>bar</i>', mẫu '<.*>' trả về toàn bộ chuỗi '<b>foo</b><i>bar</i>' thay vì chỉ '<b>'. Giải pháp là biến bộ định lượng thành LƯỜI (lazy) bằng cách thêm ?: '<.*?>' trả về '<b>' trước, rồi '</b>', rồi '<i>', rồi '</i>' riêng lẻ. Quy tắc: khi phần tiếp theo trong mẫu là ký tự chữ thường (như > đóng), dùng bộ định lượng lười. Khi muốn tiêu thụ mọi thứ đến CUỐI đầu vào, dùng tham lam. Tốt hơn nữa, thay .* bằng lớp ký tự phủ định — '<[^>]*>' nhanh hơn '<.*?>' vì hoàn toàn tránh backtracking. Đây cũng là nguyên nhân #1 của 'backtracking thảm họa' có thể treo engine regex vài giây trên đầu vào 100 ký tự.

Sự khác biệt giữa nhóm bắt, không bắt và nhóm có tên?

Dấu ngoặc trong regex phục vụ ba mục đích khác nhau mà người mới thường nhầm lẫn.

(1) Nhóm bắt: (\d{4}) — khớp VÀ lưu văn bản đã khớp để truy xuất sau qua $1/\1/match.groups[1]. Mỗi cặp ngoặc thường tạo một nhóm được đánh số mới.

(2) Nhóm không bắt: (?:\d{4}) — khớp nhưng KHÔNG lưu kết quả. Dùng nó khi bạn chỉ cần ngoặc để gộp nhóm (ví dụ áp dụng bộ định lượng cho nhiều ký tự, hoặc cho luân phiên như (?:cat|dog)s?). Bỏ qua bắt có hai lợi ích: đầu ra sạch hơn và thực thi nhanh hơn một chút.

(3) Nhóm có tên: (?<year>\d{4}) — bắt và đặt tên có nghĩa cho nhóm. Truy cập qua match.groups.year (JS), m.group('year') (Python) hoặc m['year'] (Ruby). Dùng nhóm có tên khi regex có 3+ nhóm bắt — '$1', '$2', '$3' nhanh chóng trở nên khó đọc, nhưng '${year}-${month}-${day}' tự giải thích. Được hỗ trợ trong JavaScript hiện đại (ES2018+), Python, Perl, PHP, Ruby, .NET.

Tại sao mẫu email trong thư viện không khớp với mọi email hợp lệ?

Bởi vì ngữ pháp đầy đủ RFC 5322 cho email hợp lệ dài hơn 6.000 ký tự regex và không thực tế để sử dụng. Mẫu thư viện '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' là thỏa hiệp thực dụng chuẩn ngành — nó chấp nhận 99%+ địa chỉ thực tế trong khi từ chối những địa chỉ rõ ràng sai định dạng (không có @, không có domain, không có TLD). Điều nó bỏ qua: các mẫu hợp lệ nhưng hiếm như phần cục bộ có dấu nháy ('John Doe'@example.com), domain IP literal (user@[192.168.1.1]), tên miền quốc tế hóa (user@münchen.de) và TLD mới sau 2011. Điều nó cho phép mà về mặt kỹ thuật là không hợp lệ: dấu chấm đầu ('[email protected]') và dấu chấm liên tiếp. Đối với production, cách xác thực email duy nhất thực sự an toàn là gửi email xác nhận — mọi regex chỉ là bước sàng lọc, không phải đảm bảo. Dùng mẫu để từ chối lỗi gõ; xác thực quyền sở hữu qua liên kết nhấp-để-xác-nhận.

Kỹ Thuật Regex Nâng Cao

**1. Lookahead và Lookbehind:**

**Positive Lookahead (?=...)**
```regex
# Khớp 'foo' chỉ khi theo sau bởi 'bar'
foo(?=bar)

# Khớp: 'foo' trong 'foobar'
# Không khớp: 'foo' trong 'foobaz'
```

**Negative Lookahead (?!...)**
```regex
# Khớp 'foo' chỉ khi KHÔNG theo sau bởi 'bar'
foo(?!bar)

# Khớp: 'foo' trong 'foobaz'
# Không khớp: 'foo' trong 'foobar'
```

**Positive Lookbehind (?<=...)**
```regex
# Khớp 'bar' chỉ khi đứng sau 'foo'
(?<=foo)bar

# Khớp: 'bar' trong 'foobar'
# Không khớp: 'bar' trong 'bazbar'
```

**Negative Lookbehind (?<!...)**
```regex
# Khớp 'bar' chỉ khi KHÔNG đứng sau 'foo'
(?<!foo)bar

# Khớp: 'bar' trong 'bazbar'
# Không khớp: 'bar' trong 'foobar'
```

**2. Nhóm Bắt:**

```regex
# Trích xuất phần của ngày
(\d{4})-(\d{2})-(\d{2})

# Khớp: '2025-01-15'
# Nhóm 1: '2025' (năm)
# Nhóm 2: '01' (tháng)
# Nhóm 3: '15' (ngày)
```

**Nhóm Bắt Có Tên:**
```regex
(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})

# Truy cập bằng tên trong code:
# match.groups.year
# match.groups.month
# match.groups.day
```

**Nhóm Không Bắt (?:...)**
```regex
# Nhóm cho luân phiên, nhưng không bắt
(?:cat|dog)s?

# Khớp: cat, cats, dog, dogs
# Không tạo nhóm bắt
# Hiệu năng tốt hơn
```

**3. Backreference:**

```regex
# Khớp từ lặp
\b(\w+)\s+\1\b

# Khớp: 'the the', 'hello hello'
# \1 tham chiếu nhóm bắt đầu tiên
```

**Khớp Thẻ HTML:**
```regex
# Khớp thẻ mở và đóng
<([a-z]+)>.*?<\/\1>

# Khớp: <div>content</div>
# Không khớp: <div>content</span>
```

**4. Bộ Định Lượng Tham Lam vs Lười:**

**Tham Lam (mặc định):**
```regex
# Khớp nhiều nhất có thể
<.*>

# Trong: '<div>Hello</div> <span>World</span>'
# Khớp: '<div>Hello</div> <span>World</span>' (toàn bộ)
```

**Lười (thêm ?):**
```regex
# Khớp ít nhất có thể
<.*?>

# Trong: '<div>Hello</div> <span>World</span>'
# Khớp: '<div>', '</div>', '<span>', '</span>' (riêng lẻ)
```

**Bộ định lượng lười:**
• `*?` = 0 hoặc nhiều (lười)
• `+?` = 1 hoặc nhiều (lười)
• `??` = 0 hoặc 1 (lười)
• `{n,m}?` = n đến m (lười)

**Mẹo Hiệu Năng:**

✓ Dùng nhóm không bắt (?:) khi không cần bắt
✓ Cụ thể hóa (tránh .* khi có thể)
✓ Dùng nhóm atomic để tránh backtracking
✓ Neo mẫu khi có thể (^, $, \b)
✓ Test với input lớn
✓ Tránh định lượng lồng nhau
✓ Dùng lớp ký tự [abc] thay vì (a|b|c)

**Lỗi Thường Gặp:**

❌ Backtracking thảm họa: `(a+)+b`
❌ Quá tham lam: `.*` khớp quá nhiều
❌ Thiếu neo: khớp một phần
❌ Quên escape: `. * + ? [ ] ( ) { } ^ $ | \`
❌ Không test trường hợp biên

Tính Năng Chính

• Giao diện xây dựng mẫu trực quan
• Thư viện mẫu toàn diện
• Mẫu regex phổ biến (email, URL, phone, v.v.)
• Chèn thành phần nhanh
• Kiểm tra mẫu thời gian thực
• Highlight và trực quan hóa kết quả
• Hiển thị nhóm đã bắt
• Số lượng và vị trí kết quả
• Tạo giải thích mẫu
• Phân tích từng thành phần
• Hỗ trợ cờ regex (g, i, m, s)
• Tạo code đa ngôn ngữ
• Output code JavaScript
• Output code Python
• Output code PHP
• Output code Java
• Output code Ruby
• Output code Go
• Highlight cú pháp
• Sao chép vào clipboard
• Tải xuống dưới dạng file code
• Không gửi dữ liệu đến server
• Hoạt động offline
• Giao diện thân thiện mobile
• Hỗ trợ dark mode
• 100% miễn phí
• Không cần đăng ký