Podstawienia w wyrażeniach regularnychSubstitutions in Regular Expressions

Podstawienia są elementami języka, które są rozpoznawane tylko we wzorcach zamieniania.Substitutions are language elements that are recognized only within replacement patterns. Używają one wzorca wyrażenia regularnego w celu zdefiniowania całości lub części teksu, który ma zastąpić dopasowany tekst w ciągu wejściowym.They use a regular expression pattern to define all or part of the text that is to replace matched text in the input string. Wzorzec zamieniania może składać się z co najmniej jednego podstawienia oraz znaków literału.The replacement pattern can consist of one or more substitutions along with literal characters. Wzorce zamieniania są dostarczane do przeciążeń Regex.Replace metodę, która ma replacement parametru i Match.Result metody.Replacement patterns are provided to overloads of the Regex.Replace method that have a replacement parameter and to the Match.Result method. Te metody zamieniają dopasowany wzorzec z wzorcem, który jest definiowany przez replacement parametru.The methods replace the matched pattern with the pattern that is defined by the replacement parameter.

Program .NET Framework definiuje elementy podstawień wymienione w poniższej tabeli.The .NET Framework defines the substitution elements listed in the following table.

PodstawienieSubstitution OpisDescription
$ Numer$ number Zawiera ostatni podciąg dopasowany przez grupę przechwytywania, która jest identyfikowana przez numer, gdzie numer jest wartość dziesiętna w ciągu zamiennym.Includes the last substring matched by the capturing group that is identified by number, where number is a decimal value, in the replacement string. Aby uzyskać więcej informacji, zobacz podstawianie numerowanej grupy.For more information, see Substituting a Numbered Group.
${ nazwa }${ name } Zawiera ostatni podciąg dopasowany przez nazwaną grupę, który jest wyznaczone przez (?< nazwa > ) w ciągu zamiennym.Includes the last substring matched by the named group that is designated by (?<name> ) in the replacement string. Aby uzyskać więcej informacji, zobacz podstawianie nazwanej grupy.For more information, see Substituting a Named Group.
$$ Zawiera pojedynczy literał „$” w ciągu zamiennym.Includes a single "$" literal in the replacement string. Aby uzyskać więcej informacji, zobacz podstawianie symbolu "$".For more information, see Substituting a "$" Symbol.
$& Zawiera kopię całego dopasowania w ciągu zamiennym.Includes a copy of the entire match in the replacement string. Aby uzyskać więcej informacji, zobacz podstawianie całego dopasowania.For more information, see Substituting the Entire Match.
$` Zawiera cały tekst ciągu wejściowego przed dopasowaniem w ciągu zamiennym.Includes all the text of the input string before the match in the replacement string. Aby uzyskać więcej informacji, zobacz podstawianie tekstu przed dopasowaniem.For more information, see Substituting the Text before the Match.
$'$' Zawiera cały tekst ciągu wejściowego po dopasowaniu w ciągu zamiennym.Includes all the text of the input string after the match in the replacement string. Aby uzyskać więcej informacji, zobacz podstawianie tekstu po dopasowaniu.For more information, see Substituting the Text after the Match.
$+ Zawiera ostatnią grupę przechwyconą w ciągu zamiennym.Includes the last group captured in the replacement string. Aby uzyskać więcej informacji, zobacz podstawianie ostatniej przechwyconej grupy.For more information, see Substituting the Last Captured Group.
$$ Zawiera cały ciąg wejściowy w ciągu zamiennym.Includes the entire input string in the replacement string. Aby uzyskać więcej informacji, zobacz podstawianie całego ciągu wejściowego.For more information, see Substituting the Entire Input String.

Elementy podstawienia i wzorce zamienianiaSubstitution Elements and Replacement Patterns

Podstawienia to jedyne konstrukcje specjalne rozpoznawane we wzorcu zamieniania.Substitutions are the only special constructs recognized in a replacement pattern. Żadne inne elementy języka wyrażeń regularnych, w tym znak ucieczki i kropka (.), który dopasowuje dowolny znak, są obsługiwane.None of the other regular expression language elements, including character escapes and the period (.), which matches any character, are supported. Podobnie elementy języka podstawień są rozpoznawane tylko we wzorcach zamieniania, i nigdy nie są prawidłowe we wzorcach wyrażeń regularnych.Similarly, substitution language elements are recognized only in replacement patterns and are never valid in regular expression patterns.

Jedynym znakiem, który może znajdować się we wzorcu wyrażenia regularnego, jak i w podstawieniu jest $ znaków, ale ma on inne znaczenie w każdym kontekście.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. We wzorcu wyrażenia regularnego $ jest kotwicą dopasowującą koniec ciągu.In a regular expression pattern, $ is an anchor that matches the end of the string. We wzorcu zamieniania znak $ wskazuje początek podstawienia.In a replacement pattern, $ indicates the beginning of a substitution.

Uwaga

Aby w wyrażeniu regularnym uzyskać funkcjonalność podobną do wzorca zamieniania, należy użyć dopasowywania wstecznego.For functionality similar to a replacement pattern within a regular expression, use a backreference. Aby uzyskać więcej informacji dotyczących dopasowywania wstecznego, zobacz konstrukcje dopasowywania wstecznego.For more information about backreferences, see Backreference Constructs.

Podstawianie numerowanej grupySubstituting a Numbered Group

$ Numer element języka zawiera ostatni podciąg dopasowany przez numer przechwytywania grupy w ciągu zamiennym, gdzie numer jest Indeks grupy przechwytywania.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. Na przykład wzorzec zamieniania $1 wskazuje, że dopasowany podciąg ma zostać zamieniony na pierwszą przechwyconą grupę.For example, the replacement pattern $1 indicates that the matched substring is to be replaced by the first captured group. Aby uzyskać więcej informacji dotyczących numerowanych grup przechwytywania, zobacz Grouping Constructs.For more information about numbered capturing groups, see Grouping Constructs.

Wszystkie cyfry po znaku $ są interpretowane jako należące do numer grupy.All digits that follow $ are interpreted as belonging to the number group. Jeśli nie jest to zgodne z zamiarami użytkownika, można podstawić grupę nazwaną.If this is not your intent, you can substitute a named group instead. Na przykład, można użyć ciągu zamiennym ${1}1 zamiast $11 Aby zdefiniować ciąg zamienny jako wartość pierwszej przechwyconej grupy wraz z liczbą "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". Aby uzyskać więcej informacji, zobacz podstawianie nazwanej grupy.For more information, see Substituting a Named Group.

Grupy przechwytywania, którym nie przypisano jawnie nazw, używając (?< nazwa >) składni są numerowane od lewej do prawej, począwszy jeden.Capturing groups that are not explicitly assigned names using the (?<name>) syntax are numbered from left to right starting at one. Nazwane grupy także są numerowane od lewej do prawej, począwszy od numeru większego o 1 od indeksu ostatniej nienazwanej grupy.Named groups are also numbered from left to right, starting at one greater than the index of the last unnamed group. Na przykład w wyrażeniu regularnym (\w)(?<digit>\d), indeks digit nazwaną grupę wynosi 2.For example, in the regular expression (\w)(?<digit>\d), the index of the digit named group is 2.

Jeśli numer nie określa prawidłowej grupy przechwytywania zdefiniowanej we wzorcu wyrażenia regularnego $ numer jest interpretowany jako sekwencja znaków literału, który służy do zastępowania każdego dopasowania.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.

W poniższym przykładzie użyto $ numer podstawienia do oddzielenia symbolu waluty od wartości dziesiętnej.The following example uses the $number substitution to strip the currency symbol from a decimal value. Usuwane są symbole waluty znajdujące się na początku lub końcu wartości pieniężnej i rozpoznawane są dwa najpopularniejsze separatory dziesiętne („.” i „,”).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

Definicję wzorca wyrażenia regularnego \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* is defined as shown in the following table.

WzorzecPattern OpisDescription
\p{Sc}* Dopasowanie do zera lub większej liczby znaków symbolu waluty.Match zero or more currency symbol characters.
\s? Dopasowanie do zera lub jednego znaku odstępu.Match zero or one white-space characters.
\d+ Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits.
[.,]? Dopasowanie do zera lub jednej kropki lub przecinka.Match zero or one period or comma.
\d* Dopasowanie do zera lub większej liczby cyfr dziesiętnych.Match zero or more decimal digits.
(\s?\d+[.,]?\d*) Dopasowanie do odstępu, po którym następuje co najmniej jedna cyfra dziesiętna, po której następuje zero lub jedna kropka albo przecinek, po którym następuje zero lub większa liczba cyfr dziesiętnych.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. Jest to pierwsza grupa przechwytywania.This is the first capturing group. Ponieważ jest wzorzec zamieniania $1, wywołanie Regex.Replace metoda zastępuje całego dopasowanego podciągu na tę przechwyconą grupę.Because the replacement pattern is $1, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

Powrót do początkuBack to top

Podstawianie nazwanej grupySubstituting a Named Group

${ Nazwa } element języka podstawia ostatni podciąg dopasowany przez nazwa grupa przechwytywania — gdzie nazwa nazywa się zdefiniowany przez grupę przechwytywania (?< nazwa >) element języka.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. Aby uzyskać więcej informacji dotyczących nazwanych grup przechwytywania, zobacz Grouping Constructs.For more information about named capturing groups, see Grouping Constructs.

Jeśli nazwa nie określa prawidłowej nazwanej grupy przechwytywania zdefiniowanej we wzorcu wyrażenia regularnego, ale zawiera cyfry, ${ nazwa } jest interpretowany jako numerowana grupa.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.

Jeśli nazwa określa prawidłowej nazwanej grupy przechwytywania, ani prawidłowej numerowanej grupy przechwytywania zdefiniowanej we wzorcu wyrażenia regularnego ${ nazwa } jest interpretowany jako Sekwencja znaków literału, który służy do zastępowania każdego dopasowania.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.

W poniższym przykładzie użyto ${ nazwa } podstawienia do oddzielenia symbolu waluty od wartości dziesiętnej.The following example uses the ${name} substitution to strip the currency symbol from a decimal value. Usuwane są symbole waluty znajdujące się na początku lub końcu wartości pieniężnej i rozpoznawane są dwa najpopularniejsze separatory dziesiętne („.” i „,”).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

Definicję wzorca wyrażenia regularnego \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* is defined as shown in the following table.

WzorzecPattern OpisDescription
\p{Sc}* Dopasowanie do zera lub większej liczby znaków symbolu waluty.Match zero or more currency symbol characters.
\s? Dopasowanie do zera lub jednego znaku odstępu.Match zero or one white-space characters.
\d+ Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits.
[.,]? Dopasowanie do zera lub jednej kropki lub przecinka.Match zero or one period or comma.
\d* Dopasowanie do zera lub większej liczby cyfr dziesiętnych.Match zero or more decimal digits.
(?<amount>\s?\d[.,]?\d*) Dopasowanie do odstępu, po którym następuje co najmniej jedna cyfra dziesiętna, po której następuje zero lub jedna kropka albo przecinek, po którym następuje zero lub większa liczba cyfr dziesiętnych.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. Jest to grupa przechwytywania o nazwie amount.This is the capturing group named amount. Ponieważ jest wzorzec zamieniania ${amount}, wywołanie Regex.Replace metoda zastępuje całego dopasowanego podciągu na tę przechwyconą grupę.Because the replacement pattern is ${amount}, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

Powrót do początkuBack to top

Podstawianie znaku „$”Substituting a "$" Character

$$ Podstawienia Wstawia znak literału "$" w zamienianym ciągu.The $$ substitution inserts a literal "$" character in the replaced string.

W poniższym przykładzie użyto NumberFormatInfo obiektu, aby ustalić symbol waluty bieżącej kultury i jego położenie w ciągu waluty.The following example uses the NumberFormatInfo object to determine the current culture's currency symbol and its placement in a currency string. Następnie jest dynamicznie tworzony wzorzec wyrażenia regularnego i wzorzec zamieniania.It then builds both a regular expression pattern and a replacement pattern dynamically. Jeśli ten przykład zostanie uruchomiony na komputerze, którego bieżącą kulturą jest en US, generuje wzorzec wyrażenia regularnego \b(\d+)(\.(\d+))? oraz wzorzec zamieniania $$ $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. Wzorzec zamieniania zamienia dopasowany tekst na symbol waluty i spację, po której następują pierwsza i druga przechwycona grupa.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

Definicję wzorca wyrażenia regularnego \b(\d+)(\.(\d+))? jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \b(\d+)(\.(\d+))? is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczęcie dopasowywania na początku granicy wyrazu.Start the match at the beginning of a word boundary.
(\d+) Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\. Dopasowanie kropki (separator dziesiętny).Match a period (the decimal separator).
(\d+) Dopasowanie do co najmniej jednej cyfry dziesiętnej.Match one or more decimal digits. Jest to trzecia grupa przechwytywania.This is the third capturing group.
(\.(\d+))? Dopasowanie zera lub jednego wystąpienia kropki, po którym następuje co najmniej jedna cyfra dziesiętna.Match zero or one occurrence of a period followed by one or more decimal digits. Jest to druga grupa przechwytywania.This is the second capturing group.

Podstawianie całego dopasowaniaSubstituting the Entire Match

$& Podstawienia zawiera całe dopasowanie w ciągu zamiennym.The $& substitution includes the entire match in the replacement string. Często jest używane do dodawania podciągu na początku lub końcu dopasowanego ciągu.Often, it is used to add a substring to the beginning or end of the matched string. Na przykład ($&) wzorzec zamieniania dodaje nawiasy na początku i końcu każdego dopasowania.For example, the ($&) replacement pattern adds parentheses to the beginning and end of each match. Jeśli nie zostanie odnaleziony odpowiednik $& podstawienia nie ma wpływu.If there is no match, the $& substitution has no effect.

W poniższym przykładzie użyto $& podstawienia w celu dodania znaków cudzysłowu na początku i na końcu tytułów książek przechowywanych w tablicy ciągów.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"

Definicję wzorca wyrażenia regularnego ^(\w+\s?)+$ jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern ^(\w+\s?)+$ is defined as shown in the following table.

WzorzecPattern OpisDescription
^ Rozpoczęcie dopasowywania na początku ciągu wejściowego.Start the match at the beginning of the input string.
(\w+\s?)+ Dopasowanie wzorca jednego lub większej liczby znaków słowa, po których co najmniej raz następuje zero lub jeden znak odstępu.Match the pattern of one or more word characters followed by zero or one white-space characters one or more times.
$ Dopasowuje koniec ciągu wejściowego.Match the end of the input string.

"$&" Wzorzec zamieniania dodaje literalny znak cudzysłowu na początku i końcu każdego dopasowania.The "$&" replacement pattern adds a literal quotation mark to the beginning and end of each match.

Powrót do początkuBack to top

Podstawianie tekstu przed dopasowaniemSubstituting the Text Before the Match

$` Podstawienia zamienia dopasowany ciąg na cały ciąg wejściowy przed dopasowaniem.The $` substitution replaces the matched string with the entire input string before the match. Oznacza to, że duplikuje ciąg wejściowy przed dopasowaniem, a jednocześnie usuwa dopasowany tekst.That is, it duplicates the input string up to the match while removing the matched text. Ciąg znajdujący się po dopasowanym tekście zostanie umieszczony w ciągu wynikowym bez zmian.Any text that follows the matched text is unchanged in the result string. Jeśli w ciągu wejściowym będzie znajdować się wiele dopasowań, tekst zamienny będzie pochodził z oryginalnego ciągu wejściowego, a nie z ciągu, w którym tekst został zamieniony na poprzednie dopasowania.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. (Przykład stanowi ilustrację.) Jeśli nie zostanie odnaleziony odpowiednik $` podstawienia nie ma wpływu.(The example provides an illustration.) If there is no match, the $` substitution has no effect.

W poniższym przykładzie użyto wzorca wyrażenia regularnego \d+ dostosowując sekwencji jednego lub więcej cyfr dziesiętnych w ciągu wejściowym.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. Ciąg zastępujący $` zamienia te cyfry na tekst, który poprzedza dopasowanie.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

W tym przykładzie ciąg wejściowy "aa1bb2cc3dd4ee5" zawiera pięć dopasowań.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. W poniższej tabeli przedstawiono sposób, w jaki $` podstawienia powoduje, że aparat wyrażeń regularnych do zastępowania każdego dopasowania w ciągu wejściowym.The following table illustrates how the $` substitution causes the regular expression engine to replace each match in the input string. Wstawiony tekst wyróżniono pogrubieniem w kolumnie wyników.Inserted text is shown in bold in the results column.

DopasowanieMatch PozycjaPosition Ciąg przed dopasowaniemString before match Ciąg wynikowyResult string
11 22 aaaa aaaabb2cc3dd4ee5aaaabb2cc3dd4ee5
22 55 aa1bbaa1bb aaaabbaa1bbcc3dd4ee5aaaabbaa1bbcc3dd4ee5
33 88 aa1bb2ccaa1bb2cc aaaabbaa1bbccaa1bb2ccdd4ee5aaaabbaa1bbccaa1bb2ccdd4ee5
44 1111 aa1bb2cc3ddaa1bb2cc3dd aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5
55 1414 aa1bb2cc3dd4eeaa1bb2cc3dd4ee aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4eeaaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Powrót do początkuBack to top

Podstawianie tekstu po dopasowaniuSubstituting the Text After the Match

$' Podstawienia zamienia dopasowany ciąg na cały ciąg wejściowy po dopasowaniu.The $' substitution replaces the matched string with the entire input string after the match. Oznacza to, że duplikuje ciąg wejściowy za dopasowaniem, a jednocześnie usuwa dopasowany tekst.That is, it duplicates the input string after the match while removing the matched text. Ciąg znajdujący się przed dopasowanym tekstem zostanie umieszczony w ciągu wynikowym bez zmian.Any text that precedes the matched text is unchanged in the result string. Jeśli nie zostanie odnaleziony odpowiednik $' podstawienia nie ma wpływu.If there is no match, the $' substitution has no effect.

W poniższym przykładzie użyto wzorca wyrażenia regularnego \d+ dostosowując sekwencji jednego lub więcej cyfr dziesiętnych w ciągu wejściowym.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. Ciąg zastępujący $' zamienia te cyfry na tekst, który następuje po dopasowaniu.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

W tym przykładzie ciąg wejściowy "aa1bb2cc3dd4ee5" zawiera pięć dopasowań.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. W poniższej tabeli przedstawiono sposób, w jaki $' podstawienia powoduje, że aparat wyrażeń regularnych do zastępowania każdego dopasowania w ciągu wejściowym.The following table illustrates how the $' substitution causes the regular expression engine to replace each match in the input string. Wstawiony tekst wyróżniono pogrubieniem w kolumnie wyników.Inserted text is shown in bold in the results column.

DopasowanieMatch PozycjaPosition Ciąg po dopasowaniuString after match Ciąg wynikowyResult string
11 22 bb2cc3dd4ee5bb2cc3dd4ee5 aabb2cc3dd4ee5bb2cc3dd4ee5aabb2cc3dd4ee5bb2cc3dd4ee5
22 55 cc3dd4ee5cc3dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5
33 88 dd4ee5dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5
44 1111 ee5ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5
55 1414 String.Empty aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5eeaabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Powrót do początkuBack to top

Podstawianie ostatniej przechwyconej grupySubstituting the Last Captured Group

$+ Podstawienia zamienia dopasowany ciąg na ostatnią przechwyconą grupę.The $+ substitution replaces the matched string with the last captured group. W przypadku braku przechwyconych grup lub jeśli ma wartość ostatnią przechwyconą grupę String.Empty, $+ podstawienia nie ma wpływu.If there are no captured groups or if the value of the last captured group is String.Empty, the $+ substitution has no effect.

W poniższym przykładzie identyfikowane zduplikowane wyrazy w ciągu i używa $+ podstawienia w celu zamieniania ich na pojedyncze wystąpienie wyrazu.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 Opcja służy do zapewnienia, że wyrazy, które różnią się w przypadku, ale które w przeciwnym razie są identyczne są traktowane jako duplikaty.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.

Definicję wzorca wyrażenia regularnego \b(\w+)\s\1\b jest zdefiniowany jak pokazano w poniższej tabeli.The regular expression pattern \b(\w+)\s\1\b is defined as shown in the following table.

WzorzecPattern OpisDescription
\b Rozpoczyna dopasowanie na granicy wyrazu.Begin the match at a word boundary.
(\w+) Dopasowuje co najmniej jeden znak słowa.Match one or more word characters. Jest to pierwsza grupa przechwytywania.This is the first capturing group.
\s Dopasowuje znak odstępu.Match a white-space character.
\1 Dopasowanie pierwszej przechwyconej grupy.Match the first captured group.
\b Kończy dopasowanie na granicy wyrazu.End the match at a word boundary.

Powrót do początkuBack to top

Podstawianie całego ciągu wejściowegoSubstituting the Entire Input String

$_ Podstawienia zamienia dopasowany ciąg na cały ciąg wejściowy.The $_ substitution replaces the matched string with the entire input string. Oznacza to, że usuwa dopasowany tekst i zastępuje go całym ciągiem, w tym dopasowanym tekstem.That is, it removes the matched text and replaces it with the entire string, including the matched text.

W poniższym przykładzie jest dopasowywana co najmniej jedna cyfra dziesiętna w ciągu wejściowym.The following example matches one or more decimal digits in the input string. Używa ona $_ podstawienia w celu zamieniania ich na cały ciąg wejściowy.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

W tym przykładzie ciąg wejściowy "ABC123DEF456" zawiera dwa dopasowania.In this example, the input string "ABC123DEF456" contains two matches. W poniższej tabeli przedstawiono sposób, w jaki $_ podstawienia powoduje, że aparat wyrażeń regularnych do zastępowania każdego dopasowania w ciągu wejściowym.The following table illustrates how the $_ substitution causes the regular expression engine to replace each match in the input string. Wstawiony tekst wyróżniono pogrubieniem w kolumnie wyników.Inserted text is shown in bold in the results column.

DopasowanieMatch PozycjaPosition DopasowanieMatch Ciąg wynikowyResult string
11 33 123123 ABCABC123DEF456DEF456ABCABC123DEF456DEF456
22 55 456456 ABCABC123DEF456DEFABC123DEF456ABCABC123DEF456DEFABC123DEF456

Zobacz takżeSee also