Nahrazení v regulárních výrazech
Nahrazení jsou prvky jazyka, které jsou rozpoznány pouze v rámci vzorů nahrazení. Pro definování celého textu nebo jeho části, která má nahradit odpovídající text ve vstupním řetězci, používají vzor regulárního výrazu. Vzor pro nahrazení se může skládat z jedné nebo několika substitucí spolu s literálními znaky. Vzory nahrazení jsou poskytovány Regex.Replace přetížení metody, které mají replacement parametr a metodu Match.Result . Metody nahrazují odpovídající vzor vzorem, který je definován parametrem replacement .
.NET definuje náhradní prvky uvedené v následující tabulce.
| Substituce | Popis |
|---|---|
| $ Číslo | Zahrne poslední podřetězce odpovídající zachytávaný skupině, která je identifikována číslem, kde je číslo desetinnou hodnotou v náhradním řetězci. Další informace najdete v tématu Nahrazení číslování skupiny. |
| ${ name } | Obsahuje poslední podřetězce odpovídající pojmenované skupině, která je určena (?<názvem> ) v náhradním řetězci. Další informace naleznete v tématu Nahrazení pojmenované skupiny. |
| $$ | Zahrnuje jediný literál "$" v řetězci pro nahrazení. Další informace najdete v tématu Nahrazení symbolu "$". |
| $& | Zahrnuje kopii celé shody v řetězci pro nahrazení. Další informace najdete v tématu Nahrazení celé shody. |
| $` | Zahrnuje celý text vstupního řetězce před porovnáním v řetězci pro nahrazení. Další informace najdete v tématu Nahrazení textu před shodou. |
| $' | Zahrnuje celý text vstupního řetězce po porovnání v řetězci pro nahrazení. Další informace najdete v tématu Nahrazení textu za shodou. |
| $+ | Zahrnuje poslední skupinu zachycenou v řetězci pro nahrazení. Další informace najdete v tématu Nahrazení poslední zachycené skupiny. |
| $_ | Zahrnuje celý vstupní řetězec v řetězci pro nahrazení. Další informace naleznete v tématu Nahrazení celého vstupního řetězce. |
Prvky substituce a vzory pro nahrazení
Substituce jsou jediné speciální konstrukce, které jsou rozpoznány ve vzorech pro nahrazení. Žádný z ostatních prvků jazyka regulárních výrazů, včetně řídicích znaků a tečky (.), která odpovídá jakémukoli znaku, nejsou podporovány. Obdobně jsou prvky jazyka pro substituci rozpoznány jen ve vzorech pro nahrazení a nejsou nikdy platné ve vzorech regulárního výrazu.
Jediným znakem, který se může objevit ve vzoru regulárního výrazu nebo v nahrazení, je $ znak, i když má v každém kontextu jiný význam. V vzoru regulárního výrazu je kotva, $ která odpovídá konci řetězce. V modelu $ nahrazení označuje začátek nahrazení.
Poznámka:
Pro funkce podobné vzoru pro nahrazení v rámci regulárního výrazu použijte zpětný odkaz. Další informace o zpětných odvozování naleznete v tématu Backreference Konstrukts.
Nahrazování číslované skupiny
Prvek $číselného jazyka zahrnuje poslední podřetězce odpovídající skupině zachycení čísel v náhradním řetězci, kde číslo je index zachytávání skupiny zachycení. Například vzor $1 nahrazení označuje, že odpovídající podřetětěc se má nahradit první zachycenou skupinou. Další informace o číslování zachycených skupin naleznete v tématu Seskupování konstruktorů.
Všechny následující $ číslice jsou interpretovány jako patřící do číselné skupiny. Pokud to však není vaším záměrem, můžete namísto toho nahradit pojmenovanou skupinu. Můžete například použít náhradní řetězec ${1}1 místo $11 definování náhradního řetězce jako hodnotu první zachycené skupiny spolu s číslem "1". Další informace naleznete v tématu Nahrazení pojmenované skupiny.
Zachytávání skupin, které nejsou explicitně přiřazené názvy pomocí (?<syntaxe názvu>) , jsou číslování zleva doprava počínaje jedním z nich. Pojmenované skupiny jsou rovněž číslovány zleva doprava. Číslování začíná číslem o jedno vyšším než index poslední nepojmenované skupiny. Například v regulárním výrazu (\w)(?<digit>\d)je index digit pojmenované skupiny 2.
Pokud číslo neurčuje platnou skupinu zachycení definovanou v vzoru regulárního výrazu, $číslo se interpretuje jako literálová sekvence znaků, která se používá k nahrazení každé shody.
Následující příklad používá $nahrazení čísla k odstranění symbolu měny z desetinné hodnoty. Odebere symboly měny nalezené na začátku nebo konci peněžní hodnoty a rozpozná dva nejběžnější oddělovače desetinných míst "." a ",".
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
Vzor regulárního výrazu \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* je definován, jak je znázorněno v následující tabulce.
| Vzor | Popis |
|---|---|
\p{Sc}* |
Porovná žádný nebo více znaků symbolu měny. |
\s? |
Porovná žádný nebo jeden prázdný znak. |
\d+ |
Porovná jednu nebo více desítkových číslic. |
[.,]? |
Porovná žádnou nebo jednu tečku či čárku. |
\d* |
Porovná žádnou nebo několik desítkových číslic. |
(\s?\d+[.,]?\d*) |
Porovná prázdný znak, následovaný jednou nebo několika desítkovými číslicemi, následovanými žádnou nebo jednou tečkou nebo čárkou, následovanou žádnou nebo několika desítkovými číslicemi. Toto je první zachytávající skupina. Vzhledem k tomu, že vzor nahrazení je $1, volání Regex.Replace metody nahradí celý odpovídající podřetězce touto zachycenou skupinou. |
Nahrazování pojmenované skupiny
Element ${jazyka name} nahrazuje poslední podřetěc odpovídající skupině zachycení názvu, kde název je název zachytávání skupiny definované(?< elementem jazyka name>). Další informace o pojmenovaných zachytávání skupin naleznete v tématu Seskupování konstruktorů.
Pokud název neurčuje platnou pojmenovanou skupinu zachycení definovanou v vzoru regulárního výrazu, ale skládá se z číslic, ${název} se interpretuje jako číslová skupina.
Pokud název určuje platnou pojmenovanou skupinu zachycení ani platnou číslované zachytávané skupiny definované v vzoru regulárního výrazu, ${název} se interpretuje jako sekvence literálů, která se používá k nahrazení každé shody.
Následující příklad používá ${nahrazení názvu} k odstranění symbolu měny z desítkové hodnoty. Odebere symboly měny nalezené na začátku nebo konci peněžní hodnoty a rozpozná dva nejběžnější oddělovače desetinných míst "." a ",".
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
Vzor regulárního výrazu \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* je definován, jak je znázorněno v následující tabulce.
| Vzor | Popis |
|---|---|
\p{Sc}* |
Porovná žádný nebo více znaků symbolu měny. |
\s? |
Porovná žádný nebo jeden prázdný znak. |
\d+ |
Porovná jednu nebo více desítkových číslic. |
[.,]? |
Porovná žádnou nebo jednu tečku či čárku. |
\d* |
Porovná žádnou nebo několik desítkových číslic. |
(?<amount>\s?\d[.,]?\d*) |
Porovná prázdný znak, následovaný jednou nebo několika desítkovými číslicemi, následovanými žádnou nebo jednou tečkou nebo čárkou, následovanou žádnou nebo několika desítkovými číslicemi. Toto je zachytácí skupina s názvem amount. Vzhledem k tomu, že vzor nahrazení je ${amount}, volání Regex.Replace metody nahradí celý odpovídající podřetězce touto zachycenou skupinou. |
Nahrazování znaku "$"
Nahrazení $$ vloží do nahrazeného řetězce literál "$".
Následující příklad používá NumberFormatInfo objekt k určení symbolu měny aktuální jazykové verze a jeho umístění v řetězci měny. Poté dynamicky sestaví vzor regulárního výrazu a vzor pro nahrazení. Pokud je příklad spuštěn na počítači, jehož aktuální jazyková verze je en-US, generuje vzor \b(\d+)(\.(\d+))? regulárního výrazu a náhradní vzor $$ $1$2. Vzor pro nahrazení nahradí odpovídající text symbolem měny a mezerou následovanou první a druhou zachycenou skupinou.
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
Vzor regulárního výrazu \b(\d+)(\.(\d+))? je definován, jak je znázorněno v následující tabulce.
| Vzor | Popis |
|---|---|
\b |
Zahájí porovná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í zachytávající skupina. |
(\.(\d+))? |
Porovná žádný nebo jeden výskyt tečky následované jednou nebo několika desítkovými číslicemi. Toto je druhá zachytávající skupina. |
Nahrazování celé shody
Náhrada $& zahrnuje celou shodu v náhradním řetězci. Často se používá k přidání podřetězce na začátek nebo konec porovnávaného řetězce. Vzor nahrazení například ($&) přidá závorky na začátek a konec každé shody. Pokud neexistuje shoda, $& nahrazení nemá žádný vliv.
Následující příklad používá náhradu $& k přidání uvozovek na začátek a konec knih titulů uložených v řetězcovém poli.
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"
Vzor regulárního výrazu ^(\w+\s?)+$ je definován, jak je znázorněno v následující tabulce.
| Vzor | Popis |
|---|---|
^ |
Zahájí porovnávání na začátku vstupního řetězce. |
(\w+\s?)+ |
Jednou nebo vícekrát porovná vzor jednoho nebo několika znaků slova následovaného žádným nebo jedním prázdným znakem. |
$ |
Porovná konec vstupního řetězce. |
Náhradní "$&" vzor přidá na začátek a konec každé shody literálovou uvozovku.
Nahrazování textu před porovnáváním
Nahrazení $` nahradí odpovídající řetězec celým vstupním řetězcem před shodou. To znamená, že duplikuje vstupní řetězec až po shodu a odebírá odpovídající text. Jakýkoli text, který následuje za odpovídajícím textem, zůstane ve výsledném řetězci nezměněn. Pokud existuje více shod ve vstupním řetězci, je text pro nahrazení 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 obsahuje ilustraci.) Pokud neexistuje shoda, $` nahrazení nemá žádný vliv.
Následující příklad používá vzor \d+ regulárního výrazu ke sekvenci jedné nebo více desetinných číslic ve vstupním řetězci. Náhradní řetězec $` nahradí tyto číslice textem, který předchází shodě.
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
V tomto příkladu obsahuje vstupní řetězec "aa1bb2cc3dd4ee5" pět shod. Následující tabulka ukazuje, jak $` nahrazení způsobí, že modul regulárních výrazů nahradí každou shodu ve vstupním řetězci. Vložený text je zobrazen tučně ve sloupci výsledků.
| Párování | Position | Řetězec před shodou | Výsledný řetězec |
|---|---|---|---|
| 1 | 2 | aa | aabb2cc3dd4ee5 |
| 2 | 5 | aa1bb | aaaabbaa1bbcc3dd4ee5 |
| 3 | 8 | aa1bb2cc | aaaabbaa1bbccaa1bb2ccdd4ee5 |
| 4 | 11 | aa1bb2cc3dd | aaaabbaa1bbccaa1bb2ccdddaa1bb2cc3dddee5 |
| 5 | 14 | aa1bb2cc3dd4ee | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee aa1bb2cc3ddd4e |
Nahrazování textu po shodě
Nahrazení $' nahradí odpovídající řetězec celým vstupním řetězcem za shodu. 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ímu textu, zůstává ve výsledném řetězci nezměněn. Pokud neexistuje shoda, $' nahrazení nemá žádný vliv.
Následující příklad používá vzor \d+ regulárního výrazu ke sekvenci jedné nebo více desetinných číslic ve vstupním řetězci. Náhradní řetězec $' nahradí tyto číslice textem, který následuje za shodou.
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
V tomto příkladu obsahuje vstupní řetězec "aa1bb2cc3dd4ee5" pět shod. Následující tabulka ukazuje, jak $' nahrazení způsobí, že modul regulárních výrazů nahradí každou shodu ve vstupním řetězci. Vložený text je zobrazen tučně ve sloupci výsledků.
| Párování | Position | Řetězec po shodě | Výsledný řetězec |
|---|---|---|---|
| 1 | 2 | bb2cc3dd4ee5 | aabb2cc3dd4ee5bb2cc3dd4ee5 |
| 2 | 5 | cc3dd4ee5 | aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5 |
| 3 | 8 | dd4ee5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5 dd4ee5dd4ee5 |
| 4 | 11 | ee5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd ee5ee5 |
| 5 | 14 | String.Empty | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee |
Nahrazování poslední zachycené skupiny
Nahrazení $+ nahradí odpovídající řetězec poslední zachycenou skupinou. Pokud neexistují žádné zachycené skupiny nebo pokud je String.Emptyhodnota poslední zachycené skupiny, $+ nahrazení nemá žádný vliv.
Následující příklad identifikuje duplicitní slova v řetězci a pomocí $+ nahrazení je nahradí jediným výskytem slova. Tato RegexOptions.IgnoreCase možnost slouží k zajištění toho, aby se slova, která se liší v případě, že jsou ale jinak identická, považují se za duplicitní.
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.
Vzor regulárního výrazu \b(\w+)\s\1\b je definován, jak je znázorněno v následující tabulce.
| Vzor | Popis |
|---|---|
\b |
Začne porovnání na hranici slova. |
(\w+) |
Porovná jeden nebo více znaků slova. Toto je první zachytávající skupina. |
\s |
Porovná prázdný znak. |
\1 |
Porovná první zachycenou skupinu. |
\b |
Ukončí porovnání na hranici slova. |
Nahrazování celého vstupního řetězce
Nahrazení $_ nahradí odpovídající ř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á jednu nebo několik desítkových číslic ve vstupním řetězci. Nahrazuje $_ je celým vstupním řetězcem.
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
V tomto příkladu obsahuje vstupní řetězec "ABC123DEF456" dvě shody. Následující tabulka ukazuje, jak $_ nahrazení způsobí, že modul regulárních výrazů nahradí každou shodu ve vstupním řetězci. Vložený text je zobrazen tučně ve sloupci výsledků.
| Párování | Position | Párování | Výsledný řetězec |
|---|---|---|---|
| 1 | 3 | 123 | ABCABC123DEF456DEF456 |
| 2 | 5 | 456 | ABCABC123DEF456DEF ABC123DEF456 |
Viz také
Váš názor
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu: https://aka.ms/ContentUserFeedback.
Odeslat a zobrazit názory pro