정규식의 대체Substitutions in Regular Expressions

대체는 바꾸기 패턴에서만 인식되는 언어 요소입니다.Substitutions are language elements that are recognized only within replacement patterns. 정규식 패턴을 사용하여 입력 문자열에서 일치하는 텍스트를 바꿀 텍스트의 전부 또는 일부를 정의합니다.They use a regular expression pattern to define all or part of the text that is to replace matched text in the input string. 바꾸기 패턴은 리터럴 문자와 하나 이상의 대체로 구성될 수 있습니다.The replacement pattern can consist of one or more substitutions along with literal characters. Regex.Replace 매개 변수가 포함된 replacement 메서드의 오버로드와 Match.Result 메서드에 대해 바꾸기 패턴이 제공됩니다.Replacement patterns are provided to overloads of the Regex.Replace method that have a replacement parameter and to the Match.Result method. 해당 메서드는 일치하는 패턴을 replacement 매개 변수에 정의된 패턴으로 바꿉니다.The methods replace the matched pattern with the pattern that is defined by the replacement parameter.

.NET Framework에서 다음 표에 나와 있는 대체 요소를 정의합니다.The .NET Framework defines the substitution elements listed in the following table.

대체Substitution 설명Description
$ number$ number number(여기서 number 는 10진수 값)로 식별되는 캡처 그룹과 일치하는 마지막 부분 문자열을 바꾸기 문자열에 포함합니다.Includes the last substring matched by the capturing group that is identified by number, where number is a decimal value, in the replacement string. 자세한 내용은 번호 매겨진 그룹 대체를 참조하십시오.For more information, see Substituting a Numbered Group.
${ name }${ name } (?<name> ) 에서 지정한 명명된 그룹과 일치하는 마지막 부분 문자열을 바꾸기 문자열에 포함합니다.Includes the last substring matched by the named group that is designated by (?<name> ) in the replacement string. 자세한 내용은 명명된 그룹 대체를 참조하십시오.For more information, see Substituting a Named Group.
$$ 대체 문자열에 한 개의 "$" 리터럴을 포함합니다.Includes a single "$" literal in the replacement string. 자세한 내용은 "$" 기호 대체를 참조하십시오.For more information, see Substituting a "$" Symbol.
$& 대체 문자열에 일치하는 전체 문자열의 복사본을 포함합니다.Includes a copy of the entire match in the replacement string. 자세한 내용은 일치하는 전체 문자열 대체를 참조하십시오.For more information, see Substituting the Entire Match.
$` 대체 문자열에서 일치하는 문자열 앞에 입력 문자열의 모든 텍스트를 포함합니다.Includes all the text of the input string before the match in the replacement string. 자세한 내용은 일치하는 문자열 앞에 있는 텍스트 대체를 참조하십시오.For more information, see Substituting the Text before the Match.
$'$' 대체 문자열에서 일치하는 문자열 뒤에 입력 문자열의 모든 텍스트를 포함합니다.Includes all the text of the input string after the match in the replacement string. 자세한 내용은 일치하는 문자열 뒤에 있는 텍스트 대체를 참조하십시오.For more information, see Substituting the Text after the Match.
$+ 대체 문자열에 캡처된 마지막 그룹을 포함합니다.Includes the last group captured in the replacement string. 자세한 내용은 캡처된 마지막 그룹 대체를 참조하십시오.For more information, see Substituting the Last Captured Group.
$_ 대체 문자열에 전체 입력 문자열을 포함합니다.Includes the entire input string in the replacement string. 자세한 내용은 전체 입력 문자열 대체를 참조하십시오.For more information, see Substituting the Entire Input String.

요소 및 바꾸기 패턴 대체Substitution Elements and Replacement Patterns

대체는 바꾸기 패턴에서 인식되는 유일한 특수 구문입니다.Substitutions are the only special constructs recognized in a replacement pattern. 임의의 문자를 찾는 마침표(.) 및 문자 이스케이프 등 다른 정규식 언어 요소는 지원되지 않습니다.None of the other regular expression language elements, including character escapes and the period (.), which matches any character, are supported. 마찬가지로, 대체 언어 요소는 바꾸기 패턴에서만 인식되고 정규식 패턴에는 사용할 수 없습니다.Similarly, substitution language elements are recognized only in replacement patterns and are never valid in regular expression patterns.

컨텍스트마다 다른 의미를 가지지만 정규식 패턴이나 대체에 나타나는 유일한 문자는 $ 문자입니다.The only character that can appear either in a regular expression pattern or in a substitution is the $ character, although it has a different meaning in each context. 정규식 패턴에서 $ 는 문자열의 끝 부분을 찾는 앵커입니다.In a regular expression pattern, $ is an anchor that matches the end of the string. 바꾸기 패턴에서 $ 는 대체 시작을 나타냅니다.In a replacement pattern, $ indicates the beginning of a substitution.

참고

정규식의 바꾸기 패턴과 유사한 기능으로, 역참조를 사용합니다.For functionality similar to a replacement pattern within a regular expression, use a backreference. 역참조에 대한 자세한 내용은 역참조 구문을 참조하십시오.For more information about backreferences, see Backreference Constructs.

번호 매겨진 그룹 대체Substituting a Numbered Group

$number 언어 요소는 바꾸기 문자열에서 number 캡처 그룹과 일치하는 마지막 부분 문자열을 포함합니다. 여기서 number 는 캡처 그룹의 인덱스입니다.The $number language element includes the last substring matched by the number capturing group in the replacement string, where number is the index of the capturing group. 예를 들어 바꾸기 패턴 $1 은 일치하는 부분 문자열이 처음 캡처한 그룹으로 대체됨을 나타냅니다.For example, the replacement pattern $1 indicates that the matched substring is to be replaced by the first captured group. 번호가 매겨진 캡처링 그룹에 대한 자세한 내용은 Grouping Constructs을 참조하세요.For more information about numbered capturing groups, see Grouping Constructs.

$ 다음에 나오는 모든 숫자는 number 그룹에 속한 것으로 해석됩니다.All digits that follow $ are interpreted as belonging to the number group. 이런 것을 의도한 것이 아니라면, 그 대신 명명된 그룹을 대체할 수 있습니다.If this is not your intent, you can substitute a named group instead. 예를 들어, ${1}1 대신 $11 대체 문자열을 사용하여 대체 문자열을 숫자 "1"과 함께 처음으로 캡처된 그룹의 값으로 정의할 수 있습니다.For example, you can use the replacement string ${1}1 instead of $11 to define the replacement string as the value of the first captured group along with the number "1". 자세한 내용은 명명된 그룹 대체를 참조하십시오.For more information, see Substituting a Named Group.

(?<name>) 구문을 사용하여 명시적으로 이름을 할당하지 않은 그룹을 캡처할 때는 1부터 시작하여 왼쪽에서 오른쪽으로 번호를 매깁니다.Capturing groups that are not explicitly assigned names using the (?<name>) syntax are numbered from left to right starting at one. 명명된 그룹도 명명되지 않은 마지막 그룹의 인덱스보다 큰 1부터 시작하여 왼쪽에서 오른쪽으로 번호가 매겨집니다.Named groups are also numbered from left to right, starting at one greater than the index of the last unnamed group. 예를 들어 정규식 (\w)(?<digit>\d)에서 digit 명명된 그룹의 인덱스는 2입니다.For example, in the regular expression (\w)(?<digit>\d), the index of the digit named group is 2.

number 가 정규식 패턴에 정의된 올바른 캡처 그룹을 지정하지 않으면 $number 는 일치하는 문자열을 바꾸는 데 사용되는 리터럴 문자 시퀀스로 해석됩니다.If number does not specify a valid capturing group defined in the regular expression pattern, $number is interpreted as a literal character sequence that is used to replace each match.

다음 예제에서는 $number 대체를 사용하여 10진수 값에서 통화 기호를 삭제합니다.The following example uses the $number substitution to strip the currency symbol from a decimal value. 통화 값의 시작 부분이나 끝 부분에 있는 통화 기호를 제거하고 두 개의 가장 일반적인 소수 구분 기호("." 및 ",")를 인식합니다.It removes currency symbols found at the beginning or end of a monetary value, and recognizes the two most common decimal separators ("." and ",").

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*";
      string replacement = "$1";
      string input = "$16.32 12.19 £16.29 €18.29  €18,29";
      string result = Regex.Replace(input, pattern, replacement);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//       16.32 12.19 16.29 18.29  18,29
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*"
      Dim replacement As String = "$1"
      Dim input As String = "$16.32 12.19 £16.29 €18.29  €18,29"
      Dim result As String = Regex.Replace(input, pattern, replacement)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'       16.32 12.19 16.29 18.29  18,29

정규식 패턴 \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* 는 다음 테이블과 같이 정의됩니다.The regular expression pattern \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* is defined as shown in the following table.

무늬Pattern 설명Description
\p{Sc}* 통화 기호 문자를 0개 이상 찾습니다.Match zero or more currency symbol characters.
\s? 0회 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space characters.
\d+ 하나 이상의 10진수 숫자가 일치하는지 확인합니다.Match one or more decimal digits.
[.,]? 0-1개의 마침표 또는 쉼표를 찾습니다.Match zero or one period or comma.
\d* 0번 이상 나오는 10진수를 찾습니다.Match zero or more decimal digits.
(\s?\d+[.,]?\d*) 공백, 하나 이상의 10진수 숫자, 0-1개의 마침표나 쉼표, 0-1개의 10진수 숫자가 차례로 표시된 문자열을 찾습니다.Match a white space followed by one or more decimal digits, followed by zero or one period or comma, followed by zero or more decimal digits. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group. 바꾸기 패턴이 $1이기 때문에 Regex.Replace 메서드를 호출하면 일치하는 전체 부분 문자열이 이 캡처된 그룹으로 바뀝니다.Because the replacement pattern is $1, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

명명된 그룹 대체Substituting a Named Group

${name} 언어 요소는 name 캡처 그룹과 일치하는 마지막 부분 문자열을 대체합니다. 여기서 name(?<name>) 언어 요소가 정의한 캡처 그룹의 이름입니다.The ${name} language element substitutes the last substring matched by the name capturing group, where name is the name of a capturing group defined by the (?<name>) language element. 명명된 캡처링 그룹에 대한 자세한 내용은 Grouping Constructs을 참조하세요.For more information about named capturing groups, see Grouping Constructs.

name 이 정규식 패턴에 정의된 명명된 유효한 캡처 그룹을 지정하지 않지만 숫자로 구성된 경우, ${name} 은 번호가 매겨진 그룹으로 해석됩니다.If name doesn't specify a valid named capturing group defined in the regular expression pattern but consists of digits, ${name} is interpreted as a numbered group.

name 이 명명된 유효한 캡처 그룹도, 정규식 패턴에 정의되어 번호가 매겨진 유효한 캡처 그룹도 지정하지 않는 경우, ${name} 은 각 일치 항목을 바꾸는 데 사용되는 리터럴 문자 시퀀스로 해석됩니다.If name specifies neither a valid named capturing group nor a valid numbered capturing group defined in the regular expression pattern, ${name} is interpreted as a literal character sequence that is used to replace each match.

다음 예제에서는 ${name} 대체를 사용하여 10진수 값에서 통화 기호를 삭제합니다.The following example uses the ${name} substitution to strip the currency symbol from a decimal value. 통화 값의 시작 부분이나 끝 부분에 있는 통화 기호를 제거하고 두 개의 가장 일반적인 소수 구분 기호("." 및 ",")를 인식합니다.It removes currency symbols found at the beginning or end of a monetary value, and recognizes the two most common decimal separators ("." and ",").

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*";
      string replacement = "${amount}";
      string input = "$16.32 12.19 £16.29 €18.29  €18,29";
      string result = Regex.Replace(input, pattern, replacement);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//       16.32 12.19 16.29 18.29  18,29
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*"
      Dim replacement As String = "${amount}"
      Dim input As String = "$16.32 12.19 £16.29 €18.29  €18,29"
      Dim result As String = Regex.Replace(input, pattern, replacement)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'       16.32 12.19 16.29 18.29  18,29

정규식 패턴 \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* 는 다음 테이블과 같이 정의됩니다.The regular expression pattern \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* is defined as shown in the following table.

무늬Pattern 설명Description
\p{Sc}* 통화 기호 문자를 0개 이상 찾습니다.Match zero or more currency symbol characters.
\s? 0회 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space characters.
\d+ 하나 이상의 10진수 숫자가 일치하는지 확인합니다.Match one or more decimal digits.
[.,]? 0-1개의 마침표 또는 쉼표를 찾습니다.Match zero or one period or comma.
\d* 0번 이상 나오는 10진수를 찾습니다.Match zero or more decimal digits.
(?<amount>\s?\d[.,]?\d*) 공백, 하나 이상의 10진수 숫자, 0-1개의 마침표나 쉼표, 0-1개의 10진수 숫자가 차례로 표시된 문자열을 찾습니다.Match a white space, followed by one or more decimal digits, followed by zero or one period or comma, followed by zero or more decimal digits. 이는 amount로 명명된 캡처링 그룹입니다.This is the capturing group named amount. 바꾸기 패턴이 ${amount}이기 때문에 Regex.Replace 메서드를 호출하면 일치하는 전체 부분 문자열이 이 캡처된 그룹으로 바뀝니다.Because the replacement pattern is ${amount}, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

"$" 문자 대체Substituting a "$" Character

$$ 대체는 바꾼 문자열에 리터럴 "$" 문자를 삽입합니다.The $$ substitution inserts a literal "$" character in the replaced string.

다음 예제에서는 NumberFormatInfo 개체를 사용하여 통화 문자열에서 현재 문화권의 통화 기호 및 배치를 확인합니다.The following example uses the NumberFormatInfo object to determine the current culture's currency symbol and its placement in a currency string. 그런 다음 정규식 패턴과 바꾸기 패턴을 동적으로 작성합니다.It then builds both a regular expression pattern and a replacement pattern dynamically. 현재 문화권이 en-US인 컴퓨터에서 예제가 실행될 경우, 정규식 패턴 \b(\d+)(\.(\d+))? 및 바꾸기 패턴 $$ $1$2를 생성합니다.If the example is run on a computer whose current culture is en-US, it generates the regular expression pattern \b(\d+)(\.(\d+))? and the replacement pattern $$ $1$2. 바꾸기 패턴은 일치하는 텍스트를 통화 기호와 공백, 첫 번째 및 두 번째 캡처된 그룹이 차례로 표시된 문자열로 바꿉니다.The replacement pattern replaces the matched text with a currency symbol and a space followed by the first and second captured groups.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Define array of decimal values.
      string[] values= { "16.35", "19.72", "1234", "0.99"};
      // Determine whether currency precedes (True) or follows (False) number.
      bool precedes = NumberFormatInfo.CurrentInfo.CurrencyPositivePattern % 2 == 0;
      // Get decimal separator.
      string cSeparator = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator;
      // Get currency symbol.
      string symbol = NumberFormatInfo.CurrentInfo.CurrencySymbol;
      // If symbol is a "$", add an extra "$".
      if (symbol == "$") symbol = "$$";
      
      // Define regular expression pattern and replacement string.
      string pattern = @"\b(\d+)(" + cSeparator + @"(\d+))?"; 
      string replacement = "$1$2";
      replacement = precedes ? symbol + " " + replacement : replacement + " " + symbol;
      foreach (string value in values)
         Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement));
   }
}
// The example displays the following output:
//       16.35 --> $ 16.35
//       19.72 --> $ 19.72
//       1234 --> $ 1234
//       0.99 --> $ 0.99
Imports System.Globalization
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Define array of decimal values.
      Dim values() As String = { "16.35", "19.72", "1234", "0.99"}
      ' Determine whether currency precedes (True) or follows (False) number.
      Dim precedes As Boolean = (NumberFormatInfo.CurrentInfo.CurrencyPositivePattern Mod 2 = 0)
      ' Get decimal separator.
      Dim cSeparator As String = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator
      ' Get currency symbol.
      Dim symbol As String = NumberFormatInfo.CurrentInfo.CurrencySymbol
      ' If symbol is a "$", add an extra "$".
      If symbol = "$" Then symbol = "$$"
      
      ' Define regular expression pattern and replacement string.
      Dim pattern As String = "\b(\d+)(" + cSeparator + "(\d+))?" 
      Dim replacement As String = "$1$2"
      replacement = If(precedes, symbol + " " + replacement, replacement + " " + symbol)
      For Each value In values
         Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement))
      Next
   End Sub
End Module
' The example displays the following output:
'       16.35 --> $ 16.35
'       19.72 --> $ 19.72
'       1234 --> $ 1234
'       0.99 --> $ 0.99

정규식 패턴 \b(\d+)(\.(\d+))? 는 다음 테이블과 같이 정의됩니다.The regular expression pattern \b(\d+)(\.(\d+))? is defined as shown in the following table.

무늬Pattern 설명Description
\b 단어 경계 시작 부분에서 찾기를 시작합니다.Start the match at the beginning of a word boundary.
(\d+) 하나 이상의 10진수 숫자가 일치하는지 확인합니다.Match one or more decimal digits. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group.
\. 마침표(소수 구분 기호)를 찾습니다.Match a period (the decimal separator).
(\d+) 하나 이상의 10진수 숫자가 일치하는지 확인합니다.Match one or more decimal digits. 이 그룹은 세 번째 캡처링 그룹입니다.This is the third capturing group.
(\.(\d+))? 한 개 이상의 숫자가 뒤에 오는 마침표를 0개 또는 1개 찾습니다.Match zero or one occurrence of a period followed by one or more decimal digits. 이 그룹은 두 번째 캡처링 그룹입니다.This is the second capturing group.

일치하는 전체 문자열 대체Substituting the Entire Match

$& 대체는 바꾸기 문자열에 일치하는 전체 문자열을 포함합니다.The $& substitution includes the entire match in the replacement string. 일치하는 문자열의 시작 부분이나 끝 부분에 부분 문자열을 추가하는 데 자주 사용됩니다.Often, it is used to add a substring to the beginning or end of the matched string. 예를 들어 ($&) 바꾸기 패턴은 각 일치 항목의 시작과 끝에 괄호를 추가합니다.For example, the ($&) replacement pattern adds parentheses to the beginning and end of each match. 일치하는 부분이 없으면 $& 대체가 아무 효과가 없습니다.If there is no match, the $& substitution has no effect.

다음 예제에서는 $& 대체를 사용하여 문자열 배열에 저장된 책 제목의 시작 부분과 끝 부분에 따옴표를 추가합니다.The following example uses the $& substitution to add quotation marks at the beginning and end of book titles stored in a string array.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\w+\s?)+$";
      string[] titles = { "A Tale of Two Cities", 
                          "The Hound of the Baskervilles", 
                          "The Protestant Ethic and the Spirit of Capitalism", 
                          "The Origin of Species" };
      string replacement = "\"$&\"";
      foreach (string title in titles)
         Console.WriteLine(Regex.Replace(title, pattern, replacement));
   }
}
// The example displays the following output:
//       "A Tale of Two Cities"
//       "The Hound of the Baskervilles"
//       "The Protestant Ethic and the Spirit of Capitalism"
//       "The Origin of Species"
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^(\w+\s?)+$"
      Dim titles() As String = { "A Tale of Two Cities", _
                                 "The Hound of the Baskervilles", _
                                 "The Protestant Ethic and the Spirit of Capitalism", _
                                 "The Origin of Species" }
      Dim replacement As String = """$&"""
      For Each title As String In titles
         Console.WriteLine(Regex.Replace(title, pattern, replacement))
      Next  
   End Sub
End Module
' The example displays the following output:
'       "A Tale of Two Cities"
'       "The Hound of the Baskervilles"
'       "The Protestant Ethic and the Spirit of Capitalism"
'       "The Origin of Species"

정규식 패턴 ^(\w+\s?)+$ 는 다음 테이블과 같이 정의됩니다.The regular expression pattern ^(\w+\s?)+$ is defined as shown in the following table.

무늬Pattern 설명Description
^ 입력 문자열의 시작 부분에서 일치 항목 찾기를 시작합니다.Start the match at the beginning of the input string.
(\w+\s?)+ 하나 이상의 단어 문자 다음에 0개 또는 1개의 공백 문자가 한 번 이상 나타나는 패턴을 찾습니다.Match the pattern of one or more word characters followed by zero or one white-space characters one or more times.
$ 입력 문자열의 끝 부분을 찾습니다.Match the end of the input string.

"$&" 바꾸기 패턴은 일치하는 문자열의 시작 부분과 끝 부분에 리터럴 따옴표를 추가합니다.The "$&" replacement pattern adds a literal quotation mark to the beginning and end of each match.

일치하는 문자열 앞에 있는 텍스트 대체Substituting the Text Before the Match

$` 대체는 일치하는 문자열을 일치하는 문자열 앞의 전체 입력 문자열로 바꿉니다.The $` substitution replaces the matched string with the entire input string before the match. 즉, 일치하는 텍스트를 제거하는 동안 일치하는 문자열까지의 입력 문자열을 복제합니다.That is, it duplicates the input string up to the match while removing the matched text. 일치하는 텍스트 뒤에 나오는 텍스트는 결과 문자열에서 변경되지 않습니다.Any text that follows the matched text is unchanged in the result string. 입력 문자열에 일치하는 문자열이 여러 개이면 이전 일치 문자열로 텍스트가 바뀐 문자열이 아닌 원본 입력 문자열에서 바꾸기 텍스트가 파생됩니다.If there are multiple matches in an input string, the replacement text is derived from the original input string, rather than from the string in which text has been replaced by earlier matches. (예제에서 그림을 제공합니다.) 일치하는 부분이 없으면 $` 대체가 아무 효과가 없습니다.(The example provides an illustration.) If there is no match, the $` substitution has no effect.

다음 예제에서는 \d+ 정규식 패턴을 사용하여 입력 문자열에서 하나 이상의 숫자가 연속적으로 표시된 부분을 찾습니다.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. 바꾸기 문자열 $`는 이 숫자를 일치하는 문자열 앞의 텍스트로 바꿉니다.The replacement string $` replaces these digits with the text that precedes the match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "aa1bb2cc3dd4ee5";
      string pattern = @"\d+";
      string substitution = "$`";
      Console.WriteLine("Matches:");
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);

      Console.WriteLine("Input string:  {0}", input);
      Console.WriteLine("Output string: " + 
                        Regex.Replace(input, pattern, substitution));
   }
}
// The example displays the following output:
//    Matches:
//       1 at position 2
//       2 at position 5
//       3 at position 8
//       4 at position 11
//       5 at position 14
//    Input string:  aa1bb2cc3dd4ee5
//    Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "aa1bb2cc3dd4ee5"
      Dim pattern As String = "\d+"
      Dim substitution As String = "$`"
      Console.WriteLine("Matches:")
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
      Next   
      Console.WriteLine("Input string:  {0}", input)
      Console.WriteLine("Output string: " + _
                        Regex.Replace(input, pattern, substitution))
   End Sub
End Module
' The example displays the following output:
'    Matches:
'       1 at position 2
'       2 at position 5
'       3 at position 8
'       4 at position 11
'       5 at position 14
'    Input string:  aa1bb2cc3dd4ee5
'    Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

이 예제에서는 입력 문자열 "aa1bb2cc3dd4ee5" 에 다섯 개의 일치 항목이 포함되어 있습니다.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. 다음 표에서는 $` 대체를 사용할 경우 정규식 엔진이 입력 문자열에서 일치하는 부분을 어떻게 바꾸는지 보여줍니다.The following table illustrates how the $` substitution causes the regular expression engine to replace each match in the input string. 삽입된 텍스트는 결과 열에서 굵게 표시됩니다.Inserted text is shown in bold in the results column.

일치Match 위치Position 일치하는 문자열 앞에 있는 문자열String before match 결과 문자열Result string
11 22 aaaa aaaabb2cc3dd4ee5aaaabb2cc3dd4ee5
22 55 aa1bbaa1bb aaaabbaa1bbcc3dd4ee5aaaabbaa1bbcc3dd4ee5
33 88 aa1bb2ccaa1bb2cc aaaabbaa1bbccaa1bb2ccdd4ee5aaaabbaa1bbccaa1bb2ccdd4ee5
44 1111 aa1bb2cc3ddaa1bb2cc3dd aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5
55 1414 aa1bb2cc3dd4eeaa1bb2cc3dd4ee aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4eeaaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

일치하는 문자열 뒤에 있는 텍스트 대체Substituting the Text After the Match

$' 대체는 일치하는 문자열을 일치하는 문자열 뒤의 전체 입력 문자열로 바꿉니다.The $' substitution replaces the matched string with the entire input string after the match. 즉, 일치하는 텍스트를 제거하는 동안 일치하는 문자열 뒤의 입력 문자열을 복제합니다.That is, it duplicates the input string after the match while removing the matched text. 일치하는 텍스트 앞에 나오는 텍스트는 결과 문자열에서 변경되지 않습니다.Any text that precedes the matched text is unchanged in the result string. 일치하는 부분이 없으면 $' 대체가 아무 효과가 없습니다.If there is no match, the $' substitution has no effect.

다음 예제에서는 \d+ 정규식 패턴을 사용하여 입력 문자열에서 하나 이상의 숫자가 연속적으로 표시된 부분을 찾습니다.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. 바꾸기 문자열 $' 는 이 숫자를 일치하는 문자열 뒤의 텍스트로 바꿉니다.The replacement string $' replaces these digits with the text that follows the match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "aa1bb2cc3dd4ee5";
      string pattern = @"\d+";
      string substitution = "$'";
      Console.WriteLine("Matches:");
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
      Console.WriteLine("Input string:  {0}", input);
      Console.WriteLine("Output string: " + 
                        Regex.Replace(input, pattern, substitution));
   }
}
// The example displays the following output:
//    Matches:
//       1 at position 2
//       2 at position 5
//       3 at position 8
//       4 at position 11
//       5 at position 14
//    Input string:  aa1bb2cc3dd4ee5
//    Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "aa1bb2cc3dd4ee5"
      Dim pattern As String = "\d+"
      Dim substitution As String = "$'"
      Console.WriteLine("Matches:")
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
      Next   
      Console.WriteLine("Input string:  {0}", input)
      Console.WriteLine("Output string: " + _
                        Regex.Replace(input, pattern, substitution))
   End Sub
End Module
' The example displays the following output:
'    Matches:
'       1 at position 2
'       2 at position 5
'       3 at position 8
'       4 at position 11
'       5 at position 14
'    Input string:  aa1bb2cc3dd4ee5
'    Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

이 예제에서는 입력 문자열 "aa1bb2cc3dd4ee5" 에 다섯 개의 일치 항목이 포함되어 있습니다.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. 다음 표에서는 $' 대체를 사용할 경우 정규식 엔진이 입력 문자열에서 일치하는 부분을 어떻게 바꾸는지 보여줍니다.The following table illustrates how the $' substitution causes the regular expression engine to replace each match in the input string. 삽입된 텍스트는 결과 열에서 굵게 표시됩니다.Inserted text is shown in bold in the results column.

일치Match 위치Position 일치하는 문자열 뒤에 있는 문자열String after match 결과 문자열Result string
11 22 bb2cc3dd4ee5bb2cc3dd4ee5 aabb2cc3dd4ee5bb2cc3dd4ee5aabb2cc3dd4ee5bb2cc3dd4ee5
22 55 cc3dd4ee5cc3dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5
33 88 dd4ee5dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5
44 1111 ee5ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5
55 1414 String.Empty aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5eeaabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

캡처된 마지막 그룹 대체Substituting the Last Captured Group

$+ 대체는 일치하는 문자열을 캡처된 마지막 그룹으로 바꿉니다.The $+ substitution replaces the matched string with the last captured group. 캡처된 그룹이 없거나 캡처된 마지막 그룹 값이 String.Empty이면 $+ 대체가 적용되지 않습니다.If there are no captured groups or if the value of the last captured group is String.Empty, the $+ substitution has no effect.

다음 예제에서는 문자열에서 중복 단어를 확인한 다음 $+ 대체를 사용하여 해당 단어가 한 번만 나타나도록 바꿉니다.The following example identifies duplicate words in a string and uses the $+ substitution to replace them with a single occurrence of the word. RegexOptions.IgnoreCase 옵션은 대소문자만 다르고 나머지는 동일한 단어를 중복으로 인식하도록 하는 데 사용됩니다.The RegexOptions.IgnoreCase option is used to ensure that words that differ in case but that are otherwise identical are considered duplicates.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s\1\b";
      string substitution = "$+";
      string input = "The the dog jumped over the fence fence.";
      Console.WriteLine(Regex.Replace(input, pattern, substitution, 
                        RegexOptions.IgnoreCase));
   }
}
// The example displays the following output:
//      The dog jumped over the fence.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\w+)\s\1\b"
      Dim substitution As String = "$+"
      Dim input As String = "The the dog jumped over the fence fence."
      Console.WriteLine(Regex.Replace(input, pattern, substitution, _
                                      RegexOptions.IgnoreCase))
   End Sub
End Module
' The example displays the following output:
'      The dog jumped over the fence.

정규식 패턴 \b(\w+)\s\1\b 는 다음 테이블과 같이 정의됩니다.The regular expression pattern \b(\w+)\s\1\b is defined as shown in the following table.

무늬Pattern 설명Description
\b 단어 경계에서 일치 항목 찾기를 시작합니다.Begin the match at a word boundary.
(\w+) 하나 이상의 단어 문자를 찾습니다.Match one or more word characters. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group.
\s 공백 문자를 찾습니다.Match a white-space character.
\1 캡처된 첫 번째 그룹을 찾습니다.Match the first captured group.
\b 단어 경계에서 일치 항목 찾기를 끝냅니다.End the match at a word boundary.

전체 입력 문자열 대체Substituting the Entire Input String

$_ 대체는 일치하는 문자열을 전체 입력 문자열로 바꿉니다.The $_ substitution replaces the matched string with the entire input string. 즉, 일치하는 텍스트를 제거한 다음 일치하는 텍스트를 포함한 전체 문자열로 바꿉니다.That is, it removes the matched text and replaces it with the entire string, including the matched text.

다음 예제에서는 입력 문자열에서 하나 이상의 10진수 숫자를 찾습니다.The following example matches one or more decimal digits in the input string. $_ 대체를 사용하여 전체 입력 문자열로 바꿉니다.It uses the $_ substitution to replace them with the entire input string.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "ABC123DEF456";
      string pattern = @"\d+";
      string substitution = "$_";
      Console.WriteLine("Original string:          {0}", input);
      Console.WriteLine("String with substitution: {0}", 
                        Regex.Replace(input, pattern, substitution));      
   }
}
// The example displays the following output:
//       Original string:          ABC123DEF456
//       String with substitution: ABCABC123DEF456DEFABC123DEF456
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ABC123DEF456"
      Dim pattern As String = "\d+"
      Dim substitution As String = "$_"
      Console.WriteLine("Original string:          {0}", input)
      Console.WriteLine("String with substitution: {0}", _
                        Regex.Replace(input, pattern, substitution))      
   End Sub
End Module
' The example displays the following output:
'       Original string:          ABC123DEF456
'       String with substitution: ABCABC123DEF456DEFABC123DEF456

이 예제에서는 입력 문자열 "ABC123DEF456" 에 두 개의 일치 항목이 포함되어 있습니다.In this example, the input string "ABC123DEF456" contains two matches. 다음 표에서는 $_ 대체를 사용할 경우 정규식 엔진이 입력 문자열에서 일치하는 부분을 어떻게 바꾸는지 보여줍니다.The following table illustrates how the $_ substitution causes the regular expression engine to replace each match in the input string. 삽입된 텍스트는 결과 열에서 굵게 표시됩니다.Inserted text is shown in bold in the results column.

일치Match 위치Position 일치Match 결과 문자열Result string
11 33 123123 ABCABC123DEF456DEF456ABCABC123DEF456DEF456
22 55 456456 ABCABC123DEF456DEFABC123DEF456ABCABC123DEF456DEFABC123DEF456

참고 항목See also