Sdílet prostřednictvím

Substituce

  • Článek

Náhrady jsou prvky jazyka, které jsou rozpoznány pouze v rámci vzorků pro nahrazování. Používají vzorek regulárního výrazu pro definování celého textu nebo jeho části, která má být nahrazena odpovídajícím textem vstupního řetězce. Vzorek pro nahrazení se může skládat z jedné nebo více náhrad spolu s literálními znaky. Vzorky pro nahrazení jsou poskytovány přetížení metody Regex.Replace, která má parametr replacement a metodou Match.Result. Metody nahradí odpovídající vzorek, který je definován parametrem replacement.

Rozhraní .NET Framework definuje prvky pro nahrazování uvedené v následující tabulce.

Substituce

Popis

$číslo

Obsahuje poslední podřetězec porovnáváný zachycujícím seskupením, které je identifikováno number, kde number je desítková hodnota v řetězci pro nahrazování. Další informace naleznete v tématu Nahrazování číslované skupiny.

${název}

Obsahuje poslední podřetězec odpovídající pojmenované skupině, která je stanovena podle (?<name> ) v řetězci pro nahrazování. Další informace naleznete v tématu Nahrazování pojmenované skupiny.

$$

Zahrnuje jediný literál $ v řetězci pro nahrazování. Další informace naleznete v tématu Náhrada symbolu $.

$&

Obsahuje kopii celé shody v řetězci pro nahrazování. Další informace naleznete v tématu Nahrazování celé shody.

$`

Zahrne celý text vstupního řetězce před porovnáváním v řetězci pro nahrazování. Další informace naleznete v tématu Nahrazování textu před porovnáváním.

$'

Zahrne celý text vstupního řetězce po porovnávání v řetězci pro nahrazování. Další informace naleznete v tématu Nahrazování textu po porovnávání.

$+

Zahrnuje poslední skupinu zachycenou v řetězci pro nahrazování. Další informace naleznete v tématu Nahrazování poslední zachycené skupiny.

$_

Zahrnuje celý vstupní řetězec v řetězci pro nahrazování. Další informace naleznete v tématu Nahrazování celého vstupního řetězce.

Nahrazování prvků a vzorků pro nahrazování

Náhrady jsou jediné speciální konstrukce, které jsou rozpoznávány ve vzorcích pro nahrazování. Nejsou podporovány žádné z dalších prvků jazyka regulárních výrazů, včetně řídících znaků a tečky (.), která odpovídá libovolnému znaku. Podobně jazykové prvky nahrazování jsou rozpoznány jen ve vzorcích pro náhrazení a nejsou nikdy platné ve vzorcích regulárních výrazů.

Jediný znak, který se může zobrazit ve vzorcích regulárních výrazů i v náhradách je znak $, má v každém kontextu jiný význam. Ve vzorku regulárního výrazu je $ kotva, která odpovídá konci řetězce. Ve vzorku pro nahrazování $ označuje začátek nahrazování.

PoznámkaPoznámka

Pro funkce podobné vzorkům pro nahrazování v rámci regulárního výrazu, použijte zpětný odkaz.Další informace o zpětných odkazech naleznete v tématu Konstrukce zpětných odkazů.

Nahrazování číslované skupiny

Jazykový prvek $number obsahuje poslední podřetězec porovnávaný zachycující skupinou number v řetězci pro nahrazení, kde number je index zachycující skupiny. Například vzorek pro nahrazení $1 označuje, že odpovídající podřetězec bude nahrazen první zachycenou skupinou. Další informace o číslovaných zachycujících skupinách naleznete v tématu Seskupovací konstrukce.

Zachycující skupiny, kterým nejsou explicitně přiřazeny názvy pomocí syntaxe (?<name>) jsou číslovány zleva doprava počínaje číslem jedna. Pojmenované skupiny jsou rovněž číslovány zleva doprava. Číslování začína číslem o jedno vyšším než index poslední nepojmenované skupiny. Například v regulárním výrazu (\w)(?<digit>\d) je index pojmenované skupiny digit 2.

Pokud number neurčuje platnou zachycující skupinu definovanou ve vzorku regulárního výrazu, je $number interpretováno jako literální sekvence znaků, která slouží k nahrazení každé shody.

Následující příklad používá nahrazení $number pro oříznutí symbolu měny z desítkové hodnoty čísla. Odebere symboly měny nalezené na začátku nebo konci peněžní hodnota a rozpoznává dva nejběžnější desítkové oddělovače "." a ",".

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

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

Vzorce regulárního výrazu \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* je definován podle následující tabulky.

Maska

Popis

\p{Sc}*

porovná nula nebo více znaků symbolu měny.

\s?

Porovná nula nebo jeden prázdný znak.

\d+

Porovná jednu nebo více desítkových číslic.

[.,]?

Porovná nula nebo jednu tečku nebo čárku.

\d*

Porovnává nula nebo více desetinných číslic.

(\s? \d+[.,]? \d*)

Porovnává prázdný znak, následovaný jednou nebo více desítkovými číslicemi, následované nula nebo jednou tečkou nebo čárkou, následované nula nebo více desítkovými číslicemi. Toto je první zachytávající skupina. Protože vzorek pro nahrazování je $1, volání metody Regex.Replace nahradí celý odpovídající podřetězec touto zachycenou skupinou.

Zpět na začátek

Nahrazení pojmenované skupiny

Jazykový prvek ${name} nahradí poslední podřetězec zachycený zachycující skupinou name, kde name je název zachytávající skupiny definovaný prvkem jazyka (?<name>). Další informace o pojmenovaných zachycujících skupinách naleznete v tématu Seskupovací konstrukce.

Pokud name neurčuje platnou pojmenovanou zachycující skupinu definovanou ve vzorku regulárního výrazu, je ${name} interpretováno jako literální sekvence znaků, která slouží k nahrazení každé shody.

Následující příklad používá substituci ${name} pro oříznutí symbolu měny z desítkové hodnoty čísla. Odebere symboly měny nalezené na začátku nebo konci peněžní hodnota a rozpoznává dva nejběžnější desítkové oddělovače "." a ",".

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

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

Vzorce regulárního výrazu \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* je definován podle následující tabulky.

Maska

Popis

\p{Sc}*

porovná nula nebo více znaků symbolu měny.

\s?

Porovná nula nebo jeden prázdný znak.

\d+

Porovná jednu nebo více desítkových číslic.

[.,]?

Porovná nula nebo jednu tečku nebo čárku.

\d*

Porovnává nula nebo více desetinných číslic.

(?<amount>\s? \d[.,]? \d*)

Porovnává prázdný znak, následovaný jednou nebo více desítkovými číslicemi, následované nula nebo jednou tečkou nebo čárkou, následované nula nebo více desítkovými číslicemi. Toto je zachycující skupina s názvem amount. Protože vzorek pro nahrazování je ${amount}, volání metody Regex.Replace nahradí celý odpovídající podřetězec touto zachycenou skupinou.

Zpět na začátek

Nahrazení znaku $

Nahrazení $$ vloží literální znak $ do nahrazeného řetězce.

Následující příklad používá objekt NumberFormatInfo pro určení symbolu měny aktuální jazykové verze a jeho umístění v řetězci měny. Poté dynamicky sestaví vzorek regulárního výrazu a vzorek pro nahrazení. Pokud je příklad spuštěn na počítači, jehož aktuální jazyková verze je en-US, generuje vzorek regulárního výrazu \b(\d+)(\.(\d+))? a vzorek pro nahrazení $$ $1$2. Vzorek pro nahrazování nahradí odpovídající text symbolem měny a mezerou, následovanou první a druhou zachycenou skupinou.

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

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

Vzorce regulárního výrazu \b(\d+)(\.(\d+))? je definován podle následující tabulky.

Maska

Popis

\b

Zahájí porovnávání na začátku hranice slova.

(\d+)

Porovná jednu nebo více desítkových číslic. Toto je první zachytávající skupina.

\.

Porovná tečku (oddělovač desetinných míst).

(\d+)

Porovná jednu nebo více desítkových číslic. Toto je třetí zachycující skupina.

(\.(\d+))?

Porovnává nula nebo jeden výskyt tečky, následovaný jednou nebo více desítkovými číslicemi. Toto je druhá zachytávající skupina.

Nahrazení celé shody

Nahrazení $& obsahuje celou shodu v řetězci pro nahrazování. Často se používá k přidání podřetězce na začátek nebo konec porovnávaného řetězce. Například vzorek pro nahrazování ($&) přidá závorky na začátek a konec každé shoda. Pokud není nalezena žádná shoda, nahrazení $& nemá žádný vliv.

Následující příklad používá substituci $& pro přidání uvozovek na začátek a konec názvů knih uložených v poli řetězců.

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"

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"

Vzorce regulárního výrazu ^(\w+\s?)+$ je definován podle následující tabulky.

Maska

Popis

^

Zahájí porovnávání na začátku vstupního řetězce.

(\w+\s?)+

Porovná vzorek jednoho nebo více znaků slova následovaného nula nebo jedním prázdným znakem jednou nebo vícekrát.

$

Porovná konec vstupního řetězce.

Vzorek pro nahrazení "$&" přidá literální znak uvozovek na začátek a konec každé shody.

Zpět na začátek

Nahrazení textu před porovnáváním

Nahrazení $` nahradí porovnávaný vstupní řetězec celým vstupním řetězcem před porovnáváním. To znamená, že duplikuje vstupní řetězec až po shodu a odebírá odpovídající text. Jakýkoli text, který následuje odpovídající text je nezměněn ve výsledném řetězci. Pokud existuje více shod ve vstupním řetězci, text pro nahrazování je odvozen z původního vstupního řetězce, nikoli z řetězce, ve kterém byl text nahrazen předchozími shodami. (Příklad uvádí ukázku.) Pokud není nalezena žádná shoda, nahrazení $` nemá žádný vliv.

Následující příklad používá vzorek regulárního výrazu \d+ pro porovnání sekvence jedné nebo více desítkových číslic ve vstupním řetězci. Řetězec pro nahrazování $` nahradí tyto číslice textem, který předchází shodě.

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

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

V tomto příkladu vstupní řetězec "aa1bb2cc3dd4ee5" obsahuje pět shod. Následující tabulka popisuje, jak nahrazení $` způsobí, že modul regulárních výrazů nahradí každou shodu ve vstupním řetězci. Vložený text je uveden v tučném písmě ve sloupci výsledků.

neodpovídají

Pozice

Řetězec před shodou

Výsledný řetězec

1

2

aa

aaaabb2cc3dd4ee5

2

5

aa1bb

aaaabbaa1bbcc3dd4ee5

3

8

aa1bb2cc

aaaabbaa1bbccaa1bb2ccdd4ee5

4

11

aa1bb2cc3dd

aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5

5

14

aa1bb2cc3dd4ee

aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee aa1bb2cc3dd4ee

Zpět na začátek

Nahrazení textu po porovnávání

Nahrazení $' nahradí porovnávaný vstupní řetězec celým vstupním řetězcem po porovnávání. To znamená, že duplikuje vstupní řetězec po shodě a odebírá odpovídající text. Jakýkoli text, který předchází odpovídající text je nezměněn ve výsledném řetězci. Pokud není nalezena žádná shoda, nahrazení $' nemá žádný vliv.

Násldující příklad používá vzorek regulárního výrazu \d+ pro porovnání sekvence jedné nebo více desítkových číslic ve vstupním řetězci. Řetězec pro nahrazování $' nahradí tyto číslice textem, který následuje po shodě.

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

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

V tomto příkladu vstupní řetězec "aa1bb2cc3dd4ee5" obsahuje pět shod. Následující tabulka popisuje, jak nahrazení $' způsobí, že modul regulárních výrazů nahradí každou shodu ve vstupním řetězci. Vložený text je uveden v tučném písmě ve sloupci výsledků.

neodpovídají

Pozice

Řetězec po shoda

Výsledný řetězec

1

2

bb2cc3dd4ee5

aabb2cc3dd4ee5bb2cc3dd4ee5

2

5

cc3dd4ee5

aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5

3

8

dd4ee5

aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5

4

11

ee5

aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5

5

14

String.Empty

aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Zpět na začátek

Nahrazení poslední zachycené skupiny

Nahrazení $+ nahradí odpovídající řetězec poslední zachycenou skupinou. Pokud nebyly nalezeny žádné zachycené skupiny nebo je hodnota poslední zachycené skupiny String.Empty nahrazení $+ nemá žádný vliv.

Následující příklad určuje duplicitní slova v řetězci a používá nahrazení $+ pro jejich nahrazení jedním výskytem slova. Možnost RegexOptions.IgnoreCase se používá k zajištění, že slova, která se liší ve velikosti písmen, ale které jsou jinak identická, jsou považována za duplicitní.

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.

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.

Vzorce regulárního výrazu \b(\w+)\s\1\b je definován podle následující tabulky.

Maska

Popis

\b

Začne porovnání na hranici slova.

(\w+)

Porovná jeden nebo více slovních znaků. Toto je první zachytávající skupina.

\s

Porovná prázdný znak.

\1

Porovná první zachycenou skupinu.

\b

Ukončí porovnání na hranici slova.

Zpět na začátek

Nahrazení celého vstupního řetězce

Nahrazení $_ nahradí porovnávaný řetězec celým vstupním řetězcem. To znamená, že odebere odpovídající text a nahradí jej celým řetězcem, včetně odpovídajícího textu.

Následující příklad porovnává jedno nebo více desítkových čísel ve vstupním řetězci. Používá substituci $_ pro nahrazení celým vstupním řetězcem.

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

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

V tomto příkladu vstupní řetězec "ABC123DEF456" obsahuje dvě shody. Následující tabulka popisuje, jak nahrazení $_ způsobí, že modul regulárních výrazů nahradí každou shodu ve vstupním řetězci. Vložený text je uveden v tučném písmě ve sloupci výsledků.

neodpovídají

Pozice

neodpovídají

Výsledný řetězec

1

3

123

ABCABC123DEF456DEF456

2

5

456

ABCABC123DEF456DEFABC123DEF456

Zpět na začátek

Viz také

Koncepty

Prvky jazyka regulárních výrazů