Compartilhar via

Substituições

  • Artigo

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 seqüência de entrada. O padrão de substituição pode consistir de substituições de uma ou mais, juntamente com caracteres literais. Padrões de substituição são fornecidos para as sobrecargas da Regex.Replace método tem um replacement parâmetro e o Match.Result método. Os métodos de substituir o padrão correspondente com o padrão definido pela replacement parâmetro.

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

Substituição

Descrição

$número

Inclui a subseqüência última correspondida com o grupo de captura é identificado por número, onde número é um valor decimal, a seqüência de caracteres de substituição. Para obter mais informações, consulte a substituição de um grupo de numerada.

${name}

Inclui a subseqüência última correspondida pelo grupo nomeado que é designado pelo (?<nome> ) a seqüência de caracteres de substituição. Para obter mais informações, consulte a substituição de um grupo nomeado.

$$

Inclui um único "$" literal de seqüência de caracteres de substituição. Para obter mais informações, consulte Substituting "$" Símbolo.

$&

Inclui uma cópia da correspondência toda a seqüência de caracteres de substituição. Para obter mais informações, consulte substituindo a correspondência de todo.

$`

Inclui todo o texto da seqüência de entrada antes da correspondência na seqüência de caracteres de substituição. Para obter mais informações, consulte substituindo o texto antes da correspondência.

$'

Inclui todo o texto da seqüência de entrada após a correspondência na seqüência de caracteres de substituição. Para obter mais informações, consulte substituindo o texto após a correspondência.

$+

Inclui o último grupo capturado na string de substituição. Para obter mais informações, consulte substituindo o último grupo capturados.

$_

Inclui toda a seqüência de entrada na seqüência de caracteres de substituição. Para obter mais informações, consulte substituindo toda a seqüência de entrada.

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

Substituições são as construções apenas especiais reconhecidas em um padrão de substituição. Nenhum dos outros expressão regular idioma elementos, incluindo caracteres de escapa e o período (.), que corresponde a qualquer caractere, são suportadas. Da mesma forma, os elementos de 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ões regulares.

O único caractere que pode aparecer em um padrão de expressão regular ou em uma substituição é a $ de caracteres, embora ele tem uma conotação diferente em cada contexto. Em um padrão de expressão regular, $ é uma âncora que corresponde ao final da seqüência de caracteres. Em um padrão de substituição, $ indica o início de uma substituição.

Observação

Para obter funcionalidade semelhante a um padrão de substituição dentro de uma expressão regular, use uma retrorreferência.Para obter mais informações sobre referências anteriores, consulte Retrorreferência constrói.

Substituindo um grupo numerado

O $número elemento de linguagem inclui a última substring correspondido a número captura o grupo na string de substituição, onde número é o índice do grupo de captura. Por exemplo, o padrão de substituição $1 indica que a substring correspondida está a ser substituído pelo primeiro capturados grupo. Para obter mais informações sobre grupos de captura numeradas, consulte Agrupando Construtores.

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

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

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

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

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

Padrão

Descrição

\p{Sc}*

Corresponde a zero ou mais caracteres de símbolo de moeda.

\s?

Corresponde a zero ou um caracteres de espaço em branco.

\d+

Corresponde a um ou mais dígitos decimais.

[.,]?

Corresponde a zero ou um ponto ou uma vírgula.

\d*

Corresponde a zero ou mais dígitos decimais.

(\s? \d+[.,]? \d*)

Correspondência de um espaço em branco seguido de uma ou mais dígitos decimais, seguidos de zero ou um ponto ou uma vírgula, seguido de zero ou mais dígitos decimais. Este é o primeiro grupo de capturando. Como o padrão de substituição é $1, a chamada para o Regex.Replace método substitui a substring correspondida inteira com esse grupo capturados.

Voltar ao topo

Substituindo um grupo nomeado

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

Se nome não especifica um válido, denominado grupo de captura definido no padrão de expressão regular, ${nome} é interpretado como uma seqüência de caracteres literal é usada para substituir cada correspondência.

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

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

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

Padrão

Descrição

\p{Sc}*

Corresponde a zero ou mais caracteres de símbolo de moeda.

\s?

Corresponde a zero ou um caracteres de espaço em branco.

\d+

Corresponde a um ou mais dígitos decimais.

[.,]?

Corresponde a zero ou um ponto ou uma vírgula.

\d*

Corresponde a zero ou mais dígitos decimais.

(?<amount>\s? \d[.,]? \d*)

Corresponde a um espaço em branco, seguido por um ou mais dígitos decimais, seguidos de zero ou um de ponto ou vírgula, seguido de zero ou mais dígitos decimais. Esse é o grupo de capturando chamado amount. Como o padrão de substituição é ${amount}, a chamada para o Regex.Replace método substitui a substring correspondida inteira com esse grupo capturados.

Voltar ao topo

Substituindo "$" Caractere

O $$ substituição insere uma literal "$" caractere na seqüência de caracteres foram substituído.

O exemplo a seguir usa a NumberFormatInfo o objeto para determinar o símbolo de moeda da cultura atual e sua colocação em uma seqüência de caracteres de moeda. Em seguida, 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 for en-US, ele gera o padrão de expressão regular \b(\d+)(\.(\d+))? e o padrão de substituição $$ $1$2. Padrão de substituição substitui o texto correspondido com um símbolo de moeda e um espaço seguido por grupos de capturados primeiro e segundo.

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

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

Padrão

Descrição

\b

Inicie a correspondência no início de um limite de palavra.

(\d+)

Corresponde a um ou mais dígitos decimais. Este é o primeiro grupo de capturando.

\.

Corresponde a um período (separador decimal).

(\d+)

Corresponde a um ou mais dígitos decimais. Este é o terceiro grupo de capturando.

(\.(\d+))?

Corresponde a zero ou em uma ocorrência de um ponto seguido de um ou mais dígitos decimais. Este é o segundo grupo de capturando.

Substituindo a correspondência de inteiro

O $& substituição inclui a toda correspondência na seqüência de caracteres de substituição. Em geral, ele é usado para adicionar uma subseqüência de caracteres para o início ou fim da seqüência de caracteres correspondente. Por exemplo, o ($&) o padrão de substituição adiciona parênteses para o início e final de cada correspondência. Se não houver nenhuma correspondência, o $& substituição tem nenhum efeito.

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

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"

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

Padrão

Descrição

^

Inicie a correspondência no início da seqüência de entrada.

(\w+\s?)+

Correspondência do padrão de um ou mais caracteres do word, seguido de zero ou um espaço em branco caracteres de uma ou mais vezes.

$

Corresponde ao final da seqüência de entrada.

O "$&" o padrão de substituição adiciona uma aspa de literal para o início e final de cada correspondência.

Voltar ao topo

Substituindo o texto antes da correspondência

O $` substituição substitui a seqüência de caracteres correspondente com a seqüência inteira de entrada antes da correspondência. Ou seja, ele reproduz a seqüência de caracteres de entrada para a correspondência ao remover o texto correspondente. Qualquer texto que segue o texto correspondente é inalterado na seqüência de resultado. Se houver várias correspondências em uma seqüência de caracteres de entrada, o texto de substituição é derivado da seqüência de caracteres de entrada original, em vez da cadeia de caracteres na qual o texto foi substituído pelo correspondências anteriores. (O exemplo fornece uma ilustração). Se não houver nenhuma correspondência, o $` substituição tem nenhum efeito.

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

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

Neste exemplo, a seqüência de caracteres de entrada "aa1bb2cc3dd4ee5" contém cinco correspondências. A tabela a seguir ilustra como o $` substituição faz com que o mecanismo de expressões regulares substituir cada correspondência na seqüência de caracteres de entrada. Texto inserido é mostrado em negrito na coluna de resultados.

Correspondência

Position

A seqüência de caracteres antes de correspondência

Seqüência de resultado

1

2

AA

AAaabb2cc3dd4ee5

2

5

aa1bb

aaaabbaa1bbcc3dd4ee5

3

8

aa1bb2cc

aaaabbaa1bbccaa1bb2ccdd4ee5

4

11

aa1bb2cc3dd

aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5

5

14

aa1bb2cc3dd4ee

aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Voltar ao topo

Substituindo o texto depois de correspondência.

O $' substituição substitui a seqüência de caracteres correspondente com a seqüência inteira de entrada após a correspondência. Ou seja, reproduz a seqüência de caracteres de entrada após a correspondência ao remover o texto correspondente. Qualquer texto que precede o texto correspondente é inalterado na seqüência de resultado. Se não houver nenhuma correspondência, o $' substituição tem nenhum efeito.

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

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

Neste exemplo, a seqüência de caracteres de entrada "aa1bb2cc3dd4ee5" contém cinco correspondências. A tabela a seguir ilustra como o $' substituição faz com que o mecanismo de expressões regulares substituir cada correspondência na seqüência de caracteres de entrada. Texto inserido é mostrado em negrito na coluna de resultados.

Correspondência

Position

String depois correspondência

Seqüência de resultado

1

2

bb2cc3dd4ee5

AAbb2cc3dd4ee5bb2cc3dd4ee5

2

5

cc3dd4ee5

aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5

3

8

dd4ee5

aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5

4

11

EE5

aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5

5

14

String.Empty

aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Voltar ao topo

Substituir o último grupo de capturados

O $+ substituição substitui a seqüência de caracteres correspondente com o último grupo capturados. Se houver grupos capturados ou se o valor do último grupo capturado for String.Empty, o $+ substituição tem nenhum efeito.

O exemplo a seguir identifica as palavras duplicadas em uma seqüência de caracteres e usa o $+ substituição para substituí-los com uma única ocorrência do word. O RegexOptions.IgnoreCase opção é usada para garantir que as palavras que diferem no caso, mas que são idênticas são consideradas duplicatas.

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.

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

Padrão

Descrição

\b

Começa a correspondência de um limite de palavra.

(\w+)

Corresponde a um ou mais caracteres do word. Este é o primeiro grupo de capturando.

\s

Corresponde a um caractere de espaço em branco.

\1

Corresponde ao primeiro grupo capturado.

\b

Finalize a correspondência de um limite de palavra.

Voltar ao topo

Substituindo a seqüência de caracteres de entrada de inteiro

O $_ substituição substitui a seqüência de caracteres correspondente com a entrada inteira de seqüência. Ou seja, ele remove o texto correspondente e substitui-lo com a seqüência inteira, incluindo o texto correspondente.

O exemplo a seguir corresponde a um ou mais dígitos decimais na seqüência de entrada. Ele usa o $_ substituição para substituí-los com a entrada inteira de seqüência.

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

Neste exemplo, a seqüência de caracteres de entrada "ABC123DEF456" contém duas correspondências. A tabela a seguir ilustra como o $_ substituição faz com que o mecanismo de expressões regulares substituir cada correspondência na seqüência de caracteres de entrada. Texto inserido é mostrado em negrito na coluna de resultados.

Correspondência

Position

Correspondência

Seqüência de resultado

1

3

123

ABCABC123DEF456DEF456

2

5

456

ABCABC123DEF456DEFABC123DEF456

Voltar ao topo

Consulte também

Conceitos

Elementos de linguagem das expressões regulares