Ersetzungen

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 gesuchte Muster durch das Muster, das vom replacement-Parameter definiert wird.

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

Ersetzungselemente und Ersetzungsmuster

Ersetzungen sind die einzigen Sonderkonstrukte, die in einem Ersetzungsmuster akzeptiert werden. Keines der anderen Sprachelemente für reguläre Ausdrücke, einschließlich Escapezeichen und des Punkts (.), der eine Entsprechung für beliebige Zeichen findet, wird unterstützt. Auf ähnliche Weise werden Ersetzungssprachelemente nur in Ersetzungsmustern erkannt und sind nie in Mustern eines regulären Ausdrucks 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.

Hinweis
Für die Funktionalität wie bei einem Ersetzungsmuster innerhalb eines regulären Ausdrucks verwenden Sie einen Rückverweis.Weitere Informationen zu Rückverweisen finden Sie unter Rückverweiskonstrukte.

Ersetzen einer nummerierten Gruppe

Das $ Nummer-Sprachelement schließt die letzte Teilzeichenfolge ein, die der von der Zahlenerfassungsgruppe in der Ersetzungszeichenfolge entspricht, wobei Nummer der Index der Erfassungsgruppe ist. Das Ersetzungsmuster $1 gibt z. B. an, dass die übereinstimmende Teilzeichenfolge durch die erste Erfassungsgruppe ersetzt werden soll. Weitere Informationen zu nummerierten Erfassungsgruppen finden Sie unter Gruppierungskonstrukte.

Erfassungsgruppen, denen mit der Syntax (?< Name >) keine Namen explizit zugewiesen sind, werden beginnend mit 1 von links nach rechts durchnummeriert. Benannte Gruppen werden auch von links nach rechts nummeriert und beginnen mit einem größeren Index als dem der letzten unbenannten Gruppe. Im regulären Ausdruck (\w)(?<digit>\d) ist der Index der benannten Gruppe digit z. B. 2.

Wenn Zahl keine im Muster eines regulären Ausdrucks definierte gültige Erfassungsgruppe angibt, wird $Nummer als Literalzeichensequenz interpretiert, die verwendet wird, um jede Übereinstimmung zu ersetzen.

Das folgende Beispiel entfernt das Währungssymbol mit der $Zahl-Ersetzung aus einem Dezimalwert. Es entfernt am Anfang oder Ende eines Währungswerts gefundene Währungssymbole und erkennt die zwei häufigsten Dezimaltrennzeichen ("." und ",").

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

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

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

Zurück nach oben

Ersetzen einer benannten Gruppe

Das ${Name}-Sprachelement ersetzt die letzte mit der Erfassungsgruppe Name übereinstimmende Teilzeichenfolge, wobei Name der Name einer Erfassungsgruppe ist, die vom Sprachelement (?< Namen >) definiert wurde. Weitere Informationen zu benannten Erfassungsgruppen finden Sie unter Gruppierungskonstrukte.

Wenn Name keine im Muster eines regulären Ausdrucks definierte gültige benannte Erfassungsgruppe angibt, wird ${Name} als Literalzeichensequenz interpretiert, die verwendet wird, um jede Übereinstimmung zu ersetzen.

Das folgende Beispiel verwendet die ${Name}-Ersetzung, um das Währungssymbol aus einem Dezimalwert zu entfernen. Es entfernt am Anfang oder Ende eines Währungswerts gefundene Währungssymbole und erkennt die zwei häufigsten Dezimaltrennzeichen ("." und ",").

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

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

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

Zurück nach oben

Ersetzen eines "$"-Zeichens

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

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

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

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

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

Ersetzen der gesamten Entsprechung

Die $&-Ersetzung schließt die ganze Übereinstimmung in die Ersetzungszeichenfolge ein. Oft wird es verwendet, um dem Anfang oder dem Ende der entsprechenden Zeichenfolge eine Teilzeichenfolge hinzuzufügen. Das Ersetzungsmuster ($&) fügt z. B. dem Anfang und dem Ende jeder Übereinstimmung Klammern hinzu. Wenn keine Übereinstimung vorhanden ist, wirkt sich die $&-Ersetzung nicht aus.

Das folgende Beispiel fügt Anführungszeichen am Anfang und dem Ende von Buchtiteln, die in einem Zeichenfolgenarray gespeichert wurden, mithilfe der $&-Ersetzung hinzu.

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"

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"

Das Muster für reguläre Ausdrücke ^(\w+\s?)+$ wird entsprechend der folgenden Tabelle definiert:

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

Zurück nach oben

Ersetzen des Texts vor der Entsprechung

Die $`-Ersetzung ersetzt vor der Übereinstimmung die entsprechende Zeichenfolge durch die ganze Eingabezeichenfolge. Das heißt, beim Entfernen des entsprechenden Texts dupliziert es die Eingabezeichenfolge bis zur Übereinstimmung. Jeder Text, der dem übereinstimmenden Text folgt, bleibt in der Ergebniszeichenfolge unverändert. Wenn es mehrere Übereinstimmungen in einer Eingabezeichenfolge gibt, wird der Ersatztext von der ursprünglichen Eingabezeichenfolge abgeleitet und nicht von der Zeichenfolge, in der Text von früheren Übereinstimmungen ersetzt wurde. (Dies wird im Beispiel veranschaulicht.) Wenn keine Übereinstimung vorhanden ist, wirkt sich die $`-Ersetzung nicht aus.

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

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

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

In diesem Beispiel enthält die Eingabezeichenfolge "aa1bb2cc3dd4ee5" fünf Übereinstimmungen. Die folgende Tabelle veranschaulicht, wie die $`-Ersetzung bewirkt, dass das Modul für reguläre Ausdrücke jede Übereinstimmung in der Eingabezeichenfolge ersetzt. Eingefügter Text wird in Fettdruck in der Ergebnisspalte angezeigt.

Zurück nach oben

Ersetzen des Texts nach der Entsprechung

Die $'-Ersetzung ersetzt nach der Übereinstimmung die entsprechende Zeichenfolge durch die ganze Eingabezeichenfolge. Das heißt, beim Entfernen des entsprechenden Texts dupliziert es die Eingabezeichenfolge nach der Übereinstimmung. Jeder Text, der dem übereinstimmenden Text vorausgeht, bleibt in der Ergebniszeichenfolge unverändert. Wenn es keine Übereinstimmung gibt, hat die $'-Ersetzung keine Auswirkungen.

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

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

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

In diesem Beispiel enthält die Eingabezeichenfolge "aa1bb2cc3dd4ee5" fünf Übereinstimmungen. Die folgende Tabelle veranschaulicht, wie die $'-Ersetzung bewirkt, dass das Modul für reguläre Ausdrücke jede Übereinstimmung in der Eingabezeichenfolge ersetzt. Eingefügter Text wird in Fettdruck in der Ergebnisspalte angezeigt.

Zurück nach oben

Ersetzen der zuletzt erfassten Gruppe

Die $+-Ersetzung ersetzt die entsprechende Zeichenfolge durch die letzte Erfassungsgruppe. Wenn es keine Erfassungsgruppen gibt oder wenn der Wert der letzten Erfassungsgruppe String.Empty ist, 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.

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.

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.

Das Muster für reguläre Ausdrücke \b(\w+)\s\1\b wird entsprechend der folgenden Tabelle definiert:

Zurück nach oben

Ersetzen der gesamten Eingabezeichenfolge

Die $_-Ersetzung ersetzt die entsprechende Zeichenfolge durch die ganze Eingabezeichenfolge. Das heißt, es entfernt den entsprechenden Text und ersetzt ihn durch die ganze Zeichenfolge, einschließlich des entsprechenden Texts.

Das folgende Beispiel entspricht einer oder mehreren Dezimalstellen in der Eingabezeichenfolge. Es ersetzt sie mithilfe der $_-Ersetzung durch die ganze Eingabezeichenfolge.

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

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

In diesem Beispiel enthält die Eingabezeichenfolge "ABC123DEF456" zwei Übereinstimmungen. Die folgende Tabelle veranschaulicht, wie die $_-Ersetzung bewirkt, dass das Modul für reguläre Ausdrücke jede Übereinstimmung in der Eingabezeichenfolge ersetzt. Eingefügter Text wird in Fettdruck in der Ergebnisspalte angezeigt.

Zurück nach oben

Siehe auch

Konzepte

Sprachelemente für reguläre Ausdrücke