Share via


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