Substituições em expressões regularesSubstitutions in Regular Expressions

As substituições são elementos de linguagem que são reconhecidos apenas em padrões de substituição.Substitutions are language elements that are recognized only within replacement patterns. Eles usam um padrão de expressão regular para definir o todo ou parte do texto que substitui o texto correspondente na cadeia de caracteres de entrada.They use a regular expression pattern to define all or part of the text that is to replace matched text in the input string. O padrão de substituição pode consistir em uma ou mais substituições junto com caracteres literais.The replacement pattern can consist of one or more substitutions along with literal characters. Padrões de substituição são fornecidos para sobrecargas do método Regex.Replace que têm um parâmetro replacement e para o método Match.Result.Replacement patterns are provided to overloads of the Regex.Replace method that have a replacement parameter and to the Match.Result method. Os métodos substituem o padrão correspondente pelo padrão que é definido pelo parâmetro replacement.The methods replace the matched pattern with the pattern that is defined by the replacement parameter.

O .NET Framework define os elementos de substituição listados na tabela a seguir.The .NET Framework defines the substitution elements listed in the following table.

SubstituiçãoSubstitution DESCRIÇÃODescription
$ número$ number Inclui a última subcadeia de caracteres correspondida pelo grupo de captura que é identificado por number, no qual number é um valor decimal na cadeia de caracteres de substituição.Includes the last substring matched by the capturing group that is identified by number, where number is a decimal value, in the replacement string. Para obter mais informações, consulte Substituindo um grupo numerado.For more information, see Substituting a Numbered Group.
${ name }${ name } Inclui a última subcadeia de caracteres correspondida pelo grupo nomeado que é designado por (?<name> ) na cadeia de caracteres de substituição.Includes the last substring matched by the named group that is designated by (?<name> ) in the replacement string. Para obter mais informações, consulte Substituindo um grupo nomeado.For more information, see Substituting a Named Group.
$$ Inclui um único literal “$” na cadeia de caracteres de substituição.Includes a single "$" literal in the replacement string. Para obter mais informações, consulte Substituindo um símbolo "$".For more information, see Substituting a "$" Symbol.
$& Inclui uma cópia da correspondência inteira na cadeia de caracteres de substituição.Includes a copy of the entire match in the replacement string. Para obter mais informações, consulte Substituindo a correspondência inteira.For more information, see Substituting the Entire Match.
$` Inclui todo o texto da cadeia de caracteres de entrada antes da correspondência na cadeia de caracteres de substituição.Includes all the text of the input string before the match in the replacement string. Para obter mais informações, consulte Substituindo o texto antes da correspondência.For more information, see Substituting the Text before the Match.
$'$' Inclui todo o texto da cadeia de caracteres de entrada após a correspondência na cadeia de caracteres de substituição.Includes all the text of the input string after the match in the replacement string. Para obter mais informações, consulte Substituindo o texto após a correspondência.For more information, see Substituting the Text after the Match.
$+ O inclui o último grupo capturado na cadeia de caracteres de substituição.Includes the last group captured in the replacement string. Para obter mais informações, consulte Substituindo o último grupo capturado.For more information, see Substituting the Last Captured Group.
$$ Inclui a cadeia de entrada inteira na cadeia de caracteres de substituição.Includes the entire input string in the replacement string. Para obter mais informações, consulte Substituindo a cadeia de caracteres de entrada inteira.For more information, see Substituting the Entire Input String.

Elementos de substituição e padrões de substituiçãoSubstitution Elements and Replacement Patterns

As substituições são as únicas construções especiais reconhecidas em um padrão de substituição.Substitutions are the only special constructs recognized in a replacement pattern. Nenhum dos outros elementos de linguagem de expressões regulares, incluindo caracteres de escape e o ponto final (.), que corresponde a qualquer caractere, são aceitos.None of the other regular expression language elements, including character escapes and the period (.), which matches any character, are supported. Da mesma forma, os elementos de linguagem de substituição são reconhecidos apenas nos padrões de substituição e nunca são válidos em padrões de expressões regulares.Similarly, substitution language elements are recognized only in replacement patterns and are never valid in regular expression patterns.

O único caractere que pode aparecer em um padrão de expressão regular ou em uma substituição é o caractere $, embora ele tenha um significado diferente em cada contexto.The only character that can appear either in a regular expression pattern or in a substitution is the $ character, although it has a different meaning in each context. Em um padrão de expressão regular, $ é uma âncora que corresponde ao final da cadeia de caracteres.In a regular expression pattern, $ is an anchor that matches the end of the string. Em um padrão de substituição, $ indica o início de uma substituição.In a replacement pattern, $ indicates the beginning of a substitution.

Observação

Para uma funcionalidade semelhante a um padrão de substituição dentro de uma expressão regular, use um backreference.For functionality similar to a replacement pattern within a regular expression, use a backreference. Para obter mais informações sobre referências inversas, consulte Construtores de referência inversa.For more information about backreferences, see Backreference Constructs.

Substituindo um grupo numeradoSubstituting a Numbered Group

O elemento de linguagem $number inclui a última subcadeia de caracteres correspondida pelo grupo de captura number na cadeia de caracteres de substituição, no qual number é o índice do grupo de captura.The $number language element includes the last substring matched by the number capturing group in the replacement string, where number is the index of the capturing group. Por exemplo, o padrão de substituição $1 indica que a subcadeia de caracteres correspondente deve ser substituída pelo primeiro grupo capturado.For example, the replacement pattern $1 indicates that the matched substring is to be replaced by the first captured group. Para saber mais sobre os grupos de captura numerados, consulte Constructos de agrupamento.For more information about numbered capturing groups, see Grouping Constructs.

Todos os dígitos após $ são interpretados como pertencentes ao grupo number.All digits that follow $ are interpreted as belonging to the number group. Se essa não for sua intenção, você poderá substituir um grupo nomeado.If this is not your intent, you can substitute a named group instead. Por exemplo, você pode usar a cadeia de caracteres de substituição ${1}1 em vez de $11 para definir a cadeia de caracteres de substituição como o valor do primeiro grupo capturado junto com o número “1 ".For example, you can use the replacement string ${1}1 instead of $11 to define the replacement string as the value of the first captured group along with the number "1". Para obter mais informações, consulte Substituindo um grupo nomeado.For more information, see Substituting a Named Group.

Grupos de captura, aos quais não são atribuídos nomes explicitamente usando a sintaxe (?<name>), são numerados da esquerda para a direita, começando em um.Capturing groups that are not explicitly assigned names using the (?<name>) syntax are numbered from left to right starting at one. Os grupos nomeados também são numerados da esquerda para a direita, começando em um maior que o índice do último grupo não nomeado.Named groups are also numbered from left to right, starting at one greater than the index of the last unnamed group. Por exemplo, na expressão regular (\w)(?<digit>\d), o índice do grupo nomeado digit é 2.For example, in the regular expression (\w)(?<digit>\d), the index of the digit named group is 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 que será usada para substituir cada correspondência.If number does not specify a valid capturing group defined in the regular expression pattern, $number is interpreted as a literal character sequence that is used to replace each match.

O exemplo a seguir usa a substituição $number para remover o símbolo de moeda de um valor decimal.The following example uses the $number substitution to strip the currency symbol from a decimal value. Ele remove os símbolos de moeda localizados no início ou término de um valor monetário e reconhece os dois separadores decimais mais comuns (“.” e “, ").It removes currency symbols found at the beginning or end of a monetary value, and recognizes the two most common decimal separators ("." and ",").

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 de expressão regular \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* é definido conforme mostrado na tabela a seguir.The regular expression pattern \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\p{Sc}* Corresponde a zero ou mais caracteres de símbolos de moedas.Match zero or more currency symbol characters.
\s? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space characters.
\d+ Corresponde a um ou mais dígitos decimais.Match one or more decimal digits.
[.,]? Corresponde a zero ou um ponto ou vírgula.Match zero or one period or comma.
\d* Corresponde a zero ou mais dígitos decimais.Match zero or more decimal digits.
(\s?\d+[.,]?\d*) Corresponde a um espaço em branco seguido por um ou mais dígitos decimais, seguidos por zero ou um ponto ou uma vírgula, seguidos por zero ou mais dígitos decimais.Match a white space followed by one or more decimal digits, followed by zero or one period or comma, followed by zero or more decimal digits. Este é o primeiro grupo de captura.This is the first capturing group. Como o padrão de substituição é $1, a chamada ao método Regex.Replace substitui a subcadeia de caracteres inteira correspondente a esse grupo capturado.Because the replacement pattern is $1, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

Voltar ao inícioBack to top

Substituindo um grupo nomeadoSubstituting a Named Group

O elemento de linguagem ${name} substitui a última subcadeia de caracteres correspondida pelo grupo de captura name, no qual name é o nome de um grupo de captura definido pelo elemento de linguagem (?<name>).The ${name} language element substitutes the last substring matched by the name capturing group, where name is the name of a capturing group defined by the (?<name>) language element. Para saber mais sobre os grupos de captura nomeados, consulte Constructos de agrupamento.For more information about named capturing groups, see Grouping Constructs.

Se name não especificar um grupo de captura nomeado válido, definido no padrão da expressão regular, mas consistir em dígitos, ${name} será interpretado como um grupo numerado.If name doesn't specify a valid named capturing group defined in the regular expression pattern but consists of digits, ${name} is interpreted as a numbered group.

Se name não especificar um grupo de captura nomeado válido nem um grupo de captura numerado válido, definido no padrão da expressão regular, ${name} será interpretado como uma sequência de caracteres literal que será usada para substituir cada correspondência.If name specifies neither a valid named capturing group nor a valid numbered capturing group defined in the regular expression pattern, ${name} is interpreted as a literal character sequence that is used to replace each match.

O exemplo a seguir usa a substituição ${name} para remover o símbolo de moeda de um valor decimal.The following example uses the ${name} substitution to strip the currency symbol from a decimal value. Ele remove os símbolos de moeda localizados no início ou término de um valor monetário e reconhece os dois separadores decimais mais comuns (“.” e “, ").It removes currency symbols found at the beginning or end of a monetary value, and recognizes the two most common decimal separators ("." and ",").

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 de expressão regular \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* é definido conforme mostrado na tabela a seguir.The regular expression pattern \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\p{Sc}* Corresponde a zero ou mais caracteres de símbolos de moedas.Match zero or more currency symbol characters.
\s? Corresponder a zero ou a um caractere de espaço em branco.Match zero or one white-space characters.
\d+ Corresponde a um ou mais dígitos decimais.Match one or more decimal digits.
[.,]? Corresponde a zero ou um ponto ou vírgula.Match zero or one period or comma.
\d* Corresponde a zero ou mais dígitos decimais.Match zero or more decimal digits.
(?<amount>\s?\d[.,]?\d*) Corresponde a um espaço em branco seguido por um ou mais dígitos decimais, seguidos por zero ou um ponto ou uma vírgula, seguidos por zero ou mais dígitos decimais.Match a white space, followed by one or more decimal digits, followed by zero or one period or comma, followed by zero or more decimal digits. Este é o grupo de captura chamado amount.This is the capturing group named amount. Como o padrão de substituição é ${amount}, a chamada ao método Regex.Replace substitui a subcadeia de caracteres inteira correspondente a esse grupo capturado.Because the replacement pattern is ${amount}, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

Voltar ao inícioBack to top

Substituindo um caractere “$”Substituting a "$" Character

A substituição de $$ insere um caractere literal “$” na cadeia de caracteres substituída.The $$ substitution inserts a literal "$" character in the replaced string.

O exemplo a seguir usa o objeto NumberFormatInfo para determinar o símbolo de moeda atual da cultura e seu posicionamento em uma cadeia de caracteres de moeda.The following example uses the NumberFormatInfo object to determine the current culture's currency symbol and its placement in a currency string. Ele então cria um padrão de expressão regular e um padrão de substituição dinamicamente.It then builds both a regular expression pattern and a replacement pattern dynamically. Se o exemplo é executado em um computador cuja cultura atual é en-US, ele gera o padrão de expressão regular \b(\d+)(\.(\d+))? e o padrão de substituição $$ $1$2.If the example is run on a computer whose current culture is en-US, it generates the regular expression pattern \b(\d+)(\.(\d+))? and the replacement pattern $$ $1$2. 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.The replacement pattern replaces the matched text with a currency symbol and a space followed by the first and second captured groups.

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 de expressão regular \b(\d+)(\.(\d+))? é definido conforme mostrado na tabela a seguir.The regular expression pattern \b(\d+)(\.(\d+))? is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Inicia a correspondência no começo de um limite de palavra.Start the match at the beginning of a word boundary.
(\d+) Corresponde a um ou mais dígitos decimais.Match one or more decimal digits. Este é o primeiro grupo de captura.This is the first capturing group.
\. Faz a correspondência a um período (o separador decimal).Match a period (the decimal separator).
(\d+) Corresponde a um ou mais dígitos decimais.Match one or more decimal digits. Este é o terceiro grupo de captura.This is the third capturing group.
(\.(\d+))? Faz a correspondência de zero ou uma ocorrência de um período seguido por um ou mais dígitos decimais.Match zero or one occurrence of a period followed by one or more decimal digits. Este é o segundo grupo de captura.This is the second capturing group.

Substituindo a correspondência inteiraSubstituting the Entire Match

A substituição $& inclui a correspondência inteira na cadeia de caracteres de substituição.The $& substitution includes the entire match in the replacement string. Muitas vezes, ela é usada para adicionar uma subcadeia de caracteres ao início ou fim da cadeia de caracteres correspondente.Often, it is used to add a substring to the beginning or end of the matched string. Por exemplo, o padrão de substituição ($&) adiciona parênteses no início e no final de cada correspondência.For example, the ($&) replacement pattern adds parentheses to the beginning and end of each match. Se não houver correspondência, a substituição $& não terá efeito.If there is no match, the $& substitution has no effect.

O exemplo a seguir usa a substituição $& para adicionar aspas no início e no final de títulos de livros armazenados em uma matriz de cadeia de caracteres.The following example uses the $& substitution to add quotation marks at the beginning and end of book titles stored in a string array.

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 de expressão regular ^(\w+\s?)+$ é definido conforme mostrado na tabela a seguir.The regular expression pattern ^(\w+\s?)+$ is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
^ Começa a correspondência no início da cadeia de caracteres de entrada.Start the match at the beginning of the input string.
(\w+\s?)+ Corresponde ao padrão de um ou mais caracteres de palavra seguidos por zero ou um espaço em branco uma ou mais vezes.Match the pattern of one or more word characters followed by zero or one white-space characters one or more times.
$ Corresponder ao final da cadeia de caracteres de entrada.Match the end of the input string.

O padrão de substituição "$&" adiciona aspas literais no início e no final de cada correspondência.The "$&" replacement pattern adds a literal quotation mark to the beginning and end of each match.

Voltar ao inícioBack to top

Substituindo texto antes da correspondênciaSubstituting the Text Before the Match

A substituição $` substitui a cadeia de caracteres correspondida pela cadeia de caracteres de entrada inteira antes da correspondência.The $` substitution replaces the matched string with the entire input string before the match. Ou seja, ela duplica a cadeia de caracteres de entrada até a correspondência e remove o texto correspondido.That is, it duplicates the input string up to the match while removing the matched text. Qualquer texto após o texto correspondido permanece inalterado na cadeia de caracteres de resultado.Any text that follows the matched text is unchanged in the result string. 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 em que o texto foi substituído por correspondências anteriores.If there are multiple matches in an input string, the replacement text is derived from the original input string, rather than from the string in which text has been replaced by earlier matches. (O exemplo fornece uma ilustração.) Se não houver correspondência, a substituição $` não terá efeito.(The example provides an illustration.) If there is no match, the $` substitution has no effect.

O exemplo a seguir usa o padrão de expressão regular \d+ para corresponder a uma sequência de um ou mais dígitos decimais na cadeia de caracteres de entrada.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. A cadeia de caracteres de substituição $` substitui esses dígitos pelo texto que precede a correspondência.The replacement string $` replaces these digits with the text that precedes the match.

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 de entrada "aa1bb2cc3dd4ee5" contém cinco correspondências.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. 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.The following table illustrates how the $` substitution causes the regular expression engine to replace each match in the input string. O texto inserido é mostrado em negrito na coluna de resultados.Inserted text is shown in bold in the results column.

Corresponder aMatch PosiçãoPosition Cadeia de caracteres antes da correspondênciaString before match Cadeia de caracteres de resultadoResult string
11 22 aaaa aaaabb2cc3dd4ee5aaaabb2cc3dd4ee5
22 55 aa1bbaa1bb aaaabbaa1bbcc3dd4ee5aaaabbaa1bbcc3dd4ee5
33 88 aa1bb2ccaa1bb2cc aaaabbaa1bbccaa1bb2ccdd4ee5aaaabbaa1bbccaa1bb2ccdd4ee5
44 1111 aa1bb2cc3ddaa1bb2cc3dd aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5
55 1414 aa1bb2cc3dd4eeaa1bb2cc3dd4ee aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4eeaaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Voltar ao inícioBack to top

Substituindo texto após a correspondênciaSubstituting the Text After the Match

A substituição $' substitui a cadeia de caracteres correspondida pela cadeia de caracteres de entrada inteira após a correspondência.The $' substitution replaces the matched string with the entire input string after the match. Ou seja, ela duplica a cadeia de caracteres de entrada após a correspondência e remove o texto correspondido.That is, it duplicates the input string after the match while removing the matched text. Qualquer texto antes do texto correspondido permanece inalterado na cadeia de caracteres de resultado.Any text that precedes the matched text is unchanged in the result string. Se não houver correspondência, a substituição $' não terá efeito.If there is no match, the $' substitution has no effect.

O exemplo a seguir usa o padrão de expressão regular \d+ para corresponder a uma sequência de um ou mais dígitos decimais na cadeia de caracteres de entrada.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. A cadeia de caracteres de substituição $' substitui esses dígitos pelo texto após a correspondência.The replacement string $' replaces these digits with the text that follows the match.

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 de entrada "aa1bb2cc3dd4ee5" contém cinco correspondências.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. 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.The following table illustrates how the $' substitution causes the regular expression engine to replace each match in the input string. O texto inserido é mostrado em negrito na coluna de resultados.Inserted text is shown in bold in the results column.

Corresponder aMatch PosiçãoPosition Cadeia de caracteres após a correspondênciaString after match Cadeia de caracteres de resultadoResult string
11 22 bb2cc3dd4ee5bb2cc3dd4ee5 aabb2cc3dd4ee5bb2cc3dd4ee5aabb2cc3dd4ee5bb2cc3dd4ee5
22 55 cc3dd4ee5cc3dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5
33 88 dd4ee5dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5
44 1111 ee5ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5
55 1414 String.Empty aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5eeaabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Voltar ao inícioBack to top

Substituindo o último grupo capturadoSubstituting the Last Captured Group

A substituição $+ substitui a cadeia de caracteres correspondida pelo último grupo capturado.The $+ substitution replaces the matched string with the last captured group. Se não houver nenhum grupo capturado ou se o valor do grupo capturado por último for String.Empty, a substituição $+ não terá efeito.If there are no captured groups or if the value of the last captured group is String.Empty, the $+ substitution has no effect.

O exemplo a seguir identifica palavras duplicadas em uma cadeia de caracteres e usa a substituição $+ para substituí-los por uma única ocorrência da palavra.The following example identifies duplicate words in a string and uses the $+ substitution to replace them with a single occurrence of the word. A opção RegexOptions.IgnoreCase é usada para garantir que as palavras que diferem apenas em termos de letras maiúsculas e minúsculas, mas que de outra forma são idênticas, sejam consideradas duplicadas.The RegexOptions.IgnoreCase option is used to ensure that words that differ in case but that are otherwise identical are considered duplicates.

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 de expressão regular \b(\w+)\s\1\b é definido conforme mostrado na tabela a seguir.The regular expression pattern \b(\w+)\s\1\b is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Começa a correspondência em um limite de palavra.Begin the match at a word boundary.
(\w+) Corresponde a um ou mais caracteres de palavra.Match one or more word characters. Este é o primeiro grupo de captura.This is the first capturing group.
\s Corresponde a um caractere de espaço em branco.Match a white-space character.
\1 Corresponde ao primeiro grupo capturado.Match the first captured group.
\b Termina a correspondência em um limite de palavra.End the match at a word boundary.

Voltar ao inícioBack to top

Substituindo a cadeia de caracteres de entrada inteiraSubstituting the Entire Input String

A substituição $_ substitui a cadeia de caracteres correspondida pela cadeia de caracteres de entrada inteira.The $_ substitution replaces the matched string with the entire input string. Ou seja, ela remove o texto correspondido e o substitui pela cadeia de caracteres inteira, inclusive o texto correspondido.That is, it removes the matched text and replaces it with the entire string, including the matched text.

O exemplo a seguir corresponde a um ou mais dígitos decimais na cadeia de caracteres de entrada.The following example matches one or more decimal digits in the input string. Ele usa a substituição $_ para substituí-los pela cadeia de caracteres de entrada inteira.It uses the $_ substitution to replace them with the entire input string.

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 de entrada "ABC123DEF456" contém duas correspondências.In this example, the input string "ABC123DEF456" contains two matches. 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.The following table illustrates how the $_ substitution causes the regular expression engine to replace each match in the input string. O texto inserido é mostrado em negrito na coluna de resultados.Inserted text is shown in bold in the results column.

Corresponder aMatch PosiçãoPosition Corresponder aMatch Cadeia de caracteres de resultadoResult string
11 33 123123 ABCABC123DEF456DEF456ABCABC123DEF456DEF456
22 55 456456 ABCABC123DEF456DEFABC123DEF456ABCABC123DEF456DEFABC123DEF456

Consulte tambémSee also