다음을 통해 공유

Regular Expression 개체 모델

  • 아티클

이 항목에서는 .NET Framework 정규식을 다룰 때 사용되는 개체 모델을 설명합니다. 여기에는 다음 단원이 포함되어 있습니다.

  • 정규식 엔진

  • MatchCollection 및 Match 개체

  • 그룹 컬렉션

  • 캡처된 그룹

  • 캡처 컬렉션

  • 개별 캡처

정규식 엔진

.NET Framework의 정규식 엔진은 Regex 클래스로 나타냅니다. 정규식 엔진은 정규식 구문 분석 및 컴파일을 담당하고, 정규식 패턴을 입력 문자열과 일치시키는 작업의 수행을 담당합니다. 이 엔진은 .NET Framework 정규식 개체 모델의 중심적 구성 요소입니다.

정규식은 다음 두 가지 방법 중 하나로 사용할 수 있습니다.

  • Regex 클래스의 정적 메서드 호출. 이 메서드의 매개 변수는 입력 문자열 및 정규식 패턴을 포함합니다. 정규식 엔진은 정적 메서드 호출에서 사용되는 정규식을 캐시하므로 나중에 동일한 정규식이 사용되는 정적 정규식 메서드의 반복 호출을 통해 성능이 향상됩니다.

  • 정규식을 클래스 생성자에 전달하여 Regex 개체를 인스턴스화. 이 경우 Regex 개체는 변경 불가능하여 읽을 수만 있으며, 단일 정규식과 긴밀히 결합된 정규식 엔진을 나타냅니다. Regex 인스턴스에서 사용하는 정규식은 캐시되지 않기 때문에 동일한 정규식을 사용하여 Regex 개체를 여러 번 인스턴스화하면 안 됩니다.

Regex 클래스의 메서드를 호출하여 다음 작업을 수행할 수 있습니다.

  • 문자열이 정규식 패턴과 일치하는지 확인

  • 단일 일치 항목 또는 첫 번째 일치 항목 추출

  • 모든 일치 항목 추출

  • 일치하는 부분 문자열 대체

  • 단일 문자열을 문자열 배열로 분할

다음 단원에서는 이러한 작업에 대해 설명합니다.

정규식 패턴 일치

Regex.IsMatch 메서드는 문자열과 패턴이 일치하면 true를 반환하고, 그렇지 않으면 false를 반환합니다. IsMatch 메서드는 주로 문자열 입력의 유효성을 검사하는 데 사용됩니다. 예를 들어, 다음 코드에서는 문자열이 미국의 유효한 사회 보장 번호와 일치하는지 확인합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim values() As String = { "111-22-3333", "111-2-3333"}
      Dim pattern As String = "^\d{3}-\d{2}-\d{4}$"
      For Each value As String In values
         If Regex.IsMatch(value, pattern) Then
            Console.WriteLine("{0} is a valid SSN.", value)
         Else   
            Console.WriteLine("{0}: Invalid", value)
         End If   
      Next
   End Sub
End Module
' The example displays the following output:
'       111-22-3333 is a valid SSN.
'       111-2-3333: Invalid

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] values = { "111-22-3333", "111-2-3333"};
      string pattern = @"^\d{3}-\d{2}-\d{4}$";
      foreach (string value in values) {
         if (Regex.IsMatch(value, pattern))
            Console.WriteLine("{0} is a valid SSN.", value);
         else   
            Console.WriteLine("{0}: Invalid", value);
      }
   }
}
// The example displays the following output:
//       111-22-3333 is a valid SSN.
//       111-2-3333: Invalid

정규식 패턴 ^\d{3}-\d{2}-\d{4}$는 다음 표에서와 같이 해석됩니다.

패턴

설명

^

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

\d{3}

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

-

하이픈을 찾습니다.

\d{2}

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

-

하이픈을 찾습니다.

\d{4}

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

$

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

단일 일치 항목 또는 첫 번째 일치 항목 추출

Regex.Match 메서드는 정규식 패턴과 일치하는 첫 번째 부분 문자열에 대한 정보가 들어 있는 Match 개체를 반환합니다. 일치 항목이 있음을 나타내는 true를 Match.Success 속성에서 반환하면 Match.NextMatch 메서드를 호출하여 나머지 일치 항목에 대한 정보를 검색할 수 있습니다. 이러한 메서드 호출은 Match.Success 속성에서 false를 반환할 때까지 계속될 수 있습니다. 예를 들어, 다음 코드에서는 Regex.Match(String, String) 메서드를 사용하여 중복된 단어가 문자열에서 처음으로 나타나는 위치를 검색합니다. 그런 다음 Match.NextMatch 메서드를 호출하여 중복되는 다음 단어를 검색합니다. 이 예제에서는 각 메서드 호출 이후 Match.Success 속성을 검사하여 일치 항목을 찾았는지 확인하고 다음 단계로 Match.NextMatch 메서드를 호출해야 하는지 결정합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is a a farm that that raises dairy cattle." 
      Dim pattern As String = "\b(\w+)\W+(\1)\b"
      Dim match As Match = Regex.Match(input, pattern)
      Do While match.Success
         Console.WriteLine("Duplicate '{0}' found at position {1}.", _ 
                           match.Groups(1).Value, match.Groups(2).Index)
         match = match.NextMatch()
      Loop                       
   End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle."; 
      string pattern = @"\b(\w+)\W+(\1)\b";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("Duplicate '{0}' found at position {1}.",  
                           match.Groups[1].Value, match.Groups[2].Index);
         match = match.NextMatch();
      }                       
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

정규식 패턴 \b(\w+)\W+(\1)\b는 다음 표에서와 같이 해석됩니다.

패턴

설명

\b

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

(\w+)

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

\W+

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

(\1)

캡처된 첫 번째 문자열을 찾습니다. 이 그룹은 두 번째 캡처링 그룹입니다.

\b

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

모든 일치 항목 추출

Regex.Matches 메서드는 정규식 엔진이 입력 문자열에서 찾은 모든 일치 항목에 대한 정보를 포함하는 MatchCollection 개체를 반환합니다. 예를 들어, 이전 예제를 다시 작성하여 Match and NextMatch 메서드 대신 Matches 메서드를 호출할 수 있습니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is a a farm that that raises dairy cattle." 
      Dim pattern As String = "\b(\w+)\W+(\1)\b"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Duplicate '{0}' found at position {1}.", _ 
                           match.Groups(1).Value, match.Groups(2).Index)
      Next                       
   End Sub
End Module
' The example displays the following output:
'       Duplicate 'a' found at position 10.
'       Duplicate 'that' found at position 22.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is a a farm that that raises dairy cattle."; 
      string pattern = @"\b(\w+)\W+(\1)\b";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Duplicate '{0}' found at position {1}.",  
                           match.Groups[1].Value, match.Groups[2].Index);
   }
}
// The example displays the following output:
//       Duplicate 'a' found at position 10.
//       Duplicate 'that' found at position 22.

일치하는 부분 문자열 대체

Regex.Replace 메서드는 정규식 패턴과 일치하는 각 부분 문자열을 지정된 문자열 또는 정규식 패턴으로 바꾸고, 전체 입력 문자열을 대체 문자열과 함께 반환합니다. 예를 들어, 다음 코드는 문자열에서 10진수 앞에 미국 통화 기호를 추가합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\d+\.\d{2}\b"
      Dim replacement As String = "$$$&" 
      Dim input As String = "Total Cost: 103.64"
      Console.WriteLine(Regex.Replace(input, pattern, replacement))     
   End Sub
End Module
' The example displays the following output:
'       Total Cost: $103.64

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+\.\d{2}\b";
      string replacement = "$$$&"; 
      string input = "Total Cost: 103.64";
      Console.WriteLine(Regex.Replace(input, pattern, replacement));     
   }
}
// The example displays the following output:
//       Total Cost: $103.64

정규식 패턴 \b\d+\.\d{2}\b는 다음 표와 같이 해석됩니다.

패턴

설명

\b

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

\d+

하나 이상의 10진수를 찾습니다.

\.

마침표를 찾습니다.

\d{2}

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

\b

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

바꾸기 패턴 $$$&는 다음 표에서와 같이 해석됩니다.

패턴

대체 문자열

$$

달러 기호($) 문자

$&

일치하는 부분 문자열 전체

단일 문자열을 문자열 배열로 분할

Regex.Split 메서드는 정규식 일치에 의해 정의된 위치에서 입력 문자열을 분할합니다. 예를 들어, 다음 코드에서는 번호 매기기 목록의 항목을 문자열 배열에 삽입합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea"
      Dim pattern As String = "\b\d{1,2}\.\s"
      For Each item As String In Regex.Split(input, pattern)
         If Not String.IsNullOrEmpty(item) Then
            Console.WriteLine(item)
         End If
      Next      
   End Sub
End Module
' The example displays the following output:
'       Eggs
'       Bread
'       Milk
'       Coffee
'       Tea

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea";
      string pattern = @"\b\d{1,2}\.\s";
      foreach (string item in Regex.Split(input, pattern))
      {
         if (! String.IsNullOrEmpty(item))
            Console.WriteLine(item);
      }      
   }
}
// The example displays the following output:
//       Eggs
//       Bread
//       Milk
//       Coffee
//       Tea

정규식 패턴 \b\d{1,2}\.\s는 다음 표와 같이 해석됩니다.

패턴

설명

\b

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

\d{1,2}

하나 또는 두 개의 10진수를 찾습니다.

\.

마침표를 찾습니다.

\s

공백 문자를 찾습니다.

MatchCollection 및 Match 개체

메서드는 정규식 개체 모델의 일부인 두 개체, 즉 MatchCollection 개체 및 Match 개체를 반환합니다.

Match 컬렉션

Regex.Matches 메서드는 정규식 엔진이 찾은 모든 일치 항목을 나타내는 Match 개체를 입력 문자열에서 일치 항목이 발견되는 순서에 따라 포함하는 MatchCollection 개체를 반환합니다. 일치 항목이 없는 경우 이 메서드는 멤버가 없는 MatchCollection 개체를 반환합니다. MatchCollection.Item 속성을 사용하면 컬렉션의 개별 멤버에 인덱스로 액세스할 수 있습니다. 인덱스는 0부터 시작하며 MatchCollection.Count 속성의 값보다 1만큼 작습니다. Item은 C#에서 컬렉션의 인덱서이고 Visual Basic에서는 기본 속성입니다.

Regex.Matches 메서드 호출에서는 기본적으로 지연 계산을 사용하여 MatchCollection 개체를 채웁니다. MatchCollection.Count 및 MatchCollection.Item 속성과 같이 완전히 채워진 컬렉션이 필요한 속성에 액세스할 경우 성능이 저하될 수 있습니다. 따라서 MatchCollection.GetEnumerator 메서드에서 반환하는 IEnumerator 개체를 사용하여 컬렉션에 액세스하는 것이 좋습니다. Visual Basic의 For Each 및 C#의 foreach와 같이 각 언어에서는 컬렉션의 IEnumerator 인터페이스를 래핑하는 구문을 제공합니다.

다음 예제 코드에서는 Regex.Matches(String) 메서드를 사용하여 MatchCollection 개체를 입력 문자열에서 찾은 모든 일치 항목으로 채웁니다. 이 예제는 컬렉션을 열거하고, 일치 항목을 문자열 배열로 복사하고, 문자 위치를 정수 배열에 기록합니다.

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
       Dim matches As MatchCollection
       Dim results As New List(Of String)
       Dim matchposition As New List(Of Integer)

       ' Create a new Regex object and define the regular expression.
       Dim r As New Regex("abc")
       ' Use the Matches method to find all matches in the input string.
       matches = r.Matches("123abc4abcd")
       ' Enumerate the collection to retrieve all matches and positions.
       For Each match As Match In matches
          ' Add the match string to the string array.
           results.Add(match.Value)
           ' Record the character position where the match was found.
           matchposition.Add(match.Index)
       Next
       ' List the results.
       For ctr As Integer = 0 To results.Count - 1
         Console.WriteLine("'{0}' found at position {1}.", _
                           results(ctr), matchposition(ctr))  
       Next
   End Sub
End Module
' The example displays the following output:
'       'abc' found at position 3.
'       'abc' found at position 7.

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
       MatchCollection matches;
       List<string> results = new List<string>();
       List<int> matchposition = new List<int>();

       // Create a new Regex object and define the regular expression.
       Regex r = new Regex("abc");
       // Use the Matches method to find all matches in the input string.
       matches = r.Matches("123abc4abcd");
       // Enumerate the collection to retrieve all matches and positions.
       foreach (Match match in matches)
       {
          // Add the match string to the string array.
           results.Add(match.Value);
           // Record the character position where the match was found.
           matchposition.Add(match.Index);
       }
       // List the results.
       for (int ctr = 0; ctr < results.Count; ctr++)
         Console.WriteLine("'{0}' found at position {1}.", 
                           results[ctr], matchposition[ctr]);  
   }
}
// The example displays the following output:
//       'abc' found at position 3.
//       'abc' found at position 7.

Match

Match 클래스는 단일 정규식 일치의 결과를 나타냅니다. Match 개체는 두 가지 방법으로 액세스할 수 있습니다.

  • Regex.Matches 메서드에서 반환하는 MatchCollection 개체에서 검색. 개별 Match 개체를 검색하려면 foreach(C#) 또는 For Each...Next(Visual Basic) 구문을 사용하여 컬렉션을 반복합니다. 또는 MatchCollection.Item 속성을 사용하여 인덱스 또는 이름을 기준으로 특정 Match 개체를 검색합니다. 또한 인덱스로 컬렉션을 반복하여 컬렉션의 개별 Match 개체를 검색할 수도 있습니다. 인덱스는 0부터 시작하며 해당 컬렉션의 개체 수보다 1만큼 작습니다. 그러나 이 메서드는 MatchCollection.Count 속성에 액세스하기 때문에 지연 계산의 이점을 활용하지 못합니다.

    다음 예제에서는 foreach 또는 For Each...Next 구문을 사용해 컬렉션을 반복하여 MatchCollection 개체에 있는 개별 Match 개체를 검색합니다. 정규식은 입력 문자열에서 문자열 "abc"만 찾습니다.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "abc"
      Dim input As String = "abc123abc456abc789"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("{0} found at position {1}.", _
                           match.Value, match.Index)
      Next                     
   End Sub
End Module
' The example displays the following output:
'       abc found at position 0.
'       abc found at position 6.
'       abc found at position 12.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "abc";
      string input = "abc123abc456abc789";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("{0} found at position {1}.", 
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       abc found at position 0.
//       abc found at position 6.
//       abc found at position 12.

  • 문자열이나 부분 문자열에 있는 첫 번째 일치 항목을 나타내는 Match 개체를 반환하는 Regex.Match 메서드 호출. 일치 항목을 찾았는지 여부는 Match.Success 속성의 값을 검색하여 확인할 수 있습니다. 나머지 일치 항목을 나타내는 Match 개체를 검색하려면 반환된 Match 개체의 Success 속성이 false가 될 때까지 Match.NextMatch 메서드를 반복하여 호출합니다.

    다음 예제에서는 Regex.Match(String, String) 및 Match.NextMatch 메서드를 사용하여 입력 문자열에서 문자열 "abc"를 찾습니다.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "abc"
      Dim input As String = "abc123abc456abc789"
      Dim match As Match = Regex.Match(input, pattern)
      Do While match.Success
         Console.WriteLine("{0} found at position {1}.", _
                           match.Value, match.Index)
         match = match.NextMatch()                  
      Loop                     
   End Sub
End Module
' The example displays the following output:
'       abc found at position 0.
'       abc found at position 6.
'       abc found at position 12.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "abc";
      string input = "abc123abc456abc789";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("{0} found at position {1}.", 
                           match.Value, match.Index);
         match = match.NextMatch();                  
      }                     
   }
}
// The example displays the following output:
//       abc found at position 0.
//       abc found at position 6.
//       abc found at position 12.

Match 클래스의 다음 두 속성은 컬렉션 개체를 반환합니다.

  • Match.Groups 속성은 정규식 패턴의 캡처링 그룹과 일치하는 부분 문자열에 대한 정보가 들어 있는 GroupCollection 개체를 반환합니다.

  • Group.Captures 속성은 용도가 제한된 CaptureCollection 개체를 반환합니다. 컬렉션은 Success 속성이 false인 Match 개체로 채워지지 않습니다. 그 밖의 경우에는 Match 개체와 동일한 정보를 가지는 단일 Capture 개체를 포함합니다.

이러한 개체에 대한 자세한 내용은 이 항목의 그룹 컬렉션 및 캡처 컬렉션 단원을 참조하십시오.

Match 클래스에는 일치에 대한 정보를 제공하는 추가적 속성이 두 개 있습니다. Match.Value 속성은 입력 문자열에서 정규식 패턴과 일치하는 부분 문자열을 반환합니다. Match.Index 속성은 입력 문자열에 있는 일치 문자열의 시작 위치(0부터 시작)를 반환합니다.

Match 클래스에는 패턴 일치 메서드도 두 개 있습니다.

  • Match.NextMatch 메서드는 현재 Match 개체가 나타내는 일치 항목 뒤에서 일치 항목을 찾고, 해당 일치 항목을 나타내는 Match 개체를 반환합니다.

  • Match.Result 메서드는 일치하는 문자열에 대해 지정된 바꾸기 작업을 수행하고 결과를 반환합니다.

다음 예제에서는 Match.Result 메서드를 사용하여 소수 자릿수를 포함하는 모든 숫자 앞에 $ 기호 및 공백을 추가합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\d+(,\d{3})*\.\d{2}\b"
      Dim input As String = "16.32" + vbCrLf + "194.03" + vbCrLf + "1,903,672.08" 

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Result("$$ $&"))
      Next
   End Sub
End Module
' The example displays the following output:
'       $ 16.32
'       $ 194.03
'       $ 1,903,672.08

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\d+(,\d{3})*\.\d{2}\b";
      string input = "16.32\n194.03\n1,903,672.08"; 

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Result("$$ $&"));
   }
}
// The example displays the following output:
//       $ 16.32
//       $ 194.03
//       $ 1,903,672.08

\b\d+(,\d{3})*\.\d{2}\b 정규식 패턴은 다음 표에서와 같이 정의됩니다.

패턴

설명

\b

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

\d+

하나 이상의 10진수를 찾습니다.

(,\d{3})*

세 개의 10진수 앞에 있는 쉼표를 0개 이상 찾습니다.

\.

소수점 문자를 찾습니다.

\d{2}

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

\b

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

바꾸기 패턴 $$ $&는 일치하는 부분 문자열이 달러($) 기호($$ 패턴), 공백 및 일치 항목의 값($& 패턴)으로 대체되어야 함을 나타냅니다.

맨 위로 이동

그룹 컬렉션

Match.Groups 속성은 단일 일치 항목의 캡처된 그룹을 나타내는 Group 개체를 포함하는 GroupCollection 개체를 반환합니다. 이 컬렉션에서 첫 번째 Group 개체(인덱스 0)는 일치하는 전체 문자열을 나타냅니다. 나머지 개체 각각은 단일 캡처링 그룹의 결과를 나타냅니다.

컬렉션의 개별 Group 개체는 GroupCollection.Item 속성을 사용하여 검색할 수 있습니다. 명명되지 않은 그룹은 컬렉션에서의 서수 위치로 검색할 수 있고, 명명된 그룹은 이름 또는 서수 위치로 검색할 수 있습니다. 명명되지 않은 캡처는 컬렉션에서 명명된 캡처보다 앞에 위치하며 정규식 패턴에 나타나는 순서에 따라 왼쪽에서 오른쪽으로 인덱스가 지정됩니다. 명명된 캡처는 컬렉션에서 명명되지 않은 캡처보다 뒤에 위치하며 정규식 패턴에 나타나는 순서에 따라 왼쪽에서 오른쪽으로 인덱스가 지정됩니다.

GroupCollection.Item 속성은 C#에서 컬렉션의 인덱서이고 Visual Basic에서는 컬렉션 개체의 기본 속성입니다. 따라서 개별 Group 개체는 인덱스(명명된 그룹의 경우에는 이름)로 다음과 같이 액세스할 수 있습니다.

Dim group As Group = match.Groups(ctr)         

Group group = match.Groups[ctr];

다음 예제에서는 그룹화 구문을 사용하여 특정 날짜의 월, 일 및 년도를 캡처하는 정규식을 정의합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\w+)\s(\d{1,2}),\s(\d{4})\b"
      Dim input As String = "Born: July 28, 1989"
      Dim match As Match = Regex.Match(input, pattern)
      If match.Success Then
         For ctr As Integer = 0 To match.Groups.Count - 1
            Console.WriteLine("Group {0}: {1}", ctr, match.Groups(ctr).Value)
         Next      
      End If   
   End Sub
End Module
' The example displays the following output:
'       Group 0: July 28, 1989
'       Group 1: July
'       Group 2: 28
'       Group 3: 1989

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s(\d{1,2}),\s(\d{4})\b";
      string input = "Born: July 28, 1989";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
         for (int ctr = 0; ctr <  match.Groups.Count; ctr++)
            Console.WriteLine("Group {0}: {1}", ctr, match.Groups[ctr].Value);
    }
}
// The example displays the following output:
//       Group 0: July 28, 1989
//       Group 1: July
//       Group 2: 28
//       Group 3: 1989

\b(\w+)\s(\d{1,2}),\s(\d{4})\b 정규식 패턴은 다음 표에서와 같이 정의됩니다.

패턴

설명

\b

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

(\w+)

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

\s

공백 문자를 찾습니다.

(\d{1,2})

하나 또는 두 개의 10진수를 찾습니다. 이 그룹은 두 번째 캡처링 그룹입니다.

,

쉼표를 찾습니다.

\s

공백 문자를 찾습니다.

(\d{4})

네 개의 10진수를 찾습니다. 이 그룹은 세 번째 캡처링 그룹입니다.

\b

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

맨 위로 이동

캡처된 그룹

Group 클래스는 단일 캡처링 그룹 결과를 나타냅니다. 정규식에 정의된 캡처링 그룹을 나타내는 그룹 개체는 Match.Groups 속성에서 반환하는 GroupCollection 개체의 Item 속성을 통해 반환됩니다. Item 속성은 Group 클래스의 기본 속성(Visual Basic의 경우)이면서 인덱서(C#의 경우)입니다. 개별 멤버는 foreach 또는 For Each 구문을 통해 컬렉션을 반복하여 검색할 수도 있습니다. 예제는 이전 단원을 참조하십시오.

다음 예제에서는 중첩 그룹화 구문을 사용하여 부분 문자열을 그룹으로 캡처합니다. (a(b))c 정규식 패턴은 문자열 "abc"를 찾습니다. 이 패턴에 의해 부분 문자열 "ab"는 첫 번째 캡처링 그룹에 할당되고 부분 문자열 "b"는 두 번째 캡처링 그룹에 할당됩니다.

 Dim matchposition As New List(Of Integer)
 Dim results As New List(Of String)
 ' Define substrings abc, ab, b.
 Dim r As New Regex("(a(b))c") 
 Dim m As Match = r.Match("abdabc")
 Dim i As Integer = 0
 While Not (m.Groups(i).Value = "")    
    ' Add groups to string array.
    results.Add(m.Groups(i).Value)     
    ' Record character position. 
    matchposition.Add(m.Groups(i).Index) 
     i += 1
 End While

 ' Display the capture groups.
 For ctr As Integer = 0 to results.Count - 1
    Console.WriteLine("{0} at position {1}", _ 
                      results(ctr), matchposition(ctr))
 Next                     
' The example displays the following output:
'       abc at position 3
'       ab at position 3
'       b at position 4

List<int> matchposition = new List<int>();
List<string> results = new List<string>();
// Define substrings abc, ab, b.
Regex r = new Regex("(a(b))c"); 
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++) 
{
   // Add groups to string array.
   results.Add(m.Groups[i].Value); 
   // Record character position.
   matchposition.Add(m.Groups[i].Index); 
}

// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
   Console.WriteLine("{0} at position {1}", 
                     results[ctr], matchposition[ctr]);
// The example displays the following output:
//       abc at position 3
//       ab at position 3
//       b at position 4

다음 예제에서는 명명된 그룹화 구문을 사용하여 "DATANAME:VALUE" 형식의 데이터를 포함하는 문자열에서 부분 문자열을 캡처합니다. 이 정규식은 콜론(:)으로 두 값을 분할합니다.

Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Console.WriteLine(m.Groups("name").Value)
Console.WriteLine(m.Groups("value").Value)
' The example displays the following output:
'       Section1
'       119900

Regex r = new Regex("^(?<name>\\w+):(?<value>\\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
//       Section1
//       119900

^(?<name>\w+):(?<value>\w+) 정규식 패턴은 다음 표에서와 같이 정의됩니다.

패턴

설명

^

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

(?<name>\w+)

하나 이상의 단어 문자를 찾습니다. 이 캡처링 그룹의 이름은 name입니다.

:

콜론을 찾습니다.

(?<value>\w+)

하나 이상의 단어 문자를 찾습니다. 이 캡처링 그룹의 이름은 value입니다.

Group 클래스의 속성은 캡처된 그룹에 대한 정보를 제공합니다. Group.Value 속성은 캡처된 부분 문자열을 포함하고, Group.Index 속성은 캡처된 그룹이 입력 텍스트에서 시작되는 위치를 나타내고, Group.Length 속성은 캡처된 텍스트의 길이를 포함하고, Group.Success 속성은 캡처링 그룹으로 정의한 패턴과 부분 문자열이 일치하는지 여부를 나타냅니다.

그룹에 수량자를 적용하면 캡처와 캡처링 그룹 간 일대일 관계가 두 가지 방식으로 수정됩니다. 수량자 적용에 대한 자세한 내용은 수량자를 참조하십시오.

  • 0개 이상의 일치 항목을 지정하는 * 또는 *? 수량자가 그룹에 적용되면 캡처링 그룹에는 입력 문자열의 일치 항목이 포함되지 않을 수 있습니다. 캡처된 텍스트가 없는 경우 Group 개체의 속성은 다음 표에서와 같이 설정됩니다.

    그룹 속성

    값

    Success

    false

    Value

    String.Empty

    Length

    0

    다음 예제에서 이에 대해 설명합니다. aaa(bbb)*ccc 정규식 패턴에서 첫 번째 캡처링 그룹(부분 문자열 "bbb")은 해당하는 일치 항목이 없어도 됩니다. 입력 문자열이 "aaaccc"인 경우 이 패턴과 일치하게 되므로 첫 번째 캡처링 그룹에는 일치 항목이 없습니다.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "aaa(bbb)*ccc"
      Dim input As String = "aaaccc"
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match value: {0}", match.Value)
      If match.Groups(1).Success Then
         Console.WriteLine("Group 1 value: {0}", match.Groups(1).Value)
      Else
         Console.WriteLine("The first capturing group has no match.")
     End If   
   End Sub
End Module
' The example displays the following output:
'       Match value: aaaccc
'       The first capturing group has no match.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "aaa(bbb)*ccc";
      string input = "aaaccc";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match value: {0}", match.Value);
      if (match.Groups[1].Success)
         Console.WriteLine("Group 1 value: {0}", match.Groups[1].Value);
      else
         Console.WriteLine("The first capturing group has no match.");
   }
}
// The example displays the following output:
//       Match value: aaaccc
//       The first capturing group has no match.

  • 수량자는 캡처링 그룹으로 정의한 패턴의 문자열과 반복적으로 일치될 수 있습니다. 이 경우 Group 개체의 Value 및 Length 속성에는 마지막으로 캡처된 부분 문자열에 대한 정보만 포함됩니다. 예를 들어, 다음 정규식에서는 마침표로 끝나는 단일 문장을 찾습니다. 이 정규식은 두 개의 그룹화 구문을 사용합니다. 첫 번째 그룹화 구문에서는 공백 문자를 포함하는 개별 단어를 캡처하고, 두 번째 그룹화 구문에서는 개별 단어를 캡처합니다. 예제 출력을 통해 알 수 있듯이 정규식은 전체 문장을 캡처하는 데 성공하지만 두 번째 캡처링 그룹은 마지막 단어만 캡처합니다.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b((\w+)\s?)+\."
      Dim input As String = "This is a sentence. This is another sentence."
      Dim match As Match = Regex.Match(input, pattern)
      If match.Success Then
         Console.WriteLine("Match: " + match.Value)
         Console.WriteLine("Group 2: " + match.Groups(2).Value)
      End If   
   End Sub
End Module
' The example displays the following output:
'       Match: This is a sentence.
'       Group 2: sentence

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((\w+)\s?)+\.";
      string input = "This is a sentence. This is another sentence.";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Match: " + match.Value);
         Console.WriteLine("Group 2: " + match.Groups[2].Value);
      }   
   }
}
// The example displays the following output:
//       Match: This is a sentence.
//       Group 2: sentence

맨 위로 이동

캡처 컬렉션

Group 개체는 마지막 캡처에 대한 정보만 포함합니다. 그러나 캡처링 그룹에서 만든 캡처의 전체 집합은 Group.Captures 속성에서 반환하는 CaptureCollection 개체를 통해 계속 사용할 수 있습니다. 컬렉션의 각 멤버는 해당 캡처링 그룹에서 만든 캡처를 나타내는 Capture 개체입니다. 이 개체는 캡처된 순서, 즉 캡처된 문자열을 입력 문자열의 왼쪽에서부터 찾은 순서에 따라 컬렉션에 포함됩니다. 개별 Capture 개체는 다음 두 가지 방법 중 하나로 컬렉션에서 검색할 수 있습니다.

  • foreach(C#의 경우) 또는 For Each(Visual Basic의 경우) 같은 구문을 사용하여 컬렉션을 반복

  • CaptureCollection.Item 속성을 사용하여 인덱스로 특정 개체 검색. Item 속성은 CaptureCollection 개체의 기본 속성(Visual Basic의 경우) 또는 인덱서(C#의 경우)입니다.

수량자가 그룹에 적용되지 않는 경우 CaptureCollection 개체는 Capture 개체 하나를 포함합니다. 이 개체는 Group 개체와 동일한 일치 항목에 대한 정보를 제공하기 때문에 이점이 별로 없습니다. 수량자가 캡처링 그룹에 적용되면 CaptureCollection 개체는 해당 캡처링 그룹에서 만든 모든 캡처를 포함하고, Group 개체와 동일한 캡처를 나타내는 컬렉션의 마지막 멤버를 포함합니다.

예를 들어, ((a(b))c)+(여기서 + 수량자는 하나 이상의 일치 항목을 지정함) 정규식 패턴을 사용하여 "abcabcabc" 문자열에서 일치 항목을 캡처하는 경우 각 Group 개체에 대한 CaptureCollection 개체는 세 개의 멤버를 포함합니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "((a(b))c)+"
      Dim input As STring = "abcabcabc"

      Dim match As Match = Regex.Match(input, pattern)
      If match.Success Then
         Console.WriteLine("Match: '{0}' at position {1}", _ 
                           match.Value, match.Index)
         Dim groups As GroupCollection = match.Groups
         For ctr As Integer = 0 To groups.Count - 1
            Console.WriteLine("   Group {0}: '{1}' at position {2}", _
                              ctr, groups(ctr).Value, groups(ctr).Index)
            Dim captures As CaptureCollection = groups(ctr).Captures
            For ctr2 As Integer = 0 To captures.Count - 1
               Console.WriteLine("      Capture {0}: '{1}' at position {2}", _
                                 ctr2, captures(ctr2).Value, captures(ctr2).Index)
            Next
         Next
      End If
   End Sub
End Module
' The example dosplays the following output:
'       Match: 'abcabcabc' at position 0
'          Group 0: 'abcabcabc' at position 0
'             Capture 0: 'abcabcabc' at position 0
'          Group 1: 'abc' at position 6
'             Capture 0: 'abc' at position 0
'             Capture 1: 'abc' at position 3
'             Capture 2: 'abc' at position 6
'          Group 2: 'ab' at position 6
'             Capture 0: 'ab' at position 0
'             Capture 1: 'ab' at position 3
'             Capture 2: 'ab' at position 6
'          Group 3: 'b' at position 7
'             Capture 0: 'b' at position 1
'             Capture 1: 'b' at position 4
'             Capture 2: 'b' at position 7

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "((a(b))c)+";
      string input = "abcabcabc";

      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Match: '{0}' at position {1}",  
                           match.Value, match.Index);
         GroupCollection groups = match.Groups;
         for (int ctr = 0; ctr < groups.Count; ctr++) {
            Console.WriteLine("   Group {0}: '{1}' at position {2}", 
                              ctr, groups[ctr].Value, groups[ctr].Index);
            CaptureCollection captures = groups[ctr].Captures;
            for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
               Console.WriteLine("      Capture {0}: '{1}' at position {2}", 
                                 ctr2, captures[ctr2].Value, captures[ctr2].Index);
            }                     
         }
      }
   }
}
// The example displays the following output:
//       Match: 'abcabcabc' at position 0
//          Group 0: 'abcabcabc' at position 0
//             Capture 0: 'abcabcabc' at position 0
//          Group 1: 'abc' at position 6
//             Capture 0: 'abc' at position 0
//             Capture 1: 'abc' at position 3
//             Capture 2: 'abc' at position 6
//          Group 2: 'ab' at position 6
//             Capture 0: 'ab' at position 0
//             Capture 1: 'ab' at position 3
//             Capture 2: 'ab' at position 6
//          Group 3: 'b' at position 7
//             Capture 0: 'b' at position 1
//             Capture 1: 'b' at position 4
//             Capture 2: 'b' at position 7

다음 예제에서는 (Abc)+ 정규식을 사용하여 "XYZAbcAbcAbcXYZAbcAb" 문자열에서 연속적인 "Abc" 문자열을 하나 이상 찾습니다. 이 예제에서는 Group.Captures 속성을 사용하여 캡처링된 부분 문자열의 여러 그룹을 반환하는 것을 보여 줍니다.

Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection

' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+") 
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups

' Display the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())

' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
    cc = gc(i).Captures
    counter = cc.Count

    ' Display the number of captures in this group.
    Console.WriteLine("Captures count = " & counter.ToString())

    ' Loop through each capture in the group.            
    For ii = 0 To counter - 1
        ' Display the capture and its position.
        Console.WriteLine(cc(ii).ToString() _
            & "   Starts at character " & cc(ii).Index.ToString())
    Next ii
Next i
' The example displays the following output:
'       Captured groups = 2
'       Captures count = 1
'       AbcAbcAbc   Starts at character 3
'       Captures count = 3
'       Abc   Starts at character 3
'       Abc   Starts at character 6
'       Abc   Starts at character 9  

   int counter;
   Match m;
   CaptureCollection cc;
   GroupCollection gc;

   // Look for groupings of "Abc".
   Regex r = new Regex("(Abc)+"); 
   // Define the string to search.
   m = r.Match("XYZAbcAbcAbcXYZAbcAb"); 
   gc = m.Groups;

   // Display the number of groups.
   Console.WriteLine("Captured groups = " + gc.Count.ToString());

   // Loop through each group.
   for (int i=0; i < gc.Count; i++) 
   {
      cc = gc[i].Captures;
      counter = cc.Count;

      // Display the number of captures in this group.
      Console.WriteLine("Captures count = " + counter.ToString());

      // Loop through each capture in the group.
      for (int ii = 0; ii < counter; ii++) 
      {
         // Display the capture and its position.
         Console.WriteLine(cc[ii] + "   Starts at character " + 
              cc[ii].Index);
      }
   }
}
// The example displays the following output:
//       Captured groups = 2
//       Captures count = 1
//       AbcAbcAbc   Starts at character 3
//       Captures count = 3
//       Abc   Starts at character 3
//       Abc   Starts at character 6
//       Abc   Starts at character 9

맨 위로 이동

개별 캡처

Capture 클래스는 단일 하위 식 캡처 결과를 포함합니다. Capture.Value 속성은 일치하는 텍스트를 포함하고, Capture.Index 속성은 일치하는 부분 문자열이 입력 문자열에서 시작되는 위치(0부터 시작)를 나타냅니다.

다음 예제에서는 입력 문자열을 구문 분석하여 선택된 도시의 온도를 확인합니다. 쉼표(",")는 도시와 온도를 구분하기 위해 사용되고, 세미 콜론(";")은 각 도시 데이터를 구분하기 위해 사용됩니다. 전체 입력 문자열은 단일 일치 항목을 나타냅니다. 문자열 구문 분석에 사용되는 ((\w+(\s\w+)*),(\d+);)+ 정규식 패턴에서 도시 이름은 두 번째 캡처링 그룹에 할당되고 온도는 네 번째 캡처링 그룹에 할당됩니다.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;" 
      Dim pattern As String = "((\w+(\s\w+)*),(\d+);)+"
      Dim match As Match = Regex.Match(input, pattern)
      If match.Success Then
         Console.WriteLine("Current temperatures:")
         For ctr As Integer = 0 To match.Groups(2).Captures.Count - 1
            Console.WriteLine("{0,-20} {1,3}", match.Groups(2).Captures(ctr).Value, _
                              match.Groups(4).Captures(ctr).Value)
         Next
      End If
   End Sub
End Module
' The example displays the following output:
'       Current temperatures:
'       Miami                 78
'       Chicago               62
'       New York              67
'       San Francisco         59

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;"; 
      string pattern = @"((\w+(\s\w+)*),(\d+);)+";
      Match match = Regex.Match(input, pattern);
      if (match.Success)
      {
         Console.WriteLine("Current temperatures:");
         for (int ctr = 0; ctr < match.Groups[2].Captures.Count; ctr++)
            Console.WriteLine("{0,-20} {1,3}", match.Groups[2].Captures[ctr].Value, 
                              match.Groups[4].Captures[ctr].Value);
      }
   }
}
// The example displays the following output:
//       Current temperatures:
//       Miami                 78
//       Chicago               62
//       New York              67
//       San Francisco         59

정규식은 다음 표에서와 같이 정의됩니다.

패턴

설명

\w+

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

(\s\w+)*

하나 이상의 단어 문자 앞에 있는 0개 이상의 공백 문자를 찾습니다. 이 패턴은 여러 단어로 이루어진 도시 이름을 찾습니다. 이 그룹은 세 번째 캡처링 그룹입니다.

(\w+(\s\w+)*)

0개 이상의 공백 문자 및 하나 이상의 단어 문자 앞에 있는 하나 이상의 단어 문자를 찾습니다. 이 그룹은 두 번째 캡처링 그룹입니다.

,

쉼표를 찾습니다.

(\d+)

하나 이상의 10진수를 찾습니다. 이 그룹은 네 번째 캡처링 그룹입니다.

;

세미콜론을 찾습니다.

((\w+(\s\w+)*),(\d+);)+

단어로 시작하고 다른 단어, 쉼표, 하나 이상의 10진수, 세미콜론이 차례로 나열되어 한 번 이상 반복되는 패턴을 찾습니다. 이 그룹은 첫 번째 캡처링 그룹입니다.

맨 위로 이동

참고 항목

참조

System.Text.RegularExpressions

개념

.NET Framework 정규식

정규식 언어 요소