Ersetzungen in regulären Ausdrücken

Ersetzungen sind Sprachelemente, die nur in Ersetzungsmustern erkannt werden. Sie definieren den gesamten Text oder einen Teil des Texts, der den entsprechenden Text in der Eingabezeichenfolge ersetzen soll, mithilfe eines Musters eines regulären Ausdrucks. Das Ersetzungsmuster kann zusammen mit Literalzeichen aus einer oder mehreren Ersetzungen bestehen. Ersetzungsmuster werden für Überladungen der Regex.Replace -Methode bereitgestellt, die über einen replacement -Parameter verfügen, und für die Match.Result -Methode. 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.

Ersetzungselemente und Ersetzungsmuster

Ersetzungen sind die einzigen Sonderkonstrukte, die in einem Ersetzungsmuster 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. Auf ähnliche Weise werden Ersetzungssprachelemente nur in Ersetzungsmustern erkannt und sind in Mustern für reguläre Ausdrücke nie gültig.

Das einzige Zeichen, das entweder in einem Muster eines regulären Ausdrucks oder in einer Ersetzung vorkommen kann, ist das $ -Zeichen, obwohl es in jedem Kontext eine andere Bedeutung hat. In einem Muster eines regulären Ausdrucks ist $ ein Anker, der dem Ende der Zeichenfolge entspricht. In einem Ersetzungsmuster gibt $ den Anfang einer Ersetzung an.

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. Beispielsweise gibt das Ersetzungsmuster $1 an, dass die übereinstimmende Teilzeichenfolge durch die erste erfasste Gruppe ersetzt werden soll. Weitere Informationen zu nummerierten Erfassungsgruppen finden Sie unter Grouping Constructs.

Alle Ziffern, die auf $ folgen, werden als zur Gruppe Zahl gehörend interpretiert. Wenn dies nicht Ihre Absicht ist, können Sie stattdessen eine benannte Gruppe ersetzen. Sie können z. B. die Ersetzungszeichenfolge ${1}1 anstelle von $11 verwenden, um die Ersetzungszeichenfolge als Wert der ersten erfassten Gruppe zusammen mit der Nummer "1" zu definieren. Weitere Informationen finden Sie unter Ersetzen einer benannten Gruppe.

Erfassungsgruppen, denen mit der Syntax (?<Name>) keine Namen explizit zugewiesen sind, werden beginnend mit Eins von links nach rechts durchnummeriert. Auch benannte Gruppen werden von links nach rechts durchnummeriert, wobei der Startwert um eins größer ist als der Index der letzten unbenannten Gruppe. Im regulären Ausdruck (\w)(?<digit>\d)ist z. B. der Index der benannten Gruppe digit 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.

Das folgende Beispiel verwendet die $Zahl -Ersetzung, um das aktuelle Symbol aus einem Dezimalwert zu extrahieren. Sie entfernt am Anfang oder Ende eines Währungswerts gefundene Währungssymbole und erkennt die zwei häufigsten 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 für reguläre Ausdrücke \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* wird entsprechend der folgenden Tabelle definiert:

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 Name keine im Muster eines regulären Ausdrucks definierte gültige benannte Erfassungsgruppe angibt, aber aus Ziffern besteht, wird ${Name} als eine nummerierte Gruppe interpretiert.

Wenn Name weder eine im Muster eines regulären Ausdrucks definierte gültige benannte Erfassungsgruppe noch eine gültige nummerierte Erfassungsgruppe angibt, wird ${Name} als Literalzeichensequenz interpretiert, die verwendet wird, um alle Übereinstimmungen zu ersetzen.

Im folgenden Beispiel wird die ${Name} -Ersetzung verwendet, um das Währungssymbol aus einem Dezimalwert zu entfernen. Sie entfernt am Anfang oder Ende eines Währungswerts gefundene Währungssymbole und erkennt die zwei häufigsten 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 für reguläre Ausdrücke \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* wird entsprechend der folgenden Tabelle definiert:

Ersetzen eines "$"-Zeichens

Die $$ -Ersetzung fügt ein literales "$"-Zeichen in der ersetzten Zeichenfolge ein.

Im folgenden Beispiel werden das Währungssymbol der aktuellen Kultur und seine Platzierung in einer Währungszeichenfolge mithilfe des NumberFormatInfo -Objekts bestimmt. Anschließend werden sowohl ein Muster eines regulären Ausdrucks als auch ein Ersetzungsmuster dynamisch erstellt. Wenn das Beispiel auf einem Computer ausgeführt wird, dessen aktuelle Kultur en-US ist, werden das Muster eines regulären Ausdrucks \b(\d+)(\.(\d+))? und das Ersetzungsmuster $$ $1$2generiert. Das Ersetzungsmuster ersetzt den übereinstimmenden Text durch ein Währungssymbol und ein Leerzeichen, gefolgt von der ersten und zweiten erfassten Gruppe.

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

Das Muster für reguläre Ausdrücke \b(\d+)(\.(\d+))? wird entsprechend der folgenden Tabelle definiert:

Ersetzen der gesamten Übereinstimmung

Die Ersetzung $& schließt die gesamte Übereinstimmung in die Ersetzungszeichenfolge ein. Sie wird häufig dazu verwendet, dem Anfang oder Ende der übereinstimmenden Zeichenfolge eine Teilzeichenfolge hinzuzufügen. Das Ersetzungsmuster ($&) fügt z. B. dem Anfang und Ende jeder Übereinstimmung Klammern hinzu. Wenn keine Übereinstimmung vorhanden ist, wirkt sich die Ersetzung $& nicht aus.

Im folgenden Beispiel werden mithilfe der Ersetzung $& Anführungszeichen am Anfang und Ende von Buchtiteln hinzugefügt, die in einem Zeichenfolgenarray gespeichert wurden.

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 für reguläre Ausdrücke ^(\w+\s?)+$ wird entsprechend der folgenden Tabelle definiert:

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, die Eingabezeichenfolge wird bis zur Übereinstimmung dupliziert, während der übereinstimmende Text entfernt wird. Jeder Text, der dem übereinstimmenden Text folgt, bleibt in der Ergebniszeichenfolge unverändert. Wenn mehrere Übereinstimmungen in einer Eingabezeichenfolge vorhanden sind, wird der Ersetzungstext von der ursprünglichen Eingabezeichenfolge abgeleitet und nicht von der Zeichenfolge, in der Text durch frühere Übereinstimmungen ersetzt wurde. (Dies wird im Beispiel veranschaulicht.) Wenn keine Übereinstimmung vorhanden ist, wirkt sich die $` -Ersetzung nicht aus.

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

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 in Fettdruck angezeigt.

Ersetzen des Texts nach der Übereinstimmung

Die Ersetzung $' ersetzt die übereinstimmende Zeichenfolge nach der Übereinstimmung durch die gesamte Eingabezeichenfolge. Das heißt, die Eingabezeichenfolge wird nach der Übereinstimmung dupliziert, während der übereinstimmende Text entfernt wird. Jeder Text, der dem übereinstimmenden Text vorausgeht, bleibt in der Ergebniszeichenfolge unverändert. Wenn keine Übereinstimmung vorhanden ist, wirkt sich die Ersetzung $' nicht aus.

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

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 in Fettdruck angezeigt.

Ersetzen der zuletzt erfassten Gruppe

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

Im folgenden Beispiel werden doppelte Wörter in einer Zeichenfolge identifiziert, und es wird die Ersetzung $+ verwendet, um sie durch ein einzelnes Vorkommen des Worts zu ersetzen. Die RegexOptions.IgnoreCase -Option wird verwendet, um sicherzustellen, dass Wörter, die sich ausschließlich in der Groß-/Kleinschreibung unterscheiden, 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 für reguläre Ausdrücke \b(\w+)\s\1\b wird entsprechend der folgenden Tabelle definiert:

Ersetzen der ganzen Eingabezeichenfolge

Die Ersetzung $_ ersetzt die übereinstimmende Zeichenfolge durch die gesamte Eingabezeichenfolge. Das heißt, dass der übereinstimmende Text entfernt und durch die gesamte Zeichenfolge, einschließlich des übereinstimmenden Texts, ersetzt wird.

Im folgenden Beispiel werden eine oder mehrere Dezimalstellen in der Eingabezeichenfolge abgeglichen. Mithilfe der Ersetzung $_ werden diese durch die gesamte Eingabezeichenfolge ersetzt.

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

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 in Fettdruck angezeigt.

Siehe auch

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