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

Công cụ tạo và kiểm tra regex trực tuyến mạnh mẽ với trình xây dựng mẫu trực quan. Tạo, kiểm tra và debug biểu thức chính quy với phản hồi tức thì. Bao gồm thư viện mẫu toàn diện, chèn thành phần nhanh, highlight cú pháp, trực quan hóa kết quả khớp, và tạo code cho JavaScript, Python, PHP, Java, Ruby và Go.

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

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ý