Cơ bản về regular expression trong C# docx

CƠ BẢN VỀ REGULAR EXPRESSION TRONG C#
1. Giới thiệu:
RE là một ngôn ngữ cực mạnh dùng mô tả văn bản cũng như thao tác trên văn bản. Một RE thường được
ứng dụng lên một chuỗi, nghĩa là lên một nhóm ký tự.
Chẳng hạn, ta có chuỗi sau:
Mot, Hai, Ba, Bon, NEVERLAND.
Bạn có thể trả về bất cứ hoặc tất cả các chuỗi con của nó (Hai hoặc Bon chẳng hạn) hoặc thay đổi phiên
bản của những chuỗi con của nó (Mot hoặc BoN chẳng hạn).
Một RE là một kiểu mẫu văn bản gồm 2 phần: literal (trực kiện) và metacharacters (ký tự siêu).
• Một literal đơn thuần chỉ là một ký tự (a-z) mà bạn muốn đem so khớp với chuỗi đích.
• Metacharacters là một ký tự đặc biệt hoạt động như là 1 mệnh lệnh đối với bộ phận phân tích
ngữ nghĩa (parser) của RE
Bây giờ chúng ta thử tạo một regular expression như sau:
Code:
^(From|To|Subject|Date):
RE này sẽ khớp với bất cứ chuỗi con nào miễn là chuỗi này là một hàng mới bắt đầu với “From” hoặc
“To” hoặc các chữ “Subject” hoặc “Date” (Dấu ^ nghĩa là bắt đầu 1 hàng mới) chuỗi này kết thúc bởi dấu
hai chấm (:).
Dấu ^ cho bộ parser của RE biết chuỗi mà ban đang truy tìm phải bắt đầu bởi một hàng mới. Các chữ
“From”, “To”, là những literal, và những metacharacter “(“, “)”, và “|” được dùng để tạo nhóm literal và
cho biết bất cứ những lựa chọn nào cũng phải khớp. Dấu ^ cũng là metacharacter, nó cho biết là khởi
đầu 1 hàng. Do đó, bạn đọc hàng sau đây:
Code:
^(From|To|Subject|Date):
Như sau: “cho khớp bất cứ chuỗi con nào bắt đầu bởi một hàng mới theo sau bởi bất cứ 4
chuỗi literal: From,To,Subject và Date rồi theo sau bởi dấu hai chấm”
2. Các ký tự siêu thường dùng (vô cùng quan trọng cần phải nắm)
. : đại diện cho 1 ký tự bất kỳ trừ ký tự xuống dòng \n.
\d : ký tự chữ số tương đương [0-9]
\D : ký tự ko phải chữ số
\s : ký tự khoảng trắng tương đương [ \f\n\r\t\v]

\S : ký tự không phải khoảng trắng tương đương [ ^\f\n\r\t\v]
\w : ký tự word (gồm chữ cái và chữ số, dấu gạch dưới _ ) tương đương [a-zA-Z_0-9]
\W : ký tự không phải ký tự word tương đương [^a-zA-Z_0-9]
^ : bắt đầu 1 chuỗi hay 1 dòng
$ : kết thúc 1 chuỗi hay 1 dòng
\A : bắt đầu 1 chuỗi
\z : kết thúc 1 chuỗi
| : ký tự ngăn cách so trùng tương đương với phép or (lưu ý cái này nếu muốn kết hợp nhiều điều kiện)
[abc] : khớp với 1 ký tự nằm trong nhóm là a hay b hay c.
[a-z] so trùng với 1 ký tự nằm trong phạm vi a-z, dùng dấu - làm dấu ngăn cách.
[^abc] sẽ không so trùng với 1 ký tự nằm trong nhóm, ví dụ không so trùng với a hay b hay c.
() : Xác định 1 group (biểu thức con) xem như nó là một yếu tố đơn lẻ trong pattern .ví dụ ((a(b))c) sẽ
khớp với b, ab, abc.
? : khớp với đứng trước từ 0 hay 1 lần. Ví dụ A?B sẽ khớp với B hay AB.
* : khớp với đứng trước từ 0 lần trở lên . A*B khớp với B, AB, AAB
+ : khớp với đứng trước từ 1 lần trở lên. A+B khớp với AB, AAB.
{n} : n là con số, Khớp đúng với n ký tự đúng trước nó . Ví dụ A{2}) khớp đúng với 2 chữ A.
{n, } : khớp đúng với n ký tự trở lên đứng trước nó , A{2,} khớp vói AA, AAA
{m,n} : khớp đùng với từ m->n ký tự đứng trước nó, A{2,4} khớp vói AA,AAA,AAAA.
3. Các lớp để thao tác với Regular Expression trong .NET:
.NET cung cấp một cách tiếp cận hướng đối tượng về việc so khớp chuỗi và thay thế theo RE.
System.Text.RegularExpression là namespace trên thư viện các lớp chuẩn của .NET liên quan đến tất cả
các đối tượng gắn liền với RE. Sau đây mình xin giới thiệu sơ lược về các lớp này:
1.Regex:
Lớp Regex tượng trưng cho 1 regular expression bất di bất dịch (read-only). Nó cũng chứa một phương
thức tĩnh (static) cho phép chúng ta sử dụng những lớp rex khác mà khỏi khởi tạo 1 đối tượng khác. Ví
dụ:
Code:
string pattern = @"\s2000";
Regex myRegex = new Regex(pattern);

Sau đây, mình sẽ kể ra vài thành phần của lớp Regex này:
-Thuộc tính:
+Options: trả về những mục chọn được trao qua cho constructor Regex.
+RightToLeft: nhận 1 trị cho biết liệu xem regular expression dò tìm từ phải qua trái hay không
-Phương thức:
+GetGroupNames: trả về mảng gồm toàn tên nhóm thu lượm đối với RE.
+GetGroupNumbers: trả về mảng gồm toàn số nhóm thu lượm tương ứng với tên nhóm trên 1 mảng.
+GroupNameFromNumber: đi lấy tên nhóm tương ứng với số nhóm được khai báo.
+IsMatch: trả về trị bool cho biết liệu xem RE có tìm thấy một so khớp hay không trên pattern.
+Match: dò tìm trên pattern xem có xuất hiện một RE hay không rồi trả về kết quả chính xác như là một
đối tượng Match duy nhất.
+Matches: dò tìm trên pattern xem tất cả các xuất hiện của một RE có hay không rồi trả về tất cả những
so khớp thành công xem như Match được gọi nhiều lần.
+Replace: cho thay thế những xuất hiện của một pattern được định nghĩa bởi một RE bởi một chuỗi ký
tự thay thế được chỉ định.
+Split: chẻ một pattern thành một mảng gồm những chuỗi con ở những vị trí được chỉ định bởi một so
khớp trên RE
+Unescape: cho unescape bất cứ những ký tự nào được escape trên pattern.
Sau đây là ví dụ sử dụng lớp Regex để tách chuỗi qua việc dùng phương thức Split của nó:
Code:
string chuoi = "Mot, Hai, Ba, Bon, NEVERLAND.";
//tạo pattern
//luật: xem chuỗi nào có chứa khoảng trắng hay dấu phẩy
string pattern = " |, ";
Regex myRegex = new Regex(pattern);
string[] sKetQua = myRegex.Split(chuoi);
foreach (string subString in sKetQua)
{
Console.WriteLine(subString);
}

Và đây là kết quả của nó:
Code:
1. Mot
2. Hai
3. Ba
4. Bon
5. NEVERLAND.
Như bạn thấy , phương thức khởi tạo của class Regex sẽ nhận 1 chuỗi pattern làm đối số.
Phương thức Regex.Split() hoạt động cũng giống như String.Split(), trả về 1 mảng chuỗi như là kết
quả việc so khớp pattern của RE trong lòng myRegex.
2.Lớp Match:
Lớp này tượng trưng cho những kết quả duy nhất của một tác vụ so khớp (match) RE. Sau đây mình có
1 ví dụ nhỏ sử dụng phương thức Match của lớp Regex để trả về 1 đối tượng kiểu Match để có thể tìm ra
so khớp đầu tiên trên chuỗi nhập.
Sử dụng thuộc tính Match.Access của lớp Match báo cho biết liệu xem đã tìm ra 1 so khớp hay chưa.
Code:
string chuoi = "123abcd456bdabc";
string pattern = "abc";
Regex myRegex = new Regex(pattern);
Match m = myRegex.Match(chuoi);
if (m.Success)
{
Console.WriteLine("Tim thay chuoi con {0} o vi tri thu {1}
trong chuoi", m.Value, m.Index);
}
else
Console.WriteLine("Khong tim thay chi ca");
Kết quả như sau:
Code:
Tim thay chuoi con abc o vi tri thu 3 trong chuoi

3.Lớp MatchCollection
Lớp này tượng trưng cho 1 loạt những so khớp thành công đè chồng lên nhau tạo thành một tập hợp bất
di bất dịch và lớp này không có phương thức khởi tạo. Nhũng đối tượng MatchCollection sẽ do thuộc
tính Regex.Matches của lớp Regex trả về.
Hiểu nôm na MatchCollection là mảng các đối tượng Match là được.
Ví dụ:
Code:
static void Main(string[] args)
{
//tập hợp chứa những so khớp
MatchCollection mc;
//1 chuỗi thử nghiệm
string chuoi = "I like money, like woman and like C#";
//tạo pattern
string pattern = "like";
//khởi tạo 1 đối tượng của Regex
//truyền chuỗi pattern vào constructor
Regex myRegex = new Regex(pattern);
//dùng phương thức Matches của myRegex
//để tìm ra matches và chỉ mục của từng match
mc = myRegex.Matches(chuoi);
foreach (Match m in mc)
{
Console.WriteLine("Chuoi con '{0}' xuat hien o chi muc {1}",
m.Value, m.Index);
}
}
Ta có kết quả sau:
Code:
Chuoi con 'like' xuat hien o chi muc 2

Chuoi con 'like' xuat hien o chi muc 14
Chuoi con 'like' xuat hien o chi muc 29
Sử dụng Regex Match Collections:
Hai thuộc tính của đối tượng Match là chiều dài và vị trí của nó, mà ta có thể đọc như ví dụ sau:
Code:
static void Main(string[] args)
{
//tập hợp chứa những so khớp
MatchCollection mc;
//1 chuỗi thử nghiệm
string chuoi = "This is a example string.";
//tạo pattern
//luật:cho tìm ra bất cứ những ký tự không phải ký tự khoảng trắng
//rồi theo sau nó là kí tự khoảng trắng
string pattern = @"\S+\s";
//khởi tạo 1 đối tượng của Regex
//truyền chuỗi pattern vào constructor
Regex myRegex = new Regex(pattern);
//dùng phương thức Matches của myRegex
//để tìm ra matches và chỉ mục của từng match
mc = myRegex.Matches(chuoi);
for (int i = 0; i < mc.Count; i++)
{
Console.WriteLine("The match[{0}]: '{1}' co chieu dai la {2}",
i,mc[i].Value, mc[i].Length);
}
Chuỗi \S đi tìm những ký tự không phải khoảng trắng, và dấu + cho biết một hoặc nhiều ký tự ở đằng
sau. Còn \s (s thường nhá) cho biết là khoảng trắng. Do đó, gộp lại ta có mệnh đề “hãy đi tìm bất cứ ký
tự non-whitespace theo sau bởi whitespace”.
Kết quả của ví dụ trên là:

Code:
The match[0]: 'This ' co chieu dai la 5
The match[1]: 'is ' co chieu dai la 3
The match[2]: 'a ' co chieu dai la 2
The match[3]: 'example ' co chieu dai la 8
Lý do từ chót “string.” không được tìm thấy là vì nó có kết thúc là dấu chấm (không phải khoảng trắng).
4.Lớp Group
Đôi khi người ta cho là rất tiện khi cho gộp lại những biểu thức con so khớp với nhau như vậy bạn có thể
phân tích ngữ nghĩa những đoạn của chuỗi khớp.
Ví dụ, có thể bạn muốn so khớp dựa trên địa chỉ IP và cho gộp lại tất cả các IP tìm thấy được bất cứ nơi
nào trên đoạn chuỗi.
Lớp Group cho phép bạn tạo những nhóm so khớp dựa trên cú pháp RE, và tượng trưng cho kết quả từ 1
biểu thức gộp nhóm duy nhất.
Một biểu thức gộp nhóm đặt tên cho một nhóm v2 cung cấp 1 RE; bất cứ chuỗi con nào khớp với RE sẽ
được đưa vào nhóm. Ví dụ, muốn tạo 1 nhóm IP, bạn có thể viết một RE cho biết một hoặc nhiều digit
hay dot theo sau bởi space như sau:
Code:
@”(?<ip>(\d|\.)+)\s”
Lớp Match được dẫn xuất từ Group, và có một tập hợp mang tên Groups chứa tất cả các nhóm mà Match
tìm thấy.
Lớp Group tượng trưng cho những kết quả thu hoạch được từ 1 thu lượm nhóm duy nhất. Ví Group có
thể thu lượm 0, 1 hoặc nhiều chuỗi chữ trong một lần so khớp duy nhất, nó chứa một tập hợp gồm
những đối tượng của Capture. Vì Group kế thừa từ Capture, substring bị thu lượm có thể được truy xuất
trực tiếp.
Các thể hiện của Group sẽ được trả về bởi thuộc tính Match.Groups(số group) hoặc Match.Groups(“tên
group”) nếu cấu trúc gộp nhóm “(?<groupname>)” được dùng đến.
Ví dụ sau đây sử dụng kiến trúc gộp nhóm lồng nhau để thu lượm những chuỗi con gộp thành nhóm:
Code:
static void Main(string[] args)
{

string pattern = "(a(b))c";
string chuoi = "abdabc";
//định nghĩa những substring abc,ab,b
Regex myRegex = new Regex(pattern);
Match m = myRegex.Match(chuoi);

for (int i = 0; m.Groups[i].Value != ""; i++)
{
Console.WriteLine("{0} co chieu dai {1}", m.Groups[i].Value,
m.Groups[i].Length);
}
}
Kết quả:
Code:
abc co chieu dai 3
ab co chieu dai 2
b co chieu dai 1
Đoạn mã sau đây sử dụng kiến trúc gộp nhóm có mang tên (name và value) để thu lượm những
substrings từ một chuỗi chứa dữ liệu trên 1 dạng thức “DATANAME:VALUE” mà RE bị chẻ ở dâu dấu hai
chấm (:)
Code:
static void Main(string[] args)
{
string pattern = @"^(?<name>\w+):(?<value>\w+)";
Regex myRegex = new Regex(pattern);
Match m = myRegex.Match("Section:119900");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
Console.WriteLine("{0} co chieu dai {1}", m.Groups[i].Value,
m.Groups[i].Length);

}
}
Kết quả:
Code:
Section:119900 co chieu dai 14
Section co chieu dai 7
119900 co chieu dai 6
RE sẻ trả về kết xuất sau đây:
Code:
m.Groups[“name”].Value = “Section1”
m.Groups[“value”].Value = “119900”
Sử dụng cụ thể lớp Group:
Code:
static void Main(string[] args)
{
//một chuỗi ví dụ
string chuoi = "04:03:27 127.0.0.0 sinhvienit.net";
//group time = một hoặc nhiều digit hoặc dấu hai chấm
//theo sau bởi khoảng trắng
string timePattern = @"(?<time>(\d|\:)+)\s";
string ipPattren = @"(?<ip>(\d|\.)+)\s";
string sitePattern = @"(?<site>\S+)";
string pattern = timePattern + ipPattren + sitePattern;
Regex myRegex = new Regex(pattern);
//đi lấy tập hợp những so khớp
MatchCollection matches = myRegex.Matches(chuoi);

foreach (Match match in matches)
{
if (match.Length != 0)

{
Console.WriteLine("\nMatch: {0}", match.ToString());
Console.WriteLine("\nTime: {0}", match.Groups["time"]);
Console.WriteLine("\nIP: {0}", match.Groups["ip"]);
Console.WriteLine("\nSite: {0}", match.Groups["site"]);
}
}
}
Kết quả:
Code:
Match: 04:03:27 127.0.0.0 sinhvienit.net
Time: 04:03:27
IP: 127.0.0.0
Site: sinhvienit.net
Theo ví dụ trên, đầu tiên ta tạo một chuỗi để tiến hành dò khớp:
Code:
string chuoi = "04:03:27 127.0.0.0 sinhvienit.net";
Chuỗi này có thể là 1 trong nhiều chuỗi được ghi nhận trên một tập tin log của web server như là kết quả
dò tìm của CSDL. Trong ví dụ đơn giản này có 3 cột: time – IP – Site, mỗi cột cách nhau bởi một khoảng
trắng.
Bạn muốn tạo một đối tượng Regex duy nhất để dò tìm những chuỗi kiểu này, và chặt chúng thành 3
nhóm: time,ip và site :
Code:
string timePattern = @"(?<time>(\d|\:)+)\s";
string ipPattren = @"(?<ip>(\d|\.)+)\s";
string sitePattern = @"(?<site>\S+)";
string pattern = timePattern + ipPattren + sitePattern;
Regex myRegex = new Regex(pattern);
Ta tập trung xem các ký tự hình thành nhóm:
Các dấu ngoặc () sẽ tạo nên một nhóm. Những gì nằm giữa dấu ngoặc mở (ngay trước dấu ?)

và dấu ngoặc đóng (sau dấu + trong trường hợp này) là 1 nhóm đơn độc chưa mang tên.
Code:
@"(?<time>(\d|\:)+)\s"
• Chuỗi ?<time> đặt tên nhóm là time và nhóm gắn liền với đoạn văn bản so khớp, là regular
expression “(\d|\:)+)\s”. RE này ược suy diễn như sau: “một hoặc nhiều digit hoặc dấu hai chấm
theo sau bởi khoảng trắng”.
• Chuỗi ?<ip> đặt tên cho nhóm ip, và ?<site> đặt tên cho nhóm site.
Như các ví dụ trước, ví dụ trên cũng đòi hỏi một tập hợp của tát cả các đoạn khớp:
Code:
MatchCollection matches = myRegex.Matches(chuoi);
Tiếp theo, cho đi xuyên qua tập hợp matches để lôi ra từng phần tử match của nó:
Code:
foreach (Match match in matches)
Nếu chiều dài Length của match lớn hơn 0 có nghĩa là đã tìm thấy một so khớp. Sau đó, thì cho in ra
toàn bộ những mục so khớp:
Code:
Console.WriteLine("\nMatch: {0}", match.ToString());
Tiếp theo, là đi lấy nhóm time từ tập hợp Groups của match rồi cho in ra nội dung:
Code:
Console.WriteLine("\nTime: {0}", match.Groups["time"]);
Kết quả
Code:
Time: 04:03:27
Tương tự như thế với các nhóm site và ip ta có kết quả
Code:
IP: 127.0.0.0
Site: sinhvienit.net
5.Lớp GroupCollection:
Là lớp tượng trưng cho 1 tập hợp gồm toàn những nhóm được thu lượm và trả về một lô những nhóm
được thu lượm trong một lần so khớp duy nhất. Collection này thuộc loại read-only và không có phương

thức khởi tạo. Các thể hiện của lớp GroupCollection được trả về trong tập hợp mà thuộc tính
Match.Groups trả về.
Ví dụ: dò tìm và in ra số những nhóm được thu lượm bởi một RE. Làm thế nào để trích từng thu lượm
riêng rẽ trên mỗi thành viên của môt group collection.
Code:
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Regex myRegex = new Regex("(a(b))c");
Match m = myRegex.Match("abdabc");
Console.WriteLine("So nhom duoc tim thay la: {0}",m.Groups.Count);
}
}
}
Kết quả:
Code:
So nhom duoc tim thay la 3
6.Lớp Cature:
Lớp này chứa những kết quả từ một thu lượm duy nhất dựa trên một expression-con (sub-expression)
7.Lớp CatureCollection:
Mỗi lần một đối tượng Regex khớp với một subexpression, một thể hiện Capture sẽ được tạo ra, và được
thêm vào tập hợp CaptureCollection. Mỗi đối tượng Capture tượng trưng cho một thu lượm (capture) đơn

lẻ. Mỗi nhóm sẽ có riêng cho mình một capture collection những mục khớp với subexpression được gắn
liền với nhóm.
Lớp CaptureCollection tượng trưng cho một loạt những chuỗi con được thu lượm và trả về một lô những
thu lượm được thực hiện chỉ qua một nhóm thu lượm duy nhất. Thuộc tính Captures, một đối tượng của
lớp CaptureCollection, được cung cấp như là một thành viên của các lớp Match và Group giúp truy xuất
dễ dàng lô các chuỗi con được thu lượm.
Ví dụ: nếu bạn sử dụng regular expression ((a(b)c)+ (dấu + cho biết là một hoặc nhiều chuỗi so khớp)
để thu lượm những so khớp từ chuỗi chữ “abcabcabc”. CaptureCollection đối với mỗi matching Group của
những substring sẽ chứa 3 thành viên.
Ví dụ sau đây mình dùng đến regular expression (Abc)+ để tìm ra một hoặc nhiều so khớp trên chuỗi
“XYZAbcAbcAbcXYZAbcAb”. Ví dụ minh họa việc sử dụng thuộc tính Captures để trả về nhiều nhóm các
chuỗi con bị thu lượm:
Code:
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
string chuoi = "XYZAbcAbcAbcXYZAbcAb";
string pattern = "(Abc)+";
Regex myRegex = new Regex(pattern);
Match m = myRegex.Match(chuoi);

GroupCollection gc = m.Groups;

CaptureCollection cc;
Console.WriteLine("So nhom thu luom duoc =
{0}",gc.Count.ToString());
Console.WriteLine();
for(int i=0;i<gc.Count;i++)
{
cc = gc[i].Captures;
Console.WriteLine("So capture = " + cc.Count.ToString());
for(int j=0;j< cc.Count;j++)
{
Console.WriteLine(cc[j] + " bat dau tu ky tu " +
cc[j].Index);
}
Console.WriteLine();
}
}
}
}
Kêt quả
Code:
So nhom thu luom duoc = 2

So capture = 1
AbcAbcAbc bat dau tu ky tu 3

So capture = 3
Abc bat dau tu ky tu 3
Abc bat dau tu ky tu 6
Abc bat dau tu ky tu 9
Sử dụng lớp CaptureCollection:

Thuộc tính chủ chốt của đối tượng Capture là Length, cho biết chiều dài của chuỗi con bị thu lượm. Khi
bạn yêu cầu Match cho biết chiều dài, thì chính Capture.Length bạn tìm thấy, vì Match được thừa kế từ
Group, và Group lại được dẫn xuất từ Capture.
Điển hình, bạn sẽ chỉ tìm thấy một Capture đơn độc trong mộg CaptureCollection; nhưng điều này không
buộc phải như thế. Điều gì sẽ xảy ra nếu bạn phân tích ngữ nghĩa một chuỗi trong ấy tên công ty có thể
xuất hiện hoặc ở hai nơi. Muốn gộp các tên này vào chung thành một match đơn lẻ, bạn tạo nhóm ?
<company> ở 2 nơi trong pattern của regular expression.
Code:
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
string chuoi = "05:04:27 NEVERLAND 192.168.10.1 TNHH";
string pattern = @"(?<time>(\d|\:)+)\s" +
@"(?<company>\S+)\s" +
@"(?<ip>(\d|\.)+)\s" +
@"(?<company>\S+)";
Regex myRegex = new Regex(pattern);
MatchCollection mc = myRegex.Matches(chuoi);

foreach(Match match in mc)
{
if (match.Length!=0)

{
Console.WriteLine("Match: {0}",match.ToString());
Console.WriteLine("Time: {0}",match.Groups["time"]);
Console.WriteLine("IP: {0}",match.Groups["ip"]);
Console.WriteLine("Company: {0}",match.Groups["company"]);
Console.WriteLine();
foreach(Capture cap in match.Groups["company"].Captures)
{
Console.WriteLine("cap: {0}",cap.ToString());
}
}
}
}
}
}
Đoạn mã sau cho rảo qua tập hợp Capture đối với nhóm company:
Code:
foreach(Capture cap in match.Groups["company"].Captures)
Compiler bắt đầu bằng cách tìm ra tập hợp mà ta rảo qua trên ấy. match là một đối tượng có một tập
hợp mang tên Groups. Tập hợp Groups có bộ chỉ mục (indexer) cho phép trích một chuỗi và trả về một
đối tượng Group đơn lẻ. Do đó, lệnh sau đây trả về một đối tượng Group đơn lẻ:
Code:
match.Groups["company"].Captures
Đến phiên, vòng lặp foreach rảo qua tập hợp Captures, trích mỗi phần tử trong tập hợp và gán cho biến
toàn cục cap, thuộc kiểu dữ liệu Capture. Bạn có thể là trên kết xuất có 2 phần tử capture: NEVERLAND
và TNHH. Phần tử thứ hai đè chồng lên phần tử đầu trên nhóm, do đó chỉ in ra TNHH, nhưng khi quan
sát tập hợp Captures thì bạn thấy có 2 trị bị thu lượm.
Kết quả của ví dụ trên:
Code:
Match: 05:04:27 NEVERLAND 192.168.10.1 TNHH

Time: 05:04:27
IP: 192.168.10.1
Company: TNHH

cap: NEVERLAND
cap: TNHH
Ultrapico Expresso v3.0.3276 - Công cụ hữu ích khi lập trình
regular expression
Home:

Download