정규식의 문자 클래스Character classes in regular expressions

문자 클래스는 문자 집합을 정의하며, 이 중 하나가 입력 문자열에서 발생하면 일치하는 것으로 판정할 수 있습니다.A character class defines a set of characters, any one of which can occur in an input string for a match to succeed. .NET의 정규식 언어는 다음과 같은 문자 클래스를 지원합니다.The regular expression language in .NET supports the following character classes:

  • 긍정 문자 그룹.Positive character groups. 입력 문자열의 문자는 지정된 문자 집합 중 하나와 일치해야 합니다.A character in the input string must match one of a specified set of characters. 자세한 내용은 긍정 문자 그룹을 참조하세요.For more information, see Positive Character Group.

  • 부정 문자 그룹.Negative character groups. 입력 문자열의 문자는 지정된 문자 집합 중 하나와 일치하면 안 됩니다.A character in the input string must not match one of a specified set of characters. 자세한 내용은 부정 문자 그룹을 참조하세요.For more information, see Negative Character Group.

  • 임의의 문자.Any character. 정규식의 .(점 또는 마침표) 문자는 \n을 제외한 모든 문자와 일치하는 와일드카드 문자입니다.The . (dot or period) character in a regular expression is a wildcard character that matches any character except \n. 자세한 내용은 임의의 문자를 참조하세요.For more information, see Any Character.

  • 일반 유니코드 범주 또는 명명된 블록입니다.A general Unicode category or named block. 입력 문자열의 문자는 일치하는 것으로 판정하려면 특정 유니코드 범주의 멤버이거나 유니코드 문자의 연속된 범위 내에 있어야 합니다.A character in the input string must be a member of a particular Unicode category or must fall within a contiguous range of Unicode characters for a match to succeed. 자세한 내용은 유니코드 범주 또는 유니코드 블록을 참조하세요.For more information, see Unicode Category or Unicode Block.

  • 부정 일반 유니코드 범주 또는 명명된 블록입니다.A negative general Unicode category or named block. 입력 문자열의 문자는 일치하는 것으로 판정하려면 특정 유니코드 범주의 멤버가 아니거나 유니코드 문자의 연속된 범위 내에 있으면 안 됩니다.A character in the input string must not be a member of a particular Unicode category or must not fall within a contiguous range of Unicode characters for a match to succeed. 자세한 내용은 부정 유니코드 범주 또는 유니코드 블록을 참조하세요.For more information, see Negative Unicode Category or Unicode Block.

  • 단어 문자입니다.A word character. 입력 문자열의 문자는 단어에 있는 문자에 적합한 유니코드 범주에 속할 수 있습니다.A character in the input string can belong to any of the Unicode categories that are appropriate for characters in words. 자세한 내용은 단어 문자를 참조하세요.For more information, see Word Character.

  • 비단어 문자입니다.A non-word character. 입력 문자열의 문자는 단어 문자가 아닌 유니코드 범주에 속할 수 있습니다.A character in the input string can belong to any Unicode category that is not a word character. 자세한 내용은 단어가 아닌 문자를 참조하세요.For more information, see Non-Word Character.

  • 공백 문자.A white-space character. 입력 문자열의 문자는 유니코드 구분 문자뿐만 아니라 많은 제어 문자 중 하나가 될 수 있습니다.A character in the input string can be any Unicode separator character, as well as any one of a number of control characters. 자세한 내용은 공백 문자를 참조하세요.For more information, see White-Space Character.

  • 공백이 아닌 문자.A non-white-space character. 입력 문자열의 문자는 공백 문자가 아닌 문자를 사용할 수 있습니다.A character in the input string can be any character that is not a white-space character. 자세한 내용은 공백이 아닌 문자를 참조하세요.For more information, see Non-White-Space Character.

  • 10진수입니다.A decimal digit. 입력 문자열의 문자는 유니코드 10진 자릿수로 분류된 모든 문자가 될 수 있습니다.A character in the input string can be any of a number of characters classified as Unicode decimal digits. 자세한 내용은 10진수 숫자 문자를 참조하세요.For more information, see Decimal Digit Character.

  • 10진수가 아닙니다.A non-decimal digit. 입력 문자열의 문자는 유니코드 10진수 이외의 문자는 모두 사용할 수 있습니다.A character in the input string can be anything other than a Unicode decimal digit. 자세한 내용은 10진수 숫자 문자를 참조하세요.For more information, see Decimal Digit Character.

.NET에서는 한 문자 클래스에서 다른 문자 클래스를 제외한 결과로 문자 집합을 정의하는 데 사용할 수 있는 문자 클래스 빼기 식을 지원합니다..NET supports character class subtraction expressions, which enables you to define a set of characters as the result of excluding one character class from another character class. 자세한 내용은 문자 클래스 빼기를 참조하세요.For more information, see Character Class Subtraction.

참고

일치하는 단어 문자를 검색하는 \w 또는 일치하는 유니코드 범주를 검색하는 \p{}와 같이 범주별로 일치하는 문자를 검색하는 문자 클래스는 CharUnicodeInfo 클래스를 활용하여 문자 범주에 대한 정보를 제공합니다.Character classes that match characters by category, such as \w to match word characters or \p{} to match a Unicode category, rely on the CharUnicodeInfo class to provide information about character categories. .NET Framework 4.6.2부터, 문자 범주는 유니코드 표준, 버전 8.0.0을 기준으로 합니다.Starting with the .NET Framework 4.6.2, character categories are based on The Unicode Standard, Version 8.0.0. .NET Framework 4에서 .NET Framework 4.6.1까지는 유니코드 표준, 버전 6.3.0을 기반으로 합니다.In the .NET Framework 4 through the .NET Framework 4.6.1, they are based on The Unicode Standard, Version 6.3.0.

긍정 문자 그룹: [ ]Positive character group: [ ]

긍정 문자 그룹은 일치 항목으로 간주되려면 입력 문자열에 나타날 수 있는 문자 목록을 지정합니다.A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. 이 문자 목록은 개별적으로, 범위로 또는 둘 다 지정할 수 있습니다.This list of characters may be specified individually, as a range, or both.

개별 문자 목록을 지정하는 구문은 다음과 같습니다.The syntax for specifying a list of individual characters is as follows:

[*character_group*]

여기서 character_group은 일치가 성공하기 위해 입력 문자열에 나타날 수 있는 개별 문자 목록입니다.where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group은 하나 이상의 리터럴 문자, 이스케이프 문자 또는 문자 클래스로 이루어진 조합으로 구성될 수 있습니다.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

문자의 범위를 지정하는 구문은 다음과 같습니다.The syntax for specifying a range of characters is as follows:

[firstCharacter-lastCharacter]

여기서 firstCharacter는 범위를 시작하는 문자이고 lastCharacter는 범위를 끝내는 문자입니다.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. 문자 범위는 일련의 문자로서, 문자 범위를 정의하려면 연속된 문자 중 첫 번째 문자와 마지막 문자를 하이픈(-)으로 연결하여 지정합니다.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. 두 문자의 유니코드 코드 포인트가 연속되면 이 두 문자는 연속된 문자입니다.Two characters are contiguous if they have adjacent Unicode code points. firstCharacter는 낮은 코드 포인트를 가진 문자여야 하며 lastCharacter는 높은 코드 포인트를 가진 문자여야 합니다.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

참고

양수 문자 그룹에는 문자 세트와 문자 범위가 모두 포함될 수 있기 때문에, 하이픈 문자(-)는 그룹의 첫 번째 또는 마지막 문자가 아닌 한 항상 범위 구분 기호로 해석됩니다.Because a positive character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

긍정 문자 클래스가 포함된 몇 가지 일반적인 정규식 패턴은 다음과 같습니다.Some common regular expression patterns that contain positive character classes are listed in the following table.

무늬Pattern 설명Description
[aeiou] 모든 모음을 찾습니다.Match all vowels.
[\p{P}\d] 모든 문장 부호 및 10진수 문자를 찾습니다.Match all punctuation and decimal digit characters.
[\s\p{P}] 모든 공백 및 문장 부호를 찾습니다.Match all white space and punctuation.

다음 예제에서는 입력 문자열이 문자 "grey" 또는 "gray"에 이어 일치할 다른 일치 단어를 포함하도록 단어 "a"와 "e"가 포함된 긍정 문자 그룹을 정의합니다.The following example defines a positive character group that contains the characters "a" and "e" so that the input string must contain the words "grey" or "gray" followed by another word for a match to occur.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine($"'{match.Value}'");
   }
}
// The example displays the following output:
//       'gray wolf '
//       'grey wall.'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
      Dim input As String = "The gray wolf jumped over the grey wall."
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      For Each match As Match In matches
         Console.WriteLine($"'{match.Value}'")
      Next
   End Sub
End Module
' The example displays the following output:
'       'gray wolf '
'       'grey wall.'

gr[ae]y\s\S+?[\s|\p{P}] 정규식은 다음과 같이 정의됩니다.The regular expression gr[ae]y\s\S+?[\s|\p{P}] is defined as follows:

무늬Pattern 설명Description
gr 리터럴 문자 "gr"을 찾습니다.Match the literal characters "gr".
[ae] "a" 또는 "e"를 찾습니다.Match either an "a" or an "e".
y\s 리터럴 문자 y 다음에 공백 문자를 찾습니다.Match the literal character "y" followed by a white-space character.
\S+? 하나 이상의 공백이 아닌 문자이지만 가능한 적은 문자를 찾습니다.Match one or more non-white-space characters, but as few as possible.
[\s\p{P}] 공백 문자 또는 문장 부호를 찾습니다.Match either a white-space character or a punctuation mark.

다음 예제에서는 모든 대문자로 시작하는 단어를 찾습니다.The following example matches words that begin with any capital letter. A-Z의 대문자로 범위를 나타내기 위해 [A-Z] 하위 식을 사용합니다.It uses the subexpression [A-Z] to represent the range of capital letters from A to Z.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[A-Z]\w*\b"
      Dim input As String = "A city Albany Zulu maritime Marseilles"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module

\b[A-Z]\w*\b 정규식은 다음 테이블과 같이 정의됩니다.The regular expression \b[A-Z]\w*\b is defined as shown in the following table.

무늬Pattern 설명Description
\b 단어 경계를 시작합니다.Start at a word boundary.
[A-Z] A-Z의 대문자를 모두 찾습니다.Match any uppercase character from A to Z.
\w* 0개 이상의 단어 문자를 찾습니다.Match zero or more word characters.
\b 단어 경계를 찾습니다.Match a word boundary.

부정 문자 그룹: [^]Negative character group: [^]

부정 문자 그룹은 일치 항목으로 간주되려면 입력 문자열에 나타나서는 안 되는 문자 목록을 지정합니다.A negative character group specifies a list of characters that must not appear in an input string for a match to occur. 문자 목록은 개별적으로, 범위로 또는 둘 다 지정할 수 있습니다.The list of characters may be specified individually, as a range, or both.

개별 문자 목록을 지정하는 구문은 다음과 같습니다.The syntax for specifying a list of individual characters is as follows:

[*^character_group*]

여기서 character_group은 일치가 성공하기 위해 입력 문자열에 나타날 수 없는 개별 문자 목록입니다.where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group은 하나 이상의 리터럴 문자, 이스케이프 문자 또는 문자 클래스로 이루어진 조합으로 구성될 수 있습니다.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

문자의 범위를 지정하는 구문은 다음과 같습니다.The syntax for specifying a range of characters is as follows:

[^*firstCharacter*-*lastCharacter*]

여기서 firstCharacter는 범위를 시작하는 문자이고 lastCharacter는 범위를 끝내는 문자입니다.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. 문자 범위는 일련의 문자로서, 문자 범위를 정의하려면 연속된 문자 중 첫 번째 문자와 마지막 문자를 하이픈(-)으로 연결하여 지정합니다.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. 두 문자의 유니코드 코드 포인트가 연속되면 이 두 문자는 연속된 문자입니다.Two characters are contiguous if they have adjacent Unicode code points. firstCharacter는 낮은 코드 포인트를 가진 문자여야 하며 lastCharacter는 높은 코드 포인트를 가진 문자여야 합니다.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

참고

음수 문자 그룹에는 문자 세트와 문자 범위가 모두 포함될 수 있기 때문에, 하이픈 문자(-)는 그룹의 첫 번째 또는 마지막 문자가 아닌 한 항상 범위 구분 기호로 해석됩니다.Because a negative character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

두 개 이상의 문자 범위를 연결할 수도 있습니다.Two or more character ranges can be concatenated. 예를 들어, "0"부터 "9"까지의 10진수 범위, "a"부터 "f"까지의 소문자 범위 및 "A"부터 "F"까지의 대문자 범위를 지정하려면 [0-9a-fA-F]를 사용합니다.For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].

부정 문자 그룹에서 맨 앞의 캐럿 문자(^)는 필수 문자로서, 해당 문자 그룹이 긍정 문자 그룹이 아니라 부정 문자 그룹임을 나타냅니다.The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.

중요

큰 정규식 패턴에서 부정 문자 그룹은 너비가 0인 어설션이 아닙니다.A negative character group in a larger regular expression pattern is not a zero-width assertion. 즉, 부정 문자 그룹을 평가한 후 정규식 엔진은 입력 문자열에서 한 문자를 이동합니다.That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.

부정 문자 그룹이 포함된 몇 가지 일반적인 정규식 패턴은 다음과 같습니다.Some common regular expression patterns that contain negative character groups are listed in the following table.

무늬Pattern 설명Description
[^aeiou] 모음을 제외한 모든 문자를 찾습니다.Match all characters except vowels.
[^\p{P}\d] 문장 부호 및 10진수 문자를 제외한 모든 문자를 찾습니다.Match all characters except punctuation and decimal digit characters.

다음 예제에서는 "th" 문자로 시작하고 이어서 "o"가 나오지 않는 단어를 찾습니다.The following example matches any word that begins with the characters "th" and is not followed by an "o".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bth[^o]\w+\b"
      Dim input As String = "thought thing though them through thus " + _
                            "thorough this"
      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:
'       thing
'       them
'       through
'       thus
'       this

\bth[^o]\w+\b 정규식은 다음 테이블과 같이 정의됩니다.The regular expression \bth[^o]\w+\b is defined as shown in the following table.

무늬Pattern 설명Description
\b 단어 경계를 시작합니다.Start at a word boundary.
th 리터럴 문자 "th"를 찾습니다.Match the literal characters "th".
[^o] "o"가 아닌 모든 문자를 찾습니다.Match any character that is not an "o".
\w+ 하나 이상의 단어 문자를 찾습니다.Match one or more word characters.
\b 단어 경계를 종료합니다.End at a word boundary.

임의의 문자: .Any character: .

마침표 문자(.)는 \n(줄바꿈 문자, \u000A)를 제외하고 다음 두 한정자가 있는 모든 문자를 찾습니다.The period character (.) matches any character except \n (the newline character, \u000A), with the following two qualifications:

  • 정규식 패턴이 RegexOptions.Singleline 옵션에 의해 수정되거나 . 문자 클래스를 포함하는 패턴의 일부가 s 옵션에 의해 수정되는 경우 .가 문자를 일치시킵니다.If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the s option, . matches any character. 자세한 내용은 정규식 옵션을 참조하세요.For more information, see Regular Expression Options.

    다음 예제에서는 기본 및 . 옵션으로 RegexOptions.Singleline 문자 클래스의 다른 동작을 보여줍니다.The following example illustrates the different behavior of the . character class by default and with the RegexOptions.Singleline option. 정규식 ^.+는 문자열의 시작 부분에서 시작하여 모든 문자를 찾습니다.The regular expression ^.+ starts at the beginning of the string and matches every character. 기본적으로 일치는 첫 번째 줄의 끝 부분에서 끝납니다. 정규식 패턴은 캐리지 리턴 문자, \r 또는 \u000D와 일치하지만 \n과는 일치하지 않습니다.By default, the match ends at the end of the first line; the regular expression pattern matches the carriage return character, \r or \u000D, but it does not match \n. RegexOptions.Singleline 옵션은 전체 입력 문자열을 한 줄로 해석하기 때문에 \n을 포함하여 입력 문자열의 모든 문자와 일치합니다.Because the RegexOptions.Singleline option interprets the entire input string as a single line, it matches every character in the input string, including \n.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = "^.+";
          string input = "This is one line and" + Environment.NewLine + "this is the second.";
          foreach (Match match in Regex.Matches(input, pattern))
             Console.WriteLine(Regex.Escape(match.Value));
    
          Console.WriteLine();
          foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
             Console.WriteLine(Regex.Escape(match.Value));
       }
    }
    // The example displays the following output:
    //       This\ is\ one\ line\ and\r
    //       
    //       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          Dim pattern As String = "^.+"
          Dim input As String = "This is one line and" + vbCrLf + "this is the second."
          For Each match As Match In Regex.Matches(input, pattern)
             Console.WriteLine(Regex.Escape(match.Value))
          Next
          Console.WriteLine()
          For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
             Console.WriteLine(Regex.Escape(match.Value))
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       This\ is\ one\ line\ and\r
    '       
    '       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
    

참고

\n을 제외한 모든 문자와 일치하기 때문에 . 문자 클래스가 \r(캐리지 리턴 문자, \u000D)과도 일치합니다.Because it matches any character except \n, the . character class also matches \r (the carriage return character, \u000D).

  • 긍정 또는 부정 문자 그룹의 마침표는 문자 클래스가 아니라 리터럴 마침표 문자로 처리됩니다.In a positive or negative character group, a period is treated as a literal period character, and not as a character class. 자세한 내용은 이 항목 앞부분의 긍정 문자 그룹부정 문자 그룹을 참조하세요.For more information, see Positive Character Group and Negative Character Group earlier in this topic. 다음 예제는 문자 클래스와 긍정 문자 그룹으로 마침표 문자(.)를 포함하는 정규식을 정의하는 그림을 제공합니다.The following example provides an illustration by defining a regular expression that includes the period character (.) both as a character class and as a member of a positive character group. \b.*[.?!;:](\s|\z) 정규식은 단어 경계에서 시작하여 마침표를 포함하여 다섯 가지 문장 부호 중 하나와 만날 때까지 임의의 문자를 찾은 다음 공백 문자 또는 문자열 끝을 찾습니다.The regular expression \b.*[.?!;:](\s|\z) begins at a word boundary, matches any character until it encounters one of five punctuation marks, including a period, and then matches either a white-space character or the end of the string.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = @"\b.*[.?!;:](\s|\z)";
          string input = "this. what: is? go, thing.";
          foreach (Match match in Regex.Matches(input, pattern))
             Console.WriteLine(match.Value);
       }
    }
    // The example displays the following output:
    //       this. what: is? go, thing.
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          Dim pattern As STring = "\b.*[.?!;:](\s|\z)"
          Dim input As String = "this. what: is? go, thing."
          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:
    '       this. what: is? go, thing.
    

참고

모든 문자와 일치하기 때문에 . 언어 요소는 정규식 패턴이 여러 번 임의의 문자와 일치하도록 시도할 경우 종종 lazy 수량자와 함께 사용됩니다.Because it matches any character, the . language element is often used with a lazy quantifier if a regular expression pattern attempts to match any character multiple times. 자세한 내용은 수량자를 참조하세요.For more information, see Quantifiers.

유니코드 범주 또는 유니코드 블록: \p{}Unicode category or Unicode block: \p{}

유니코드 표준에서는 각 문자를 일반 범주에 할당합니다.The Unicode standard assigns each character a general category. 예를 들어, 특정 문자는 대문자(Lu 범주로 표현), 10진수(Nd 범주), 수학 기호(Sm 범주) 또는 단락 구분 기호(Zl 범주)가 될 수 있습니다.For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). 유니코드 표준의 특정 문자 집합이 특정 범위 또는 연속된 코드 포인트의 블록도 차지합니다.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. 예를 들어, 기본 라틴 문자 집합은 \u0000부터 \u007F까지에서 발견되고, 아랍어 문자 집합이 \u0600부터 \u06FF까지에서 발견됩니다.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

정규식 만들기The regular expression construct

\p{ name }\p{ name }

유니코드 일반 범주 또는 명명된 블록에 속하는 모든 문자를 찾습니다. 여기서 name은 범주 약어 또는 명명된 블록 이름입니다.matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. 범주 약어 목록은 이 항목의 뒷부분에 있는 지원되는 유니코드 일반 범주 섹션을 참조하세요.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. 명명된 블록 목록은 이 항목의 뒷부분에 있는 지원되는 명명된 블록 섹션을 참조하세요.For a list of named blocks, see the Supported Named Blocks section later in this topic.

다음 예제에서는 \p{name} 구문을 사용하여 유니코드 일반 범주(이 경우 Pd 또는 문장 부호, 대시 범주) 및 명명된 블록(명명된 블록 IsGreekIsBasicLatin)을 모두 찾습니다.The following example uses the \p{name} construct to match both a Unicode general category (in this case, the Pd, or Punctuation, Dash category) and a named block (the IsGreek and IsBasicLatin named blocks).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

      Console.WriteLine(Regex.IsMatch(input, pattern));        // Displays True.
   }
}
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
      Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

      Console.WriteLine(Regex.IsMatch(input, pattern))         ' Displays True.
   End Sub
End Module

\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ 정규식은 다음 테이블과 같이 정의됩니다.The regular expression \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ is defined as shown in the following table.

무늬Pattern 설명Description
\b 단어 경계를 시작합니다.Start at a word boundary.
\p{IsGreek}+ 둘 이상의 그리스어 문자를 찾습니다.Match one or more Greek characters.
(\s)? 0번 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space character.
(\p{IsGreek}+(\s)?)+ 하나 이상의 그리스 문자 다음에 0개 또는 1개의 공백 문자가 한 번 이상 나타나는 패턴을 찾습니다.Match the pattern of one or more Greek characters followed by zero or one white-space characters one or more times.
\p{Pd} 문장 부호, 대시 문자를 찾습니다.Match a Punctuation, Dash character.
\s 공백 문자를 찾습니다.Match a white-space character.
\p{IsBasicLatin}+ 하나 이상의 기본 라틴 문자를 찾습니다.Match one or more basic Latin characters.
(\s)? 0번 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space character.
(\p{IsBasicLatin}+(\s)?)+ 하나 이상의 기본 라틴 문자 다음에 0개 또는 1개의 공백 문자가 한 번 이상 나타나는 패턴을 찾습니다.Match the pattern of one or more basic Latin characters followed by zero or one white-space characters one or more times.

부정 유니코드 범주 또는 유니코드 블록: \P{}Negative Unicode category or Unicode block: \P{}

유니코드 표준에서는 각 문자를 일반 범주에 할당합니다.The Unicode standard assigns each character a general category. 예를 들어, 특정 문자는 대문자(Lu 범주로 표현), 10진수(Nd 범주), 수학 기호(Sm 범주) 또는 단락 구분 기호(Zl 범주)가 될 수 있습니다.For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). 유니코드 표준의 특정 문자 집합이 특정 범위 또는 연속된 코드 포인트의 블록도 차지합니다.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. 예를 들어, 기본 라틴 문자 집합은 \u0000부터 \u007F까지에서 발견되고, 아랍어 문자 집합이 \u0600부터 \u06FF까지에서 발견됩니다.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

정규식 만들기The regular expression construct

\P{ name }\P{ name }

유니코드 일반 범주 또는 명명된 블록에 속하지 않는 모든 문자를 찾습니다. 여기서 name은 범주 약어 또는 명명된 블록 이름입니다.matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. 범주 약어 목록은 이 항목의 뒷부분에 있는 지원되는 유니코드 일반 범주 섹션을 참조하세요.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. 명명된 블록 목록은 이 항목의 뒷부분에 있는 지원되는 명명된 블록 섹션을 참조하세요.For a list of named blocks, see the Supported Named Blocks section later in this topic.

다음 예제에서는 \P{name} 구문을 사용하여 숫자 문자열에서 모든 통화 기호(이 경우, Sc 또는 기호, 통화 범주)를 제거합니다.The following example uses the \P{name} construct to remove any currency symbols (in this case, the Sc, or Symbol, Currency category) from numeric strings.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";
      
      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\P{Sc})+"
      
      Dim values() As String = { "$164,091.78", "£1,073,142.68", "73¢", "€120"}
      For Each value As String In values
         Console.WriteLine(Regex.Match(value, pattern).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

정규식 패턴 (\P{Sc})+는 통화 기호가 아닌 하나 이상의 문자를 찾습니다. 결과 문자열에서 모든 통화 기호를 효과적으로 제거합니다.The regular expression pattern (\P{Sc})+ matches one or more characters that are not currency symbols; it effectively strips any currency symbol from the result string.

단어 문자: \wWord character: \w

\w는 단어 문자를 찾습니다.\w matches any word character. 단어 문자는 다음 표에 나열된 유니코드 범주의 멤버입니다.A word character is a member of any of the Unicode categories listed in the following table.

범주Category 설명Description
LlLl 문자, 소문자Letter, Lowercase
LuLu 문자, 대문자Letter, Uppercase
LtLt 문자, 제목 스타일Letter, Titlecase
LoLo 문자, 기타Letter, Other
LmLm 문자, 한정자Letter, Modifier
MnMn 표시, 공백 없음Mark, Nonspacing
NdNd 숫자, 10진수Number, Decimal Digit
PcPc 문장 부호, 연결자.Punctuation, Connector. 이 범주는 가장 일반적으로 사용되는 LOWLINE 문자 (), U + 005F인 10개의 문자를 포함합니다.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

ECMAScript와 호환되는 동작을 지정한 경우 \w[a-zA-Z_0-9]와 같습니다.If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9]. ECMAScript 정규식에 대한 자세한 내용은 정규식 옵션에서 "ECMAScript 일치 동작" 섹션을 참조하세요.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

참고

모든 단어 문자와 일치하기 때문에 \w 언어 요소는 정규식 패턴이 특정 단어 문자가 따라오는 임의의 단어 문자를 여러 번 찾으려 하는 경우 lazy 수량자와 함께 사용되는 경우가 많습니다.Because it matches any word character, the \w language element is often used with a lazy quantifier if a regular expression pattern attempts to match any word character multiple times, followed by a specific word character. 자세한 내용은 수량자를 참조하세요.For more information, see Quantifiers.

다음 예제에서는 \w 언어 요소를 사용하여 단어의 중복 문자를 찾습니다.The following example uses the \w language element to match duplicate characters in a word. 예제는 다음과 같이 해석될 수 있는 정규식 패턴 (\w)\1을 정의합니다.The example defines a regular expression pattern, (\w)\1, which can be interpreted as follows.

요소Element 설명Description
(\w)(\w) 단어 문자를 찾습니다.Match a word character. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group.
\1\1 첫 번째 캡처의 값을 찾습니다.Match the value of the first capture.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer", 
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", 
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }                                                  
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w)\1"
      Dim words() As String = { "trellis", "seer", "latter", "summer", _
                                "hoarse", "lesser", "aardvark", "stunned" }
      For Each word As String In words
         Dim match As Match = Regex.Match(word, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                              match.Value, word, match.Index)
         Else
            Console.WriteLine("No double characters in '{0}'.", word)
         End If
      Next                                                  
   End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

단어가 아닌 문자: \WNon-word character: \W

\W는 비단어 문자를 찾습니다.\W matches any non-word character. \W 언어 요소는 다음 문자 클래스에 해당합니다.The \W language element is equivalent to the following character class:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]

즉, 다음 표에 나열된 유니코드 범주의 문자를 제외한 모든 문자를 찾습니다.In other words, it matches any character except for those in the Unicode categories listed in the following table.

범주Category 설명Description
LlLl 문자, 소문자Letter, Lowercase
LuLu 문자, 대문자Letter, Uppercase
LtLt 문자, 제목 스타일Letter, Titlecase
LoLo 문자, 기타Letter, Other
LmLm 문자, 한정자Letter, Modifier
MnMn 표시, 공백 없음Mark, Nonspacing
NdNd 숫자, 10진수Number, Decimal Digit
PcPc 문장 부호, 연결자.Punctuation, Connector. 이 범주는 가장 일반적으로 사용되는 LOWLINE 문자 (), U + 005F인 10개의 문자를 포함합니다.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

ECMAScript와 호환되는 동작을 지정한 경우 \W[^a-zA-Z_0-9]와 같습니다.If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9]. ECMAScript 정규식에 대한 자세한 내용은 정규식 옵션에서 "ECMAScript 일치 동작" 섹션을 참조하세요.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

참고

모든 비단어 문자와 일치하기 때문에 \W 언어 요소는 정규식 패턴이 특정 비단어 문자가 따라오는 임의의 비단어 문자를 여러 번 찾으려 하는 경우 lazy 수량자와 함께 사용되는 경우가 많습니다.Because it matches any non-word character, the \W language element is often used with a lazy quantifier if a regular expression pattern attempts to match any non-word character multiple times followed by a specific non-word character. 자세한 내용은 수량자를 참조하세요.For more information, see Quantifiers.

다음 예제에서는 \W 문자 클래스를 보여 줍니다.The following example illustrates the \W character class. 공백 또는 문장 부호와 같은 한두 개의 비단어 문자가 따라오는 단어와 일치하는 정규식 패턴 \b(\w+)(\W){1,2}를 정의합니다.It defines a regular expression pattern, \b(\w+)(\W){1,2}, that matches a word followed by one or two non-word characters, such as white space or punctuation. 정규식은 다음 표와 같이 해석됩니다.The regular expression is interpreted as shown in the following table.

요소Element 설명Description
\b\b 단어 경계에서 일치 항목 찾기를 시작합니다.Begin the match at a word boundary.
(\w+)(\w+) 하나 이상의 단어 문자를 찾습니다.Match one or more word characters. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group.
(\W){1,2}(\W){1,2} 단어가 아닌 문자를 한 개 또는 두 개 찾습니다.Match a non-word character either one or two times. 이 그룹은 두 번째 캡처링 그룹입니다.This is the second capturing group.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value, 
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"), 
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\w+)(\W){1,2}"
      Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         Console.Write("   Non-word character(s):")
         Dim captures As CaptureCollection = match.Groups(2).Captures
         For ctr As Integer = 0 To captures.Count - 1
             Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                           Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                           If(ctr < captures.Count - 1, ", ", ""))
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

두 번째 캡처링 그룹의 Group 개체가 단일 캡처된 비단어 문자만 포함하기 때문에 예제에서는 CaptureCollection 속성에 의해 반환되는 Group.Captures 개체에서 모든 캡처된 비단어 문자를 검색합니다.Because the Group object for the second capturing group contains only a single captured non-word character, the example retrieves all captured non-word characters from the CaptureCollection object that is returned by the Group.Captures property.

공백 문자: \sWhitespace character: \s

\s는 공백 문자를 찾습니다.\s matches any whitespace character. 다음 표에 나열된 이스케이프 시퀀스 및 유니코드 범주와 동일합니다.It is equivalent to the escape sequences and Unicode categories listed in the following table.

범주Category 설명Description
\f 용지 공급 문자, \u000C.The form feed character, \u000C.
\n 줄 바꿈 문자, \u000A.The newline character, \u000A.
\r 캐리지 리턴 문자 \u000D입니다.The carriage return character, \u000D.
\t 탭 문자, \u0009.The tab character, \u0009.
\v 세로 탭 문자, \u000B.The vertical tab character, \u000B.
\x85 줄임표 또는 NEXT LINE (NEL) 문자 (…), \u0085.The ellipsis or NEXT LINE (NEL) character (…), \u0085.
\p{Z} 임의의 구분 기호 문자와 일치합니다.Matches any separator character.

ECMAScript와 호환되는 동작을 지정한 경우 \s[ \f\n\r\t\v]와 같습니다.If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v]. ECMAScript 정규식에 대한 자세한 내용은 정규식 옵션에서 "ECMAScript 일치 동작" 섹션을 참조하세요.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

다음 예제에서는 \s 문자 클래스를 보여 줍니다.The following example illustrates the \s character class. "s" 또는 "es"로 끝나고 그 뒤에 공백 문자나 입력 문자열의 끝이 있는 단어와 일치하는 정규식 패턴 \b\w+(e)?s(\s|$)를 정의합니다.It defines a regular expression pattern, \b\w+(e)?s(\s|$), that matches a word ending in either "s" or "es" followed by either a white-space character or the end of the input string. 정규식은 다음 표와 같이 해석됩니다.The regular expression is interpreted as shown in the following table.

요소Element 설명Description
\b\b 단어 경계에서 일치 항목 찾기를 시작합니다.Begin the match at a word boundary.
\w+\w+ 하나 이상의 단어 문자를 찾습니다.Match one or more word characters.
(e)?(e)? "e"를 0개 또는 한 개 찾습니다.Match an "e" either zero or one time.
s "s"를 찾습니다.Match an "s".
(\s|$)(\s|$) 공백 문자 또는 입력 문자열의 끝을 찾습니다.Match either a white-space character or the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)?s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(e)?s(\s|$)"
      Dim input As String = "matches stores stops leave leaves"
      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:
'       matches
'       stores
'       stops
'       leaves

공백이 아닌 문자: \SNon-whitespace character: \S

\S는 공백 문자가 아닌 문자를 찾습니다.\S matches any non-white-space character. [^\f\n\r\t\v\x85\p{Z}] 정규식 패턴과 동일하거나, 공백 문자와 일치하는 \s과 동일한 정규식 패턴의 반대입니다.It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. 자세한 내용은 공백 문자: \s를 참조하세요.For more information, see White-Space Character: \s.

ECMAScript와 호환되는 동작을 지정한 경우 \S[^ \f\n\r\t\v]와 같습니다.If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v]. ECMAScript 정규식에 대한 자세한 내용은 정규식 옵션에서 "ECMAScript 일치 동작" 섹션을 참조하세요.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

다음 예제에서는 \S 언어 요소를 보여 줍니다.The following example illustrates the \S language element. 정규식 패턴 \b(\S+)\s?는 공백 문자로 구분된 문자열을 찾습니다.The regular expression pattern \b(\S+)\s? matches strings that are delimited by white-space characters. 일치 GroupCollection 개체의 두 번째 요소는 일치하는 문자열을 포함합니다.The second element in the match's GroupCollection object contains the matched string. 정규식은 다음 표에 나와 있는 것처럼 해석할 수 있습니다.The regular expression can be interpreted as shown in the following table.

요소Element 설명Description
\b 단어 경계에서 일치 항목 찾기를 시작합니다.Begin the match at a word boundary.
(\S+) 공백이 아닌 문자를 하나 이상 찾습니다.Match one or more non-white-space characters. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group.
\s? 0번 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space character.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s?";
      string input = "This is the first sentence of the first paragraph. " + 
                            "This is the second sentence.\n" + 
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\S+)\s?"
      Dim input As String = "This is the first sentence of the first paragraph. " + _
                            "This is the second sentence." + vbCrLf + _
                            "This is the only sentence of the second paragraph."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Groups(1))
      Next
   End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

10진수 문자: \dDecimal digit character: \d

\d는 10진수를 찾습니다.\d matches any decimal digit. 많은 다른 문자 집합의 10진수뿐만 아니라 표준 10진수 0-9를 포함하는 \p{Nd} 정규식 패턴과 동일합니다.It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets.

ECMAScript와 호환되는 동작을 지정한 경우 \d[0-9]와 같습니다.If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9]. ECMAScript 정규식에 대한 자세한 내용은 정규식 옵션에서 "ECMAScript 일치 동작" 섹션을 참조하세요.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

다음 예제에서는 \d 언어 요소를 보여 줍니다.The following example illustrates the \d language element. 입력 문자열이 미국 및 캐나다의 올바른 전화 번호를 나타내는지 여부를 테스트합니다.It tests whether an input string represents a valid telephone number in the United States and Canada. 정규식 패턴 ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ 는 다음 테이블과 같이 정의됩니다.The regular expression pattern ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ is defined as shown in the following table.

요소Element 설명Description
^ 입력 문자열의 시작 부분에서 일치 항목 찾기를 시작합니다.Begin the match at the beginning of the input string.
\(? 0개 또는 한 개의 리터럴 "(" 문자를 찾습니다.Match zero or one literal "(" character.
\d{3} 세 개의 10진수를 찾습니다.Match three decimal digits.
\)? 0개 또는 한 개의 리터럴 ")" 문자를 찾습니다.Match zero or one literal ")" character.
[\s-] 하이픈 또는 공백 문자를 찾습니다.Match a hyphen or a white-space character.
(\(?\d{3}\)?[\s-])? 옵션 여는 괄호에 이어 세 개의 10진수, 옵션 닫는 괄호 및 공백 문자나 하이픈 0개 또는 1개를 찾습니다.Match an optional opening parenthesis followed by three decimal digits, an optional closing parenthesis, and either a white-space character or a hyphen zero or one time. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group.
\d{3}-\d{4} 세 개의 10진수, 하이픈, 네 개 이상의 10진수를 찾습니다.Match three decimal digits followed by a hyphen and four more decimal digits.
$ 입력 문자열의 끝 부분을 찾습니다.Match the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444", 
                          "(212) 111-1111", "111-AB1-1111", 
                          "212-111-1111", "01 999-9999" };
      
      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern)) 
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
      Dim inputs() As String = { "111 111-1111", "222-2222", "222 333-444", _
                                 "(212) 111-1111", "111-AB1-1111", _
                                 "212-111-1111", "01 999-9999" }
      
      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then 
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

숫자가 아닌 문자: \DNon-digit character: \D

\D는 숫자가 아닌 문자를 찾습니다.\D matches any non-digit character. \P{Nd} 정규식 패턴과 동일합니다.It is equivalent to the \P{Nd} regular expression pattern.

ECMAScript와 호환되는 동작을 지정한 경우 \D[^0-9]와 같습니다.If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9]. ECMAScript 정규식에 대한 자세한 내용은 정규식 옵션에서 "ECMAScript 일치 동작" 섹션을 참조하세요.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

다음 예제에서는 \D 언어 요소를 보여 줍니다.The following example illustrates the \D language element. 부품 번호 같은 문자열이 10진수 문자 및 10진수가 아닌 문자의 적절한 조합으로 구성되어 있는지 여부를 테스트합니다.It tests whether a string such as a part number consists of the appropriate combination of decimal and non-decimal characters. 정규식 패턴 ^\D\d{1,5}\D*$ 는 다음 테이블과 같이 정의됩니다.The regular expression pattern ^\D\d{1,5}\D*$ is defined as shown in the following table.

요소Element 설명Description
^ 입력 문자열의 시작 부분에서 일치 항목 찾기를 시작합니다.Begin the match at the beginning of the input string.
\D 숫자가 아닌 문자를 찾습니다.Match a non-digit character.
\d{1,5} 1~5의 10진수를 찾습니다.Match from one to five decimal digits.
\D* 0개 또는 하나 이상의 10진수가 아닌 문자를 찾습니다.Match zero, one, or more non-decimal characters.
$ 입력 문자열의 끝 부분을 찾습니다.Match the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$"; 
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" }; 
      
      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^\D\d{1,5}\D*$" 
      Dim inputs() As String = { "A1039C", "AA0001", "C18A", "Y938518" } 
      
      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:

지원되는 유니코드 일반 범주Supported Unicode general categories

유니코드는 다음 표에 나와 있는 일반 범주를 정의합니다.Unicode defines the general categories listed in the following table. 자세한 내용은 유니코드 문자 데이터베이스의 하위 항목인 "UCD 파일 형식"과 "일반 범주 값"을 참조하세요.For more information, see the "UCD File Format" and "General Category Values" subtopics at the Unicode Character Database.

범주Category 설명Description
Lu 문자, 대문자Letter, Uppercase
Ll 문자, 소문자Letter, Lowercase
Lt 문자, 제목 스타일Letter, Titlecase
Lm 문자, 한정자Letter, Modifier
Lo 문자, 기타Letter, Other
L 모든 문자All letter characters. 여기에는 Lu, Ll, Lt, LmLo 문자가 포함됩니다.This includes the Lu, Ll, Lt, Lm, and Lo characters.
Mn 표시, 공백 없음Mark, Nonspacing
Mc 표시, 공백 조합Mark, Spacing Combining
Me 표시, 묶기Mark, Enclosing
M 모든 분음 기호All diacritic marks. 여기에는 Mn, McMe 범주가 포함됩니다.This includes the Mn, Mc, and Me categories.
Nd 숫자, 10진수Number, Decimal Digit
Nl 숫자, 문자Number, Letter
No 숫자, 기타Number, Other
N 모든 숫자.All numbers. 여기에는 Nd, NlNo 범주가 포함됩니다.This includes the Nd, Nl, and No categories.
Pc 문장 부호, 연결자Punctuation, Connector
Pd 문장 부호, 대시Punctuation, Dash
Ps 문장 부호, 열기Punctuation, Open
Pe 문장 부호, 닫기Punctuation, Close
Pi 문장 부호, 처음 따옴표(사용 방식에 따라 Ps 또는 Pe와 같이 동작)Punctuation, Initial quote (may behave like Ps or Pe depending on usage)
Pf 문장 부호, 마지막 따옴표(사용 방식에 따라 Ps 또는 Pe와 같이 동작)Punctuation, Final quote (may behave like Ps or Pe depending on usage)
Po 문장 부호, 기타Punctuation, Other
P 모든 구두점 문자.All punctuation characters. 여기에는 Pc, Pd, Ps, Pe, Pi, PfPo 범주가 포함됩니다.This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.
Sm 기호, 수학Symbol, Math
Sc 기호, 통화Symbol, Currency
Sk 기호, 한정자Symbol, Modifier
So 기호, 기타Symbol, Other
S 모든 기호.All symbols. 여기에는 Sm, Sc, SkSo 범주가 포함됩니다.This includes the Sm, Sc, Sk, and So categories.
Zs 구분 기호, 공백Separator, Space
Zl 구분 기호, 줄Separator, Line
Zp 구분 기호, 단락Separator, Paragraph
Z 모든 구분 기호 문자.All separator characters. 여기에는 Zs, ZlZp 범주가 포함됩니다.This includes the Zs, Zl, and Zp categories.
Cc 기타, 제어Other, Control
Cf 기타, 서식Other, Format
Cs 기타, 서로게이트Other, Surrogate
Co 기타, 전용 항목Other, Private Use
Cn 기타, 지정되지 않음(이 속성을 가진 문자가 없음)Other, Not Assigned (no characters have this property)
C 모든 제어 문자.All control characters. 여기에는 Cc, Cf, Cs, CoCn 범주가 포함됩니다.This includes the Cc, Cf, Cs, Co, and Cn categories.

해당 문자를 GetUnicodeCategory 메서드로 전달하여 특정 문자의 유니코드 범주를 확인할 수 있습니다.You can determine the Unicode category of any particular character by passing that character to the GetUnicodeCategory method. 다음 예제에서는 GetUnicodeCategory 메서드를 사용하여 선택한 라틴 문자를 포함하는 배열에서 각 요소의 범주를 결정합니다.The following example uses the GetUnicodeCategory method to determine the category of each element in an array that contains selected Latin characters.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };
      
      foreach (char ch in chars)
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), 
                           Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim chars() As Char = { "a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c }
      
      For Each ch As Char In chars
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                           Char.GetUnicodeCategory(ch))
      Next         
   End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

지원되는 명명된 블록Supported named blocks

.NET에서는 다음 표에 나와 있는 명명된 블록을 제공합니다..NET provides the named blocks listed in the following table. 지원되는 명명된 블록 집합은 유니코드 4.0 및 Perl 5.6을 기반으로 합니다.The set of supported named blocks is based on Unicode 4.0 and Perl 5.6. 명명된 블록을 사용하는 정규식에 대해서는 유니코드 범주 또는 유니코드 블록: \p{} 섹션을 참조하세요.For a regular expression that uses named blocks, see the Unicode category or Unicode block: \p{} section.

코드 포인트 범위Code point range 블록 이름Block name
0000 - 007F0000 - 007F IsBasicLatin
0080 - 00FF0080 - 00FF IsLatin-1Supplement
0100 - 017F0100 - 017F IsLatinExtended-A
0180 - 024F0180 - 024F IsLatinExtended-B
0250 - 02AF0250 - 02AF IsIPAExtensions
02B0 - 02FF02B0 - 02FF IsSpacingModifierLetters
0300 - 036F0300 - 036F IsCombiningDiacriticalMarks
0370 - 03FF0370 - 03FF IsGreek

또는-or-

IsGreekandCoptic
0400 - 04FF0400 - 04FF IsCyrillic
0500 - 052F0500 - 052F IsCyrillicSupplement
0530 - 058F0530 - 058F IsArmenian
0590 - 05FF0590 - 05FF IsHebrew
0600 - 06FF0600 - 06FF IsArabic
0700 - 074F0700 - 074F IsSyriac
0780 - 07BF0780 - 07BF IsThaana
0900 - 097F0900 - 097F IsDevanagari
0980 - 09FF0980 - 09FF IsBengali
0A00 - 0A7F0A00 - 0A7F IsGurmukhi
0A80 - 0AFF0A80 - 0AFF IsGujarati
0B00 - 0B7F0B00 - 0B7F IsOriya
0B80 - 0BFF0B80 - 0BFF IsTamil
0C00 - 0C7F0C00 - 0C7F IsTelugu
0C80 - 0CFF0C80 - 0CFF IsKannada
0D00 - 0D7F0D00 - 0D7F IsMalayalam
0D80 - 0DFF0D80 - 0DFF IsSinhala
0E00 - 0E7F0E00 - 0E7F IsThai
0E80 - 0EFF0E80 - 0EFF IsLao
0F00 - 0FFF0F00 - 0FFF IsTibetan
1000 - 109F1000 - 109F IsMyanmar
10A0 - 10FF10A0 - 10FF IsGeorgian
1100 - 11FF1100 - 11FF IsHangulJamo
1200 - 137F1200 - 137F IsEthiopic
13A0 - 13FF13A0 - 13FF IsCherokee
1400 - 167F1400 - 167F IsUnifiedCanadianAboriginalSyllabics
1680 - 169F1680 - 169F IsOgham
16A0 - 16FF16A0 - 16FF IsRunic
1700 - 171F1700 - 171F IsTagalog
1720 - 173F1720 - 173F IsHanunoo
1740 - 175F1740 - 175F IsBuhid
1760 - 177F1760 - 177F IsTagbanwa
1780 - 17FF1780 - 17FF IsKhmer
1800 - 18AF1800 - 18AF IsMongolian
1900 - 194F1900 - 194F IsLimbu
1950 - 197F1950 - 197F IsTaiLe
19E0 - 19FF19E0 - 19FF IsKhmerSymbols
1D00 - 1D7F1D00 - 1D7F IsPhoneticExtensions
1E00 - 1EFF1E00 - 1EFF IsLatinExtendedAdditional
1F00 - 1FFF1F00 - 1FFF IsGreekExtended
2000 - 206F2000 - 206F IsGeneralPunctuation
2070 - 209F2070 - 209F IsSuperscriptsandSubscripts
20A0 - 20CF20A0 - 20CF IsCurrencySymbols
20D0 - 20FF20D0 - 20FF IsCombiningDiacriticalMarksforSymbols

또는-or-

IsCombiningMarksforSymbols
2100 - 214F2100 - 214F IsLetterlikeSymbols
2150 - 218F2150 - 218F IsNumberForms
2190 - 21FF2190 - 21FF IsArrows
2200 - 22FF2200 - 22FF IsMathematicalOperators
2300 - 23FF2300 - 23FF IsMiscellaneousTechnical
2400 - 243F2400 - 243F IsControlPictures
2440 - 245F2440 - 245F IsOpticalCharacterRecognition
2460 - 24FF2460 - 24FF IsEnclosedAlphanumerics
2500 - 257F2500 - 257F IsBoxDrawing
2580 - 259F2580 - 259F IsBlockElements
25A0 - 25FF25A0 - 25FF IsGeometricShapes
2600 - 26FF2600 - 26FF IsMiscellaneousSymbols
2700 - 27BF2700 - 27BF IsDingbats
27C0 - 27EF27C0 - 27EF IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF27F0 - 27FF IsSupplementalArrows-A
2800 - 28FF2800 - 28FF IsBraillePatterns
2900 - 297F2900 - 297F IsSupplementalArrows-B
2980 - 29FF2980 - 29FF IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF2A00 - 2AFF IsSupplementalMathematicalOperators
2B00 - 2BFF2B00 - 2BFF IsMiscellaneousSymbolsandArrows
2E80 - 2EFF2E80 - 2EFF IsCJKRadicalsSupplement
2F00 - 2FDF2F00 - 2FDF IsKangxiRadicals
2FF0 - 2FFF2FF0 - 2FFF IsIdeographicDescriptionCharacters
3000 - 303F3000 - 303F IsCJKSymbolsandPunctuation
3040 - 309F3040 - 309F IsHiragana
30A0 - 30FF30A0 - 30FF IsKatakana
3100 - 312F3100 - 312F IsBopomofo
3130 - 318F3130 - 318F IsHangulCompatibilityJamo
3190 - 319F3190 - 319F IsKanbun
31A0 - 31BF31A0 - 31BF IsBopomofoExtended
31F0 - 31FF31F0 - 31FF IsKatakanaPhoneticExtensions
3200 - 32FF3200 - 32FF IsEnclosedCJKLettersandMonths
3300 - 33FF3300 - 33FF IsCJKCompatibility
3400 - 4DBF3400 - 4DBF IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF4DC0 - 4DFF IsYijingHexagramSymbols
4E00 - 9FFF4E00 - 9FFF IsCJKUnifiedIdeographs
A000 - A48FA000 - A48F IsYiSyllables
A490 - A4CFA490 - A4CF IsYiRadicals
AC00 - D7AFAC00 - D7AF IsHangulSyllables
D800 - DB7FD800 - DB7F IsHighSurrogates
DB80 - DBFFDB80 - DBFF IsHighPrivateUseSurrogates
DC00 - DFFFDC00 - DFFF IsLowSurrogates
E000 - F8FFE000 - F8FF IsPrivateUse 또는 IsPrivateUseAreaIsPrivateUse or IsPrivateUseArea
F900 - FAFFF900 - FAFF IsCJKCompatibilityIdeographs
FB00 - FB4FFB00 - FB4F IsAlphabeticPresentationForms
FB50 - FDFFFB50 - FDFF IsArabicPresentationForms-A
FE00 - FE0FFE00 - FE0F IsVariationSelectors
FE20 - FE2FFE20 - FE2F IsCombiningHalfMarks
FE30 - FE4FFE30 - FE4F IsCJKCompatibilityForms
FE50 - FE6FFE50 - FE6F IsSmallFormVariants
FE70 - FEFFFE70 - FEFF IsArabicPresentationForms-B
FF00 - FFEFFF00 - FFEF IsHalfwidthandFullwidthForms
FFF0 - FFFFFFF0 - FFFF IsSpecials

문자 클래스 빼기: [base_group - [excluded_group]]Character class subtraction: [base_group - [excluded_group]]

문자 클래스는 문자 집합을 정의합니다.A character class defines a set of characters. 문자 클래스 빼기는 한 문자 클래스에서 다른 문자 클래스의 문자를 제외한 결과로 문자 집합을 생성합니다.Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class.

문자 클래스 빼기 식의 형식은 다음과 같습니다.A character class subtraction expression has the following form:

[ base_group -[ excluded_group ]][ base_group -[ excluded_group ]]

대괄호([])와 하이픈(-)은 필수 요소입니다.The square brackets ([]) and hyphen (-) are mandatory. base_group긍정 문자 그룹 또는 부정 문자 그룹입니다.The base_group is a positive character group or a negative character group. excluded_group 구성 요소는 다른 긍정 또는 부정 문자 그룹이거나 다른 문자 클래스 빼기 식입니다. 즉, 문자 클래스 빼기 식을 중첩할 수 있습니다.The excluded_group component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions).

예를 들어, "a"부터 "z"까지의 문자 범위로 구성된 기본 그룹이 있다고 가정합니다.For example, suppose you have a base group that consists of the character range from "a" through "z". 문자 "m"을 제외한 기본 그룹으로 구성된 문자 집합을 정의하려면 [a-z-[m]]을 사용합니다.To define the set of characters that consists of the base group except for the character "m", use [a-z-[m]]. 문자 "d", "j" 및 "p"를 제외한 기본 그룹으로 구성된 문자 집합을 정의하려면 [a-z-[djp]]를 사용합니다.To define the set of characters that consists of the base group except for the set of characters "d", "j", and "p", use [a-z-[djp]]. "m"부터 "p"까지의 문자 범위를 제외한 기본 그룹으로 구성된 문자 집합을 정의하려면 [a-z-[m-p]]를 사용합니다.To define the set of characters that consists of the base group except for the character range from "m" through "p", use [a-z-[m-p]].

중첩된 문자 클래스 빼기 식인 [a-z-[d-w-[m-o]]]를 고려합니다.Consider the nested character class subtraction expression, [a-z-[d-w-[m-o]]]. 가장 안쪽 문자 범위에서 바깥쪽으로 식이 계산됩니다.The expression is evaluated from the innermost character range outward. 먼저 'd'부터 'w'까지의 문자 범위에서 "m"부터 "o"까지의 문자 범위를 뺍니다. 그러면 "d"부터 "l"까지와 "p"부터 "w"까지의 문자로 구성된 문자 집합이 생성됩니다.First, the character range from "m" through "o" is subtracted from the character range "d" through "w", which yields the set of characters from "d" through "l" and "p" through "w". 그런 다음 "a"부터 "z"까지의 문자 범위에서 이 집합을 뺍니다. 그러면 문자 집합 [abcmnoxyz]가 생성됩니다.That set is then subtracted from the character range from "a" through "z", which yields the set of characters [abcmnoxyz].

모든 문자 클래스에 문자 클래스 빼기를 사용할 수 있습니다.You can use any character class with character class subtraction. \u0000부터 \uFFFF까지의 문자에서 공백 문자(\s), 문장 부호 일반 범주의 문자(\p{P}), 명명된 블록 IsGreek의 문자(\p{IsGreek}) 및 유니코드 NEXT LINE 제어 문자(\x85)를 제외한 모든 유니코드 문자로 구성된 문자 집합을 정의하려면 [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]]를 사용합니다.To define the set of characters that consists of all Unicode characters from \u0000 through \uFFFF except white-space characters (\s), the characters in the punctuation general category (\p{P}), the characters in the IsGreek named block (\p{IsGreek}), and the Unicode NEXT LINE control character (\x85), use [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

문자 클래스 빼기 식에 사용할 문자 클래스를 선택할 때는 유용한 결과를 생성할 수 있도록 해야 합니다.Choose character classes for a character class subtraction expression that will yield useful results. 어떤 문자도 나타낼 수 없는 빈 문자 집합을 생성하는 식이나 원래 기본 그룹에 해당하는 식은 사용하지 않습니다.Avoid an expression that yields an empty set of characters, which cannot match anything, or an expression that is equivalent to the original base group. 예를 들어, IsBasicLatin 일반 범주에서 IsBasicLatin 문자 범위의 모든 문자를 빼는 [\p{IsBasicLatin}-[\x00-\x7F]] 식을 사용하면 빈 집합이 생성됩니다.For example, the empty set is the result of the expression [\p{IsBasicLatin}-[\x00-\x7F]], which subtracts all characters in the IsBasicLatin character range from the IsBasicLatin general category. 마찬가지로 [a-z-[0-9]] 식을 사용하면 원래 기본 그룹이 생성됩니다.Similarly, the original base group is the result of the expression [a-z-[0-9]]. "a"부터 "z"까지의 문자 범위를 나타내는 기본 그룹에는 제외할 그룹의 문자, 즉 "0"부터 "9"까지의 10진수 문자 범위가 없기 때문입니다.This is because the base group, which is the character range of letters from "a" through "z", does not contain any characters in the excluded group, which is the character range of decimal digits from "0" through "9".

다음 예제에서는 입력 문자열에서 0과 홀수를 찾는 정규식 ^[0-9-[2468]]+$를 정의합니다.The following example defines a regular expression, ^[0-9-[2468]]+$, that matches zero and odd digits in an input string. 정규식은 다음 표와 같이 해석됩니다.The regular expression is interpreted as shown in the following table.

요소Element 설명Description
^ 입력 문자열의 시작 부분에서 일치 항목 찾기를 시작합니다.Begin the match at the start of the input string.
[0-9-[2468]]+ 모든 문자 0에서 9까지 2, 4, 6 및 8을 제외한 하나 이상의 항목을 일치하세요.Match one or more occurrences of any character from 0 to 9 except for 2, 4, 6, and 8. 즉, 한 번 이상 나오는 0 또는 홀수와 일치합니다.In other words, match one or more occurrences of zero or an odd digit.
$ 입력 문자열의 끝 부분에서 검색을 종료합니다.End the match at the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";
      
      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success) 
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       13579753
//       335599901
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "123", "13579753", "3557798", "335599901" }
      Dim pattern As String = "^[0-9-[2468]]+$"
      
      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

참고 항목See also