Podstawianie w wyrażeniach regularnych

Substytucje to elementy języka, które są rozpoznawane tylko w ramach wzorców zastępowania. Używają wzorca wyrażenia regularnego do definiowania wszystkich lub części tekstu, który ma zastąpić dopasowany tekst w ciągu wejściowym. Wzorzec zamiany może składać się z jednego lub więcej podstawień wraz z dosłownymi znakami. Wzorce zastępcze są przekazywane przeciążeniom metody Regex.Replace, które zawierają parametr replacement, oraz do metody Match.Result. Metody zastępują dopasowany wzorzec wzorcem zdefiniowanym replacement przez parametr .

Platforma .NET definiuje elementy zamiany wymienione w poniższej tabeli.

Zastąpienie	Opis
$ numer	Zawiera ostatni podciąg zgodny z grupą przechwytywania, która jest identyfikowana przez liczbę, gdzie liczba jest wartością dziesiętną w ciągu zastępczym. Więcej informacji znajdziesz w Podstawianie grupy numerowanej.
${ name }	Zawiera ostatni podciąg zgodny z nazwaną grupą, która jest wyznaczona przez (?<nazwę> ) w ciągu zastępczym. Aby uzyskać więcej informacji, zobacz Podstawianie nazwanej grupy.
$$	Zawiera pojedynczy dosłowny znak "$" w łańcuchu zastępczym. Aby uzyskać więcej informacji, zobacz Podstawianie symbolu "$".
$&	Zawiera kopię całego dopasowania w ciągu zastępczym. Aby uzyskać więcej informacji, zobacz Podstawianie całego dopasowania.
$`	Zawiera cały tekst ciągu wejściowego sprzed dopasowania w ciągu zamiennym. Aby uzyskać więcej informacji, zobacz Zamiana tekstu przed dopasowaniem.
$'	Zawiera cały tekst ciągu wejściowego po dopasowaniu w ciągu zastępczym. Aby uzyskać więcej informacji, zobacz Podstawianie tekstu po dopasowaniu.
$+	Zawiera ostatnią grupę przechwyconą w ciągu zastępczym. Aby uzyskać więcej informacji, zobacz Podstawianie ostatniej przechwyconej grupy.
$_	Zawiera cały ciąg wejściowy w ciągu zastępczym. Aby uzyskać więcej informacji, zapoznaj się z Podstawianiem całego ciągu wejściowego.

Elementy zamienników i wzorce zamiany

Podstawienia to jedyne konstrukcje specjalne rozpoznawane we wzorcu zamiany. Żaden z innych elementów języka wyrażeń regularnych, w tym sekwencje ucieczki znaków i kropka (.), która pasuje do dowolnego znaku, nie jest obsługiwany. Podobnie elementy języka podstawienia są rozpoznawane tylko w wzorcach zastępczych i nigdy nie są prawidłowe we wzorcach wyrażeń regularnych.

Jedynym znakiem, który może pojawić się we wzorcu wyrażenia regularnego lub w podstawieniu, jest znak $, chociaż w każdym z tych kontekstów ma inne znaczenie. W wzorcu wyrażenia regularnego $ jest kotwicą odpowiadającą końcowi ciągu. We wzorcu zastępczym $ oznacza początek podstawienia.

Uwaga / Notatka

Aby uzyskać funkcje podobne do wzorca zastępczego w wyrażeniu regularnym, należy użyć wnioskowania wstecznego. Aby uzyskać więcej informacji na temat odsyłaczy wstecznych, zobacz Konstrukcje wsteczne.

Podstawianie grupy numerowanej

Element języka liczba zawiera ostatni podciąg zgodny z grupą przechwytywania w ciągu zastępczym, gdzie liczba jest indeksem przechwyconej grupy. Na przykład zastępczy wzorzec $1 wskazuje, że dopasowany podciąg ma zostać zastąpiony przez pierwszą przechwyconą grupę. Aby uzyskać więcej informacji na temat grup przechwytywania numerowanych, zobacz Grouping Constructs (Konstrukcje grupowania).

Wszystkie następujące $ cyfry są interpretowane jako należące do grupy liczb . Jeśli nie jest to twoja intencja, możesz zamiast tego zastąpić nazwaną grupę. Można na przykład użyć ciągu zastępczego ${1}1 zamiast $11, aby zdefiniować ciąg zastępczy jako wartość pierwszej przechwyconej grupy wraz z liczbą "1". Aby uzyskać więcej informacji, zobacz Podstawianie nazwanej grupy.

Przechwytywanie grup, którym nie przypisano jawnie nazw przy użyciu składni (?<nazwa>), są numerowane od lewej do prawej, zaczynając od jednego. Nazwane grupy są również numerowane od lewej do prawej, zaczynając od liczby o jeden większej niż indeks ostatniej grupy bez nazwy. Na przykład w wyrażeniu (\w)(?<digit>\d)regularnym indeks nazwanej digit grupy to 2.

Jeśli liczba nie określa ważnej grupy przechwytującej zdefiniowanej we wzorcu wyrażenia regularnego, $liczba jest interpretowana jako dosłowna sekwencja znaków, której używa się do zastępowania każdego dopasowanego elementu.

W poniższym przykładzie użyto podstawienia $liczby, aby pozbawić wartość dziesiętną symbolu waluty. Usuwa symbole waluty znalezione na początku lub na końcu wartości pieniężnej i rozpoznaje dwa najbardziej typowe separatory dziesiętne ("." i ",").

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

Wzorzec \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzór	Opis
\p{Sc}*	Dopasuj zero lub więcej znaków symboli waluty.
\s?	Dopasowanie do zera lub jednego znaku białej spacji.
\d+	Dopasuj jedną lub więcej cyfr.
[.,]?	Dopasuj zero lub jedną kropkę lub przecinek.
\d*	Dopasuj zero lub więcej cyfr dziesiętnych.
(\s?\d+[.,]?\d*)	Dopasuj biały znak, po którym następuje co najmniej jedna cyfra dziesiętna, po której następuje zero lub jeden kropka lub przecinek, po którym następuje zero lub więcej cyfr dziesiętnych. Jest to pierwsza przechwycona grupa. Ponieważ wzorzec zastępczy to $1, wywołanie metody Regex.Replace zastępuje cały dopasowany podciąg tekstu z tą przechwyconą grupą.

Zamiana nazwanej grupy

Element ${ językowy nazw} zastępuje ostatni podciąg pasujący do grupy przechwytywania o nazwie nazwa, gdzie nazwa jest nazwą grupy przechwytywania zdefiniowaną (?< przez element językowy nazw>). Aby uzyskać więcej informacji na temat nazwanych grup przechwytywania, zobacz Grouping Constructs (Konstrukcje grupowania).

Jeśli nazwa nie określa prawidłowej nazwy grupy przechwytywania zdefiniowanej we wzorcu wyrażenia regularnego, ale składa się z cyfr, ${nazwa} jest interpretowana jako grupa numerowana.

Jeśli nazwa nie określa ani prawidłowej nazwy grupy przechwytywania, ani prawidłowej grupy przechwytywania numerowanej we wzorcu wyrażenia regularnego, ${nazwa} jest interpretowana jako dosłowna sekwencja znaków używana do zastępowania każdego dopasowania.

W poniższym przykładzie użyto ${ zamiany nazwy}, aby usunąć symbol waluty z wartości dziesiętnej liczbowej. Usuwa symbole waluty znalezione na początku lub na końcu wartości pieniężnej i rozpoznaje dwa najbardziej typowe separatory dziesiętne ("." i ",").

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

Wzorzec \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzór	Opis
\p{Sc}*	Dopasuj zero lub więcej znaków symboli waluty.
\s?	Dopasowanie do zera lub jednego znaku białej spacji.
\d+	Dopasuj jedną lub więcej cyfr.
[.,]?	Dopasuj zero lub jedną kropkę lub przecinek.
\d*	Dopasuj zero lub więcej cyfr dziesiętnych.
(?<amount>\s?\d[.,]?\d*)	Dopasuj biały znak, po którym następuje co najmniej jedna cyfra dziesiętna, po której następuje zero lub jeden kropka lub przecinek, po którym następuje zero lub więcej cyfr dziesiętnych. Jest to grupa przechwytywania o nazwie amount. Ponieważ wzorzec zastępczy to ${amount}, wywołanie metody Regex.Replace zastępuje cały dopasowany podciąg tekstu z tą przechwyconą grupą.

Podstawianie znaku "$"

Funkcja $$ wstawia dosłowny znak "$" do zastąpionego ciągu.

W poniższym przykładzie użyto obiektu NumberFormatInfo do określenia symbolu waluty aktualnej kultury oraz jego umiejscowienia w ciągu walutowym. Następnie kompiluje zarówno wzorzec wyrażenia regularnego, jak i wzorzec wymiany dynamicznie. Jeśli przykład jest uruchamiany na komputerze, którego bieżąca kultura to en-US, generuje wzorzec wyrażenia regularnego \b(\d+)(\.(\d+))? i wzorzec wymiany $$ $1$2. Wzorzec zastępowania zastępuje dopasowany tekst symbolem waluty i spacją, po której następuje pierwsza i druga przechwycona grupa.

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($"{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

Wzorzec \b(\d+)(\.(\d+))? wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzór	Opis
\b	Rozpocznij dopasowanie na początku granicy wyrazu.
(\d+)	Dopasuj jedną lub więcej cyfr. Jest to pierwsza przechwycona grupa.
\.	Dopasuj kropkę (separator dziesiętny).
(\d+)	Dopasuj jedną lub więcej cyfr. Jest to trzecia grupa przechwytywań.
(\.(\d+))?	Dopasuj zero lub jedno wystąpienie kropki, po którym następuje co najmniej jedna cyfra dziesiętna. Jest to druga grupa przechwytywania.

Podstawianie całego dopasowania

Podstawianie $& zawiera całe dopasowanie w stringu znaków zastępczych. Często jest używany do dodawania podłańcucha na początku lub na końcu dopasowanego ciągu. Na przykład wzorzec zastępczy ($&) dodaje nawiasy na początku i na końcu każdego dopasowania. Jeśli nie ma dopasowania, $& podstawienie nie ma wpływu.

W poniższym przykładzie użyto $& podstawienia, aby dodać cudzysłowy na początku i na końcu tytułów książek przechowywanych w tablicy ciągów znaków.

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"

Wzorzec ^(\w+\s?)+$ wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzór	Opis
^	Rozpocznij dopasowanie na początku ciągu wejściowego.
(\w+\s?)+	Dopasuj wzorzec co najmniej jednego znaku słowa, po którym następuje zero lub jeden znak odstępu co najmniej jeden raz.
$	Dopasowuje koniec ciągu wejściowego.

Wzorzec "$&" zastępczy dodaje dosłowny znak cudzysłowu na początku i końcu każdego dopasowania.

Zastępowanie tekstu przed dopasowaniem

Zamiana $` zastępuje dopasowany ciąg całym początkowym ciągiem wejściowym przed dopasowaniem. Oznacza to, że powiela ciąg wejściowy aż do miejsca dopasowania, usuwając dopasowany tekst. Dowolny tekst zgodny z dopasowanym tekstem nie zmienia się w ciągu wynikowym. Jeśli w ciągu wejściowym istnieje wiele dopasowań, tekst zastępczy pochodzi z oryginalnego ciągu wejściowego, a nie z ciągu, w którym tekst został zastąpiony wcześniejszymi dopasowaniami. (Przykład zawiera ilustrację). Jeśli nie ma dopasowania, $` podstawienie nie ma wpływu.

W poniższym przykładzie użyto wzorca wyrażenia regularnego \d+, aby dopasować w ciągu wejściowym sekwencję złożoną z jednej lub więcej cyfr dziesiętnych. Ciąg $` zastępczy zastępuje te cyfry tekstem poprzedzającym dopasowanie.

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($"   {match.Value} at position {match.Index}");

      Console.WriteLine($"Input string:  {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 "aa1bb2cc3dd4ee5" wejściowy zawiera pięć pasujących elementów. W poniższej tabeli pokazano, jak podstawianie $` powoduje, że silnik wyrażeń regularnych zastępuje każde dopasowanie w ciągu wchodzącym. Wstawiony tekst jest wyświetlany pogrubionym w kolumnie wyników.

Mecz	Stanowisko	Ciąg przed dopasowaniem	Ciąg wyniku
1	2	Aa	aa aabb2cc3dd4ee5
2	5	aa1bb	aaaabbaa1bbcc3dd4ee5
3	8	aa1bb2cc	aaaabbaa1bbccaa1bb2ccdd4ee5
4	11	aa1bb2cc3dd	aaaabbaa1bbccaa1bb2ccdddaa1bb2cc3ddee5
5	14	aa1bb2cc3d4ee	aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Zastępowanie tekstu po znalezieniu dopasowania

$' Zamiana zastępuje dopasowany ciąg cały ciągiem wejściowym po jego dopasowaniu. Oznacza to, że duplikuje ciąg wejściowy po dopasowaniu podczas usuwania dopasowanego tekstu. Dowolny tekst poprzedzający dopasowany tekst pozostaje niezmieniony w ciągu wynikowym. Jeśli nie ma dopasowania, $' podstawienie nie ma wpływu.

W poniższym przykładzie użyto wzorca wyrażenia regularnego \d+, aby dopasować w ciągu wejściowym sekwencję złożoną z jednej lub więcej cyfr dziesiętnych. Ciąg $' zastępczy zastępuje te cyfry tekstem zgodnym z dopasowaniem.

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($"   {match.Value} at position {match.Index}");
      Console.WriteLine($"Input string:  {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 "aa1bb2cc3dd4ee5" wejściowy zawiera pięć pasujących elementów. W poniższej tabeli pokazano, jak podstawianie $' powoduje, że silnik wyrażeń regularnych zastępuje każde dopasowanie w ciągu wchodzącym. Wstawiony tekst jest wyświetlany pogrubionym w kolumnie wyników.

Mecz	Stanowisko	Ciąg po dopasowaniu	Ciąg wyniku
1	2	bb2cc3dd4ee5	aabb2cc3d4ee5bb2cc3dd4ee5
2	5	cc3dd4ee5	aabb2cc3d4ee5bbcc3d4ee5 cc3dd4ee5cc3dd4ee5
3	8	dd4ee5	aabb2cc3d4ee5bbcc3d4ee5ccdd4ee5dd4ee5
4	11	ee5	aabb2cc3d4ee5bbcc3d4ee5ccdd4ee5ddee5 ee5
5	14	String.Empty	aabb2cc3d4ee5bbcc3d4ee5ccdd4ee5ddee5e

Podstawianie ostatniej przechwyconej grupy

Podstawianie $+ zastępuje dopasowany ciąg ostatnio przechwyconą grupą. Jeśli nie ma przechwyconych grup lub jeśli wartość ostatniej przechwyconej grupy to String.Empty, $+ podstawienie nie ma żadnego wpływu.

Poniższy przykład identyfikuje zduplikowane wyrazy w ciągu i używa $+ podstawienia, aby zastąpić je pojedynczym wystąpieniem danego wyrazu. Opcja RegexOptions.IgnoreCase służy do zapewnienia, że wyrazy, które różnią się tylko wielkością liter, a w pozostałych aspektach są identyczne, są traktowane jako duplikaty.

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.

Wzorzec \b(\w+)\s\1\b wyrażenia regularnego jest zdefiniowany, jak pokazano w poniższej tabeli.

Wzór	Opis
\b	Rozpocznij dopasowanie od granicy słowa.
(\w+)	Dopasuj jeden lub więcej znaków słowa. Jest to pierwsza przechwycona grupa.
\s	Dopasuj znak odstępu.
\1	Dopasuj pierwszą przechwyconą grupę.
\b	Zakończ mecz na granicy wyrazu.

Zamiana całego ciągu wejściowego

Podstawienie $_ zastępuje pasujący ciąg cały ciągiem wejściowym. Oznacza to, że usuwa dopasowany tekst i zastępuje go całym ciągiem, w tym dopasowanym tekstem.

Poniższy przykład pasuje do jednej lub więcej cyfr dziesiętnych w łańcuchu wejściowym. Używa substytucji $_ , aby zastąpić je całym ciągiem wejściowym.

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:          {input}");
      Console.WriteLine($"String with substitution: {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 "ABC123DEF456" wejściowy zawiera dwa dopasowania. W poniższej tabeli pokazano, jak podstawianie $_ powoduje, że silnik wyrażeń regularnych zastępuje każde dopasowanie w ciągu wchodzącym. Wstawiony tekst jest wyświetlany pogrubionym w kolumnie wyników.

Mecz	Stanowisko	Mecz	Ciąg wyniku
1	3	123	ABCABC123DEF456DEF456
2	5	456	ABCABC123DEF456DEF ABC123DEF456

Zobacz także

• Język wyrażeń regularnych — podręczny wykaz