Helyettesítések reguláris kifejezésekben
A helyettesítések olyan nyelvi elemek, amelyek csak a helyettesítő mintákban vannak felismerve. Normál kifejezésmintát használnak a szöveg egészének vagy egy részének meghatározásához, amely a bemeneti sztringben lévő egyező szöveg helyére kerül. A csereminta egy vagy több helyettesítésből és literális karakterekből állhat. A helyettesítő minták a paraméterrel és a Regex.Replace metódussal rendelkező replacement metódus túlterhelésére szolgálnak Match.Result . A metódusok a megfeleltetett mintát a paraméter által replacement meghatározott mintára cserélik.
A .NET az alábbi táblázatban felsorolt helyettesítési elemeket határozza meg.
| Helyettesítő | Leírás |
|---|---|
| $ Szám | Tartalmazza a számmal azonosított rögzítési csoport által egyeztetett utolsó részsztringet, ahol a szám decimális érték, a helyettesítő sztringben. További információ: Számozott csoport helyettesítése. |
| ${ name } | Tartalmazza a helyettesítő sztringben név> ) szerint (?<kijelölt elnevezett csoport által egyeztetett utolsó részsztringet. További információ: Elnevezett csoport helyettesítése. |
| $$ | Egyetlen "$" literált tartalmaz a helyettesítő sztringben. További információ: "$" szimbólum helyettesítése. |
| $& | Tartalmazza a teljes egyezés másolatát a helyettesítő sztringben. További információ: A teljes egyezés helyettesítése. |
| $` | Tartalmazza a bemeneti sztring összes szövegét a helyettesítő sztringben szereplő egyezés előtt. További információ: A szöveg helyettesítése az egyezés előtt. |
| $' | A helyettesítő sztringben szereplő egyezés után a bemeneti sztring összes szövegét tartalmazza. További információ: A szöveg helyettesítése az egyezés után. |
| $+ | Tartalmazza a helyettesítő sztringben rögzített utolsó csoportot. További információ: Az utolsó rögzített csoport helyettesítése. |
| $_ | Tartalmazza a teljes bemeneti sztringet a helyettesítő sztringben. További információ: A teljes bemeneti sztring helyettesítése. |
Helyettesítési elemek és csereminták
A helyettesítések az egyetlen speciális szerkezetek, amelyek felismerhetők a cseremintában. A többi reguláris kifejezés nyelvi eleme, beleértve a karaktermeneküléseket és a bármely karakternek megfelelő pont (.) nem támogatott. Hasonlóképpen, a helyettesítő nyelvi elemek csak a helyettesítő mintákban vannak felismerve, és a reguláris kifejezésmintákban soha nem érvényesek.
Az egyetlen karakter, amely megjelenhet egy reguláris kifejezési mintában vagy egy helyettesítésben, az a $ karakter, bár minden környezetben más jelentéssel rendelkezik. A reguláris kifejezési mintában egy horgony, $ amely megfelel a sztring végének. A helyettesítési mintában $ a helyettesítés kezdetét jelzi.
Feljegyzés
A normál kifejezésen belüli helyettesítő mintához hasonló funkciókhoz használjon háttérrendszert. További információ a háttérrendszerekről: Backreference Constructs.
Számozott csoport helyettesítése
A $számnyelvi elem tartalmazza a helyettesítő sztring számrögzítési csoportjával egyeztetett utolsó részsztringet, ahol a szám a rögzítési csoport indexe. A csereminta $1 például azt jelzi, hogy a megfeleltethető részszúrást az első rögzített csoportnak kell lecserélnie. A számozott rögzítési csoportokról további információt a Csoportosítási szerkezetek című témakörben talál.
Az alábbi $ számjegyek a számcsoporthoz tartozóként lesznek értelmezve. Ha nem ez a szándéka, helyettesíthet helyette egy elnevezett csoportot. Használhatja például a helyettesítő sztringet ${1}1$11 ahelyett, hogy a helyettesítő sztringet az első rögzített csoport értékeként definiálja az "1" számmal együtt. További információ: Elnevezett csoport helyettesítése.
A névszintaxissal (?<>) explicit módon nem hozzárendelt csoportok rögzítése balról jobbra egytől egyig történik. A névvel ellátott csoportok is számozottak balról jobbra, kezdve az utolsó névtelen csoport indexénél nagyobb számmal. A reguláris kifejezésben (\w)(?<digit>\d)például a digit névvel ellátott csoport indexe 2.
Ha a szám nem ad meg érvényes rögzítési csoportot, amely a reguláris kifejezés mintájában van definiálva, $akkor a szám egy literális karaktersorozatként van értelmezve, amely az egyes egyezések helyére kerül.
Az alábbi példa a számhelyettesítést használja a $pénznemszimbólum tizedesjegyből való kivonásához. Eltávolítja a pénzügyi érték elején vagy végén található pénznemszimbólumokat, és felismeri a két leggyakoribb tizedeselválasztót ("." és ".").
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
A reguláris kifejezésminta \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
\p{Sc}* |
Nulla vagy több pénznemszimbólum karakterének egyeztetése. |
\s? |
Nulla vagy egy szóköz karakter egyezése. |
\d+ |
Egy vagy több tizedesjegy egyeztetése. |
[.,]? |
Nulla vagy egy pont vagy vessző egyeztetése. |
\d* |
Nulla vagy több tizedesjegy egyeztetése. |
(\s?\d+[.,]?\d*) |
Egy fehér szóköz, majd egy vagy több tizedesjegy, majd nulla vagy egy pont vagy vessző, majd nulla vagy több tizedesjegy. Ez az első rögzítési csoport. Mivel a csereminta az $1, a Regex.Replace metódus hívása a teljes egyeztetett részszűrést lecseréli erre a rögzített csoportra. |
Elnevezett csoport helyettesítése
A ${névnyelvi} elem a névrögzítési csoporttal egyeztetett utolsó részszúrást helyettesíti, ahol a név a név>) nyelvi elem által definiált rögzítési (?<csoport neve. A névvel ellátott rögzítési csoportokról további információt a Csoportosítási szerkezetek című témakörben talál.
Ha a név nem ad meg érvényes, a reguláris kifejezés mintájában definiált, de számjegyekből álló rögzítési csoportot, ${a rendszer számozott csoportként értelmezi a nevet} .
Ha a név sem érvényes elnevezett rögzítési csoportot, sem érvényes számozott rögzítési csoportot nem határoz meg a reguláris kifejezés mintájában, ${a rendszer az egyes egyezések helyére használt literális karaktersorozatként értelmezi a nevet} .
Az alábbi példa a névhelyettesítést} használja a ${pénznemszimbólum tizedesjegyből való kivonásához. Eltávolítja a pénzügyi érték elején vagy végén található pénznemszimbólumokat, és felismeri a két leggyakoribb tizedeselválasztót ("." és ".").
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
A reguláris kifejezésminta \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
\p{Sc}* |
Nulla vagy több pénznemszimbólum karakterének egyeztetése. |
\s? |
Nulla vagy egy szóköz karakter egyezése. |
\d+ |
Egy vagy több tizedesjegy egyeztetése. |
[.,]? |
Nulla vagy egy pont vagy vessző egyeztetése. |
\d* |
Nulla vagy több tizedesjegy egyeztetése. |
(?<amount>\s?\d[.,]?\d*) |
Egyezik egy szóközzel, amelyet egy vagy több tizedesjegy követ, amelyet nulla vagy egy pont vagy vessző követ, majd nulla vagy több tizedesjegy. Ez a rögzítési csoport neve amount. Mivel a csereminta az ${amount}, a Regex.Replace metódus hívása a teljes egyeztetett részszűrést lecseréli erre a rögzített csoportra. |
"$" karakter helyettesítése
A $$ helyettesítés egy literális "$" karaktert szúr be a lecserélt sztringbe.
Az alábbi példa az objektumot használja az NumberFormatInfo aktuális kultúra pénznemszimbólumának és pénznemsztringben való elhelyezésének meghatározására. Ezután dinamikusan készít egy reguláris kifejezésmintát és egy helyettesítő mintát is. Ha a példa egy olyan számítógépen fut, amelynek jelenlegi kultúrája en-US, akkor a normál kifejezésmintát \b(\d+)(\.(\d+))? és a cseremintát $$ $1$2hozza létre. A csereminta egy pénznemszimbólumra és egy szóközre cseréli a egyeztetett szöveget, amelyet az első és a második rögzített csoport követ.
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
A reguláris kifejezésminta \b(\d+)(\.(\d+))? az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
\b |
Indítsa el az egyezést egy szóhatár elején. |
(\d+) |
Egy vagy több tizedesjegy egyeztetése. Ez az első rögzítési csoport. |
\. |
Egy pont (a tizedeselválasztó) egyeztetése. |
(\d+) |
Egy vagy több tizedesjegy egyeztetése. Ez a harmadik rögzítési csoport. |
(\.(\d+))? |
Egy pont nulla vagy egy előfordulása, amelyet egy vagy több tizedesjegy követ. Ez a második rögzítési csoport. |
A teljes egyezés helyettesítése
A $& helyettesítés tartalmazza a teljes egyezést a helyettesítő sztringben. Gyakran használják egy részsztring hozzáadására a megfeleltethető sztring elejéhez vagy végéhez. A csereminta például ($&) zárójeleket ad hozzá az egyes egyezések elejéhez és végéhez. Ha nincs egyezés, a $& helyettesítésnek nincs hatása.
Az alábbi példa idézőjelek hozzáadására használja a $& sztringtömbben tárolt könyvcímek elején és végén található idézőjeleket.
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"
A reguláris kifejezésminta ^(\w+\s?)+$ az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
^ |
Indítsa el az egyezést a bemeneti sztring elején. |
(\w+\s?)+ |
Egy vagy több szókarakter mintájának egyezése, amelyet egy vagy több alkalommal nulla vagy egy szóköz karakter követ. |
$ |
Egyezzen a bemeneti sztring végére. |
A "$&" csereminta egy literális idézőjelet ad hozzá az egyes egyezések elejéhez és végéhez.
A szöveg helyettesítése az egyezés előtt
A $` helyettesítés a megfeleltetett sztringet a teljes bemeneti sztringre cseréli az egyezés előtt. Vagyis duplikálja a bemeneti sztringet az egyezésig, miközben eltávolítja a megfelelő szöveget. A találati sztringben az egyező szöveget követő szöveg nem változik. Ha egy bemeneti sztringben több egyezés van, a helyettesítő szöveg az eredeti bemeneti sztringből származik, nem pedig abból a sztringből, amelyben a szöveget korábbi egyezések helyettesítették. (A példa egy illusztrációt tartalmaz.) Ha nincs egyezés, a $` helyettesítésnek nincs hatása.
Az alábbi példa a reguláris kifejezésmintát \d+ használja a bemeneti sztring egy vagy több tizedesjegyének sorozatához. A helyettesítő sztring $` lecseréli ezeket a számjegyeket az egyezést megelőző szövegre.
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
Ebben a példában a bemeneti sztring "aa1bb2cc3dd4ee5" öt egyezést tartalmaz. Az alábbi táblázat bemutatja, hogy a $` helyettesítés hatására a normál kifejezésmotor hogyan cseréli le az egyes egyezéseket a bemeneti sztringben. A beszúrt szöveg félkövér színben jelenik meg az eredményoszlopban.
| Match | Position | Sztring egyezés előtt | Eredménysztring |
|---|---|---|---|
| 0 | 2 | Aa | aaaabb2cc3dd4ee5 |
| 2 | 5 | aa1bb | aaaabbaa1bbcc3dd4ee5 |
| 3 | 8 | aa1bb2cc | aaaabbaa1bbccaa1bb2ccdd4ee5 |
| 4 | 11 | aa1bb2cc3dd | aaaabbaa1bbccaa1bb2ccdd aa1bb2cc3ddee5 |
| 5 | 14 | aa1bb2cc3dd4ee | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee |
A szöveg helyettesítése az egyezés után
A $' helyettesítés a megfeleltetett sztringet a teljes bemeneti sztringre cseréli az egyezés után. Vagyis duplikálja a bemeneti sztringet az egyezés után, miközben eltávolítja a megfeleltethető szöveget. A találati sztringben minden olyan szöveg változatlan marad, amely megelőzi a találati sztringet. Ha nincs egyezés, a $' helyettesítésnek nincs hatása.
Az alábbi példa a reguláris kifejezésmintát \d+ használja a bemeneti sztring egy vagy több tizedesjegyének sorozatához. A helyettesítő sztring $' ezeket a számjegyeket az egyezést követő szövegre cseréli.
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
Ebben a példában a bemeneti sztring "aa1bb2cc3dd4ee5" öt egyezést tartalmaz. Az alábbi táblázat bemutatja, hogy a $' helyettesítés hatására a normál kifejezésmotor hogyan cseréli le az egyes egyezéseket a bemeneti sztringben. A beszúrt szöveg félkövér színben jelenik meg az eredményoszlopban.
| Match | Position | Sztring egyezés után | Eredménysztring |
|---|---|---|---|
| 0 | 2 | bb2cc3dd4ee5 | aabb2cc3dd4ee5bb2cc3dd4ee5 |
| 2 | 5 | cc3dd4ee5 | aabb2cc3dd4ee5bbcc3dd4ee5cc3ddd4ee5 |
| 3 | 8 | dd4ee5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5 |
| 4 | 11 | ee5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5 |
| 5 | 14 | String.Empty | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee |
Az utolsó rögzített csoport helyettesítése
A $+ helyettesítés a egyeztetett sztringet az utolsó rögzített csoportra cseréli. Ha nincsenek rögzített csoportok, vagy ha az utolsó rögzített csoport értéke az String.Empty, a $+ helyettesítésnek nincs hatása.
Az alábbi példa azonosítja az ismétlődő szavakat egy sztringben, és a $+ helyettesítéssel lecseréli őket a szó egyetlen előfordulására. Ezzel RegexOptions.IgnoreCase a beállítással biztosítható, hogy a kis- és nagybetűkben eltérő, de egyébként azonos szavak duplikáltnak minősüljenek.
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.
A reguláris kifejezésminta \b(\w+)\s\1\b az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
\b |
Kezdje el az egyezést egy szóhatáron. |
(\w+) |
Egy vagy több szó karakterének egyeztetése. Ez az első rögzítési csoport. |
\s |
Egyezik egy szóköz karakterrel. |
\1 |
Egyezik az első rögzített csoport. |
\b |
Egy szóhatáron fejezd be az egyezést. |
A teljes bemeneti sztring helyettesítése
A $_ helyettesítés a megfeleltetett sztringet a teljes bemeneti sztringre cseréli. Ez azt jelzi, hogy eltávolítja a megfeleltethető szöveget, és lecseréli a teljes sztringre, beleértve a megfeleltetett szöveget is.
Az alábbi példa egy vagy több tizedesjegyet egyezik a bemeneti sztringben. A helyettesítést a $_ teljes bemeneti sztringre cseréli.
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
Ebben a példában a bemeneti sztring "ABC123DEF456" két egyezést tartalmaz. Az alábbi táblázat bemutatja, hogy a $_ helyettesítés hatására a normál kifejezésmotor hogyan cseréli le az egyes egyezéseket a bemeneti sztringben. A beszúrt szöveg félkövér színben jelenik meg az eredményoszlopban.
| Match | Position | Match | Eredménysztring |
|---|---|---|---|
| 0 | 3 | 123 | ABCABC123DEF456DEF456 |
| 2 | 5 | 456 | ABCABC123DEF456DEF ABC123DEF456 |
Lásd még
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: