그룹화 구문

  • 아티클

그룹화 구문은 정규식의 부분식을 나타내며 입력 문자열의 부분 문자열을 캡처합니다. 그룹화 구문을 사용하여 다음 작업을 수행할 수 있습니다.

  • 입력 문자열에서 반복되는 부분식을 찾습니다.

  • 여러 정규식 언어 요소가 있는 부분식에 수량자를 적용합니다. 수량자에 대한 자세한 내용은 수량자를 참조하십시오.

  • Regex.Replace 및 Match.Result 메서드에서 반환되는 문자열에 부분식을 포함합니다.

  • Match.Groups 속성에서 개별 부분식을 검색하고 전체적으로 일치하는 텍스트와 별도로 처리합니다.

.NET Framework는 다음 정규식 그룹화 구문을 지원합니다.

  • 일치하는 부분식

  • 명명된 일치하는 부분식

  • 균형 조정 그룹 정의입니다.

  • 비캡처 그룹입니다.

  • 그룹 옵션

  • 너비가 0인 긍정 우측 어설션입니다.

  • 너비가 0인 부정 우측 어설션입니다.

  • 너비가 0인 긍정 좌측 어설션입니다.

  • 너비가 0인 부정 좌측 어설션입니다.

  • 역추적하지 않는 부분식

  • 그룹화 구문 및 정규식 개체

일치하는 부분식

다음 그룹화 구문은 일치하는 부분식을 캡처합니다.

( subexpression )

여기서 subexpression은 모든 유효한 정규식 패턴입니다. 매개 변수를 사용하는 캡처는 정규식의 여는 괄호의 순서로 1부터 시작하여 왼쪽에서 오른쪽으로 자동으로 번호가 매겨집니다. 번호가 0인 캡처는 전체 정규식 패턴에 의해 일치되는 텍스트입니다.

참고참고

정규식 패턴 일치 메서드의 RegexOptions 매개 변수에 RegexOptions.ExplicitCapture 플래그가 포함되어 있거나 n 옵션이 이 부분식에 적용되는 경우(이 항목 뒷부분의 그룹 옵션) 일치하는 부분식이 캡처되지 않습니다.

캡처된 그룹을 네 가지 방법으로 액세스할 수 있습니다.

  • 정규식 내의 역참조 구문을 사용합니다. 일치되는 부분식은 구문 \number를 사용하여 같은 정규식에서 참조됩니다. 여기서 number는 캡처된 부분식의 서수입니다.

  • 정규식 내의 명명된 역참조 구문을 사용합니다. 일치되는 부분식은 구문 \k<number>를 사용하여 같은 정규식에서 참조됩니다. 여기서 number는 캡처된 부분식의 서수입니다. 캡처된 부분식에는 해당 서수 번호와 동일한 기본 이름이 있습니다. 자세한 내용은 이 항목의 뒷부분에 나오는 명명된 일치하는 부분식을 참조하십시오.

  • $ number r를 사용하여 Regex.Replace or Match.Result 메서드의 대체 시퀀스를 호출합니다. 여기서 number는 캡처된 부분식의 서수입니다.

  • 프로그래밍 방식으로 Match.Groups 속성에서 반환하는 GroupCollection 개체를 사용합니다. 컬렉션에 있는 위치 0의 멤버는 전체 정규식 일치를 나타냅니다. 각 후속 멤버는 일치하는 부분식을 나타냅니다. 자세한 내용은 그룹화 구문 및 정규식 개체 단원을 참조하십시오.

다음 예제에서는 텍스트에서 중복된 단어를 식별하는 정규식을 보여 줍니다. 정규식 패턴의 두 캡처링 그룹은 중복된 단어의 두 인스턴스를 나타냅니다. 두 번째 인스턴스는 입력 문자열의 시작 위치를 보고하기 위해 캡처됩니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w+)\s(\1)\W"
      Dim input As String = "He said that that was the the correct answer."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
                           match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Duplicate 'that' found at positions 8 and 13.
'       Duplicate 'the' found at positions 22 and 26.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w+)\s(\1)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", 
                           match.Groups[1].Value, match.Groups[1].Index, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'that' found at positions 8 and 13.
//       Duplicate 'the' found at positions 22 and 26.

정규식 패턴은 다음과 같습니다.

(\w+)\s(\1)\W

다음 표에서는 정규식 패턴을 해석하는 방법을 설명합니다.

패턴

설명

(\w+)

둘 이상의 단어 문자를 찾습니다. 이 그룹은 첫 번째 캡처링 그룹입니다.

\s

공백 문자를 찾습니다.

(\1)

첫 번째 캡처된 그룹의 문자열을 찾습니다. 이 그룹은 두 번째 캡처링 그룹입니다. 예제는 생성된 그룹에 할당하므로 중복 단어의 시작 위치를 Match.Index 속성에서 검색할 수 있습니다.

\W

공백 및 문장 부호를 포함하여 비단어 문자를 찾습니다. 이는 정규식 패턴이 첫 번째 캡처된 그룹의 단어로 시작하는 단어를 일치시키지 못하도록 합니다.

명명된 일치하는 부분식

다음 그룹화 구문은 일치되는 부분식을 캡처하고 이름이나 번호로 액세스할 수 있습니다.

(?<name>subexpression)

또는

(?'name' subexpression)

여기서 name은 유효한 그룹 이름이고 subexpression은 모든 유효한 정규식 패턴입니다. name에는 문장 부호를 포함할 수 없고 숫자로 시작할 수 없습니다.

참고참고

정규식 패턴 일치 메서드의 RegexOptions 매개 변수에 RegexOptions.ExplicitCapture 플래그가 포함되어 있거나 n 옵션이 이 부분식에 적용되는 경우(이 항목 뒷부분의 그룹 옵션) 부분식을 캡처하는 유일한 방법은 캡처 그룹을 명시적으로 지정하는 것입니다.

다음과 같은 방법으로 명명된 캡처된 그룹을 액세스할 수 있습니다.

  • 정규식 내의 명명된 역참조 구문을 사용합니다. 일치하는 부분식 같은 정규식 구문을 \k < name > , 여기서 이름을 캡처된 부분식이 이름을 사용하여 참조됩니다.

  • 정규식 내의 역참조 구문을 사용합니다. 일치되는 부분식은 구문 \number를 사용하여 같은 정규식에서 참조됩니다. 여기서 number는 캡처된 부분식의 서수입니다. 명명된 일치하는 부분식은 부분식을 일치시킨 후에 왼쪽에서 오른쪽으로 연속적으로 번호가 매겨집니다.

  • ${name}을 사용하여 Regex.Replace 또는 Match.Result 메서드의 대체 시퀀스를 호출합니다. 여기서 name은 캡처된 부분식의 이름입니다.

  • $ number >를 사용하여 Regex.Replace or Match.Result 메서드의 대체 시퀀스를 호출합니다. 여기서 number는 캡처된 부분식의 서수입니다.

  • 프로그래밍 방식으로 Match.Groups 속성에서 반환하는 GroupCollection 개체를 사용합니다. 컬렉션에 있는 위치 0의 멤버는 전체 정규식 일치를 나타냅니다. 각 후속 멤버는 일치하는 부분식을 나타냅니다. 명명된 캡처 그룹은 캡처된 그룹의 번호를 매긴 후에 저장됩니다.

  • 프로그램 방식으로 GroupCollection 개체의 인덱서(C#) 또는 해당 Item 속성(Visual Basic)에 부분식 이름을 제공합니다.

간단한 정규식 패턴은 프로그래밍 방식이나 정규식 언어 구문을 사용하여 번호가 매겨지지 않은(명명되지 않은) 및 명명된 그룹이 참조하는 방법을 보여줍니다. 정규식 ((?<One>abc)\d+)?(?<Two>xyz)(.*) 를 사용하면 번호 및 이름별로 다음과 같은 캡처 그룹이 생성됩니다. 첫 번째 캡처 그룹(0번)은 항상 전체 패턴을 나타냅니다.

숫자

Name

패턴

0

0(기본 이름)

((?<One>abc)\d+)?(?<Two>xyz)(.*)

1

1(기본 이름)

((?<One>abc)\d+)

2

2(기본 이름)

(.*)

3

One

(?<One>abc)

4

Two

(?<Two>xyz)

다음 예제에서는 중복 단어를 식별하는 정규식과 각 중복 단어 바로 뒤에 있는 단어를 보여줍니다. 정규식 패턴은 중복 단어를 나타내는 duplicateWord 및 중복 단어 다음에 오는 단어를 나타내는 nextWord 등 두 명명된 부분식을 정의합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
      Dim input As String = "He said that that was the the correct answer."
      Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
                           match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
                           match.Groups("nextWord").Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    A duplicate 'that' at position 8 is followed by 'was'.
'    A duplicate 'the' at position 22 is followed by 'correct'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
      string input = "He said that that was the the correct answer.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", 
                           match.Groups["duplicateWord"].Value, match.Groups["duplicateWord"].Index, 
                           match.Groups["nextWord"].Value);

   }
}
// The example displays the following output:
//       A duplicate 'that' at position 8 is followed by 'was'.
//       A duplicate 'the' at position 22 is followed by 'correct'.

이 정규식 패턴은 다음과 같습니다.

(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)

다음 표에서는 정규식을 해석하는 방법을 설명합니다.

패턴

설명

(?<duplicateWord>\w+)

둘 이상의 단어 문자를 찾습니다. duplicateWord 그룹 캡처 이름을 지정합니다.

\s

공백 문자를 찾습니다.

\k<duplicateWord>

duplicateWord라는 캡처된 그룹에서 문자열을 찾습니다.

\W

공백 및 문장 부호를 포함하여 비단어 문자를 찾습니다. 이는 정규식 패턴이 첫 번째 캡처된 그룹의 단어로 시작하는 단어를 일치시키지 못하도록 합니다.

(?<nextWord>\w+)

둘 이상의 단어 문자를 찾습니다. 이 nextWord 캡처링 그룹의 이름을 지정합니다.

균형 조정 그룹 정의입니다.

균형 조정 그룹 정의는 현재 그룹에서 이전에 정의된 그룹과 저장소의 정의 및 이전에 정의한 그룹과 현재 그룹 사이의 간격을 삭제합니다. 이 그룹화 구문의 형식은 다음과 같습니다.

(?<name1-name2>subexpression)

또는

(?'name1-name2' subexpression)

여기서 name1은 현재 그룹(옵션)이고,name2는 이전에 정의한 그룹이며 subexpression은 유효한 정규식 패턴입니다. 균형 조정 그룹 정의는 name2의 정의를 삭제하고 name1에서 name2와 name1 사이의 간격을 저장합니다. name2 그룹을 정의하지 않은 경우에는 일치 항목이 역추적됩니다. name2의 마지막 정의를 삭제하면 name2의 이전 정의가 드러나므로 이 구문을 사용하면 name2 그룹에 대한 캡처 스택을 카운터로 사용하여 괄호와 같은 중첩 구문을 추적하거나 괄호를 열고 닫을 수 있습니다.

균형 조정 그룹 정의는 스택으로 name2를 사용합니다. 각 중첩된 구문의 시작 문자는 그룹 및 해당 Group.Captures 컬렉션에 놓입니다. 닫는 문자가 일치하면 해당하는 여는 문자가 그룹에서 제거되고 Captures 컬렉션이 하나씩 감소합니다. 모든 구문의 여는 문자와 닫는 문자가 일치된 후 name1이 비어 있습니다.

참고참고

다음 예제의 정규식을 수정하여 중첩된 구문의 적절한 열기 및 닫기 문자를 사용한 후에 여러 중첩된 메서드 호출을 포함하는 수식이나 프로그램 코드 줄 같은 가장 많이 중첩된 구조를 처리하는 데 사용할 수 있습니다.

다음 예제에서는 균형 조정 그룹 정의를 사용하여 입력 문자열에서 왼쪽 꺾쇠괄호와 오른쪽 꺾쇠괄호(<>)를 찾습니다. 예제는 꺽쇠 괄호의 일치 쌍을 추적할 스택처럼 사용되는 두 개의 명명된 그룹 Open 및 Close를 정의합니다. 각 캡처된 왼쪽 꺽쇠 괄호가 Open 그룹의 캡처 컬렉션에 입력되고 각 캡처된 오른쪽 꺽쇠 괄호가 Close 그룹의 캡처 컬렉션에 입력됩니다. 균형 조정 그룹 정의는 각 왼쪽 꺽쇠 괄호에 대해 일치하는 오른쪽 꺽쇠 괄호입니다. 없는 경우 최종 하위 패턴 (?(Open)(?!))은 Open 그룹이 비어 있지 않은 경우(따라서 모든 중첩된 구조가 닫히지 않은 경우)에만 평가됩니다. 최종 하위 패턴이 평가되는 경우 입력 문자열이 하위 문자열 ?!의 발생을 포함해서는 안 되기 때문에 일치가 실패합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main() 
        Dim pattern As String = "^[^<>]*" & _
                                "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
        Dim rgx AS New Regex(pattern)'
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success Then
            Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                               input, m)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
               Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value)
               grpCtr += 1
               Dim capCtr As Integer = 0
               For Each cap As Capture In grp.Captures            
                  Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value)
                  capCtr += 1
               Next
            Next
        Else
            Console.WriteLine("Match failed.")
        End If
    End Sub
End Module  
' The example displays the following output:
'       Input: "<abc><mno<xyz>>"
'       Match: "<abc><mno<xyz>>"
'          Group 0: <abc><mno<xyz>>
'             Capture 0: <abc><mno<xyz>>
'          Group 1: <mno<xyz>>
'             Capture 0: <abc>
'             Capture 1: <mno<xyz>>
'          Group 2: <xyz
'             Capture 0: <abc
'             Capture 1: <mno
'             Capture 2: <xyz
'          Group 3: >
'             Capture 0: >
'             Capture 1: >
'             Capture 2: >
'          Group 4:
'          Group 5: mno<xyz>
'             Capture 0: abc
'             Capture 1: xyz
'             Capture 2: mno<xyz>

using System;
using System.Text.RegularExpressions;

class Example
{
   public static void Main() 
   {
      string pattern = "^[^<>]*" +
                       "(" + 
                       "((?'Open'<)[^<>]*)+" +
                       "((?'Close-Open'>)[^<>]*)+" +
                       ")*" +
                       "(?(Open)(?!))$";
      string input = "<abc><mno<xyz>>";

      Match m = Regex.Match(input, pattern);
      if (m.Success == true)
      {
         Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
         int grpCtr = 0;
         foreach (Group grp in m.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", grpCtr, grp.Value);
            grpCtr++;
            int capCtr = 0;
            foreach (Capture cap in grp.Captures)
            {            
                Console.WriteLine("      Capture {0}: {1}", capCtr, cap.Value);
                capCtr++;
            }
          }
      }
      else
      {
         Console.WriteLine("Match failed.");
      }   
    }
}
// The example displays the following output:
//    Input: "<abc><mno<xyz>>"
//    Match: "<abc><mno<xyz>>"
//       Group 0: <abc><mno<xyz>>
//          Capture 0: <abc><mno<xyz>>
//       Group 1: <mno<xyz>>
//          Capture 0: <abc>
//          Capture 1: <mno<xyz>>
//       Group 2: <xyz
//          Capture 0: <abc
//          Capture 1: <mno
//          Capture 2: <xyz
//       Group 3: >
//          Capture 0: >
//          Capture 1: >
//          Capture 2: >
//       Group 4:
//       Group 5: mno<xyz>
//          Capture 0: abc
//          Capture 1: xyz
//          Capture 2: mno<xyz>

정규식 패턴은 다음과 같습니다.

^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$

정규식은 다음과 같이 해석됩니다.

패턴

설명

^

문자열의 시작 부분에서 시작합니다.

[^<>]*

왼쪽 또는 오른쪽 꺾쇠 괄호가 없는 0개 이상의 문자를 찾습니다.

(?'Open'<)

왼쪽 꺽쇠 괄호를 일치시키고 Open이라는 그룹에 할당합니다.

[^<>]*

왼쪽 또는 오른쪽 꺾쇠 괄호가 없는 0개 이상의 문자를 찾습니다.

((?'Open'<)[^<>]*) +

왼쪽 꺽쇠 괄호 다음에 왼쪽 또는 오른쪽 꺾쇠 괄호가 없는 0개 이상의 문자가 이어지는 하나 이상의 항목을 일치시킵니다. 이 그룹은 두 번째 캡처링 그룹입니다.

(?'Close-Open'>)

오른쪽 꺽쇠 괄호를 일치시키고, Open 그룹과 현재 그룹 사이의 부분 문자열을 Close 그룹에 할당하고, Open 그룹 정의를 삭제합니다.

[^<>]*

꺽쇠 괄호 왼쪽이나 오른쪽이 아닌 문자를 하나 이상 일치시킵니다.

((?'Close-Open'>)[^<>]*)+

오른쪽 꺽쇠 괄호 다음에 꺽쇠 괄호 왼쪽이나 오른쪽이 아닌 문자가 하나 이상의 이어지는 하나 이상의 항목을 일치시킵니다. 오른쪽 꺽쇠 괄호가 일치하면 Open 그룹과 현재 그룹 사이의 부분 문자열을 Close 그룹에 할당하고, Open 그룹 정의를 삭제합니다. 이 그룹은 세 번째 캡처링 그룹입니다.

(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*

다음 패턴을 0개 이상 일치시킵니다. 왼쪽 꺽쇠 괄호 다음에 하나 이상의 꺽쇠 괄호가 아닌 문자, 다음에 하나 이상의 오른쪽 꺽쇠 괄호, 다음에 0개 이상의 꺽쇠가 아닌 문자를 하나 이상 일치시킵니다. 오른쪽 꺽쇠 괄호가 일치하면 Open 그룹의 정의를 삭제하고 Open 그룹과 현재 그룹 사이의 부분 문자열을 Close 그룹에 할당합니다. 이 그룹은 첫 번째 캡처링 그룹입니다.

(?(Open)(?!))

Open 그룹이 존재하는 경우 물음표 및 느낌표를 일치시킵니다. Open 그룹이 정의된 경우 일치가 실패하여 꺾쇠 괄호에 균형이 없음을 나타냅니다.

$

입력 문자열의 끝 부분을 찾습니다.

최종 부분식 (?(Open)(?!))은 입력 문자열의 중첩 구조가 적절한 균형을 이루는지 여부를 나타냅니다(예를 들어, 각 왼쪽 꺽쇠 괄호가 오른쪽 꺽쇠 괄호와 일치하는지 여부). 유효한 캡처된 그룹을 기반으로 조건부 일치를 사용합니다. 자세한 내용은 교체 구문를 참조하십시오. Open 그룹이 정의된 경우 정규식 엔진은 입력 문자열에서 부분식 (?!)을 일치시키려고 시도합니다. 중첩 구문이 불균형할 경우에만 Open 그룹을 정의해야 합니다. 따라서 입력 문자열에서 일치시킬 패턴은 일치가 실패하도록 하는 입력 문자열에서 발생할 수 없는 패턴이 되어야 합니다.

예를 들어, 정규식 엔진은 입력된 문자열을 "< abc > < mno < xyz > >" 평가합니다.다음 표와 같이.

Step

패턴

결과

1

^

입력 문자열의 시작 부분에서 일치 항목 찾기를 시작합니다.

2

[^<>]*

왼쪽 꺽쇠 괄호 앞에서 꺾쇠 괄호가 아닌 문자를 찾습니다. 일치하는 것이 없습니다.

3

(((?'Open'<)

일치하는 "< abc >" 왼쪽된 꺽쇠 괄호Open 그룹에 할당합니다.

4

[^<>]*

"abc"를 찾습니다.

5

)+

"< abc"두 번째 캡처된 그룹의 값입니다.

입력 문자열에서 다음 문자가 왼쪽 꺽쇠 괄호가 아니므로 정규식 엔진이 (?'Open'<)[^<>]*) 하위 패턴을 다시 반복하지 않습니다.

6

((?'Close-Open'>)

"< abc >" 오른쪽 꺽쇠 괄호 일치하는, Open 그룹과 Close 그룹, 오른쪽 꺽쇠 괄호 사이의 부분 문자열을 찾은 현재 값을 삭제합니다 abc"를 할당합니다 ("<") Open 그룹의 빈 상태로.

7

[^<>]*

오른쪽 꺽쇠 괄호 뒤에서 꺾쇠 괄호가 아닌 문자를 찾습니다. 일치하는 것이 없습니다.

8

)+

세 번째 캡처된 그룹의 값이 ">".

입력 문자열에서 다음 문자가 오른쪽 꺽쇠 괄호가 아니므로 정규식 엔진이 ((?'Close-Open'>)[^<>]*) 하위 패턴을 다시 반복하지 않습니다.

9

)*

첫 번째 캡처된 그룹의 "< abc >" 값입니다.

입력 문자열에서 다음 문자가 왼쪽 꺽쇠 괄호이므로 정규식 엔진이 (((?'Open'<) 하위 패턴을 다시 반복합니다.

10

(((?'Open'<)

일치하는 "< mno >" 왼쪽된 꺽쇠 괄호Open 그룹에 할당합니다. Group.Captures 컬렉션에서 이제 이 단일 값을 가진 "<".

11

[^<>]*

"mno"를 찾습니다.

12

)+

"< mno"두 번째 캡처된 그룹의 값입니다.

입력 문자열에서 다음 문자가 왼쪽 꺽쇠 괄호이므로 정규식 엔진이 (?'Open'<)[^<>]*) 하위 패턴을 다시 반복합니다.

13

(((?'Open'<)

일치하는 "< xyz >" 왼쪽된 꺽쇠 괄호Open 그룹에 할당합니다. 두 개의 캡처 그룹의 Group.Captures Open 컬렉션에 이제 포함됩니다: "< mno >" 에서 왼쪽된 꺽쇠 괄호 및 왼쪽된 꺾쇠괄호 "< xyz >" 에서.

14

[^<>]*

"xyz"를 찾습니다.

15

)+

"< xyz"두 번째 캡처된 그룹의 값입니다.

입력 문자열에서 다음 문자가 왼쪽 꺽쇠 괄호가 아니므로 정규식 엔진이 (?'Open'<)[^<>]*) 하위 패턴을 다시 반복하지 않습니다.

16

((?'Close-Open'>)

"< xyz >" 오른쪽 꺽쇠 괄호를 일치합니다. 이때 xyz"는 Open 그룹과 Close 그룹에 대한 오른쪽 꺽쇠 괄호 사이에 부분 문자열을 할당하고 Open 그룹의 현재 값을 삭제합니다. Open 그룹의 현재 값을 이전 캡처 (왼쪽된 꺾쇠 괄호 "< mno >" 의) 값이 됩니다. 해당 Captures Open 그룹 이제 단일 캡처 "< xyz >" 에서 왼쪽된 꺽쇠 괄호 포함되어 있습니다.

17

[^<>]*

꺾쇠 괄호가 아닌 문자를 찾습니다. 일치하는 것이 없습니다.

18

)+

세 번째 캡처된 그룹의 값이 ">".

입력 문자열에서 다음 문자가 오른쪽 꺽쇠 괄호이므로 정규식 엔진이 ((?'Close-Open'>)[^<>]*) 하위 패턴을 다시 반복합니다.

19

((?'Close-Open'>)

최종 오른쪽 꺾쇠 괄호 일치하는 "xyz > >"할당합니다,"mno < xyz >"(Open 그룹과 오른쪽 꺾쇠괄호 사이의 부분) Close 그룹에 및 Open 그룹의 현재 값을 삭제합니다. Open 그룹이 이제 비어 있습니다.

20

[^<>]*

꺾쇠 괄호가 아닌 문자를 찾습니다. 일치하는 것이 없습니다.

21

)+

세 번째 캡처된 그룹의 값이 ">".

입력 문자열에서 다음 문자가 오른쪽 꺽쇠 괄호가 아니므로 정규식 엔진이 ((?'Close-Open'>)[^<>]*) 하위 패턴을 다시 반복하지 않습니다.

22

)*

첫 번째 캡처된 그룹의 "< mno < xyz > >" 값입니다.

입력 문자열에서 다음 문자가 왼쪽 꺽쇠 괄호가 아니므로 정규식 엔진이 (((?'Open'<) 하위 패턴을 다시 반복하지 않습니다.

23

(?(Open)(?!))

Open 그룹은 지원되지 않으므로 일치를 시도하지 않습니다.

24

$

입력 문자열의 끝 부분을 찾습니다.

비캡처링 그룹

다음 그룹화 구문은 부분식에 의해 일치하는 부분 문자열을 캡처하지 않습니다.

(?:subexpression)

여기서 subexpression은 모든 유효한 정규식 패턴입니다. 비캡처링 그룹 구문은 수량자가 그룹에 적용되지만 그룹별로 캡처한 하위 문자열에 관심이 없는 경우에 일반적으로 사용됩니다.

참고참고

정규식에 중첩된 그룹화 구문이 포함되어 있으면 외부 비캡처 그룹 구문은 내부 중첩된 그룹 구문에 적용되지 않습니다.

다음 예제에서는 비캡처 그룹을 포함하는 정규식을 보여 줍니다. 출력은 캡처된 그룹을 포함하지 않습니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(?:\b(?:\w+)\W*)+\.";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
   }
}
// The example displays the following output:
//       Match: This is a short sentence.

정규식 (?:\b(?:\w+)\W*)+\.는 마침표로 끝나는 문장을 일치시킵니다. 정규식은 개별 단어가 아닌 구문에 중점을 두고 있기 때문에 그룹화 구문은 수량자로만 사용됩니다. 정규식 패턴은 다음 표에서와 같이 해석됩니다.

패턴

설명

\b

단어 경계에서 일치 항목 찾기를 시작합니다.

(?:\w+)

둘 이상의 단어 문자를 찾습니다. 일치하는 텍스트를 캡처된 그룹에 할당하지 마십시오.

\W*

0개 이상의 단어 문자를 일치시킵니다.

(?:\b(?:\w+)\W*)+

단어 경계에서 시작하는 하나 이상의 단어 문자 패턴 뒤에 0개 이상의 비단어 문자를 1회 이상 일치시킵니다. 일치하는 텍스트를 캡처된 그룹에 할당하지 마십시오.

\.

마침표를 찾습니다.

그룹 옵션

다음 그룹화 구문은 부분식 내에 지정된 옵션을 적용하거나 비활성화합니다.

(?imnsx-imnsx: subexpression )

여기서 subexpression은 모든 유효한 정규식 패턴입니다. 예를 들어, (?i-s:)는 대/소문자를 구분하지 않도록 하고 단일 행 모드를 해제합니다. 지정할 수 있는 인라인 옵션에 대한 자세한 내용은 정규식 옵션을 참조하십시오.

참고참고

System.Text.RegularExpressions.Regex 클래스 생성자 또는 정적 메서드를 사용하여 부분식이 아니라 전체 정규식에 적용되는 옵션을 지정할 수 있습니다.(?imnsx-imnsx) 언어 구문을 사용하여 정규식에서 특정 지점 후에 적용되는 인라인 옵션을 지정할 수도 있습니다.

그룹 옵션 구문은 캡처링 그룹이 아닙니다. 즉, 부분식에 의해 캡처된 문자열의 일부가 일치에 포함되어 있지만 캡처된 그룹에 포함되지 않고 GroupCollection 개체를 채우는 데 사용되지도 않습니다.

예를 들어, 다음 예제의 정규식 \b(?ix: d \w+)\s는 그룹화 구문의 인라인 옵션을 사용하여 대/소문자를 구분하지 않는 일치를 활성화하고 "d" 문자로 시작하는 모든 단어를 식별하는 패턴 공백을 무시합니다. 정규식은 다음 표에서와 같이 정의됩니다.

패턴

설명

\b

단어 경계에서 일치 항목 찾기를 시작합니다.

(?ix: d \w+)

대/소문자를 구분하지 않는 일치를 사용하고 이 패턴에서 공백을 무시하여 "d" 다음에 하나 이상의 단어 문자를 일치시킵니다.

\s

공백 문자를 찾습니다.

 
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

너비가 0인 긍정 우측 어설션입니다.

다음 그룹화 구문은 너비가 0인 긍정 우측 어설션을 정의합니다.

(?= subexpression )

여기서 부분식은 모든 정규식 패턴입니다. 일치가 성공하려면 일치된 부분 문자열이 일치 결과에 포함되어 있지 않지만 입력 문자열은 부분식에 있는 정규식 패턴과 일치해야 합니다. 너비가 0인 긍정 우측 어설션은 역추적하지 않습니다.

일반적으로 너비가 0인 긍정 우측 어설션은 정규식 패턴 끝에서 발견됩니다. 일치가 발생하려면 문자열 끝에서 찾아야 하며 일치에는 포함되어서는 안 되는 부분 문자열을 정의합니다. 또한 과도한 역추적을 방지하는 데에도 유용합니다. 특정 캡처 그룹이 캡처된 해당 그룹에 대해 정의된 패턴의 하위 집합에 일치하는 텍스트와 함께 시작하도록 하려면 너비가 0인 양수 lookahead 어설션을 사용할 수 있습니다. 예를 들어, 캡처링 그룹이 연속 단어 문자와 일치하는 경우 너비가 0인 긍정 우측 어설션을 사용하여 첫 번째 문자가 알파벳 대문자가 되도록 요구할 수 있습니다.

다음 예제에서는 너비가 0인 우측 어설션을 사용하여 입력 문자열에서 동사 "is" 앞에 있는 단어를 일치시킵니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(?=\sis\b)"
      Dim inputs() As String = { "The dog is a Malamute.", _
                                 "The island has beautiful birds.", _
                                 "The pitch missed home plate.", _
                                 "Sunday is a weekend day." }

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' precedes 'is'.", match.Value)
         Else
            Console.WriteLine("'{0}' does not match the pattern.", input) 
         End If     
      Next
   End Sub
End Module
' The example displays the following output:
'       'dog' precedes 'is'.
'       'The island has beautiful birds.' does not match the pattern.
'       'The pitch missed home plate.' does not match the pattern.
'       'Sunday' precedes 'is'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(?=\sis\b)";
      string[] inputs = { "The dog is a Malamute.", 
                          "The island has beautiful birds.", 
                          "The pitch missed home plate.", 
                          "Sunday is a weekend day." };

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' precedes 'is'.", match.Value);
         else
            Console.WriteLine("'{0}' does not match the pattern.", input); 
      }
   }
}
// The example displays the following output:
//    'dog' precedes 'is'.
//    'The island has beautiful birds.' does not match the pattern.
//    'The pitch missed home plate.' does not match the pattern.
//    'Sunday' precedes 'is'.

정규식 \b\w+(?=\sis\b) 다음 표와 같이 해석됩니다.

패턴

설명

\b

단어 경계에서 일치 항목 찾기를 시작합니다.

\w+

둘 이상의 단어 문자를 찾습니다.

(?=\sis\b)

단어 문자가 공백 문자 뒤에 나타나고 문자열 "is"가 단어 경계에서 끝나는지 여부를 결정합니다. 그렇다면 일치가 성공합니다.

너비가 0인 부정 우측 어설션입니다.

다음 그룹화 구문은 너비가 0인 부정 우측 어설션을 정의합니다.

(?! subexpression )

여기서 부분식은 모든 정규식 패턴입니다. 일치가 성공하려면 일치된 문자열이 일치 결과에 포함되어 있지 않지만 입력 문자열은 부분식에 있는 정규식 패턴과 일치해서는 안 됩니다.

너비가 0인 부정 우측 어설션은 일반적으로 정규식의 시작 또는 끝 부분에서 사용됩니다. 정규식의 시작 부분이 비슷하지만 보다 일반적인 패턴을 일치시킬 때 일치해서는 안 되는 특별한 패턴을 정규식 시작 부분에서 정의할 수 있습니다. 이 경우 역추적을 제한하는 데 사용되는 경우가 많습니다. 일치의 끝에서 발생할 수 없는 부분식을 정규식 끝에서 정의할 수 있습니다.

다음 예제에서는 정규식의 시작 부분에 있는 너비가 0인 우측 어설션을 사용하여 "un"으로 시작하지 않는 단어를 일치시키는 정규식을 정의합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?!un)\w+\b"
      Dim input As String = "unite one unethical ethics use untie ultimate"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       one
'       ethics
'       use
'       ultimate

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?!un)\w+\b";
      string input = "unite one unethical ethics use untie ultimate";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       one
//       ethics
//       use
//       ultimate

정규식 \b(?!un)\w+\b는 다음 표와 같이 해석됩니다.

패턴

설명

\b

단어 경계에서 일치 항목 찾기를 시작합니다.

(?!un)

다음 두 문자가 "un"인지 여부를 결정합니다. 그렇지 않은 경우 일치는 가능합니다.

\w+

둘 이상의 단어 문자를 찾습니다.

\b

단어 경계에서 일치 항목 찾기를 끝냅니다.

다음 예제에서는 정규식의 끝 부분에 있는 너비가 0인 우측 어설션을 사용하여 문장 부호로 끝나지 않는 단어를 일치시키는 정규식을 정의합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+\b(?!\p{P})"
      Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       disjointed
'       thoughts
'       in
'       a
'       sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+\b(?!\p{P})";
      string input = "Disconnected, disjointed thoughts in a sentence fragment.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       disjointed
//       thoughts
//       in
//       a
//       sentence

정규식 \b\w+\b(?!\p{P})는 다음 표와 같이 해석됩니다.

패턴

설명

\b

단어 경계에서 일치 항목 찾기를 시작합니다.

\w+

둘 이상의 단어 문자를 찾습니다.

\b

단어 경계에서 일치 항목 찾기를 끝냅니다.

\p{P})

다음 문자가 문장 기호(예: 마침표 또는 쉼표)가 아닌 경우 일치가 성공합니다.

너비가 0인 긍정 좌측 어설션입니다.

다음 그룹화 구문은 너비가 0인 긍정 좌측 어설션을 정의합니다.

(?<= subexpression )

여기서 부분식은 모든 정규식 패턴입니다. 일치가 성공하려면 subexpression가 일치 결과에 포함되어 있지 않지만 부분식은 현재 위치 왼쪽에 있는 입력 문자열에서 발생해서는 안 됩니다. 너비가 0인 긍정 좌측 어설션은 역추적하지 않습니다.

너비가 0인 긍정 좌측 어셜션은 일반적으로 정규식 시작 부분에서 사용됩니다. 정의하는 패턴은 일치 결과의 일부는 아니지만 일치에 대한 전제 조건입니다.

예를 들어, 다음 예제에서는 21세기의 마지막 두 자리 연도를 일치시킵니다(즉, 일치된 문자열 앞의 숫자 "20"이 필요).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "2010 1999 1861 2140 2009"
      Dim pattern As String = "(?<=\b20)\d{2}\b"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next      
   End Sub
End Module
' The example displays the following output:
'       10
'       09

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "2010 1999 1861 2140 2009";
      string pattern = @"(?<=\b20)\d{2}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       10
//       09

정규식 패턴 (?<=\b20)\d{2}\b는 다음 표에서와 같이 해석됩니다.

패턴

설명

\d{2}

두 개의 10진수를 찾습니다.

{?<=\b20)

두 개의 소수 자릿수가 단어 경계에서 10진수 숫자 "20" 앞에 나타나는 경우 일치를 계속합니다.

\b

단어 경계에서 일치 항목 찾기를 끝냅니다.

너비가 0인 긍정 lookbehind 어설션은 마지막 문자 또는 캡처한 그룹의 문자가 그룹의 정규식 패턴에 일치하는 문자의 하위 집합인 경우 역추적을 제한하는 데에도 사용됩니다. 예를 들어, 그룹이 연속 단어 문자를 모두 캡처하는 경우 너비가 0인 긍정 좌측 어설션을 사용하여 마지막 문자가 알파벳이 되도록 요구할 수 있습니다.

너비가 0인 부정 좌측 어설션입니다.

다음 그룹화 구문은 너비가 0인 부정 좌측 어설션을 정의합니다.

(?<! subexpression )

여기서 부분식은 모든 정규식 패턴입니다. 일치가 성공하려면 부분식은 현재 위치 왼쪽에 있는 입력 문자열에서 발생해서는 안 됩니다. 그러나 subexpression과 일치하지 않는 부분 문자열에는 일치하는 결과가 포함되어 있지 않습니다.

너비가 0인 부정 좌측 어셜션은 일반적으로 정규식 시작 부분에서 사용됩니다. 사용자가 정의하는 패턴은 뒤에 나오는 문자열의 일치를 무시합니다. 이 값은 캡처한 그룹의 마지막 문자가 그룹의 정규식 패턴에 일치하는 하나 이상의 문자가 될 수 없는 경우 역추적을 제한하는 데에도 사용됩니다. 예를 들어, 그룹이 연속 단어 문자를 모두 캡처하는 경우 너비가 0인 긍정 좌측 어설션을 사용하여 마지막 문자가 밑줄(_)이 되지 않도록 요구할 수 있습니다.

다음 예제에서는 해당 주에서 주말이 아닌 요일의 모든 날짜를 일치시킵니다(즉, 토요일이나 일요일이 아닌 날짜).

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim dates() As String = { "Monday February 1, 2010", _
                                "Wednesday February 3, 2010", _
                                "Saturday February 6, 2010", _
                                "Sunday February 7, 2010", _
                                "Monday, February 8, 2010" }
      Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"

      For Each dateValue As String In dates
         Dim match As Match = Regex.Match(dateValue, pattern)
         If match.Success Then
            Console.WriteLine(match.Value)
         End If   
      Next      
   End Sub
End Module
' The example displays the following output:
'       February 1, 2010
'       February 3, 2010
'       February 8, 2010

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] dates = { "Monday February 1, 2010", 
                         "Wednesday February 3, 2010", 
                         "Saturday February 6, 2010", 
                         "Sunday February 7, 2010", 
                         "Monday, February 8, 2010" };
      string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";

      foreach (string dateValue in dates)
      {
         Match match = Regex.Match(dateValue, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       February 1, 2010
//       February 3, 2010
//       February 8, 2010

정규식 패턴 (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b는 다음 표에서와 같이 해석됩니다.

패턴

설명

\b

단어 경계에서 일치 항목 찾기를 시작합니다.

\w+

하나 이상의 단어 문자 뒤에 공백 문자를 일치시킵니다.

\d{1,2},

하나 또는 두 10진수, 공백 문자 및 쉼표를 찾습니다.

\d{4}\b

네 개의 10진수를 찾고 단어 경계에서 일치를 끝냅니다.

(?<!(Saturday|Sunday) )

"토요일" 또는 "일요일" 뒤에 공백이 있는 문자열 이외의 문자열이 앞에 있는 경우 일치는 성공합니다.

비역행 부분식

다음 그룹화 구문은 역추적하지 않는 부분식을 나타냅니다("greedy" 부분식이라고도 함).

(?> subexpression )

여기서 부분식은 모든 정규식 패턴입니다.

일반적으로 정규식에 선택적 또는 대체 일치 패턴이 포함되어 있고 일치가 성공하지 않는 경우 정규식 엔진은 입력 문자열을 패턴과 일치하도록 여러 방향으로 분기할 수 있습니다. 첫 번째 분기가 있는 때 해당 항목이 발견되지 않는 경우 정규식 엔진은 첫 번째 일치가 발생한 지점을 백업하거나 역추적하고 두 번째 분기를 사용하여 일치를 시도할 수 있습니다. 이 프로세스는 모든 분기를 시도할 때까지 계속할 수 있습니다.

(?> 부분식 ) 언어 구문은 역추적을 비활성화합니다. 정규식 엔진은 입력 문자열에서 가능한 많은 문자를 일치시킵니다. 더 이상 일치가 가능하지 않은 경우 대체 패턴 일치를 시도하기 위해 역추적하지 않습니다. (즉, 해당 부분식에서는 단독으로 부분식에 의해 일치하는 문자열만 찾습니다. 이는 해당 부분식 및 그 뒤에 있는 부분식을 기반으로 문자열을 찾으려고 시도하지 않습니다.)

이 옵션은 역행이 성공하지 않을 것을 알고 있는 경우에 사용하는 것이 좋습니다. 정규식 엔진이 불필요한 검색을 수행하지 않도록 하면 성능이 향상됩니다.

다음 예제에서는 역추적하지 않는 부분식이 패턴 일치의 결과를 수정하는 방법을 보여 줍니다. 정규식 역행 검사가 단어 경계에서 일련의 반복된 문자 뒤에 같은 문자의 하나 이상의 발생하는 문자를 성공적으로 일치시키지만 정규식 비역행 검사는 그렇지 않습니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "cccd.", "aaad", "aaaa" }
      Dim back As String = "(\w)\1+.\b"
      Dim noback As String = "(?>(\w)\1+).\b"

      For Each input As String In inputs
         Dim match1 As Match = Regex.Match(input, back)
         Dim match2 As Match = Regex.Match(input, noback)
         Console.WriteLine("{0}: ", input)

         Console.Write("   Backtracking : ")
         If match1.Success Then
            Console.WriteLine(match1.Value)
         Else
            Console.WriteLine("No match")
         End If

         Console.Write("   Nonbacktracking: ")
         If match2.Success Then
            Console.WriteLine(match2.Value)
         Else
            Console.WriteLine("No match")
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    cccd.:
'       Backtracking : cccd
'       Nonbacktracking: cccd
'    aaad:
'       Backtracking : aaad
'       Nonbacktracking: aaad
'    aaaa:
'       Backtracking : aaaa
'       Nonbacktracking: No match

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "cccd.", "aaad", "aaaa" };
      string back = @"(\w)\1+.\b";
      string noback = @"(?>(\w)\1+).\b";

      foreach (string input in inputs)
      {
         Match match1 = Regex.Match(input, back);
         Match match2 = Regex.Match(input, noback);
         Console.WriteLine("{0}: ", input);

         Console.Write("   Backtracking : ");
         if (match1.Success)
            Console.WriteLine(match1.Value);
         else
            Console.WriteLine("No match");

         Console.Write("   Nonbacktracking: ");
         if (match2.Success)
            Console.WriteLine(match2.Value);
         else
            Console.WriteLine("No match");
      }
   }
}
// The example displays the following output:
//    cccd.:
//       Backtracking : cccd
//       Nonbacktracking: cccd
//    aaad:
//       Backtracking : aaad
//       Nonbacktracking: aaad
//    aaaa:
//       Backtracking : aaaa
//       Nonbacktracking: No match

역추적하지 않는 정규식 패턴 (?>(\w)\1+).\b는 다음 표에서와 같이 정의됩니다.

패턴

설명

(\w)

단일 단어 문자를 찾고 첫 번째 캡처링 그룹에 할당합니다.

\1+

첫 번째 캡처된 부분 문자열의 값을 한 번 이상 찾습니다.

.

모든 문자를 찾습니다.

\b

단어 경계에서 일치 항목 찾기를 끝냅니다.

(?>(\w)\1+)

중복된 단어 문자가 하나 이상의 발견되지만 단어 경계에서 마지막 문자를 일치시키기 위해 역추적하지 마십시오.

그룹화 구문 및 정규식 개체

정규식 캡처링 그룹에 의해 일치하는 부분 문자열은 System.Text.RegularExpressions.Group 개체로 표현되며, Match.Groups 속성에 의해 반환되는 System.Text.RegularExpressions.GroupCollection 개체에서 검색할 수 있습니다. GroupCollection 개체는 다음과 같이 채워집니다.

  • 이 컬렉션에서 첫 번째 Group 개체(인덱스 0에 있는 개체)는 일치하는 전체 문자열을 나타냅니다.

  • 명명된(번호가 지정된) 캡처링 그룹을 나타내는 Group 개체의 다음 집합입니다. 왼쪽에서 오른쪽으로 정규식에 정의된 순서로 나타납니다. 이러한 그룹의 인덱스 값의 범위는1에서 컬렉션의 명명되지 않은 캡처링 그룹의 수까지입니다. (특정 그룹의 인덱스는 번호가 매겨진 역참조와 동일합니다. backreference에 대한 자세한 내용은 역참조 구문를 참조하십시오.)

  • 명명된 캡처링 그룹을 나타내는 Group 개체의 최종 집합입니다. 왼쪽에서 오른쪽으로 정규식에 정의된 순서로 나타납니다. 첫 번째 명명된 캡처링 그룹의 인덱스 값은 마지막 명명되지 않은 캡처링 그룹의 인덱스보다 큽니다. 정규식에 명명되지 않은 캡처링 그룹이 있는 경우 첫 번째 명명된 캡처링 그룹의 인덱스 값은 0입니다.

캡처링 그룹에 수량자를 적용하는 경우 해당 Group 개체의 Capture.Value, Capture.Index 및 Capture.Length 속성은 캡처링 그룹에 의해 캡처되는 마지막 부분 문자열을 반영합니다. Group.Captures 속성에 의해 반환되는 CaptureCollection 개체에서 수량자가 있는 그룹에 의해 캡처되는 부분 문자열의 전체 집합을 검색할 수 있습니다.

다음 예제에서는 Group 및 Capture 개체 사이의 관계를 명확하게 보여 줍니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\b(\w+)\W+)+"
      Dim input As String = "This is a short sentence."
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: {0}", match.Value)
      For ctr As Integer = 1 To match.Groups.Count - 1
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
         Dim capCtr As Integer = 0
         For Each capture As Capture In match.Groups(ctr).Captures
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value)
            capCtr += 1
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Match: This is a short sentence.
'          Group 1: sentence.
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence.
'          Group 2: sentence
'             Capture 0: This
'             Capture 1: is
'             Capture 2: a
'             Capture 3: short
'             Capture 4: sentence

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\b(\w+)\W+)+";
      string input = "This is a short sentence.";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: {0}", match.Value);
      for (int ctr = 1; ctr < match.Groups.Count; ctr++)
      {
         Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
         int capCtr = 0;
         foreach (Capture capture in match.Groups[ctr].Captures)
         {
            Console.WriteLine("      Capture {0}: {1}", capCtr, capture.Value);
            capCtr++;
         }
      }
   }
}
// The example displays the following output:
//       Match: This is a short sentence.
//          Group 1: sentence.
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence.
//          Group 2: sentence
//             Capture 0: This
//             Capture 1: is
//             Capture 2: a
//             Capture 3: short
//             Capture 4: sentence

정규식 패턴 \b(\w+)\W+)+은 문자열에서 개별 단어를 추출합니다. 다음 표에 표시된 대로 정의됩니다.

패턴

설명

\b

단어 경계에서 일치 항목 찾기를 시작합니다.

(\w+)

둘 이상의 단어 문자를 찾습니다. 이와 함께 이러한 문자가 단어를 형성합니다. 이 그룹은 두 번째 캡처링 그룹입니다.

\W+

단어가 아닌 둘 이상의 문자를 찾습니다.

(\w+)\W+)+

하나 이상의 단어 문자 패턴 뒤에 하나 이상의 비단어 문자를 1회 이상 일치시킵니다. 이 그룹은 첫 번째 캡처링 그룹입니다.

첫 번째 캡처링 그룹이 문장의 각 단어와 일치합니다. 두 번째 캡처링 그룹은 단어 뒤에 문장 부호 및 공백과 함께 각 단어를 일치시킵니다. 인덱스가 2인 Group 개체는 두 번째 캡처링 그룹에 의해 일치된 텍스트에 대한 정보를 제공합니다. 캡처링 그룹에 의해 캡처된 전체 단어 집합을 Group.Captures 속성에 의해 반환된 CaptureCollection 개체에서 사용할 수 있습니다.

참고 항목

개념

정규식 언어 요소

역행 검사