.NET 정규식.NET regular expressions

정규식은 텍스트를 처리하는 강력하고 유연하며 효율적인 방법을 제공합니다.Regular expressions provide a powerful, flexible, and efficient method for processing text. 정규식의 광범위한 패턴 일치 표기법을 사용하면 많은 양의 텍스트를 빠르게 구문 분석하여 다음을 할 수 있습니다.The extensive pattern-matching notation of regular expressions enables you to quickly parse large amounts of text to:

  • 특정 문자 패턴을 찾습니다.Find specific character patterns.
  • 텍스트의 유효성을 검사하여 미리 정의된 패턴(예: 전자 메일 주소)과 일치하는지 확인합니다.Validate text to ensure that it matches a predefined pattern (such as an email address).
  • 텍스트 하위 문자열을 추출, 편집, 바꾸기 또는 삭제합니다.Extract, edit, replace, or delete text substrings.
  • 보고서를 생성하기 위해 추출된 문자열을 컬렉션에 추가합니다.Add extracted strings to a collection in order to generate a report.

문자열을 처리하거나 텍스트의 큰 블록을 구문 분석하는 많은 애플리케이션의 경우 정규식은 필수적인 도구입니다.For many applications that deal with strings or that parse large blocks of text, regular expressions are an indispensable tool.

정규식의 작동 방식How regular expressions work

정규식을 사용하여 텍스트를 처리하는 중심에는 .NET에서 System.Text.RegularExpressions.Regex 개체로 표현되는 정규식 엔진이 있습니다.The centerpiece of text processing with regular expressions is the regular expression engine, which is represented by the System.Text.RegularExpressions.Regex object in .NET. 정규식을 사용하여 텍스트를 처리하려면 최소한 정규식 엔진이 다음과 같은 두 가지 정보 항목과 함께 제공되어야 합니다.At a minimum, processing text using regular expressions requires that the regular expression engine be provided with the following two items of information:

  • 텍스트에서 식별할 정규식 패턴The regular expression pattern to identify in the text.

    .NET에서 정규식 패턴은 특수 구문 또는 언어로 정의되며 Perl 5 정규식과 호환되고 오른쪽에서 왼쪽으로 일치와 같은 몇 가지 기능을 더 추가합니다.In .NET, regular expression patterns are defined by a special syntax or language, which is compatible with Perl 5 regular expressions and adds some additional features such as right-to-left matching. 자세한 내용은 정규식 언어 - 빠른 참조를 참조하세요.For more information, see Regular Expression Language - Quick Reference.

  • 정규식 패턴에 대해 구문 분석할 텍스트The text to parse for the regular expression pattern.

Regex 클래스의 메서드를 사용하여 다음과 같은 작업을 수행할 수 있습니다.The methods of the Regex class let you perform the following operations:

정규식 개체 모델의 개요는 정규식 개체 모델을 참조하세요.For an overview of the regular expression object model, see The Regular Expression Object Model.

정규식 언어에 대한 자세한 내용은 정규식 언어 - 빠른 참조를 참조하거나, 다음 브로슈어 중 하나를 다운로드하여 인쇄하세요.For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

정규식 예제Regular expression examples

String 클래스에는 큰 문자열에서 리터럴 문자열을 찾을 때 사용할 수 있는 다양한 문자열 검색 및 바꾸기 메서드가 포함되어 있습니다.The String class includes a number of string search and replacement methods that you can use when you want to locate literal strings in a larger string. 정규식은 다음 예제에서 보여 주는 것처럼 큰 문자열에서 여러 부분 문자열 중 하나를 찾거나 문자열에서 패턴을 식별할 때 가장 유용합니다.Regular expressions are most useful either when you want to locate one of several substrings in a larger string, or when you want to identify patterns in a string, as the following examples illustrate.

경고

System.Text.RegularExpressions를 사용하여 신뢰할 수 없는 입력을 처리하는 경우 시간 제한을 전달합니다.When using System.Text.RegularExpressions to process untrusted input, pass a timeout. 악의적인 사용자가 RegularExpressions에 대한 입력을 제공하여 서비스 거부 공격을 일으킬 수 있습니다.A malicious user can provide input to RegularExpressions causing a Denial-of-Service attack. RegularExpressions를 사용하는 ASP.NET Core Framework API는 시간 제한을 전달합니다.ASP.NET Core framework APIs that use RegularExpressions pass a timeout.

System.Web.RegularExpressions 네임스페이스에는 HTML, XML 및 ASP.NET 문서의 문자열을 구문 분석하기 위해 미리 정의된 정규식 패턴을 구현하는 여러 정규식 개체가 포함되어 있습니다.The System.Web.RegularExpressions namespace contains a number of regular expression objects that implement predefined regular expression patterns for parsing strings from HTML, XML, and ASP.NET documents. 예를 들어 TagRegex 클래스는 문자열의 시작 태그를 식별하고, CommentRegex 클래스는 문자열의 ASP.NET 주석을 식별합니다.For example, the TagRegex class identifies start tags in a string and the CommentRegex class identifies ASP.NET comments in a string.

예제 1: 하위 문자열 바꾸기Example 1: Replace substrings

메일 그룹에 경우에 따라 호칭(Mr., Mrs., Miss 또는 Ms.)이 이름 및 성과 함께 포함되어 있는 이름이 들어 있다고 가정합니다.Assume that a mailing list contains names that sometimes include a title (Mr., Mrs., Miss, or Ms.) along with a first and last name. 메일 그룹에서 봉투 레이블을 생성할 때 호칭을 포함하지 않으려는 경우 다음 예제에서 보여 주는 것처럼 정규식을 사용하여 호칭을 제거할 수 있습니다.If you do not want to include the titles when you generate envelope labels from the list, you can use a regular expression to remove the titles, as the following example illustrates.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(Mr\\.? |Mrs\\.? |Miss |Ms\\.? )";
      string[] names = { "Mr. Henry Hunt", "Ms. Sara Samuels",
                         "Abraham Adams", "Ms. Nicole Norris" };
      foreach (string name in names)
         Console.WriteLine(Regex.Replace(name, pattern, String.Empty));
   }
}
// The example displays the following output:
//    Henry Hunt
//    Sara Samuels
//    Abraham Adams
//    Nicole Norris
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(Mr\.? |Mrs\.? |Miss |Ms\.? )"
        Dim names() As String = {"Mr. Henry Hunt", "Ms. Sara Samuels", _
                                  "Abraham Adams", "Ms. Nicole Norris"}
        For Each name As String In names
            Console.WriteLine(Regex.Replace(name, pattern, String.Empty))
        Next
    End Sub
End Module
' The example displays the following output:
'    Henry Hunt
'    Sara Samuels
'    Abraham Adams
'    Nicole Norris

정규식 패턴 (Mr\.? |Mrs\.? |Miss |Ms\.? )는 모든 "Mr", "Mr.", "Mrs", "Mrs.", "Miss", "Ms" 또는 "Ms."가 발생하는 것과 일치합니다.The regular expression pattern (Mr\.? |Mrs\.? |Miss |Ms\.? ) matches any occurrence of "Mr ", "Mr. ", "Mrs ", "Mrs. ", "Miss ", "Ms or "Ms. ". Regex.Replace 메서드에 대한 호출은 일치하는 문자열을 String.Empty로 바꿉니다. 즉, 원래 문자열에서 일치하는 문자열을 제거합니다.The call to the Regex.Replace method replaces the matched string with String.Empty; in other words, it removes it from the original string.

예제 2: 중복된 단어 식별Example 2: Identify duplicated words

실수로 단어를 중복하는 것은 작성자가 흔히 하는 실수입니다.Accidentally duplicating words is a common error that writers make. 다음 예제에서 보여 주는 것처럼 정규식을 사용하여 중복된 단어를 식별할 수 있습니다.A regular expression can be used to identify duplicated words, as the following example shows.

using System;
using System.Text.RegularExpressions;

public class Class1
{
   public static void Main()
   {
      string pattern = @"\b(\w+?)\s\1\b";
      string input = "This this is a nice day. What about this? This tastes good. I saw a a dog.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("{0} (duplicates '{1}') at position {2}",
                           match.Value, match.Groups[1].Value, match.Index);
   }
}
// The example displays the following output:
//       This this (duplicates 'This') at position 0
//       a a (duplicates 'a') at position 66
Imports System.Text.RegularExpressions

Module modMain
    Public Sub Main()
        Dim pattern As String = "\b(\w+?)\s\1\b"
        Dim input As String = "This this is a nice day. What about this? This tastes good. I saw a a dog."
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
            Console.WriteLine("{0} (duplicates '{1}') at position {2}", _
                              match.Value, match.Groups(1).Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       This this (duplicates 'This') at position 0
'       a a (duplicates 'a') at position 66

정규식 패턴 \b(\w+?)\s\1\b는 다음과 같이 해석될 수 있습니다.The regular expression pattern \b(\w+?)\s\1\b can be interpreted as follows:

무늬Pattern 해석Interpretation
\b 단어 경계를 시작합니다.Start at a word boundary.
(\w+?) 하나 이상의 단어 문자(가능한 한 적은 문자)를 찾습니다.Match one or more word characters, but as few characters as possible. 이러한 단어 문자는 함께 \1이라고 할 수 있는 그룹을 형성합니다.Together, they form a group that can be referred to as \1.
\s 공백 문자를 찾습니다.Match a white-space character.
\1 \1이라는 그룹과 같은 부분 문자열을 찾습니다.Match the substring that is equal to the group named \1.
\b 단어 경계를 찾습니다.Match a word boundary.

Regex.Matches 메서드가 정규식 옵션이 RegexOptions.IgnoreCase로 설정된 상태로 호출됩니다.The Regex.Matches method is called with regular expression options set to RegexOptions.IgnoreCase. 따라서 찾기 작업은 대/소문자를 구분하지 않으며, 이 예제에서는 부분 문자열 "This this"를 중복으로 식별합니다.Therefore, the match operation is case-insensitive, and the example identifies the substring "This this" as a duplication.

입력 문자열에 하위 문자열 “this?The input string includes the substring "this? This"가 포함되어 있습니다.This". 그러나 문장 부호가 중간에 있어 이는 중복으로 식별되지 않습니다.However, because of the intervening punctuation mark, it is not identified as a duplication.

예제 3: 동적으로 문화권 구분 정규식 작성Example 3: Dynamically build a culture-sensitive regular expression

다음 예제에서는 정규식이 .NET의 전역화 기능에서 제공하는 유연성과 결합되었을 때의 성능을 설명합니다.The following example illustrates the power of regular expressions combined with the flexibility offered by .NET's globalization features. 이 예제에서는 NumberFormatInfo 개체를 사용하여 시스템의 현재 문화권의 통화 값 형식을 확인합니다.It uses the NumberFormatInfo object to determine the format of currency values in the system's current culture. 그런 다음 해당 정보를 사용하여 텍스트에서 통화 값을 추출하는 정규식을 동적으로 구성합니다.It then uses that information to dynamically construct a regular expression that extracts currency values from the text. 각 일치 항목에 대해 숫자 문자열만 포함된 하위 그룹을 추출하여 Decimal 값으로 변환하고 누계를 계산합니다.For each match, it extracts the subgroup that contains the numeric string only, converts it to a Decimal value, and calculates a running total.

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

public class Example
{
   public static void Main()
   {
      // Define text to be parsed.
      string input = "Office expenses on 2/13/2008:\n" +
                     "Paper (500 sheets)                      $3.95\n" +
                     "Pencils (box of 10)                     $1.00\n" +
                     "Pens (box of 10)                        $4.49\n" +
                     "Erasers                                 $2.19\n" +
                     "Ink jet printer                        $69.95\n\n" +
                     "Total Expenses                        $ 81.58\n";

      // Get current culture's NumberFormatInfo object.
      NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
      // Assign needed property values to variables.
      string currencySymbol = nfi.CurrencySymbol;
      bool symbolPrecedesIfPositive = nfi.CurrencyPositivePattern % 2 == 0;
      string groupSeparator = nfi.CurrencyGroupSeparator;
      string decimalSeparator = nfi.CurrencyDecimalSeparator;

      // Form regular expression pattern.
      string pattern = Regex.Escape( symbolPrecedesIfPositive ? currencySymbol : "") +
                       @"\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" +
                       Regex.Escape(decimalSeparator) + "[0-9]+)?)" +
                       (! symbolPrecedesIfPositive ? currencySymbol : "");
      Console.WriteLine( "The regular expression pattern is:");
      Console.WriteLine("   " + pattern);

      // Get text that matches regular expression pattern.
      MatchCollection matches = Regex.Matches(input, pattern,
                                              RegexOptions.IgnorePatternWhitespace);
      Console.WriteLine("Found {0} matches.", matches.Count);

      // Get numeric string, convert it to a value, and add it to List object.
      List<decimal> expenses = new List<Decimal>();

      foreach (Match match in matches)
         expenses.Add(Decimal.Parse(match.Groups[1].Value));

      // Determine whether total is present and if present, whether it is correct.
      decimal total = 0;
      foreach (decimal value in expenses)
         total += value;

      if (total / 2 == expenses[expenses.Count - 1])
         Console.WriteLine("The expenses total {0:C2}.", expenses[expenses.Count - 1]);
      else
         Console.WriteLine("The expenses total {0:C2}.", total);
   }
}
// The example displays the following output:
//       The regular expression pattern is:
//          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
//       Found 6 matches.
//       The expenses total $81.58.
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
    Public Sub Main()
        ' Define text to be parsed.
        Dim input As String = "Office expenses on 2/13/2008:" + vbCrLf + _
                              "Paper (500 sheets)                      $3.95" + vbCrLf + _
                              "Pencils (box of 10)                     $1.00" + vbCrLf + _
                              "Pens (box of 10)                        $4.49" + vbCrLf + _
                              "Erasers                                 $2.19" + vbCrLf + _
                              "Ink jet printer                        $69.95" + vbCrLf + vbCrLf + _
                              "Total Expenses                        $ 81.58" + vbCrLf
        ' Get current culture's NumberFormatInfo object.
        Dim nfi As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
        ' Assign needed property values to variables.
        Dim currencySymbol As String = nfi.CurrencySymbol
        Dim symbolPrecedesIfPositive As Boolean = CBool(nfi.CurrencyPositivePattern Mod 2 = 0)
        Dim groupSeparator As String = nfi.CurrencyGroupSeparator
        Dim decimalSeparator As String = nfi.CurrencyDecimalSeparator

        ' Form regular expression pattern.
        Dim pattern As String = Regex.Escape(CStr(IIf(symbolPrecedesIfPositive, currencySymbol, ""))) + _
                                "\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" + _
                                Regex.Escape(decimalSeparator) + "[0-9]+)?)" + _
                                CStr(IIf(Not symbolPrecedesIfPositive, currencySymbol, ""))
        Console.WriteLine("The regular expression pattern is: ")
        Console.WriteLine("   " + pattern)

        ' Get text that matches regular expression pattern.
        Dim matches As MatchCollection = Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
        Console.WriteLine("Found {0} matches. ", matches.Count)

        ' Get numeric string, convert it to a value, and add it to List object.
        Dim expenses As New List(Of Decimal)

        For Each match As Match In matches
            expenses.Add(Decimal.Parse(match.Groups.Item(1).Value))
        Next

        ' Determine whether total is present and if present, whether it is correct.
        Dim total As Decimal
        For Each value As Decimal In expenses
            total += value
        Next

        If total / 2 = expenses(expenses.Count - 1) Then
            Console.WriteLine("The expenses total {0:C2}.", expenses(expenses.Count - 1))
        Else
            Console.WriteLine("The expenses total {0:C2}.", total)
        End If
    End Sub
End Module
' The example displays the following output:
'       The regular expression pattern is:
'          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
'       Found 6 matches.
'       The expenses total $81.58.

현재 문화권이 영어 - 미국(en-US)인 컴퓨터에서 이 예제를 실행할 경우 정규식 \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)가 동적으로 작성됩니다.On a computer whose current culture is English - United States (en-US), the example dynamically builds the regular expression \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?). 이 정규식 패턴은 다음과 같이 해석될 수 있습니다.This regular expression pattern can be interpreted as follows:

무늬Pattern 해석Interpretation
\$ 입력 문자열에서 단일 달러 기호($)를 찾습니다.Look for a single occurrence of the dollar symbol ($) in the input string. 정규식 패턴 문자열에는 백슬래시가 포함되어 달러 기호가 정규식 앵커로 해석되는 것이 아니라 리터럴로 해석될 것임을 나타냅니다.The regular expression pattern string includes a backslash to indicate that the dollar symbol is to be interpreted literally rather than as a regular expression anchor. ($ 기호 단독으로는 정규식 엔진이 문자열의 끝 부분에서 찾기를 시작하려고 해야 한다는 사실을 나타냅니다.) 현재 문화권의 통화 기호가 정규식 기호로 잘못 해석되지 않도록 하기 위해 이 예제에서는 Regex.Escape 메서드를 호출하여 문자를 이스케이프합니다.(The $ symbol alone would indicate that the regular expression engine should try to begin its match at the end of a string.) To ensure that the current culture's currency symbol is not misinterpreted as a regular expression symbol, the example calls the Regex.Escape method to escape the character.
\s* 0개 이상의 공백 문자를 찾습니다.Look for zero or more occurrences of a white-space character.
[-+]? 0개 이상의 더하기 기호 또는 빼기 기호를 찾습니다.Look for zero or one occurrence of either a positive sign or a negative sign.
([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) 이 식을 둘러싼 바깥쪽 괄호는 이 식을 캡처링 그룹 또는 하위 식으로 정의합니다.The outer parentheses around this expression define it as a capturing group or a subexpression. 일치 항목을 찾은 경우 일치하는 문자열의 이 부분에 대한 정보는 Group 속성에서 반환하는 GroupCollection 개체의 두 번째 Match.Groups 개체에서 검색할 수 있습니다.If a match is found, information about this part of the matching string can be retrieved from the second Group object in the GroupCollection object returned by the Match.Groups property. (컬렉션의 첫 번째 요소는 전체 일치를 나타냅니다.)(The first element in the collection represents the entire match.)
[0-9]{0,3} 10진수 0-9를 0~3개 찾습니다.Look for zero to three occurrences of the decimal digits 0 through 9.
(,[0-9]{3})* 그룹 구분 기호 하나 다음에 세 개의 10진수가 있는 0개 이상의 일치 항목을 찾습니다.Look for zero or more occurrences of a group separator followed by three decimal digits.
\. 단일 소수 구분 기호를 찾습니다.Look for a single occurrence of the decimal separator.
[0-9]+ 하나 이상의 10진수를 찾습니다.Look for one or more decimal digits.
(\.[0-9]+)? 소수 구분 기호 다음에 하나 이상의 10진수가 있는 0개 이상의 일치 항목을 찾습니다.Look for zero or one occurrence of the decimal separator followed by at least one decimal digit.

입력 문자열에서 이러한 각 하위 패턴을 찾은 경우 찾기가 성공하고 일치 항목에 대한 정보가 포함된 Match 개체가 MatchCollection 개체에 추가됩니다.If each of these subpatterns is found in the input string, the match succeeds, and a Match object that contains information about the match is added to the MatchCollection object.

제목Title 설명Description
정규식 언어 - 빠른 참조Regular Expression Language - Quick Reference 정규식을 정의하는 데 사용할 수 있는 문자, 연산자 및 생성자 집합에 대한 정보를 제공합니다.Provides information on the set of characters, operators, and constructs that you can use to define regular expressions.
정규식 개체 모델The Regular Expression Object Model 정규식 클래스를 사용하는 방법을 보여 주는 코드 예제 및 정보를 제공합니다.Provides information and code examples that illustrate how to use the regular expression classes.
정규식 동작 정보Details of Regular Expression Behavior .NET 정규식의 기능 및 동작에 대한 정보를 제공합니다.Provides information about the capabilities and behavior of .NET regular expressions.
Visual Studio에서 정규식 사용Use regular expressions in Visual Studio

참고Reference