Ersetzungen in regulären Ausdrücken

Ersetzungen sind Sprachelemente, die nur innerhalb von Ersetzungsmustern erkannt werden. Sie verwenden ein Muster für reguläre Ausdrücke, um den gesamten oder einen Teil des Texts zu definieren, der übereinstimmenden Text in der Eingabezeichenfolge ersetzen soll. Das Ersetzungsmuster kann zusammen mit Literalzeichen aus einer oder mehreren Ersetzungen bestehen. Ersetzungsmuster werden für Überladungen der Regex.Replace Methode mit einem replacement Parameter und der Match.Result Methode bereitgestellt. Die Methoden ersetzen das übereinstimmende Muster durch das Muster, das durch den replacement Parameter definiert wird.

.NET definiert die in der folgenden Tabelle aufgeführten Ersetzungselemente.

Ersatz	BESCHREIBUNG
$ -Nummer	Schließt die letzte mit der Erfassungsgruppe, die durch Zahlidentifiziert wird, übereinstimmende Teilzeichenfolge in der Ersetzungszeichenfolge ein. Hierbei ist Zahl ein Dezimalwert. Weitere Informationen finden Sie unter Substituieren einer nummerierten Gruppe.
${ name }	Schließt die letzte Teilzeichenfolge in der Ersetzungszeichenfolge ein, die von der benannten Gruppe gefunden wird, die mit (?<Name> ) angegeben wird. Weitere Informationen finden Sie unter Substituieren einer benannten Gruppe.
$$	Schließt ein einzelnes "$"-Literal in der Ersetzungszeichenfolge ein. Weitere Informationen finden Sie unter Substituieren eines "$"-Symbols.
$&	Schließt eine Kopie der gesamten Übereinstimmung in der Ersetzungszeichenfolge ein. Weitere Informationen finden Sie unter Ersetzen der gesamten Übereinstimmung.
$`	Schließt den gesamten Text der Eingabezeichenfolge vor der Übereinstimmung in der Ersetzungszeichenfolge ein. Weitere Informationen finden Sie unter Ersetzen des Texts vor der Übereinstimmung.
$'	Schließt den gesamten Text der Eingabezeichenfolge nach der Übereinstimmung in der Ersetzungszeichenfolge ein. Weitere Informationen finden Sie unter Ersetzen des Texts nach einem Treffer.
$+	Schließt die letzte erfasste Gruppe in der Ersetzungszeichenfolge ein. Weitere Informationen finden Sie unter Ersetzen der letzten erfassten Gruppe.
$_	Schließt die gesamte Eingabezeichenfolge in der Ersetzungszeichenfolge ein. Weitere Informationen finden Sie unter Substituieren der gesamten Eingabezeichenfolge.

Ersetzungselemente und Ersetzungsmuster

Ersetzungen sind die einzigen speziellen Konstrukte, die in einem Ersatzmuster erkannt werden. Keines der anderen Sprachelemente für reguläre Ausdrücke, einschließlich Escapezeichen und Punkt (.), der einem beliebigen Zeichen entspricht, wird unterstützt. Ebenso werden Ersetzungssprachenelemente nur in Ersetzungsmustern erkannt und sind in regulären Ausdrucksmustern nie gültig.

Das einzige Zeichen, das entweder in einem Muster eines regulären Ausdrucks oder in einer Ersetzung angezeigt werden kann, ist das $ Zeichen, obwohl es in jedem Kontext eine andere Bedeutung hat. In einem Muster für reguläre Ausdrücke ist $ ein Anker, der dem Ende der Zeichenfolge entspricht. In einem Ersetzungsmuster zeigt $ den Beginn einer Ersetzung an.

Hinweis

Verwenden Sie für Funktionen, die einem Ersetzungsmuster innerhalb eines regulären Ausdrucks ähneln, eine Rückreferenz. Weitere Informationen zu Backreferences finden Sie unter Backreference-Konstrukte.

Ersetzen einer nummerierten Gruppe

Das $Zahl -Sprachelement schließt die letzte Teilzeichenfolge ein, die mit der Zahl -Erfassungsgruppe in der Ersetzungszeichenfolge übereinstimmt, wobei Zahl der Index der Erfassungsgruppe ist. Das Ersetzungsmuster $1 gibt beispielsweise an, dass die übereinstimmende Teilzeichenfolge durch die erste erfasste Gruppe ersetzt werden soll. Weitere Informationen zu nummerierten Erfassungsgruppen finden Sie unter Grouping Constructs.

Alle folgenden $ Ziffern werden als Zugehörigkeit zur Zahlengruppe interpretiert. Wenn dies nicht Ihre Absicht ist, können Sie stattdessen eine benannte Gruppe ersetzen. Sie können beispielsweise die Ersetzungszeichenfolge ${1}1 anstelle der Ersetzungszeichenfolge $11 als Wert der ersten erfassten Gruppe zusammen mit der Zahl "1" definieren. Weitere Informationen finden Sie unter Substituieren einer benannten Gruppe.

Das Erfassen von Gruppen, denen nicht explizit Namen mithilfe der (?<name>)-Syntax zugewiesen wird, wird von links nach rechts nummeriert, beginnend bei eins. Benannte Gruppen werden auch von links nach rechts nummeriert, beginnend mit einer Zahl, die um eins größer ist als der Index der letzten unbenannten Gruppe. Im regulären Ausdruck (\w)(?<digit>\d)ist beispielsweise der Index der digit benannten Gruppe 2.

Wenn Zahl keine gültige Erfassungsgruppe angibt, die in den regulären Ausdrucksmustern definiert sind, wird $Zahl als Literalzeichensequenz interpretiert, die zum Ersetzen der einzelnen Übereinstimmungen verwendet wird.

Im folgenden Beispiel wird die $Zahlenersetzung verwendet, um das Währungssymbol von einem Dezimalwert zu entfernen. Es entfernt Währungssymbole, die am Anfang oder Am Ende eines Geldwerts gefunden werden, und erkennt die beiden am häufigsten verwendeten Dezimaltrennzeichen ("." und ",").

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

Das Muster \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

Muster	BESCHREIBUNG
\p{Sc}*	Übereinstimmung mit keinem oder mehreren Währungssymbolzeichen.
\s?	Sucht nach einer Übereinstimmung mit keinem oder einem Leerzeichen.
\d+	Eine oder mehrere Dezimalziffern abgleichen.
[.,]?	Übereinstimmung mit keinem oder einem Punkt oder Komma.
\d*	0 (null) oder mehr Dezimalstellen sollen übereinstimmen.
(\s?\d+[.,]?\d*)	Übereinstimmung mit einem Leerzeichen, gefolgt von mindestens einer Dezimalstelle, gefolgt von keinem oder einem Punkt oder Komma, gefolgt von keiner oder mehreren Dezimalstellen. Dies ist die erste Erfassungsgruppe. Da das Ersetzungsmuster lautet $1, ersetzt der Aufruf der Regex.Replace Methode die gesamte übereinstimmende Teilzeichenfolge durch diese erfasste Gruppe.

Ersetzen einer benannten Gruppe

Das Name ${-Sprachelement} ersetzt die letzte mit der Erfassungsgruppe Name übereinstimmende Teilzeichenfolge, wobei Name der Name einer Erfassungsgruppe ist, die durch das Sprachelement (?<Name>) definiert wird. Weitere Informationen zu benannten Erfassungsgruppen finden Sie unter Grouping Constructs.

Wenn der Name keine gültige benannte Erfassungsgruppe angibt, die im Muster für reguläre Ausdrücke definiert ist, aber aus Ziffern besteht, ${ wird der Name} als nummerierte Gruppe interpretiert.

Wenn der Name weder eine gültige benannte Erfassungsgruppe noch eine gültige nummerierte Erfassungsgruppe angibt, die im Muster für reguläre Ausdrücke definiert ist, wird ${der Name} als literale Zeichensequenz interpretiert, die zum Ersetzen jeder Übereinstimmung verwendet wird.

Im folgenden Beispiel wird die ${Namensersetzung} verwendet, um das Währungssymbol von einem Dezimalwert zu entfernen. Es entfernt Währungssymbole, die am Anfang oder Am Ende eines Geldwerts gefunden werden, und erkennt die beiden am häufigsten verwendeten Dezimaltrennzeichen ("." und ",").

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

Das Muster \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

Muster	BESCHREIBUNG
\p{Sc}*	Übereinstimmung mit keinem oder mehreren Währungssymbolzeichen.
\s?	Sucht nach einer Übereinstimmung mit keinem oder einem Leerzeichen.
\d+	Eine oder mehrere Dezimalziffern abgleichen.
[.,]?	Übereinstimmung mit keinem oder einem Punkt oder Komma.
\d*	0 (null) oder mehr Dezimalstellen sollen übereinstimmen.
(?<amount>\s?\d[.,]?\d*)	Übereinstimmung mit einem Leerzeichen, gefolgt von mindestens einer Dezimalstelle, gefolgt von keinem oder einem Punkt oder Komma, gefolgt von keiner oder mehreren Dezimalstellen. Dies ist die Erfassungsgruppe mit dem Namen amount. Da das Ersetzungsmuster lautet ${amount}, ersetzt der Aufruf der Regex.Replace Methode die gesamte übereinstimmende Teilzeichenfolge durch diese erfasste Gruppe.

Ersetzen eines "$"-Zeichens

Durch die $$ Ersetzung wird ein literales "$"-Zeichen in die ersetzte Zeichenkette eingefügt.

Im folgenden Beispiel wird das Objekt verwendet, um das NumberFormatInfo Währungssymbol der aktuellen Kultur und dessen Platzierung in einer Währungszeichenfolge zu bestimmen. Anschließend wird sowohl ein Muster für reguläre Ausdrücke als auch ein Ersatzmuster dynamisch erstellt. Wenn das Beispiel auf einem Computer ausgeführt wird, dessen aktuelle Kultur en-USist, wird das Muster \b(\d+)(\.(\d+))? für reguläre Ausdrücke und das Ersetzungsmuster $$ $1$2generiert. Das Ersatzmuster ersetzt den übereinstimmenen Text durch ein Währungssymbol und ein Leerzeichen gefolgt von den ersten und zweiten erfassten Gruppen.

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($"{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

Das Muster \b(\d+)(\.(\d+))? für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

Muster	BESCHREIBUNG
\b	Beginnt den Abgleich am Anfang einer Wortgrenze.
(\d+)	Eine oder mehrere Dezimalziffern abgleichen. Dies ist die erste Erfassungsgruppe.
\.	Übereinstimmung mit einem Punkt (dem Dezimaltrennzeichen).
(\d+)	Eine oder mehrere Dezimalziffern abgleichen. Dies ist die dritte Erfassungsgruppe.
(\.(\d+))?	Übereinstimmung mit keinem oder einem Vorkommen eines Punkts gefolgt von mindestens einer Dezimalzahl. Dies ist die zweite Erfassungsgruppe.

Ersetzen der gesamten Übereinstimmung

Die Ersetzung $& schließt die gesamte Übereinstimmung in die Ersetzungszeichenfolge ein. Häufig wird eine Teilzeichenfolge an den Anfang oder das Ende der übereinstimmenden Zeichenfolge hinzugefügt. Das Ersetzungsmuster ($&) fügt z. B. dem Anfang und Ende jeder Übereinstimmung Klammern hinzu. Wenn keine Übereinstimmung vorhanden ist, hat die $& Ersetzung keine Auswirkung.

Im folgenden Beispiel wird die $&-Ersetzung verwendet, um Anführungszeichen am Anfang und Ende von Buchtiteln hinzuzufügen, die in einem String-Array gespeichert sind.

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"

Das Muster ^(\w+\s?)+$ für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

Muster	BESCHREIBUNG
^	Beginnt den Abgleich am Anfang der Eingabezeichenfolge.
(\w+\s?)+	Erstellen Sie ein Muster, das aus einem oder mehreren Wortzeichen besteht, gefolgt von null oder einem Leerzeichen, und wiederholen Sie dies ein oder mehrere Male.
$	Entsprechung für das Ende der Eingabezeichenfolge finden.

Das Ersetzungsmuster "$&" fügt dem Anfang und Ende jeder Übereinstimmung ein literales Anführungszeichen hinzu.

Ersetzen des Texts vor der Übereinstimmung

Die Ersetzung $` ersetzt die übereinstimmende Zeichenfolge vor der Übereinstimmung durch die gesamte Eingabezeichenfolge. Das heißt, sie dupliziert die Eingabezeichenfolge bis zur Übereinstimmung, während der übereinstimmende Text entfernt wird. Jeder Text, der dem übereinstimmendem Text folgt, ist in der Ergebniszeichenfolge unverändert. Wenn in einer Eingabezeichenfolge mehrere Übereinstimmungen vorhanden sind, wird der Ersetzungstext von der ursprünglichen Eingabezeichenfolge abgeleitet, anstatt von der Zeichenfolge, in der Text durch frühere Übereinstimmungen ersetzt wurde. (Das Beispiel stellt eine Abbildung bereit.) Wenn keine Übereinstimmung vorhanden ist, hat die $` Ersetzung keine Auswirkung.

Im folgenden Beispiel wird eine Sequenz von einer oder mehreren Dezimalstellen in der Eingabezeichenfolge mithilfe des Muster eines regulären Ausdrucks \d+ abgeglichen. Die Ersetzungszeichenfolge $` ersetzt diese Ziffern durch den Text, der der Übereinstimmung vorausgeht.

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($"   {match.Value} at position {match.Index}");

      Console.WriteLine($"Input string:  {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

In diesem Beispiel enthält die Eingabezeichenfolge "aa1bb2cc3dd4ee5" fünf Übereinstimmungen. Aus der folgenden Tabelle wird ersichtlich, wie die Ersetzung $` bewirkt, dass die Engine für reguläre Ausdrücke jede Übereinstimmung in der Eingabezeichenfolge ersetzt. Eingefügter Text wird in der Ergebnisspalte fett formatiert angezeigt.

Spiel	Position	Zeichenfolge vor Übereinstimmung	Ergebnisstring
1	2	aa	aa aabb2cc3ddd4ee5
2	5	aa1bb	aaaabbaa1bbcc3dd4ee5
3	8	aa1bb2cc	aaaabbaa1bbccaa1bb2ccdd4ee5
4	11	aa1bb2cc3ddd	aaaabbaa1bbccaa1bb2ccddaa1bb2cc3dddee5
5	14	aa1bb2cc3dd4ee	aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Ersetzen des Texts nach der Übereinstimmung

Die Ersetzung $' ersetzt die übereinstimmende Zeichenfolge nach der Übereinstimmung durch die gesamte Eingabezeichenfolge. Das heißt, sie dupliziert die Eingabezeichenfolge nach der Entsprechung, während sie den übereinstimmenden Text entfernt. Jeder Text, der dem übereinstimmenden Text vorausgeht, ist in der Ergebniszeichenfolge unverändert. Wenn keine Übereinstimmung vorhanden ist, hat die $' Ersetzung keine Auswirkung.

Im folgenden Beispiel wird eine Sequenz von einer oder mehreren Dezimalstellen in der Eingabezeichenfolge mithilfe des Muster eines regulären Ausdrucks \d+ abgeglichen. Der Ersetzungszeichenfolge $' ersetzt diese Ziffern durch den Text, der der Übereinstimmung folgt.

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($"   {match.Value} at position {match.Index}");
      Console.WriteLine($"Input string:  {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

In diesem Beispiel enthält die Eingabezeichenfolge "aa1bb2cc3dd4ee5" fünf Übereinstimmungen. Aus der folgenden Tabelle wird ersichtlich, wie die Ersetzung $' bewirkt, dass die Engine für reguläre Ausdrücke jede Übereinstimmung in der Eingabezeichenfolge ersetzt. Eingefügter Text wird in der Ergebnisspalte fett formatiert angezeigt.

Spiel	Position	Zeichenfolge nach Übereinstimmung	Ergebnisstring
1	2	bb2cc3dd4ee5	aabb2cc3dd4ee5bb2cc3dd4ee5 bb2cc3dd4ee5
2	5	cc3dd4ee5	aabb2cc3dd4eee5bbcc3dd4ee5cc3dd4ee5 cc3dd4ee5
3	8	dd4ee5	aabb2cc3dd4eee5bbcc3dd4ee5ccdd4ee5dd4ee5
4	11	ee5	aabb2cc3dd4eee5bbcc3dd4ee5ccdd4ee5ddee5 ee5 ee5
5	14	String.Empty	aabb2cc3dd4eee5bbcc3dd4ee5ccdd4ee5ddee5ee

Ersetzen der letzten erfassten Gruppe

Die Ersetzung $+ ersetzt die übereinstimmende Zeichenfolge durch die zuletzt erfasste Gruppe. Wenn keine erfassten Gruppen vorhanden sind oder der Wert der letzten erfassten Gruppe lautet String.Empty, hat die $+ Ersetzung keine Auswirkung.

Das folgende Beispiel identifiziert doppelte Wörter in einer Zeichenfolge und verwendet die $+ Ersetzung, um sie durch ein einzelnes Vorkommen des Worts zu ersetzen. Die RegexOptions.IgnoreCase Option wird verwendet, um sicherzustellen, dass Wörter, die sich im Fall unterscheiden, aber andernfalls identisch sind, als Duplikate betrachtet werden.

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.

Das Muster \b(\w+)\s\1\b für reguläre Ausdrücke ist wie in der folgenden Tabelle dargestellt definiert.

Muster	BESCHREIBUNG
\b	Der Vergleich beginnt an einer Wortgrenze.
(\w+)	Übereinstimmung mit mindestens einem Wortzeichen. Dies ist die erste Erfassungsgruppe.
\s	Entsprechung für ein Leerraumzeichen finden.
\1	Übereinstimmung mit der ersten erfassten Gruppe.
\b	Der Vergleich endet an einer Wortgrenze.

Ersetzen der gesamten Eingabezeichenfolge

Die $_ Ersetzung ersetzt die übereinstimmene Zeichenfolge durch die gesamte Eingabezeichenfolge. Das heißt, er entfernt den übereinstimmenden Text und ersetzt ihn durch die gesamte Zeichenfolge, einschließlich des übereinstimmenden Texts.

Das folgende Beispiel entspricht einer oder mehreren Dezimalstellen in der Eingabezeichenfolge. Es nutzt die $_-Substitution, um sie durch die gesamte Eingabezeichenfolge zu ersetzen.

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:          {input}");
      Console.WriteLine($"String with substitution: {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

In diesem Beispiel enthält die Eingabezeichenfolge "ABC123DEF456" zwei Übereinstimmungen. Aus der folgenden Tabelle wird ersichtlich, wie die Ersetzung $_ bewirkt, dass die Engine für reguläre Ausdrücke jede Übereinstimmung in der Eingabezeichenfolge ersetzt. Eingefügter Text wird in der Ergebnisspalte fett formatiert angezeigt.

Spiel	Position	Spiel	Ergebnisstring
1	3	123	ABCABC123DEF456DEF456
2	5	456	ABCABC123DEF456DEF ABC123DEF456

Siehe auch

• Sprache für reguläre Ausdrücke – Kurzübersicht