Nahrazení v regulárních výrazech

Nahrazení jsou prvky jazyka, které jsou rozpoznány pouze v rámci vzorů nahrazení. Pro definování celého textu nebo jeho části, která má nahradit odpovídající text ve vstupním řetězci, používají vzor regulárního výrazu. Vzor pro nahrazení se může skládat z jedné nebo několika substitucí spolu s literálními znaky. Vzory nahrazení jsou poskytovány Regex.Replace přetížení metody, které mají replacement parametr a metodu Match.Result . Metody nahrazují odpovídající vzor vzorem, který je definován parametrem replacement .

.NET definuje náhradní prvky uvedené v následující tabulce.

Prvky substituce a vzory pro nahrazení

Substituce jsou jediné speciální konstrukce, které jsou rozpoznány ve vzorech pro nahrazení. Žádný z ostatních prvků jazyka regulárních výrazů, včetně řídicích znaků a tečky (.), která odpovídá jakémukoli znaku, nejsou podporovány. Obdobně jsou prvky jazyka pro substituci rozpoznány jen ve vzorech pro nahrazení a nejsou nikdy platné ve vzorech regulárního výrazu.

Jediným znakem, který se může objevit ve vzoru regulárního výrazu nebo v nahrazení, je $ znak, i když má v každém kontextu jiný význam. V vzoru regulárního výrazu je kotva, $ která odpovídá konci řetězce. V modelu $ nahrazení označuje začátek nahrazení.

Nahrazování číslované skupiny

Prvek $číselného jazyka zahrnuje poslední podřetězce odpovídající skupině zachycení čísel v náhradním řetězci, kde číslo je index zachytávání skupiny zachycení. Například vzor $1 nahrazení označuje, že odpovídající podřetětěc se má nahradit první zachycenou skupinou. Další informace o číslování zachycených skupin naleznete v tématu Seskupování konstruktorů.

Všechny následující $ číslice jsou interpretovány jako patřící do číselné skupiny. Pokud to však není vaším záměrem, můžete namísto toho nahradit pojmenovanou skupinu. Můžete například použít náhradní řetězec ${1}1 místo $11 definování náhradního řetězce jako hodnotu první zachycené skupiny spolu s číslem "1". Další informace naleznete v tématu Nahrazení pojmenované skupiny.

Zachytávání skupin, které nejsou explicitně přiřazené názvy pomocí (?<syntaxe názvu>) , jsou číslování zleva doprava počínaje jedním z nich. Pojmenované skupiny jsou rovněž číslovány zleva doprava. Číslování začíná číslem o jedno vyšším než index poslední nepojmenované skupiny. Například v regulárním výrazu (\w)(?<digit>\d)je index digit pojmenované skupiny 2.

Pokud číslo neurčuje platnou skupinu zachycení definovanou v vzoru regulárního výrazu, $číslo se interpretuje jako literálová sekvence znaků, která se používá k nahrazení každé shody.

Následující příklad používá $nahrazení čísla k odstranění symbolu měny z desetinné hodnoty. Odebere symboly měny nalezené na začátku nebo konci peněžní hodnoty a rozpozná dva nejběžnější oddělovače desetinných míst "." a ",".

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

Vzor regulárního výrazu \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* je definován, jak je znázorněno v následující tabulce.

Nahrazování pojmenované skupiny

Element ${jazyka name} nahrazuje poslední podřetěc odpovídající skupině zachycení názvu, kde název je název zachytávání skupiny definované(?< elementem jazyka name>). Další informace o pojmenovaných zachytávání skupin naleznete v tématu Seskupování konstruktorů.

Pokud název neurčuje platnou pojmenovanou skupinu zachycení definovanou v vzoru regulárního výrazu, ale skládá se z číslic, ${název} se interpretuje jako číslová skupina.

Pokud název určuje platnou pojmenovanou skupinu zachycení ani platnou číslované zachytávané skupiny definované v vzoru regulárního výrazu, ${název} se interpretuje jako sekvence literálů, která se používá k nahrazení každé shody.

Následující příklad používá ${nahrazení názvu} k odstranění symbolu měny z desítkové hodnoty. Odebere symboly měny nalezené na začátku nebo konci peněžní hodnoty a rozpozná dva nejběžnější oddělovače desetinných míst "." a ",".

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

Vzor regulárního výrazu \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* je definován, jak je znázorněno v následující tabulce.

Nahrazování znaku "$"

Nahrazení $$ vloží do nahrazeného řetězce literál "$".

Následující příklad používá NumberFormatInfo objekt k určení symbolu měny aktuální jazykové verze a jeho umístění v řetězci měny. Poté dynamicky sestaví vzor regulárního výrazu a vzor pro nahrazení. Pokud je příklad spuštěn na počítači, jehož aktuální jazyková verze je en-US, generuje vzor \b(\d+)(\.(\d+))? regulárního výrazu a náhradní vzor $$ $1$2. Vzor pro nahrazení nahradí odpovídající text symbolem měny a mezerou následovanou první a druhou zachycenou skupinou.

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

Vzor regulárního výrazu \b(\d+)(\.(\d+))? je definován, jak je znázorněno v následující tabulce.

Nahrazování celé shody

Náhrada $& zahrnuje celou shodu v náhradním řetězci. Často se používá k přidání podřetězce na začátek nebo konec porovnávaného řetězce. Vzor nahrazení například ($&) přidá závorky na začátek a konec každé shody. Pokud neexistuje shoda, $& nahrazení nemá žádný vliv.

Následující příklad používá náhradu $& k přidání uvozovek na začátek a konec knih titulů uložených v řetězcovém poli.

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"

Vzor regulárního výrazu ^(\w+\s?)+$ je definován, jak je znázorněno v následující tabulce.

Náhradní "$&" vzor přidá na začátek a konec každé shody literálovou uvozovku.

Nahrazování textu před porovnáváním

Nahrazení $` nahradí odpovídající řetězec celým vstupním řetězcem před shodou. To znamená, že duplikuje vstupní řetězec až po shodu a odebírá odpovídající text. Jakýkoli text, který následuje za odpovídajícím textem, zůstane ve výsledném řetězci nezměněn. Pokud existuje více shod ve vstupním řetězci, je text pro nahrazení odvozen z původního vstupního řetězce, nikoli z řetězce, ve kterém byl text nahrazen předchozími shodami. (Příklad obsahuje ilustraci.) Pokud neexistuje shoda, $` nahrazení nemá žádný vliv.

Následující příklad používá vzor \d+ regulárního výrazu ke sekvenci jedné nebo více desetinných číslic ve vstupním řetězci. Náhradní řetězec $` nahradí tyto číslice textem, který předchází shodě.

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

V tomto příkladu obsahuje vstupní řetězec "aa1bb2cc3dd4ee5" pět shod. Následující tabulka ukazuje, jak $` nahrazení způsobí, že modul regulárních výrazů nahradí každou shodu ve vstupním řetězci. Vložený text je zobrazen tučně ve sloupci výsledků.

Nahrazování textu po shodě

Nahrazení $' nahradí odpovídající řetězec celým vstupním řetězcem za shodu. To znamená, že duplikuje vstupní řetězec po shodě a odebírá odpovídající text. Jakýkoli text, který předchází odpovídajícímu textu, zůstává ve výsledném řetězci nezměněn. Pokud neexistuje shoda, $' nahrazení nemá žádný vliv.

Následující příklad používá vzor \d+ regulárního výrazu ke sekvenci jedné nebo více desetinných číslic ve vstupním řetězci. Náhradní řetězec $' nahradí tyto číslice textem, který následuje za shodou.

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

V tomto příkladu obsahuje vstupní řetězec "aa1bb2cc3dd4ee5" pět shod. Následující tabulka ukazuje, jak $' nahrazení způsobí, že modul regulárních výrazů nahradí každou shodu ve vstupním řetězci. Vložený text je zobrazen tučně ve sloupci výsledků.

Nahrazování poslední zachycené skupiny

Nahrazení $+ nahradí odpovídající řetězec poslední zachycenou skupinou. Pokud neexistují žádné zachycené skupiny nebo pokud je String.Emptyhodnota poslední zachycené skupiny, $+ nahrazení nemá žádný vliv.

Následující příklad identifikuje duplicitní slova v řetězci a pomocí $+ nahrazení je nahradí jediným výskytem slova. Tato RegexOptions.IgnoreCase možnost slouží k zajištění toho, aby se slova, která se liší v případě, že jsou ale jinak identická, považují se za duplicitní.

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.

Vzor regulárního výrazu \b(\w+)\s\1\b je definován, jak je znázorněno v následující tabulce.

Nahrazování celého vstupního řetězce

Nahrazení $_ nahradí odpovídající řetězec celým vstupním řetězcem. To znamená, že odebere odpovídající text a nahradí jej celým řetězcem, včetně odpovídajícího textu.

Následující příklad porovnává jednu nebo několik desítkových číslic ve vstupním řetězci. Nahrazuje $_ je celým vstupním řetězcem.

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

V tomto příkladu obsahuje vstupní řetězec "ABC123DEF456" dvě shody. Následující tabulka ukazuje, jak $_ nahrazení způsobí, že modul regulárních výrazů nahradí každou shodu ve vstupním řetězci. Vložený text je zobrazen tučně ve sloupci výsledků.

Viz také

• Jazyk regulárních výrazů – stručná referenční dokumentace