상용 C \ # 정규 표현 식 집합 소개

한동안 정규 표현 식 학습 이 뜨 겁 고 유행 이 었 습 니 다. 그 당시 에 CSDN 에서 하루 에 여러 개의 정규 표현 식 게시 물 을 볼 수 있 었 습 니 다. 그 동안 포럼 과 Wrox Press 가 출판 한 을 통 해 기본 적 인 지식 을 배 웠 고 저 에 게 CSDN 에서 1000 점 을 벌 어 주 었 습 니 다. 오늘 생각해 보 니 찾 아 보 세 요.'C \ # 문자열 과 정규 표현 식 참고 매 뉴 얼' 은 이미 행방 을 알 수 없 었 습 니 다. 이 제 는 정규 로 사용 할 때 도 적 습 니 다. 이전의 노트 등 을 정리 하여 잊 지 않도록 하 세 요.
(1) "@" 기호
두 ows 표 연구실 의 뜨 거 운 열 기 를 보 여 줍 니 다. 아침 에 '@' 에 서 는 C \ # 정규 표현 식 의 '구성원' 은 아니 지만 C \ # 정규 표현 식 과 쌍 을 이 루 곤 합 니 다. '@' 에 따 르 면 그 뒤에 있 는 문자열 은 '한 글자 씩 문자열' 이 라 이해 하기 어렵 습 니 다. 예 를 들 어 다음 두 가지 성명 은 같은 효 과 를 가 집 니 다. string x = 'D: / my Huang / / my Doc', string y = @"D: / my Huang / my Doc"; 사실 다음 과 같은 성명 을 누 르 면 C \ # 는 잘못 보 고 됩 니 다. "/" 는 C \ # 에서 전 의 를 실현 하 는 데 사 용 됩 니 다. 예 를 들 어 "/ n" 줄 바 꾸 기: string x = "D: / my Huang / my Doc";
(2) 기본 문법 문자.
/d  0 - 9 의 숫자 / D  /d 의 보충 집합 (그래서 문 자 를 전체 집합, 이하 동일), 즉 모든 비 숫자 문자 / w  단어 문자  /w 의 보충 집합 / s  공백 문자, 줄 바 꿈 문자 / n, 리 턴 문자 / r, 탭 문자 / t, 수직 탭 문자 / v, 페이지 바 꿈 문자 / f / S 포함  /s 의 보 집.  줄 바 꿈 / n 을 제외 한 임의의 문자 [...]  [] 에 열 거 된 모든 문자 와 일치 합 니 다 [^...]  비 [] 에 열 거 된 문자 와 일치 하 는 간단 한 예 시 를 제공 합 니 다.

string i = "/n";
string m = "3";
Regex r = new Regex(@"/D");
// Regex r = new Regex("//D");
//r.IsMatch(i)  ：true
//r.IsMatch(m)  ：false

string i = "%";
string m = "3";
Regex r = new Regex("[a-z0-9]");
//           
//r.IsMatch(i)  ：false
//r.IsMatch(m)  ：true

(3) 위치 문자
'포 지 셔 닝 문자' 는 하나의 빈 문 자 를 대표 합 니 다. 이것 은 하나의 위 치 를 대표 합 니 다. 또한 '포 지 셔 닝 문자' 가 대표 하 는 것 은 특정한 문자 와 문자 간 의 작은 간격 이 라 고 직관 적 으로 생각 할 수 있 습 니 다. ^  다음 문 자 는 문자열 의 시작 부분 에 있어 야 합 니 다 $  앞의 문 자 는 문자열 의 끝 에 있어 야 함 을 나타 낸다 / b  단어 경계 / B 일치  단어 가 아 닌 경계 와 일치 합 니 다. 또한: / A 도 포함 합 니 다.  앞의 문 자 는 문자 의 시작 부분 에 있어 야 합 니 다. / z  앞의 문 자 는 문자열 의 끝 에 있어 야 합 니 다. / Z  앞의 문 자 는 문자열 의 끝 에 있 거나 줄 바 꿈 문자 앞 에 있 는 간단 한 예 시 를 제공 해 야 합 니 다.

string i = "Live for nothing,die for something";
Regex r1 = new Regex("^Live for nothing,die for something$");
//r1.IsMatch(i) true
Regex r2 = new Regex("^Live for nothing,die for some$");
//r2.IsMatch(i) false
Regex r3 = new Regex("^Live for nothing,die for some");
//r3.IsMatch(i) true

string i = @"Live for nothing,
die for something";//  
Regex r1 = new Regex("^Live for nothing,die for something$");
Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0
Regex r2 = new Regex("^Live for nothing,die for something$", RegexOptions.Multiline);
Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//0
Regex r3 = new Regex("^Live for nothing,/r/ndie for something$");
Console.WriteLine("r3 match count:" + r3.Matches(i).Count);//1
Regex r4 = new Regex("^Live for nothing,$");
Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//0
Regex r5 = new Regex("^Live for nothing,$", RegexOptions.Multiline);
Console.WriteLine("r5 match count:" + r5.Matches(i).Count);//0
Regex r6 = new Regex("^Live for nothing,/r/n$");
Console.WriteLine("r6 match count:" + r6.Matches(i).Count);//0
Regex r7 = new Regex("^Live for nothing,/r/n$", RegexOptions.Multiline);
Console.WriteLine("r7 match count:" + r7.Matches(i).Count);//0
Regex r8 = new Regex("^Live for nothing,/r$");
Console.WriteLine("r8 match count:" + r8.Matches(i).Count);//0
Regex r9 = new Regex("^Live for nothing,/r$", RegexOptions.Multiline);
Console.WriteLine("r9 match count:" + r9.Matches(i).Count);//1
Regex r10 = new Regex("^die for something$");
Console.WriteLine("r10 match count:" + r10.Matches(i).Count);//0
Regex r11 = new Regex("^die for something$", RegexOptions.Multiline);
Console.WriteLine("r11 match count:" + r11.Matches(i).Count);//1
Regex r12 = new Regex("^");
Console.WriteLine("r12 match count:" + r12.Matches(i).Count);//1
Regex r13 = new Regex("$");
Console.WriteLine("r13 match count:" + r13.Matches(i).Count);//1
Regex r14 = new Regex("^", RegexOptions.Multiline);
Console.WriteLine("r14 match count:" + r14.Matches(i).Count);//2
Regex r15 = new Regex("$", RegexOptions.Multiline);
Console.WriteLine("r15 match count:" + r15.Matches(i).Count);//2
Regex r16 = new Regex("^Live for nothing,/r$/n^die for something$", RegexOptions.Multiline);
Console.WriteLine("r16 match count:" + r16.Matches(i).Count);//1
//         ，    Multiline    ，^ $       。

string i = "Live for nothing,die for something";
string m = "Live for nothing,die for some thing";
Regex r1 = new Regex(@"/bthing/b");
Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0
Regex r2 = new Regex(@"thing/b");
Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//2
Regex r3 = new Regex(@"/bthing/b");
Console.WriteLine("r3 match count:" + r3.Matches(m).Count);//1
Regex r4 = new Regex(@"/bfor something/b");
Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//1
///b             

(4) 반복 설명 문자
"반복 설명 문자" 는 C \ # 정규 표현 식 "좋아, 강해" 를 나타 내 는 곳 중 하나 입 니 다: {n}  앞의 문자 n 회 {n,} 와 일치 합 니 다.  앞의 문자 n 회 이상 일치 하거나 n 회 이상 {n, m}  앞의 문자 n 에서 m 번 일치 합 니까?  앞 글자 0 또는 1 번 일치 +  앞의 문자 와 1 번 이상 일치 하거나 1 번 이상 일치 합 니 다 *  앞의 문자 와 0 번 또는 0 번 이하 로 일치 하 는 간단 한 예 시 를 제공 합 니 다.

string x = "1024";
string y = "+1024";
string z = "1,024";
string a = "1";
string b="-1024";
string c = "10000";
Regex r = new Regex(@"^/+?[1-9],?/d{3}$");
Console.WriteLine("x match count:" + r.Matches(x).Count);//1
Console.WriteLine("y match count:" + r.Matches(y).Count);//1
Console.WriteLine("z match count:" + r.Matches(z).Count);//1
Console.WriteLine("a match count:" + r.Matches(a).Count);//0
Console.WriteLine("b match count:" + r.Matches(b).Count);//0
Console.WriteLine("c match count:" + r.Matches(c).Count);//0
//  1000 9999   。

(5) 선택 일치
C \ # 정규 표현 식 의 (|) 기 호 는 전문 적 인 호칭 이 없 는 것 같 습 니 다. 우선 "선택 일치" 라 고 부 릅 니 다. 사실 [a - z] 와 같은 선택 일치 도 하나의 문자 만 일치 할 뿐 (|) 은 더 큰 범 위 를 제공 합 니 다. (ab | xy) 는 ab 와 일치 하거나 xy 와 일치 합 니 다. "|" 과 "()" 를 주의 하 십시오.이것 은 하나의 전체 입 니 다. 다음은 간단 한 예 를 제공 합 니 다. 

string x = "0";
string y = "0.23";
string z = "100";
string a = "100.01";
string b = "9.9";
string c = "99.9";
string d = "99.";
string e = "00.1";
Regex r = new Regex(@"^/+?((100(.0+)*)|([1-9]?[0-9])(/./d+)*)$");
Console.WriteLine("x match count:" + r.Matches(x).Count);//1
Console.WriteLine("y match count:" + r.Matches(y).Count);//1
Console.WriteLine("z match count:" + r.Matches(z).Count);//1
Console.WriteLine("a match count:" + r.Matches(a).Count);//0
Console.WriteLine("b match count:" + r.Matches(b).Count);//1
Console.WriteLine("c match count:" + r.Matches(c).Count);//1
Console.WriteLine("d match count:" + r.Matches(d).Count);//0
Console.WriteLine("e match count:" + r.Matches(e).Count);//0

/ / 0 에서 100 의 수 와 일치 합 니 다. 가장 바깥쪽 괄호 안에 두 부분 '(100 (. 0 +) *', '([1 - 9]? [0 - 9] (/ d +) *' 가 포함 되 어 있 습 니 다. 이 두 부분 은 'OR' 의 관계 입 니 다. 즉, 정규 표현 식 엔진 은 먼저 100 과 일치 하려 고 시도 합 니 다. 실패 하면 다음 표 달 식 ([0, 100) 범위 의 숫자 와 일치 하려 고 시도 합 니 다.
(6) 특수 문자 의 일치 아래 간단 한 예 시 를 제공 합 니 다.

string x = "\\"; 
Regex r1 = new Regex("^\\\\$"); 
Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1 
Regex r2 = new Regex(@"^\\$"); 
Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1 
Regex r3 = new Regex("^\\$"); 
Console.WriteLine("r3 match count:" + r3.Matches(x).Count);//0 
//  “\” 
string x = "\""; 
Regex r1 = new Regex("^\"$"); 
Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1 
Regex r2 = new Regex(@"^""$"); 
Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1 
//      

(7) 그룹 과 비 포획 그룹
다음은 간단 한 예 시 를 제공한다.

string x = "Live for nothing,die for something";
string y = "Live for nothing,die for somebody";
Regex r = new Regex(@"^Live ([a-z]{3}) no([a-z]{5}),die /1 some/2$");
Console.WriteLine("x match count:" + r.Matches(x).Count);//1
Console.WriteLine("y match count:" + r.Matches(y).Count);//0

/ / 정규 표현 식 엔진 은 '()' 에 일치 하 는 내용 을 '그룹' 으로 기억 하고 색인 을 통 해 참조 할 수 있 습 니 다. 표현 식 의 '/ 1' 은 표현 식 에 나타 난 첫 번 째 그룹, 즉 굵 은 표지 의 첫 번 째 괄호 내용 을 역방향 으로 참조 하 는 데 사 용 됩 니 다. '/ 2' 는 이 를 통 해 유추 합 니 다.

string x = "Live for nothing,die for something";
Regex r = new Regex(@"^Live for no([a-z]{5}),die for some/1$");
if (r.IsMatch(x))
{
 Console.WriteLine("group1 value:" + r.Match(x).Groups[1].Value);//  ：thing
}
//       。  ，   Groups[1]，  Groups[0]         ，     x   。

string x = "Live for nothing,die for something";
Regex r = new Regex(@"^Live for no(?[a-z]{5}),die for some/1$");
if (r.IsMatch(x))
{
 Console.WriteLine("group1 value:" + r.Match(x).Groups["g1"].Value);//  ：thing
}
//         。               (?…)。

string x = "Live for nothing nothing";
Regex r = new Regex(@"([a-z]+) /1");
if (r.IsMatch(x))
{
 x = r.Replace(x, "$1");
 Console.WriteLine("var x:" + x);//  ：Live for nothing
}
//            “nothing”。      ，  “$1”       ，           ：
string x = "Live for nothing nothing";
Regex r = new Regex(@"(?[a-z]+) /1");
if (r.IsMatch(x))
{
 x = r.Replace(x, "${g1}");
 Console.WriteLine("var x:" + x);//  ：Live for nothing
}

string x = "Live for nothing";
Regex r = new Regex(@"^Live for no(?:[a-z]{5})$");
if (r.IsMatch(x))
{
 Console.WriteLine("group1 value:" + r.Match(x).Groups[1].Value);//  ：( )
}
//     “?:”     “    ”，            。

(8) 탐욕 과 비 탐욕
정규 표현 식 엔진 은 탐욕 입 니 다. 패턴 이 허용 된다 면 가능 한 한 많은 문자 와 일치 합 니 다. '반복 설명 문자' (*, +) 뒤에 '?' 를 추가 하면 일치 모드 를 탐욕 이 아 닌 것 으로 바 꿀 수 있 습 니 다. 다음 예제 를 보십시오.

string x = "Live for nothing,die for something";
Regex r1 = new Regex(@".*thing");
if (r1.IsMatch(x))
{
 Console.WriteLine("match:" + r1.Match(x).Value);//  ：Live for nothing,die for something
}
Regex r2 = new Regex(@".*?thing");
if (r2.IsMatch(x))
{
 Console.WriteLine("match:" + r2.Match(x).Value);//  ：Live for nothing
}

(9) 역 추적 과 비 역 추적
"(? >...)" 방식 으로 비 역 추적 성명 을 진행 합 니 다. 정규 표현 식 엔진 의 탐욕 특성 으로 인해 어떤 경우 에는 역 추적 을 통 해 일치 하 게 됩 니 다. 다음 예제 를 보십시오.

string x = "Live for nothing,die for something";
Regex r1 = new Regex(@".*thing,");
if (r1.IsMatch(x))
{
 Console.WriteLine("match:" + r1.Match(x).Value);//  ：Live for nothing,
}
Regex r2 = new Regex(@"(?>.*)thing,");
if (r2.IsMatch(x))//   
{
 Console.WriteLine("match:" + r2.Match(x).Value);
}

/ r1 에서 ". *" 는 탐욕 적 인 특성 으로 문자열 의 마지막 까지 일치 합 니 다. 그 다음 에 "thing" 과 일치 하지만 "일치 할 때 실 패 했 습 니 다. 이 때 엔진 은 거 슬러 올 라 가" thing "에서 일치 합 니 다. / r2 에 서 는 강제 적 으로 거 슬러 올 라 가지 않 기 때문에 전체 표현 식 이 실 패 했 습 니 다.
(10) 사전 검색, 역방향 사전 검색
사전 검색 성명 형식: "(? =...)", 마이너스 성명 "(?!..)" 을 성명 하고 있 습 니 다. 성명 자 체 는 최종 일치 결과 의 일부분 이 아 닙 니 다. 아래 의 예 를 보십시오.

string x = "1024 used 2048 free";
Regex r1 = new Regex(@"/d{4}(?= used)");
if (r1.Matches(x).Count==1)
{
 Console.WriteLine("r1 match:" + r1.Match(x).Value);//  ：1024
}
Regex r2 = new Regex(@"/d{4}(?! used)");
if (r2.Matches(x).Count==1)
{
 Console.WriteLine("r2 match:" + r2.Match(x).Value); //  ：2048
}

/ / r1 의 정 성명 은 네 자리 숫자의 뒤에 반드시 "used" 를 따라 야 한 다 는 것 을 보증 해 야 한다 고 밝 혔 다. r2 의 마이너스 성명 은 네 자리 숫자 이후 에 "used" 를 따라 갈 수 없다 는 것 을 나타 낸다.
역방향 사전 검색 성명 형식: "(? < =)", 마이너스 성명 "(?

string x = "used:1024 free:2048";
Regex r1 = new Regex(@"(?<=used:)/d{4}");
if (r1.Matches(x).Count==1)
{
 Console.WriteLine("r1 match:" + r1.Match(x).Value);//  ：1024
}
Regex r2 = new Regex(@"(? 
 

/ / r1 의 역방향 성명 은 4 자리 숫자 전에 반드시 "used:" 를 따라 야 한 다 는 것 을 나타 낸다. r2 의 역방향 성명 은 4 자리 숫자 전에 "used:" 를 제외 한 문자열 을 따라 야 한 다 는 것 을 나타 낸다.
(11) 16 진수 문자 범위
정규 표현 식 에 서 는 '/ xx' 와 '/ uXXXX' 를 사용 하여 한 글자 ('X' 는 16 진수 표시) 형식의 문자 범 위 를 표시 할 수 있 습 니 다. / xx       번 호 는 0 에서 255 범위 의 문자 입 니 다. 예 를 들 어 빈 칸 은 "/ x20" 으로 표시 할 수 있 습 니 다. / uXXXX   모든 문 자 는 '/ u' 와 그 번호 의 4 비트 16 진수 로 표시 할 수 있다. 예 를 들 어 한 자 는 '[/ u4e 00 - / u9fa 5]' 로 표시 할 수 있다.
(12) 대 [0, 100] 의 비교적 완 비 된 일치
다음은 비교적 종합 적 인 예 이다. 일치 [0, 100] 에 대해 특별한 고려 가 필요 한 부분 은 * 00 합 법, 00. 합 법, 00.00 합 법, 001.100 합 법 * 빈 문자열 이 합 법 적 이지 않 고 소수점 만 합 법 적 이지 않 으 며 100 이상 합 법 적 이지 않 은 * 수 치 는 접 두 사 를 가 질 수 있다. 예 를 들 어 '1.07f' 는 이 값 이 float 형식 (고려 하지 않 음) 임 을 나타 낸다.

Regex r = new Regex(@"^/+?0*(?:100(/.0*)?|(/d{0,2}(?=/./d)|/d{1,2}(?=($|/.$)))(/./d*)?)$");
string x = "";
while (true)
{
 x = Console.ReadLine();
 if (x != "exit")
 {
  if (r.IsMatch(x))
  {
   Console.WriteLine(x + " succeed!");
  }
  else
  {
   Console.WriteLine(x + " failed!");
  }
 }
 else
 {
  break;
 }
}

(13) 정확 한 매 칭 은 어 려 울 때 가 있다.
날짜, Url, Email 주소 등 정확 한 일치 가 어 려 운 요구 사항 이 있 습 니 다. 그 중에서 일부 전문 적 인 문 서 를 연구 하여 정확 하고 완 비 된 표현 식 을 써 야 합 니 다. 이런 상황 에 대해 서 는 뒤로 물 러 나 서 그 다음 에 정확 한 일치 가 보장 되 어야 합 니 다. 예 를 들 어 날짜 에 대해 서 는 응용 시스템 의 실제 상황 을 바탕 으로 비교적 짧 은 시간 을 고려 하거나Email 과 같은 일치 에 대해 서 는 가장 흔 한 형식 만 고려 할 수 있 습 니 다.