Podstawienia w wyrażeniach regularnych

Podstawianie to elementy języka, które są rozpoznawane tylko w ramach wzorców zastępczych. 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. Wzorzec zamieniania może składać się z co najmniej jednego podstawienia oraz znaków literału. Wzorce zastępcze są dostarczane do przeciążeń Regex.Replace metody, które mają replacement parametr i do Match.Result metody. Metody zastępują dopasowany wzorzec wzorcem zdefiniowanym replacement przez parametr .

Platforma .NET definiuje elementy podstawienia 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. Aby uzyskać więcej informacji, zobacz 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 literał „$” w ciągu zamiennym. Aby uzyskać więcej informacji, zobacz Podstawianie symbolu "$".
$&	Zawiera kopię całego dopasowania w ciągu zamiennym. Aby uzyskać więcej informacji, zobacz Podstawianie całego dopasowania.
$`	Zawiera cały tekst ciągu wejściowego przed dopasowaniem w ciągu zamiennym. Aby uzyskać więcej informacji, zobacz Podstawianie tekstu przed dopasowaniem.
$'	Zawiera cały tekst ciągu wejściowego po dopasowaniu w ciągu zamiennym. Aby uzyskać więcej informacji, zobacz Podstawianie tekstu po dopasowaniu.
$+	Zawiera ostatnią grupę przechwyconą w ciągu zamiennym. Aby uzyskać więcej informacji, zobacz Podstawianie ostatniej przechwyconej grupy.
$_	Zawiera cały ciąg wejściowy w ciągu zamiennym. Aby uzyskać więcej informacji, zobacz Podstawianie całego ciągu wejściowego.

Elementy podstawienia i wzorce zamieniania

Podstawienia to jedyne konstrukcje specjalne rozpoznawane we wzorcu zamieniania. Żaden z innych elementów języka wyrażeń regularnych, w tym znaki ucieczki znaków i kropka (.), która pasuje do dowolnego znaku, są obsługiwane. Podobnie elementy języka podstawień są rozpoznawane tylko we wzorcach zamieniania, 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 podstawienia, jest $ znak, chociaż ma inne znaczenie w każdym kontekście. We wzorcu $ wyrażenia regularnego jest kotwicą zgodną z końcem ciągu. We wzorcu $ zastępczym wskazuje początek podstawienia.

Uwaga

Aby w wyrażeniu regularnym uzyskać funkcjonalność podobną do wzorca zamieniania, należy użyć dopasowywania wstecznego. Aby uzyskać więcej informacji na temat backreferences, zobacz Backreference Constructs (Konstrukcje wsteczne).

Podstawianie numerowanej grupy

Element $języka liczbowego zawiera ostatni podciąg zgodny z liczbą przechwytujących grupę w ciągu zastępczym, gdzie liczba jest indeksem grupy przechwytywania. Na przykład wzorzec $1 zastępczy wskazuje, że dopasowane podciąg ma zostać zastąpione 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 zgodne z zamiarami użytkownika, można podstawić grupę nazwaną. Można na przykład użyć ciągu ${1}1 zastępczego zamiast $11 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óre nie są jawnie przypisane nazwy przy użyciu (?<składni nazwy>) , są numerowane od lewej do prawej, zaczynając od jednego. Nazwane grupy także są numerowane od lewej do prawej, począwszy od numeru większego o 1 od indeksu ostatniej nienazwanej grupy. Na przykład w wyrażeniu (\w)(?<digit>\d)regularnym indeks nazwanej digit grupy to 2.

Jeśli liczba nie określa prawidłowej grupy przechwytywania zdefiniowanej we wzorcu wyrażenia regularnego, $liczba jest interpretowana jako sekwencja znaków literału używana do zastępowania każdego dopasowania.

W poniższym przykładzie użyto $podstawienia liczb , aby usunąć symbol waluty z wartości dziesiętnej. 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 „,”).

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.

Wzorzec	opis
\p{Sc}*	Dopasowanie do zera lub większej liczby znaków symbolu waluty.
\s?	Dopasowanie do zera lub jednego znaku odstępu.
\d+	Dopasowanie do co najmniej jednej cyfry dziesiętnej.
[.,]?	Dopasowanie do zera lub jednej kropki lub przecinka.
\d*	Dopasowanie do zera lub większej liczby cyfr dziesiętnych.
(\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. Jest to pierwsza grupa przechwytywania. Ponieważ wzorzec zastępczy to $1, wywołanie Regex.Replace metody zastępuje cały dopasowany podciąg z tą przechwyconą grupą.

Podstawianie nazwanej grupy

Element ${języka nazw} zastępuje ostatni podciąg zgodny z nazwą przechwytywania grupy, gdzie nazwa jest nazwą grupy przechwytywania zdefiniowanej(?< przez element języka 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 określa ani prawidłową nazwę grupy przechwytywania, ani prawidłową grupę przechwytywania numerowaną w wzorzec wyrażenia regularnego, ${nazwa} jest interpretowana jako sekwencja znaków literału używana do zastępowania każdego dopasowania.

W poniższym przykładzie użyto ${podstawienia nazwy} , aby usunąć symbol waluty z wartości dziesiętnej. 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 „,”).

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.

Wzorzec	opis
\p{Sc}*	Dopasowanie do zera lub większej liczby znaków symbolu waluty.
\s?	Dopasowanie do zera lub jednego znaku odstępu.
\d+	Dopasowanie do co najmniej jednej cyfry dziesiętnej.
[.,]?	Dopasowanie do zera lub jednej kropki lub przecinka.
\d*	Dopasowanie do zera lub większej liczby cyfr dziesiętnych.
(?<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. Jest to grupa przechwytywania o nazwie amount. Ponieważ wzorzec zastępczy to ${amount}, wywołanie Regex.Replace metody zastępuje cały dopasowany podciąg z tą przechwyconą grupą.

Podstawianie znaku „$”

$$ Podstawianie wstawia literał "$" w zastąpionym ciągu.

W poniższym przykładzie NumberFormatInfo użyto obiektu do określenia symbolu waluty bieżącej kultury i jego umieszczania w ciągu waluty. Następnie jest dynamicznie tworzony wzorzec wyrażenia regularnego i wzorzec zamieniania. Jeśli przykład jest uruchamiany na komputerze, którego bieżąca kultura jest en-US, generuje wzorzec \b(\d+)(\.(\d+))? wyrażenia regularnego i wzorzec $$ $1$2zastąpienia . Wzorzec zamieniania zamienia dopasowany tekst na symbol waluty i spację, po której następują 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("{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

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

Wzorzec	opis
\b	Rozpoczęcie dopasowywania na początku granicy wyrazu.
(\d+)	Dopasowanie do co najmniej jednej cyfry dziesiętnej. Jest to pierwsza grupa przechwytywania.
\.	Dopasowanie kropki (separator dziesiętny).
(\d+)	Dopasowanie do co najmniej jednej cyfry dziesiętnej. Jest to trzecia grupa przechwytywania.
(\.(\d+))?	Dopasowanie zera lub jednego wystąpienia 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 ciągu zastępczym. Często jest używane do dodawania podciągu na początku lub końcu dopasowanego ciągu. Na przykład ($&) wzorzec zastępczy dodaje nawiasy do początku i końca każdego dopasowania. Jeśli nie ma dopasowania, $& podstawienie nie ma wpływu.

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

Wzorzec	opis
^	Rozpoczęcie dopasowywania na początku ciągu wejściowego.
(\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.
$	Dopasowuje koniec ciągu wejściowego.

Wzorzec "$&" zastępczy dodaje znak cudzysłowu do początku i końca każdego dopasowania.

Podstawianie tekstu przed dopasowaniem

$` Podstawianie zastępuje dopasowany ciąg całym ciągiem wejściowym przed dopasowaniem. Oznacza to, że duplikuje ciąg wejściowy przed dopasowaniem, a jednocześnie usuwa dopasowany tekst. Ciąg znajdujący się po dopasowanym tekście zostanie umieszczony w ciągu wynikowym bez zmian. 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. (Przykład zawiera ilustrację). Jeśli nie ma dopasowania, $` podstawienie nie ma wpływu.

W poniższym przykładzie użyto wzorca \d+ wyrażenia regularnego, aby dopasować sekwencję co najmniej jednej cyfry dziesiętnej w ciągu wejściowym. 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("   {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 "aa1bb2cc3dd4ee5" wejściowy zawiera pięć dopasowań. W poniższej tabeli pokazano, jak $` podstawianie powoduje zastąpienie każdego dopasowania aparatu wyrażeń regularnych w ciągu wejściowym. Wstawiony tekst wyróżniono pogrubieniem w kolumnie wyników.

Match	Position	Ciąg przed dopasowaniem	Ciąg wynikowy
1	2	aa	aa aabb2cc3dd4ee5
2	5	aa1bb	aaaabb aa1bbcc3dd4ee5
3	8	aa1bb2cc	aaaabbaa1bbccaa1bb2ccdd4ee5
4	11	aa1bb2cc3dd	aaaabbaa1bbccaa1bb2ccdddaa1bb2cc3ddee5
5	14	aa1bb2cc3dd4ee	aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Podstawianie tekstu po dopasowaniu

$' Podstawianie zastępuje dopasowany ciąg całym ciągiem wejściowym po dopasowaniu. Oznacza to, że duplikuje ciąg wejściowy za dopasowaniem, a jednocześnie usuwa dopasowany tekst. Ciąg znajdujący się przed dopasowanym tekstem zostanie umieszczony w ciągu wynikowym bez zmian. Jeśli nie ma dopasowania, $' podstawienie nie ma wpływu.

W poniższym przykładzie użyto wzorca \d+ wyrażenia regularnego, aby dopasować sekwencję co najmniej jednej cyfry dziesiętnej w ciągu wejściowym. 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("   {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 "aa1bb2cc3dd4ee5" wejściowy zawiera pięć dopasowań. W poniższej tabeli pokazano, jak $' podstawianie powoduje zastąpienie każdego dopasowania aparatu wyrażeń regularnych w ciągu wejściowym. Wstawiony tekst wyróżniono pogrubieniem w kolumnie wyników.

Match	Position	Ciąg po dopasowaniu	Ciąg wynikowy
1	2	bb2cc3dd4ee5	aabb2cc3d4ee5bb2cc3dd4ee5
2	5	cc3dd4ee5	aabb2cc3d4ee5bbcc3d4ee5 cc3dd4ee5cc3dd4ee5
3	8	dd4ee5	aabb2cc3d4ee5bbcc3d4ee5ccdd4ee5 dd4ee5dd4ee5
4	11	ee5	aabb2cc3d4ee5bbcc3d4ee5ccdd4ee5ddee5 ee5
5	14	String.Empty	aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

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 $+ podstawień, aby zastąpić je pojedynczym wystąpieniem słowa. Opcja RegexOptions.IgnoreCase służy do zapewnienia, że wyrazy różnią się wielkością liter, ale w przeciwnym razie 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.

Wzorzec	opis
\b	Rozpoczyna dopasowanie na granicy wyrazu.
(\w+)	Dopasowuje co najmniej jeden znak słowa. Jest to pierwsza grupa przechwytywania.
\s	Dopasowuje znak odstępu.
\1	Dopasowanie pierwszej przechwyconej grupy.
\b	Kończy dopasowanie na granicy wyrazu.

Podstawianie całego ciągu wejściowego

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

W poniższym przykładzie jest dopasowywana co najmniej jedna cyfra dziesiętna w ciągu wejściowym. Używa podstawień $_ , 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:          {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 "ABC123DEF456" wejściowy zawiera dwa dopasowania. W poniższej tabeli pokazano, jak $_ podstawianie powoduje zastąpienie każdego dopasowania aparatu wyrażeń regularnych w ciągu wejściowym. Wstawiony tekst wyróżniono pogrubieniem w kolumnie wyników.

Match	Position	Match	Ciąg wynikowy
1	3	123	ABCABC123DEF456DEF456
2	5	456	ABCABC123DEF456DEF ABC123DEF456

Zobacz też

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