Substituições em expressões regulares

As substituições são elementos de linguagem que são reconhecidos apenas dentro de padrões de substituição. Eles usam um padrão de expressão regular para definir todo ou parte do texto que deve substituir o texto correspondente na cadeia de caracteres de entrada. O padrão de substituição pode consistir em uma ou mais substituições juntamente com caracteres literais. Os padrões de substituição são fornecidos para sobrecargas do Regex.Replace método que têm um replacement parâmetro e para o Match.Result método. Os métodos substituem o padrão correspondente pelo padrão definido pelo replacement parâmetro.

O .NET define os elementos de substituição listados na tabela a seguir.

Elementos de substituição e padrões de substituição

As substituições são as únicas construções especiais reconhecidas em um padrão de substituição. Nenhum dos outros elementos de linguagem de expressão regular, incluindo escapes de caracteres e o ponto (.), que corresponde a qualquer caractere, é suportado. Da mesma forma, os elementos da linguagem de substituição são reconhecidos apenas em padrões de substituição e nunca são válidos em padrões de expressão regular.

O único caractere que pode aparecer em um padrão de expressão regular ou em uma substituição é o $ caractere, embora tenha um significado diferente em cada contexto. Em um padrão de expressão regular, $ é uma âncora que corresponde ao final da cadeia de caracteres. Em um padrão de substituição, $ indica o início de uma substituição.

Substituindo um grupo numerado

O $elemento de linguagem numérica inclui a última substring correspondida pelo grupo de captura de número na cadeia de caracteres de substituição, onde number é o índice do grupo de captura. Por exemplo, o padrão $1 de substituição indica que a substring correspondente deve ser substituída pelo primeiro grupo capturado. Para obter mais informações sobre grupos de captura numerados, consulte Agrupando construções.

Todos os dígitos que se seguem $ são interpretados como pertencentes ao grupo numérico . Se essa não for a sua intenção, você pode substituir um grupo nomeado. Por exemplo, você pode usar a cadeia de caracteres ${1}1 de substituição em vez de $11 definir a cadeia de caracteres de substituição como o valor do primeiro grupo capturado junto com o número "1". Para obter mais informações, consulte Substituindo um grupo nomeado.

A captura de grupos que não são explicitamente atribuídos nomes usando a sintaxe de nome>) é numerada da esquerda para a direita, (?<começando em um. Os grupos nomeados também são numerados da esquerda para a direita, começando em um maior do que o índice do último grupo sem nome. Por exemplo, na expressão (\w)(?<digit>\d)regular , o índice do digit grupo nomeado é 2.

Se number não especificar um grupo de captura válido definido no padrão de expressão regular, $number será interpretado como uma sequência de caracteres literal usada para substituir cada correspondência.

O exemplo a seguir usa a $substituição de número para remover o símbolo de moeda de um valor decimal. Ele remove símbolos de moeda encontrados no início ou no final de um valor monetário e reconhece os dois separadores decimais mais comuns ("." e ",").

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

O padrão \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* de expressão regular é definido conforme mostrado na tabela a seguir.

Substituindo um grupo nomeado

O ${elemento name} language substitui a última substring correspondida pelo grupo de captura de nome, onde name é o nome de um grupo de captura definido pelo>)(?<elemento name language. Para obter mais informações sobre grupos de captura nomeados, consulte Agrupando construções.

Se name não especificar um grupo de captura nomeado válido definido no padrão de expressão regular, mas consistir em dígitos, ${name} será interpretado como um grupo numerado.

Se name não especificar um grupo de captura nomeado válido nem um grupo de captura numerado válido definido no padrão de expressão regular, ${name} será interpretado como uma sequência de caracteres literal usada para substituir cada correspondência.

O exemplo a seguir usa a ${substituição de nome} para remover o símbolo de moeda de um valor decimal. Ele remove símbolos de moeda encontrados no início ou no final de um valor monetário e reconhece os dois separadores decimais mais comuns ("." e ",").

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

O padrão \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* de expressão regular é definido conforme mostrado na tabela a seguir.

Substituindo um caractere "$"

A $$ substituição insere um caractere "$" literal na cadeia de caracteres substituída.

O exemplo a seguir usa o NumberFormatInfo objeto para determinar o símbolo de moeda da cultura atual e seu posicionamento em uma cadeia de caracteres de moeda. Em seguida, ele cria um padrão de expressão regular e um padrão de substituição dinamicamente. Se o exemplo for executado em um computador cuja cultura atual é en-US, ele gerará o padrão \b(\d+)(\.(\d+))? de expressão regular e o padrão $$ $1$2de substituição. O padrão de substituição substitui o texto correspondente por um símbolo de moeda e um espaço seguido pelo primeiro e segundo grupos capturados.

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

O padrão \b(\d+)(\.(\d+))? de expressão regular é definido conforme mostrado na tabela a seguir.

Substituindo toda a partida

A $& substituição inclui toda a partida na sequência de substituição. Muitas vezes, ele é usado para adicionar uma substring ao início ou ao fim da cadeia de caracteres correspondente. Por exemplo, o ($&) padrão de substituição adiciona parênteses ao início e ao fim de cada correspondência. Se não houver correspondência, a substituição não surtiu $& efeito.

O exemplo a seguir usa a $& substituição para adicionar aspas no início e no final dos títulos de livros armazenados em uma matriz de cadeia de caracteres.

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"

O padrão ^(\w+\s?)+$ de expressão regular é definido conforme mostrado na tabela a seguir.

O "$&" padrão de substituição adiciona aspas literais ao início e ao fim de cada partida.

Substituindo o texto antes da partida

A $` substituição substitui a string correspondente pela string de entrada inteira antes da partida. Ou seja, ele duplica a cadeia de caracteres de entrada até a correspondência enquanto remove o texto correspondente. Qualquer texto que siga o texto correspondente não será alterado na cadeia de caracteres de resultado. Se houver várias correspondências em uma cadeia de caracteres de entrada, o texto de substituição será derivado da cadeia de caracteres de entrada original, em vez da cadeia de caracteres na qual o texto foi substituído por correspondências anteriores. (O exemplo fornece uma ilustração.) Se não houver correspondência, a substituição não surtiu $` efeito.

O exemplo a seguir usa o padrão \d+ de expressão regular para corresponder a uma sequência de um ou mais dígitos decimais na cadeia de caracteres de entrada. A cadeia de caracteres $` de substituição substitui esses dígitos pelo texto que precede a correspondência.

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

Neste exemplo, a cadeia de caracteres "aa1bb2cc3dd4ee5" de entrada contém cinco correspondências. A tabela a seguir ilustra como a $` substituição faz com que o mecanismo de expressão regular substitua cada correspondência na cadeia de caracteres de entrada. O texto inserido é mostrado em negrito na coluna de resultados.

Substituindo o texto após a correspondência

A $' substituição substitui a string correspondente pela string de entrada inteira após a correspondência. Ou seja, ele duplica a cadeia de caracteres de entrada após a correspondência enquanto remove o texto correspondente. Qualquer texto que precede o texto correspondente permanece inalterado na cadeia de caracteres de resultado. Se não houver correspondência, a substituição não surtiu $' efeito.

O exemplo a seguir usa o padrão \d+ de expressão regular para corresponder a uma sequência de um ou mais dígitos decimais na cadeia de caracteres de entrada. A cadeia de caracteres $' de substituição substitui esses dígitos pelo texto que segue a correspondência.

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

Neste exemplo, a cadeia de caracteres "aa1bb2cc3dd4ee5" de entrada contém cinco correspondências. A tabela a seguir ilustra como a $' substituição faz com que o mecanismo de expressão regular substitua cada correspondência na cadeia de caracteres de entrada. O texto inserido é mostrado em negrito na coluna de resultados.

Substituindo o último grupo capturado

A $+ substituição substitui a cadeia de caracteres correspondente pelo último grupo capturado. Se não houver grupos capturados ou se o valor do último grupo capturado for String.Empty, a $+ substituição não terá efeito.

O exemplo a seguir identifica palavras duplicadas em uma cadeia de caracteres e usa a $+ substituição para substituí-las por uma única ocorrência da palavra. A RegexOptions.IgnoreCase opção é usada para garantir que palavras diferentes em maiúsculas e minúsculas, mas que são idênticas de outra forma, sejam consideradas duplicadas.

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.

O padrão \b(\w+)\s\1\b de expressão regular é definido conforme mostrado na tabela a seguir.

Substituindo toda a cadeia de caracteres de entrada

A $_ substituição substitui a cadeia de caracteres correspondente por toda a cadeia de entrada. Ou seja, remove o texto correspondente e substitui-o por toda a cadeia de caracteres, incluindo o texto correspondente.

O exemplo a seguir corresponde a um ou mais dígitos decimais na cadeia de caracteres de entrada. Ele usa a $_ substituição para substituí-los por toda a cadeia de caracteres de entrada.

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

Neste exemplo, a cadeia de caracteres "ABC123DEF456" de entrada contém duas correspondências. A tabela a seguir ilustra como a $_ substituição faz com que o mecanismo de expressão regular substitua cada correspondência na cadeia de caracteres de entrada. O texto inserido é mostrado em negrito na coluna de resultados.

Consulte também

• Linguagem de Expressão Regular - Referência Rápida